Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-20 07:36:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Half-convert FAT, Ext2 and NTFS filesytems to provide new ARC file infrastructure. This allows removing some compatibility code in fs.c

Browse source 
- Remove use of FsOpenBootVolume() and FsOpenSystemVolume(). If callers don't want a file on boot volume, they need to use the new ArcOpen/ArcSeek/ArcRead/ArcClose functions instead of the old FsOpenFile/FsSetFilePointer/FsReadFile/FsCloseFile

svn path=/trunk/; revision=42537
This commit is contained in:
Hervé Poussineau 2009-08-08 20:53:10 +00:00
parent ee30838ad7
commit 28bf1f3b71
22 changed files with 532 additions and 641 deletions
Download patch file Download diff file Expand all files Collapse all files

8
reactos/boot/freeldr/freeldr/arch/powerpc/mach.c
View file

@ -264,11 +264,7 @@ BOOLEAN PpcDiskGetBootVolume( PULONG DriveNumber, PULONGLONG StartSector, PULONG
BOOLEAN PpcDiskGetSystemVolume( char *SystemPath, BOOLEAN PpcDiskGetSystemVolume( char *SystemPath,
char *RemainingPath, char *RemainingPath,
PULONG Device, PULONG Device ) {
PULONG DriveNumber,
PULONGLONG StartSector,
PULONGLONG SectorCount,
int *FsType ) {
char *remain = strchr(SystemPath, '\\'); char *remain = strchr(SystemPath, '\\');
if( remain ) { if( remain ) {
strcpy( RemainingPath, remain+1 ); strcpy( RemainingPath, remain+1 );
@ -278,7 +274,7 @@ BOOLEAN PpcDiskGetSystemVolume( char *SystemPath,
*Device = 0; *Device = 0;
// Hack to be a bit easier on ram // Hack to be a bit easier on ram
CacheSizeLimit = 64 * 1024; CacheSizeLimit = 64 * 1024;
return MachDiskGetBootVolume(DriveNumber, StartSector, SectorCount, FsType); return TRUE;
} }
BOOLEAN PpcDiskGetBootPath( char *OutBootPath, unsigned Size ) { BOOLEAN PpcDiskGetBootPath( char *OutBootPath, unsigned Size ) {

6
reactos/boot/freeldr/freeldr/bootmgr.c
View file

@ -31,12 +31,6 @@ VOID RunLoader(VOID)
LONG TimeOut; LONG TimeOut;
ULONG SelectedOperatingSystem; ULONG SelectedOperatingSystem;
if (!FsOpenBootVolume())
{
UiMessageBoxCritical("Error opening boot partition for file access.");
return;
}
// FIXME: if possible, only detect and register ARC devices... // FIXME: if possible, only detect and register ARC devices...
if (!MachHwDetect()) if (!MachHwDetect())
{ {

30
reactos/boot/freeldr/freeldr/disk/disk.c
View file

@ -241,22 +241,19 @@ DiskBootingFromFloppy(VOID)
BOOLEAN DiskGetSystemVolume(char *SystemPath, BOOLEAN DiskGetSystemVolume(char *SystemPath,
char *RemainingPath, char *RemainingPath,
PULONG Device, PULONG Device)
PULONG DriveNumber,
PULONGLONG StartSector,
PULONGLONG SectorCount,
int *FsType)
{ {
ULONG PartitionNumber; ULONG PartitionNumber;
PARTITION_TABLE_ENTRY PartitionTableEntry; PARTITION_TABLE_ENTRY PartitionTableEntry;
UCHAR VolumeType; UCHAR VolumeType;
CHAR BootPath[256]; CHAR BootPath[256];
unsigned i, RosPartition; unsigned i, RosPartition;
ULONG DriveNumber;
/* /*
* Verify system path * Verify system path
*/ */
if (!DissectArcPath(SystemPath, BootPath, DriveNumber, &PartitionNumber)) if (!DissectArcPath(SystemPath, BootPath, &DriveNumber, &PartitionNumber))
{ {
return FALSE; return FALSE;
} }
@ -278,7 +275,7 @@ BOOLEAN DiskGetSystemVolume(char *SystemPath,
RosPartition = 0; RosPartition = 0;
while (1) while (1)
{ {
if (!MachDiskGetPartitionEntry(*DriveNumber, ++i, &PartitionTableEntry)) if (!MachDiskGetPartitionEntry(DriveNumber, ++i, &PartitionTableEntry))
{ {
return FALSE; return FALSE;
} }
@ -294,33 +291,28 @@ BOOLEAN DiskGetSystemVolume(char *SystemPath,
} }
/* Check for ISO9660 file system type */ /* Check for ISO9660 file system type */
if (*DriveNumber >= 0x80 && FsRecIsIso9660(*DriveNumber)) if (DriveNumber >= 0x80 && FsRecIsIso9660(DriveNumber))
{ {
DPRINTM(DPRINT_FILESYSTEM, "Drive is a cdrom drive. Assuming ISO-9660 file system.\n"); DPRINTM(DPRINT_FILESYSTEM, "Drive is a cdrom drive. Assuming ISO-9660 file system.\n");
if (NULL != Device) if (NULL != Device)
{ {
((char *)Device)[0] = (char)(*DriveNumber); ((char *)Device)[0] = (char)DriveNumber;
((char *)Device)[1] = (char)i; ((char *)Device)[1] = (char)i;
} }
*StartSector = 0;
*SectorCount = 0;
*FsType = FS_ISO9660;
return TRUE; return TRUE;
} }
if (!FsRecognizeVolume(*DriveNumber, PartitionTableEntry.SectorCountBeforePartition, &VolumeType)) if (!FsRecognizeVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition, &VolumeType))
{ {
return FALSE; return FALSE;
} }
if (NULL != Device) if (NULL != Device)
{ {
((char *)Device)[0] = (char)(*DriveNumber); ((char *)Device)[0] = (char)DriveNumber;
((char *)Device)[1] = (char)i; ((char *)Device)[1] = (char)i;
} }
*StartSector = PartitionTableEntry.SectorCountBeforePartition;
*SectorCount = PartitionTableEntry.PartitionSectorCount;
switch (VolumeType) switch (VolumeType)
{ {
@ -330,16 +322,10 @@ BOOLEAN DiskGetSystemVolume(char *SystemPath,
case PARTITION_XINT13: case PARTITION_XINT13:
case PARTITION_FAT32: case PARTITION_FAT32:
case PARTITION_FAT32_XINT13: case PARTITION_FAT32_XINT13:
*FsType = FS_FAT;
return TRUE;
case PARTITION_EXT2: case PARTITION_EXT2:
*FsType = FS_EXT2;
return TRUE;
case PARTITION_NTFS: case PARTITION_NTFS:
*FsType = FS_NTFS;
return TRUE; return TRUE;
default: default:
*FsType = 0;
return FALSE; return FALSE;
} }

210
reactos/boot/freeldr/freeldr/fs/ext2.c
View file

@ -20,6 +20,31 @@
#include <freeldr.h> #include <freeldr.h>
#include <debug.h> #include <debug.h>
BOOLEAN Ext2OpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector, ULONGLONG PartitionSectorCount);
FILE* Ext2OpenFile(PCSTR FileName);
BOOLEAN Ext2LookupFile(PCSTR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer);
BOOLEAN Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry);
BOOLEAN Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer);
BOOLEAN Ext2ReadFileBig(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* BytesRead, PVOID Buffer);
BOOLEAN Ext2ReadSuperBlock(VOID);
BOOLEAN Ext2ReadGroupDescriptors(VOID);
BOOLEAN Ext2ReadDirectory(ULONG Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer);
BOOLEAN Ext2ReadBlock(ULONG BlockNumber, PVOID Buffer);
BOOLEAN Ext2ReadPartialBlock(ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
ULONG Ext2GetGroupDescBlockNumber(ULONG Group);
ULONG Ext2GetGroupDescOffsetInBlock(ULONG Group);
ULONG Ext2GetInodeGroupNumber(ULONG Inode);
ULONG Ext2GetInodeBlockNumber(ULONG Inode);
ULONG Ext2GetInodeOffsetInBlock(ULONG Inode);
BOOLEAN Ext2ReadInode(ULONG Inode, PEXT2_INODE InodeBuffer);
BOOLEAN Ext2ReadGroupDescriptor(ULONG Group, PEXT2_GROUP_DESC GroupBuffer);
ULONG* Ext2ReadBlockPointerList(PEXT2_INODE Inode);
ULONGLONG Ext2GetInodeFileSize(PEXT2_INODE Inode);
BOOLEAN Ext2CopyIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock);
BOOLEAN Ext2CopyDoubleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock);
BOOLEAN Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock);
GEOMETRY Ext2DiskGeometry; // Ext2 file system disk geometry GEOMETRY Ext2DiskGeometry; // Ext2 file system disk geometry
PEXT2_SUPER_BLOCK Ext2SuperBlock = NULL; // Ext2 file system super block PEXT2_SUPER_BLOCK Ext2SuperBlock = NULL; // Ext2 file system super block
@ -519,43 +544,6 @@ BOOLEAN Ext2ReadFileBig(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* Byte
return TRUE; return TRUE;
} }
BOOLEAN Ext2ReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
BOOLEAN Success;
ULONGLONG BytesReadBig;
Success = Ext2ReadFileBig(FileHandle, BytesToRead, &BytesReadBig, Buffer);
*BytesRead = (ULONG)BytesReadBig;
return Success;
}
ULONG Ext2GetFileSize(FILE *FileHandle)
{
PEXT2_FILE_INFO Ext2FileHandle = (PEXT2_FILE_INFO)FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "Ext2GetFileSize() FileSize = %d\n", Ext2FileHandle->FileSize);
return Ext2FileHandle->FileSize;
}
VOID Ext2SetFilePointer(FILE *FileHandle, ULONG NewFilePointer)
{
PEXT2_FILE_INFO Ext2FileHandle = (PEXT2_FILE_INFO)FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "Ext2SetFilePointer() NewFilePointer = %d\n", NewFilePointer);
Ext2FileHandle->FilePointer = NewFilePointer;
}
ULONG Ext2GetFilePointer(FILE *FileHandle)
{
PEXT2_FILE_INFO Ext2FileHandle = (PEXT2_FILE_INFO)FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "Ext2GetFilePointer() FilePointer = %d\n", Ext2FileHandle->FilePointer);
return Ext2FileHandle->FilePointer;
}
BOOLEAN Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer) BOOLEAN Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer)
{ {
//GEOMETRY DiskGeometry; //GEOMETRY DiskGeometry;
@ -1178,12 +1166,144 @@ BOOLEAN Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBloc
return TRUE; return TRUE;
} }
const FS_VTBL Ext2Vtbl = { LONG Ext2Close(ULONG FileId)
Ext2OpenVolume, {
Ext2OpenFile, PEXT2_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
NULL,
Ext2ReadFile, MmHeapFree(FileHandle);
Ext2GetFileSize,
Ext2SetFilePointer, return ESUCCESS;
Ext2GetFilePointer, }
LONG Ext2GetFileInformation(ULONG FileId, FILEINFORMATION* Information)
{
PEXT2_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
RtlZeroMemory(Information, sizeof(FILEINFORMATION));
Information->EndingAddress.LowPart = FileHandle->FileSize;
Information->CurrentAddress.LowPart = FileHandle->FilePointer;
DPRINTM(DPRINT_FILESYSTEM, "Ext2GetFileInformation() FileSize = %d\n",
Information->EndingAddress.LowPart);
DPRINTM(DPRINT_FILESYSTEM, "Ext2GetFileInformation() FilePointer = %d\n",
Information->CurrentAddress.LowPart);
return ESUCCESS;
}
LONG Ext2Open(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
{
PEXT2_FILE_INFO FileHandle;
ULONG DeviceId;
if (OpenMode != OpenReadOnly)
return EACCES;
DeviceId = FsGetDeviceId(*FileId);
DPRINTM(DPRINT_FILESYSTEM, "Ext2Open() FileName = %s\n", Path);
//
// Call old open method
//
FileHandle = Ext2OpenFile(Path);
//
// Check for error
//
if (!FileHandle)
return ENOENT;
//
// Success. Remember the handle
//
FsSetDeviceSpecific(*FileId, FileHandle);
return ESUCCESS;
}
LONG Ext2Read(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count)
{
PFAT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
ULONGLONG BytesReadBig;
BOOLEAN ret;
//
// Read data
//
ret = Ext2ReadFileBig(FileHandle, N, &BytesReadBig, Buffer);
*Count = (ULONG)BytesReadBig;
//
// Check for success
//
if (ret)
return ESUCCESS;
else
return EIO;
}
LONG Ext2Seek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
{
PEXT2_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
DPRINTM(DPRINT_FILESYSTEM, "Ext2Seek() NewFilePointer = %lu\n", Position->LowPart);
if (SeekMode != SeekAbsolute)
return EINVAL;
if (Position->HighPart != 0)
return EINVAL;
if (Position->LowPart >= FileHandle->FileSize)
return EINVAL;
FileHandle->FilePointer = Position->LowPart;
return ESUCCESS;
}
const DEVVTBL Ext2FuncTable =
{
Ext2Close,
Ext2GetFileInformation,
Ext2Open,
Ext2Read,
Ext2Seek,
}; };
const DEVVTBL* Ext2Mount(ULONG DeviceId)
{
EXT2_SUPER_BLOCK SuperBlock;
LARGE_INTEGER Position;
ULONG Count;
LONG ret;
//
// Read the SuperBlock
//
Position.HighPart = 0;
Position.LowPart = 2 * 512;
ret = ArcSeek(DeviceId, &Position, SeekAbsolute);
if (ret != ESUCCESS)
return NULL;
ret = ArcRead(DeviceId, &SuperBlock, sizeof(SuperBlock), &Count);
if (ret != ESUCCESS || Count != sizeof(SuperBlock))
return NULL;
//
// Check if SuperBlock is valid. If yes, return Ext2 function table
//
if (SuperBlock.s_magic == EXT3_SUPER_MAGIC)
{
//
// Compatibility hack as long as FS is not using underlying device DeviceId
//
ULONG DriveNumber;
ULONGLONG StartSector;
ULONGLONG SectorCount;
int Type;
if (!MachDiskGetBootVolume(&DriveNumber, &StartSector, &SectorCount, &Type))
return NULL;
Ext2OpenVolume(DriveNumber, StartSector, SectorCount);
return &Ext2FuncTable;
}
else
return NULL;
}

236
reactos/boot/freeldr/freeldr/fs/fat.c
View file

@ -22,6 +22,20 @@
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
ULONG FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector, ULONG PartitionSectorCount);
PVOID FatBufferDirectory(ULONG DirectoryStartCluster, ULONG* EntryCountPointer, BOOLEAN RootDirectory);
BOOLEAN FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG EntryCount, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer);
LONG FatLookupFile(PCSTR FileName, ULONG DeviceId, PFAT_FILE_INFO FatFileInfoPointer);
void FatParseShortFileName(PCHAR Buffer, PDIRENTRY DirEntry);
BOOLEAN FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer);
ULONG FatCountClustersInChain(ULONG StartCluster);
ULONG* FatGetClusterChainArray(ULONG StartCluster);
BOOLEAN FatReadCluster(ULONG ClusterNumber, PVOID Buffer);
BOOLEAN FatReadClusterChain(ULONG StartClusterNumber, ULONG NumberOfClusters, PVOID Buffer);
BOOLEAN FatReadPartialCluster(ULONG ClusterNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
BOOLEAN FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer);
BOOLEAN gCacheEnabled = FALSE; BOOLEAN gCacheEnabled = FALSE;
ULONG BytesPerSector; /* Number of bytes per sector */ ULONG BytesPerSector; /* Number of bytes per sector */
@ -778,11 +792,10 @@ static BOOLEAN FatXSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG Dir
/* /*
* FatLookupFile() * FatLookupFile()
* This function searches the file system for the * This function searches the file system for the
* specified filename and fills in a FAT_FILE_INFO structure * specified filename and fills in an FAT_FILE_INFO structure
* with info describing the file, etc. returns true * with info describing the file, etc. returns ARC error code
* if the file exists or false otherwise
*/ */
BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer) LONG FatLookupFile(PCSTR FileName, ULONG DeviceId, PFAT_FILE_INFO FatFileInfoPointer)
{ {
UINT32 i; UINT32 i;
ULONG NumberOfPathParts; ULONG NumberOfPathParts;
@ -825,7 +838,7 @@ BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer)
DirectoryBuffer = FatBufferDirectory(DirectoryStartCluster, &DirectorySize, (i == 0) ); DirectoryBuffer = FatBufferDirectory(DirectoryStartCluster, &DirectorySize, (i == 0) );
if (DirectoryBuffer == NULL) if (DirectoryBuffer == NULL)
{ {
return FALSE; return ENOMEM;
} }
// //
@ -836,7 +849,7 @@ BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer)
if (!FatXSearchDirectoryBufferForFile(DirectoryBuffer, DirectorySize, PathPart, &FatFileInfo)) if (!FatXSearchDirectoryBufferForFile(DirectoryBuffer, DirectorySize, PathPart, &FatFileInfo))
{ {
MmHeapFree(DirectoryBuffer); MmHeapFree(DirectoryBuffer);
return FALSE; return ENOENT;
} }
} }
else else
@ -844,7 +857,7 @@ BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer)
if (!FatSearchDirectoryBufferForFile(DirectoryBuffer, DirectorySize, PathPart, &FatFileInfo)) if (!FatSearchDirectoryBufferForFile(DirectoryBuffer, DirectorySize, PathPart, &FatFileInfo))
{ {
MmHeapFree(DirectoryBuffer); MmHeapFree(DirectoryBuffer);
return FALSE; return ENOENT;
} }
} }
@ -863,7 +876,7 @@ BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer)
memcpy(FatFileInfoPointer, &FatFileInfo, sizeof(FAT_FILE_INFO)); memcpy(FatFileInfoPointer, &FatFileInfo, sizeof(FAT_FILE_INFO));
return TRUE; return ESUCCESS;
} }
/* /*
@ -1008,35 +1021,6 @@ BOOLEAN FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer)
return TRUE; return TRUE;
} }
/*
* FatOpenFile()
* Tries to open the file 'name' and returns true or false
* for success and failure respectively
*/
FILE* FatOpenFile(PCSTR FileName)
{
FAT_FILE_INFO TempFatFileInfo;
PFAT_FILE_INFO FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "FatOpenFile() FileName = %s\n", FileName);
if (!FatLookupFile(FileName, &TempFatFileInfo))
{
return NULL;
}
FileHandle = MmHeapAlloc(sizeof(FAT_FILE_INFO));
if (FileHandle == NULL)
{
return NULL;
}
memcpy(FileHandle, &TempFatFileInfo, sizeof(FAT_FILE_INFO));
return (FILE*)FileHandle;
}
ULONG FatCountClustersInChain(ULONG StartCluster) ULONG FatCountClustersInChain(ULONG StartCluster)
{ {
ULONG ClusterCount = 0; ULONG ClusterCount = 0;
@ -1394,33 +1378,6 @@ BOOLEAN FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID
return TRUE; return TRUE;
} }
ULONG FatGetFileSize(FILE *FileHandle)
{
PFAT_FILE_INFO FatFileHandle = (PFAT_FILE_INFO)FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "FatGetFileSize() FileSize = %d\n", FatFileHandle->FileSize);
return FatFileHandle->FileSize;
}
VOID FatSetFilePointer(FILE *FileHandle, ULONG NewFilePointer)
{
PFAT_FILE_INFO FatFileHandle = (PFAT_FILE_INFO)FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "FatSetFilePointer() NewFilePointer = %d\n", NewFilePointer);
FatFileHandle->FilePointer = NewFilePointer;
}
ULONG FatGetFilePointer(FILE *FileHandle)
{
PFAT_FILE_INFO FatFileHandle = (PFAT_FILE_INFO)FileHandle;
DPRINTM(DPRINT_FILESYSTEM, "FatGetFilePointer() FilePointer = %d\n", FatFileHandle->FilePointer);
return FatFileHandle->FilePointer;
}
BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer) BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer)
{ {
if (gCacheEnabled) if (gCacheEnabled)
@ -1443,12 +1400,147 @@ BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG Sector
} }
} }
const FS_VTBL FatVtbl = { LONG FatClose(ULONG FileId)
FatOpenVolume, {
FatOpenFile, PFAT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
NULL,
FatReadFile, MmHeapFree(FileHandle);
FatGetFileSize,
FatSetFilePointer, return ESUCCESS;
FatGetFilePointer, }
LONG FatGetFileInformation(ULONG FileId, FILEINFORMATION* Information)
{
PFAT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
RtlZeroMemory(Information, sizeof(FILEINFORMATION));
Information->EndingAddress.LowPart = FileHandle->FileSize;
Information->CurrentAddress.LowPart = FileHandle->FilePointer;
DPRINTM(DPRINT_FILESYSTEM, "FatGetFileInformation() FileSize = %d\n",
Information->EndingAddress.LowPart);
DPRINTM(DPRINT_FILESYSTEM, "FatGetFileInformation() FilePointer = %d\n",
Information->CurrentAddress.LowPart);
return ESUCCESS;
}
LONG FatOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
{
FAT_FILE_INFO TempFileInfo;
PFAT_FILE_INFO FileHandle;
ULONG DeviceId;
LONG ret;
if (OpenMode != OpenReadOnly)
return EACCES;
DeviceId = FsGetDeviceId(*FileId);
DPRINTM(DPRINT_FILESYSTEM, "FatOpen() FileName = %s\n", Path);
RtlZeroMemory(&TempFileInfo, sizeof(TempFileInfo));
ret = FatLookupFile(Path, DeviceId, &TempFileInfo);
if (ret != ESUCCESS)
return ENOENT;
FileHandle = MmHeapAlloc(sizeof(FAT_FILE_INFO));
if (!FileHandle)
return ENOMEM;
RtlCopyMemory(FileHandle, &TempFileInfo, sizeof(FAT_FILE_INFO));
FsSetDeviceSpecific(*FileId, FileHandle);
return ESUCCESS;
}
LONG FatRead(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count)
{
PFAT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
BOOLEAN ret;
//
// Call old read method
//
ret = FatReadFile(FileHandle, N, Count, Buffer);
//
// Check for success
//
if (ret)
return ESUCCESS;
else
return EIO;
}
LONG FatSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
{
PFAT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
DPRINTM(DPRINT_FILESYSTEM, "FatSeek() NewFilePointer = %lu\n", Position->LowPart);
if (SeekMode != SeekAbsolute)
return EINVAL;
if (Position->HighPart != 0)
return EINVAL;
if (Position->LowPart >= FileHandle->FileSize)
return EINVAL;
FileHandle->FilePointer = Position->LowPart;
return ESUCCESS;
}
const DEVVTBL FatFuncTable =
{
FatClose,
FatGetFileInformation,
FatOpen,
FatRead,
FatSeek,
}; };
const DEVVTBL* FatMount(ULONG DeviceId)
{
UCHAR Buffer[512];
PFAT_BOOTSECTOR BootSector = (PFAT_BOOTSECTOR)Buffer;
PFAT32_BOOTSECTOR BootSector32 = (PFAT32_BOOTSECTOR)Buffer;
PFATX_BOOTSECTOR BootSectorX = (PFATX_BOOTSECTOR)Buffer;
LARGE_INTEGER Position;
ULONG Count;
LONG ret;
//
// Read the BootSector
//
Position.HighPart = 0;
Position.LowPart = 0;
ret = ArcSeek(DeviceId, &Position, SeekAbsolute);
if (ret != ESUCCESS)
return NULL;
ret = ArcRead(DeviceId, Buffer, sizeof(Buffer), &Count);
if (ret != ESUCCESS || Count != sizeof(Buffer))
return NULL;
//
// Check if BootSector is valid. If yes, return FAT function table
//
if (RtlEqualMemory(BootSector->FileSystemType, "FAT12 ", 8) ||
RtlEqualMemory(BootSector->FileSystemType, "FAT16 ", 8) ||
RtlEqualMemory(BootSector32->FileSystemType, "FAT32 ", 8) ||
RtlEqualMemory(BootSectorX->FileSystemType, "FATX", 4))
{
//
// Compatibility hack as long as FS is not using underlying device DeviceId
//
ULONG DriveNumber;
ULONGLONG StartSector;
ULONGLONG SectorCount;
int Type;
if (!MachDiskGetBootVolume(&DriveNumber, &StartSector, &SectorCount, &Type))
return NULL;
FatOpenVolume(DriveNumber, StartSector, SectorCount);
return &FatFuncTable;
}
else
return NULL;
}

364
reactos/boot/freeldr/freeldr/fs/fs.c
View file

@ -23,31 +23,28 @@
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
/////////////////////////////////////////////////////////////////////////////////////////////
// DATA
/////////////////////////////////////////////////////////////////////////////////////////////
const FS_VTBL* pFSVtbl = NULL; // Type of filesystem on boot device, set by FsOpenVolume()
PVOID FsStaticBufferDisk = 0, FsStaticBufferData = 0;
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS // FUNCTIONS
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
static BOOLEAN CompatArcOpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector, ULONGLONG PartitionSectorCount) VOID FileSystemError(PCSTR ErrorString)
{ {
// DPRINTM(DPRINT_FILESYSTEM, "%s\n", ErrorString);
// Always return success
// UiMessageBox(ErrorString);
return TRUE;
} }
static FILE* CompatArcOpenFile(PCSTR FileName) PFILE FsOpenFile(PCSTR FileName)
{ {
CHAR FullPath[MAX_PATH]; CHAR FullPath[MAX_PATH];
ULONG FileId; ULONG FileId;
LONG ret; LONG ret;
//
// Print status message
//
DPRINTM(DPRINT_FILESYSTEM, "Opening file '%s'...\n", FileName);
// //
// Create full file name // Create full file name
// //
@ -63,12 +60,31 @@ static FILE* CompatArcOpenFile(PCSTR FileName)
// Check for success // Check for success
// //
if (ret == ESUCCESS) if (ret == ESUCCESS)
return (FILE*)FileId; return (PFILE)FileId;
else else
return NULL; return NULL;
} }
static BOOLEAN CompatArcReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer) VOID FsCloseFile(PFILE FileHandle)
{
ULONG FileId = (ULONG)FileHandle;
//
// Close the handle
//
ArcClose(FileId);
//
// Do not check for error; this function is
// supposed to always succeed
//
}
/*
* ReadFile()
* returns number of bytes read or EOF
*/
BOOLEAN FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{ {
ULONG FileId = (ULONG)FileHandle; ULONG FileId = (ULONG)FileHandle;
LONG ret; LONG ret;
@ -87,7 +103,7 @@ static BOOLEAN CompatArcReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* Byt
return FALSE; return FALSE;
} }
ULONG CompatArcGetFileSize(FILE *FileHandle) ULONG FsGetFileSize(PFILE FileHandle)
{ {
ULONG FileId = (ULONG)FileHandle; ULONG FileId = (ULONG)FileHandle;
FILEINFORMATION Information; FILEINFORMATION Information;
@ -110,7 +126,7 @@ ULONG CompatArcGetFileSize(FILE *FileHandle)
return Information.EndingAddress.LowPart; return Information.EndingAddress.LowPart;
} }
VOID CompatArcSetFilePointer(FILE *FileHandle, ULONG NewFilePointer) VOID FsSetFilePointer(PFILE FileHandle, ULONG NewFilePointer)
{ {
ULONG FileId = (ULONG)FileHandle; ULONG FileId = (ULONG)FileHandle;
LARGE_INTEGER Position; LARGE_INTEGER Position;
@ -128,7 +144,7 @@ VOID CompatArcSetFilePointer(FILE *FileHandle, ULONG NewFilePointer)
// //
} }
ULONG CompatArcGetFilePointer(FILE *FileHandle) ULONG FsGetFilePointer(PFILE FileHandle)
{ {
ULONG FileId = (ULONG)FileHandle; ULONG FileId = (ULONG)FileHandle;
FILEINFORMATION Information; FILEINFORMATION Information;
@ -151,238 +167,6 @@ ULONG CompatArcGetFilePointer(FILE *FileHandle)
return Information.CurrentAddress.LowPart; return Information.CurrentAddress.LowPart;
} }
static const FS_VTBL CompatArcVtbl =
{
CompatArcOpenVolume,
CompatArcOpenFile,
NULL,
CompatArcReadFile,
CompatArcGetFileSize,
CompatArcSetFilePointer,
CompatArcGetFilePointer,
};
VOID FileSystemError(PCSTR ErrorString)
{
DPRINTM(DPRINT_FILESYSTEM, "%s\n", ErrorString);
UiMessageBox(ErrorString);
}
/*
*
* BOOLEAN FsOpenVolume(ULONG DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount, int Type);
*
* This function is called to open a disk volume for file access.
* It must be called before any of the file functions will work.
*
*/
static BOOLEAN FsOpenVolume(ULONG DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount, int Type)
{
CHAR ErrorText[80];
if( !FsStaticBufferDisk )
FsStaticBufferDisk = MmAllocateMemory( 0x20000 );
if( !FsStaticBufferDisk )
{
FileSystemError("could not allocate filesystem static buffer");
return FALSE;
}
FsStaticBufferData = ((PCHAR)FsStaticBufferDisk) + 0x10000;
switch (Type)
{
case FS_FAT:
pFSVtbl = &FatVtbl;
break;
case FS_NTFS:
pFSVtbl = &NtfsVtbl;
break;
case FS_EXT2:
pFSVtbl = &Ext2Vtbl;
break;
case FS_ISO9660:
pFSVtbl = &CompatArcVtbl;
break;
default:
pFSVtbl = NULL;
break;
}
if (pFSVtbl && pFSVtbl->OpenVolume)
{
return (*pFSVtbl->OpenVolume)(DriveNumber, StartSector, SectorCount);
}
else
{
sprintf(ErrorText, "Unsupported file system. Type: 0x%x", Type);
FileSystemError(ErrorText);
}
return FALSE;
}
/*
*
* BOOLEAN FsOpenBootVolume()
*
* This function is called to open the boot disk volume for file access.
* It must be called before any of the file functions will work.
*/
BOOLEAN FsOpenBootVolume()
{
ULONG DriveNumber;
ULONGLONG StartSector;
ULONGLONG SectorCount;
int Type;
if (! MachDiskGetBootVolume(&DriveNumber, &StartSector, &SectorCount, &Type))
{
FileSystemError("Unable to locate boot partition\n");
return FALSE;
}
return FsOpenVolume(DriveNumber, StartSector, SectorCount, Type);
}
BOOLEAN FsOpenSystemVolume(char *SystemPath, char *RemainingPath, PULONG Device)
{
ULONG DriveNumber;
ULONGLONG StartSector;
ULONGLONG SectorCount;
int Type;
if (! MachDiskGetSystemVolume(SystemPath, RemainingPath, Device,
&DriveNumber, &StartSector, &SectorCount,
&Type))
{
FileSystemError("Unable to locate system partition\n");
return FALSE;
}
return FsOpenVolume(DriveNumber, StartSector, SectorCount, Type);
}
PFILE FsOpenFile(PCSTR FileName)
{
PFILE FileHandle = NULL;
//
// Print status message
//
DPRINTM(DPRINT_FILESYSTEM, "Opening file '%s'...\n", FileName);
//
// Check and see if the first character is '\' or '/' and remove it if so
//
while ((*FileName == '\\') || (*FileName == '/'))
{
FileName++;
}
//
// Check file system type and pass off to appropriate handler
//
if (pFSVtbl && pFSVtbl->OpenFile)
{
FileHandle = pFSVtbl->OpenFile(FileName);
}
else
{
FileSystemError("Error: Unknown filesystem.");
}
//
// Check return value
//
if (FileHandle != NULL)
{
DPRINTM(DPRINT_FILESYSTEM, "FsOpenFile() succeeded. FileHandle: 0x%x\n", FileHandle);
}
else
{
DPRINTM(DPRINT_FILESYSTEM, "FsOpenFile() failed.\n");
}
return FileHandle;
}
VOID FsCloseFile(PFILE FileHandle)
{
if (pFSVtbl)
{
if (pFSVtbl->CloseFile)
(*pFSVtbl->CloseFile)(FileHandle);
}
else
{
FileSystemError("Error: Unknown filesystem.");
}
}
/*
* ReadFile()
* returns number of bytes read or EOF
*/
BOOLEAN FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
//
// Set the number of bytes read equal to zero
//
if (BytesRead != NULL)
{
*BytesRead = 0;
}
if (pFSVtbl && pFSVtbl->ReadFile)
{
return (*pFSVtbl->ReadFile)(FileHandle, BytesToRead, BytesRead, Buffer);
}
else
{
FileSystemError("Unknown file system.");
return FALSE;
}
}
ULONG FsGetFileSize(PFILE FileHandle)
{
if (pFSVtbl && pFSVtbl->GetFileSize)
{
return (*pFSVtbl->GetFileSize)(FileHandle);
}
else
{
FileSystemError("Unknown file system.");
return 0;
}
}
VOID FsSetFilePointer(PFILE FileHandle, ULONG NewFilePointer)
{
if (pFSVtbl && pFSVtbl->SetFilePointer)
{
(*pFSVtbl->SetFilePointer)(FileHandle, NewFilePointer);
}
else
{
FileSystemError("Unknown file system.");
}
}
ULONG FsGetFilePointer(PFILE FileHandle)
{
if (pFSVtbl && pFSVtbl->SetFilePointer)
{
return (*pFSVtbl->GetFilePointer)(FileHandle);
}
else
{
FileSystemError("Unknown file system.");
return 0;
}
}
BOOLEAN FsIsEndOfFile(PFILE FileHandle) BOOLEAN FsIsEndOfFile(PFILE FileHandle)
{ {
if (FsGetFilePointer(FileHandle) >= FsGetFileSize(FileHandle)) if (FsGetFilePointer(FileHandle) >= FsGetFileSize(FileHandle))
@ -449,71 +233,6 @@ VOID FsGetFirstNameFromPath(PCHAR Buffer, PCSTR Path)
DPRINTM(DPRINT_FILESYSTEM, "FatGetFirstNameFromPath() Path = %s FirstName = %s\n", Path, Buffer); DPRINTM(DPRINT_FILESYSTEM, "FatGetFirstNameFromPath() Path = %s FirstName = %s\n", Path, Buffer);
} }
LONG CompatFsClose(ULONG FileId)
{
PFILE FileHandle = FsGetDeviceSpecific(FileId);
FsCloseFile(FileHandle);
return ESUCCESS;
}
LONG CompatFsGetFileInformation(ULONG FileId, FILEINFORMATION* Information)
{
PFILE FileHandle = FsGetDeviceSpecific(FileId);
memset(Information, 0, sizeof(FILEINFORMATION));
Information->EndingAddress.LowPart = FsGetFileSize(FileHandle);
Information->CurrentAddress.LowPart = FsGetFilePointer(FileHandle);
return ESUCCESS;
}
LONG CompatFsOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
{
PFILE FileHandle;
static BOOLEAN bVolumeOpened = FALSE;
if (!bVolumeOpened)
{
bVolumeOpened = FsOpenBootVolume();
if (!bVolumeOpened)
return EIO;
}
FileHandle = FsOpenFile(Path);
if (!FileHandle)
return EIO;
FsSetDeviceSpecific(*FileId, FileHandle);
return ESUCCESS;
}
LONG CompatFsRead(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count)
{
PFILE FileHandle = FsGetDeviceSpecific(FileId);
BOOLEAN ret;
ret = FsReadFile(FileHandle, N, Count, Buffer);
return (ret ? ESUCCESS : EFAULT);
}
LONG CompatFsSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
{
PFILE FileHandle = FsGetDeviceSpecific(FileId);
if (SeekMode != SeekAbsolute)
return EINVAL;
FsSetFilePointer(FileHandle, Position->LowPart);
return ESUCCESS;
}
const DEVVTBL CompatFsFuncTable = {
CompatFsClose,
CompatFsGetFileInformation,
CompatFsOpen,
CompatFsRead,
CompatFsSeek,
};
#define MAX_FDS 60 #define MAX_FDS 60
typedef struct tagFILEDATA typedef struct tagFILEDATA
{ {
@ -639,10 +358,17 @@ LONG ArcOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
/* Try to detect the file system */ /* Try to detect the file system */
FileData[DeviceId].FileFuncTable = IsoMount(DeviceId); FileData[DeviceId].FileFuncTable = IsoMount(DeviceId);
if (!FileData[DeviceId].FileFuncTable)
FileData[DeviceId].FileFuncTable = FatMount(DeviceId);
if (!FileData[DeviceId].FileFuncTable)
FileData[DeviceId].FileFuncTable = NtfsMount(DeviceId);
if (!FileData[DeviceId].FileFuncTable)
FileData[DeviceId].FileFuncTable = Ext2Mount(DeviceId);
if (!FileData[DeviceId].FileFuncTable) if (!FileData[DeviceId].FileFuncTable)
{ {
/* FIXME: we link there to old infrastructure... */ /* Error, unable to detect file system */
FileData[DeviceId].FileFuncTable = &CompatFsFuncTable; FileData[DeviceId].FuncTable = NULL;
return ENODEV;
} }
pDevice->DeviceId = DeviceId; pDevice->DeviceId = DeviceId;
@ -670,6 +396,10 @@ LONG ArcOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
if (i == MAX_FDS) if (i == MAX_FDS)
return EMFILE; return EMFILE;
/* Skip leading backslash, if any */
if (*FileName == '\\')
FileName++;
/* Open the file */ /* Open the file */
FileData[i].FuncTable = FileData[DeviceId].FileFuncTable; FileData[i].FuncTable = FileData[DeviceId].FileFuncTable;
FileData[i].DeviceId = DeviceId; FileData[i].DeviceId = DeviceId;

5
reactos/boot/freeldr/freeldr/fs/iso.c
View file

@ -271,9 +271,6 @@ LONG IsoOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
DPRINTM(DPRINT_FILESYSTEM, "IsoOpen() FileName = %s\n", Path); DPRINTM(DPRINT_FILESYSTEM, "IsoOpen() FileName = %s\n", Path);
if (*Path == '\\')
Path++;
RtlZeroMemory(&TempFileInfo, sizeof(TempFileInfo)); RtlZeroMemory(&TempFileInfo, sizeof(TempFileInfo));
ret = IsoLookupFile(Path, DeviceId, &TempFileInfo); ret = IsoLookupFile(Path, DeviceId, &TempFileInfo);
if (ret != ESUCCESS) if (ret != ESUCCESS)
@ -507,7 +504,7 @@ const DEVVTBL* IsoMount(ULONG DeviceId)
// //
// Check if PVD is valid. If yes, return ISO9660 function table // Check if PVD is valid. If yes, return ISO9660 function table
// //
if (Pvd->VdType == 1 && RtlCompareMemory(Pvd->StandardId, "CD001", 5) == 5) if (Pvd->VdType == 1 && RtlEqualMemory(Pvd->StandardId, "CD001", 5))
return &Iso9660FuncTable; return &Iso9660FuncTable;
else else
return NULL; return NULL;

176
reactos/boot/freeldr/freeldr/fs/ntfs.c
View file

@ -760,74 +760,156 @@ BOOLEAN NtfsOpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector, ULONGLONG
return TRUE; return TRUE;
} }
FILE* NtfsOpenFile(PCSTR FileName) LONG NtfsClose(ULONG FileId)
{
PNTFS_FILE_HANDLE FileHandle = FsGetDeviceSpecific(FileId);
NtfsReleaseAttributeContext(FileHandle->DataContext);
MmHeapFree(FileHandle);
return ESUCCESS;
}
LONG NtfsGetFileInformation(ULONG FileId, FILEINFORMATION* Information)
{
PNTFS_FILE_HANDLE FileHandle = FsGetDeviceSpecific(FileId);
RtlZeroMemory(Information, sizeof(FILEINFORMATION));
Information->EndingAddress.LowPart = (ULONG)NtfsGetAttributeSize(&FileHandle->DataContext->Record);
Information->CurrentAddress.LowPart = FileHandle->Offset;
DPRINTM(DPRINT_FILESYSTEM, "NtfsGetFileInformation() FileSize = %d\n",
Information->EndingAddress.LowPart);
DPRINTM(DPRINT_FILESYSTEM, "NtfsGetFileInformation() FilePointer = %d\n",
Information->CurrentAddress.LowPart);
return ESUCCESS;
}
LONG NtfsOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
{ {
PNTFS_FILE_HANDLE FileHandle; PNTFS_FILE_HANDLE FileHandle;
PNTFS_MFT_RECORD MftRecord; PNTFS_MFT_RECORD MftRecord;
ULONG DeviceId;
//
// Check parameters
//
if (OpenMode != OpenReadOnly)
return EACCES;
//
// Get underlying device
//
DeviceId = FsGetDeviceId(*FileId);
DPRINTM(DPRINT_FILESYSTEM, "NtfsOpen() FileName = %s\n", Path);
//
// Allocate file structure
//
FileHandle = MmHeapAlloc(sizeof(NTFS_FILE_HANDLE) + NtfsMftRecordSize); FileHandle = MmHeapAlloc(sizeof(NTFS_FILE_HANDLE) + NtfsMftRecordSize);
if (FileHandle == NULL) if (!FileHandle)
{ {
return NULL; return ENOMEM;
} }
RtlZeroMemory(FileHandle, sizeof(NTFS_FILE_HANDLE) + NtfsMftRecordSize);
//
// Search file entry
//
MftRecord = (PNTFS_MFT_RECORD)(FileHandle + 1); MftRecord = (PNTFS_MFT_RECORD)(FileHandle + 1);
if (!NtfsLookupFile(FileName, MftRecord, &FileHandle->DataContext)) if (!NtfsLookupFile(Path, MftRecord, &FileHandle->DataContext))
{ {
MmHeapFree(FileHandle); MmHeapFree(FileHandle);
return NULL; return ENOENT;
} }
FileHandle->Offset = 0; return ESUCCESS;
return (FILE*)FileHandle;
} }
VOID NtfsCloseFile(FILE *File) LONG NtfsRead(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count)
{ {
PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File; PNTFS_FILE_HANDLE FileHandle = FsGetDeviceSpecific(FileId);
NtfsReleaseAttributeContext(FileHandle->DataContext);
MmHeapFree(FileHandle);
}
BOOLEAN NtfsReadFile(FILE *File, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer)
{
PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
ULONGLONG BytesRead64; ULONGLONG BytesRead64;
BytesRead64 = NtfsReadAttribute(FileHandle->DataContext, FileHandle->Offset, Buffer, BytesToRead);
if (BytesRead64) //
{ // Read file
*BytesRead = (ULONG)BytesRead64; //
FileHandle->Offset += BytesRead64; BytesRead64 = NtfsReadAttribute(FileHandle->DataContext, FileHandle->Offset, Buffer, N);
return TRUE; *Count = (ULONG)BytesRead64;
}
return FALSE; //
// Check for success
//
if (BytesRead64 > 0)
return ESUCCESS;
else
return EIO;
} }
ULONG NtfsGetFileSize(FILE *File) LONG NtfsSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
{ {
PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File; PNTFS_FILE_HANDLE FileHandle = FsGetDeviceSpecific(FileId);
return (ULONG)NtfsGetAttributeSize(&FileHandle->DataContext->Record);
DPRINTM(DPRINT_FILESYSTEM, "NtfsSeek() NewFilePointer = %lu\n", Position->LowPart);
if (SeekMode != SeekAbsolute)
return EINVAL;
if (Position->HighPart != 0)
return EINVAL;
if (Position->LowPart >= (ULONG)NtfsGetAttributeSize(&FileHandle->DataContext->Record))
return EINVAL;
FileHandle->Offset = Position->LowPart;
return ESUCCESS;
} }
VOID NtfsSetFilePointer(FILE *File, ULONG NewFilePointer) const DEVVTBL NtfsFuncTable =
{ {
PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File; NtfsClose,
FileHandle->Offset = NewFilePointer; NtfsGetFileInformation,
} NtfsOpen,
NtfsRead,
ULONG NtfsGetFilePointer(FILE *File) NtfsSeek,
{
PNTFS_FILE_HANDLE FileHandle = (PNTFS_FILE_HANDLE)File;
return FileHandle->Offset;
}
const FS_VTBL NtfsVtbl = {
NtfsOpenVolume,
NtfsOpenFile,
NtfsCloseFile,
NtfsReadFile,
NtfsGetFileSize,
NtfsSetFilePointer,
NtfsGetFilePointer,
}; };
const DEVVTBL* NtfsMount(ULONG DeviceId)
{
NTFS_BOOTSECTOR BootSector;
LARGE_INTEGER Position;
ULONG Count;
LONG ret;
//
// Read the BootSector
//
Position.HighPart = 0;
Position.LowPart = 0;
ret = ArcSeek(DeviceId, &Position, SeekAbsolute);
if (ret != ESUCCESS)
return NULL;
ret = ArcRead(DeviceId, &BootSector, sizeof(BootSector), &Count);
if (ret != ESUCCESS || Count != sizeof(BootSector))
return NULL;
//
// Check if BootSector is valid. If yes, return NTFS function table
//
if (RtlEqualMemory(BootSector.SystemId, "NTFS", 4))
{
//
// Compatibility hack as long as FS is not using underlying device DeviceId
//
ULONG DriveNumber;
ULONGLONG StartSector;
ULONGLONG SectorCount;
int Type;
if (!MachDiskGetBootVolume(&DriveNumber, &StartSector, &SectorCount, &Type))
return NULL;
NtfsOpenVolume(DriveNumber, StartSector, SectorCount);
return &NtfsFuncTable;
}
else
return NULL;
}

1
reactos/boot/freeldr/freeldr/include/arch.h
View file

@ -47,7 +47,6 @@
#define FILESYSBUFFER 0x80000 /* Buffer to store file system data (e.g. cluster buffer for FAT) */ #define FILESYSBUFFER 0x80000 /* Buffer to store file system data (e.g. cluster buffer for FAT) */
#define DISKREADBUFFER 0x90000 /* Buffer to store data read in from the disk via the BIOS */ #define DISKREADBUFFER 0x90000 /* Buffer to store data read in from the disk via the BIOS */
#elif defined(_M_PPC) || defined(_M_MIPS) || defined(_M_ARM) #elif defined(_M_PPC) || defined(_M_MIPS) || defined(_M_ARM)
extern PVOID FsStaticBufferDisk, FsStaticBufferData;
#define DISKREADBUFFER 0x80000000 #define DISKREADBUFFER 0x80000000
#define FILESYSBUFFER 0x80000000 #define FILESYSBUFFER 0x80000000
#endif #endif

4
reactos/boot/freeldr/freeldr/include/disk.h
View file

@ -130,9 +130,7 @@ extern ULONG BootPartition;
BOOLEAN DiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, BOOLEAN DiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector,
PULONGLONG SectorCount, int *FsType); PULONGLONG SectorCount, int *FsType);
BOOLEAN DiskGetSystemVolume(char *SystemPath, char *RemainingPath, BOOLEAN DiskGetSystemVolume(char *SystemPath, char *RemainingPath,
PULONG Device, PULONG DriveNumber, PULONG Device);
PULONGLONG StartSector,
PULONGLONG SectorCount, int *FsType);
BOOLEAN DiskGetBootPath(char *BootPath, unsigned Size); BOOLEAN DiskGetBootPath(char *BootPath, unsigned Size);
VOID DiskGetBootDevice(PULONG BootDevice); VOID DiskGetBootDevice(PULONG BootDevice);
BOOLEAN DiskBootingFromFloppy(VOID); BOOLEAN DiskBootingFromFloppy(VOID);

13
reactos/boot/freeldr/freeldr/include/fs.h
View file

@ -50,8 +50,6 @@ LONG ArcRead(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count);
LONG ArcSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode); LONG ArcSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode);
VOID FileSystemError(PCSTR ErrorString); VOID FileSystemError(PCSTR ErrorString);
BOOLEAN FsOpenBootVolume();
BOOLEAN FsOpenSystemVolume(PCHAR SystemPath, PCHAR RemainingPath, PULONG BootDevice);
PFILE FsOpenFile(PCSTR FileName); PFILE FsOpenFile(PCSTR FileName);
VOID FsCloseFile(PFILE FileHandle); VOID FsCloseFile(PFILE FileHandle);
BOOLEAN FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer); BOOLEAN FsReadFile(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
@ -62,15 +60,4 @@ BOOLEAN FsIsEndOfFile(PFILE FileHandle);
ULONG FsGetNumPathParts(PCSTR Path); ULONG FsGetNumPathParts(PCSTR Path);
VOID FsGetFirstNameFromPath(PCHAR Buffer, PCSTR Path); VOID FsGetFirstNameFromPath(PCHAR Buffer, PCSTR Path);
typedef struct
{
BOOLEAN (*OpenVolume)(UCHAR DriveNumber, ULONGLONG StartSector, ULONGLONG SectorCount);
PFILE (*OpenFile)(PCSTR FileName);
VOID (*CloseFile)(PFILE FileHandle);
BOOLEAN (*ReadFile)(PFILE FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG (*GetFileSize)(PFILE FileHandle);
VOID (*SetFilePointer)(PFILE FileHandle, ULONG NewFilePointer);
ULONG (*GetFilePointer)(PFILE FileHandle);
} FS_VTBL;
#endif // #defined __FS_H #endif // #defined __FS_H

33
reactos/boot/freeldr/freeldr/include/fs/ext2.h
View file

@ -668,37 +668,6 @@ typedef struct
EXT2_INODE Inode; // File's inode EXT2_INODE Inode; // File's inode
} EXT2_FILE_INFO, * PEXT2_FILE_INFO; } EXT2_FILE_INFO, * PEXT2_FILE_INFO;
const DEVVTBL* Ext2Mount(ULONG DeviceId);
BOOLEAN Ext2OpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector, ULONGLONG PartitionSectorCount);
FILE* Ext2OpenFile(PCSTR FileName);
BOOLEAN Ext2LookupFile(PCSTR FileName, PEXT2_FILE_INFO Ext2FileInfoPointer);
BOOLEAN Ext2SearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT2_DIR_ENTRY DirectoryEntry);
BOOLEAN Ext2ReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG Ext2GetFileSize(FILE *FileHandle);
VOID Ext2SetFilePointer(FILE *FileHandle, ULONG NewFilePointer);
ULONG Ext2GetFilePointer(FILE *FileHandle);
BOOLEAN Ext2ReadVolumeSectors(UCHAR DriveNumber, ULONGLONG SectorNumber, ULONGLONG SectorCount, PVOID Buffer);
BOOLEAN Ext2ReadFileBig(FILE *FileHandle, ULONGLONG BytesToRead, ULONGLONG* BytesRead, PVOID Buffer);
BOOLEAN Ext2ReadSuperBlock(VOID);
BOOLEAN Ext2ReadGroupDescriptors(VOID);
BOOLEAN Ext2ReadDirectory(ULONG Inode, PVOID* DirectoryBuffer, PEXT2_INODE InodePointer);
BOOLEAN Ext2ReadBlock(ULONG BlockNumber, PVOID Buffer);
BOOLEAN Ext2ReadPartialBlock(ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
ULONG Ext2GetGroupDescBlockNumber(ULONG Group);
ULONG Ext2GetGroupDescOffsetInBlock(ULONG Group);
ULONG Ext2GetInodeGroupNumber(ULONG Inode);
ULONG Ext2GetInodeBlockNumber(ULONG Inode);
ULONG Ext2GetInodeOffsetInBlock(ULONG Inode);
BOOLEAN Ext2ReadInode(ULONG Inode, PEXT2_INODE InodeBuffer);
BOOLEAN Ext2ReadGroupDescriptor(ULONG Group, PEXT2_GROUP_DESC GroupBuffer);
ULONG* Ext2ReadBlockPointerList(PEXT2_INODE Inode);
ULONGLONG Ext2GetInodeFileSize(PEXT2_INODE Inode);
BOOLEAN Ext2CopyIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock);
BOOLEAN Ext2CopyDoubleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock);
BOOLEAN Ext2CopyTripleIndirectBlockPointers(ULONG* BlockList, ULONG* CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock);
extern const FS_VTBL Ext2Vtbl;
#endif // #defined __EXT2_H #endif // #defined __EXT2_H

24
reactos/boot/freeldr/freeldr/include/fs/fat.h
View file

@ -152,28 +152,6 @@ typedef struct
ULONG DriveNumber; ULONG DriveNumber;
} FAT_FILE_INFO, * PFAT_FILE_INFO; } FAT_FILE_INFO, * PFAT_FILE_INFO;
BOOLEAN FatOpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector, ULONGLONG PartitionSectorCount);
ULONG FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector, ULONG PartitionSectorCount);
PVOID FatBufferDirectory(ULONG DirectoryStartCluster, ULONG* EntryCountPointer, BOOLEAN RootDirectory);
BOOLEAN FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG EntryCount, PCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer);
BOOLEAN FatLookupFile(PCSTR FileName, PFAT_FILE_INFO FatFileInfoPointer);
void FatParseShortFileName(PCHAR Buffer, PDIRENTRY DirEntry);
BOOLEAN FatGetFatEntry(ULONG Cluster, ULONG* ClusterPointer);
FILE* FatOpenFile(PCSTR FileName);
ULONG FatCountClustersInChain(ULONG StartCluster);
ULONG* FatGetClusterChainArray(ULONG StartCluster);
BOOLEAN FatReadCluster(ULONG ClusterNumber, PVOID Buffer);
BOOLEAN FatReadClusterChain(ULONG StartClusterNumber, ULONG NumberOfClusters, PVOID Buffer);
BOOLEAN FatReadPartialCluster(ULONG ClusterNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer);
BOOLEAN FatReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG FatGetFileSize(FILE *FileHandle);
VOID FatSetFilePointer(FILE *FileHandle, ULONG NewFilePointer);
ULONG FatGetFilePointer(FILE *FileHandle);
BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG SectorCount, PVOID Buffer);
#define ATTR_NORMAL 0x00 #define ATTR_NORMAL 0x00
#define ATTR_READONLY 0x01 #define ATTR_READONLY 0x01
#define ATTR_HIDDEN 0x02 #define ATTR_HIDDEN 0x02
@ -191,6 +169,6 @@ BOOLEAN FatReadVolumeSectors(ULONG DriveNumber, ULONG SectorNumber, ULONG Sector
#define ISFATX(FT) ((FT) == FATX16 || (FT) == FATX32) #define ISFATX(FT) ((FT) == FATX16 || (FT) == FATX32)
extern const FS_VTBL FatVtbl; const DEVVTBL* FatMount(ULONG DeviceId);
#endif // #defined __FAT_H #endif // #defined __FAT_H

2
reactos/boot/freeldr/freeldr/include/fs/iso.h
View file

@ -99,8 +99,6 @@ typedef struct
ULONG DriveNumber; ULONG DriveNumber;
} ISO_FILE_INFO, * PISO_FILE_INFO; } ISO_FILE_INFO, * PISO_FILE_INFO;
extern const FS_VTBL Iso9660Vtbl;
const DEVVTBL* IsoMount(ULONG DeviceId); const DEVVTBL* IsoMount(ULONG DeviceId);
#endif // #defined __FAT_H #endif // #defined __FAT_H

10
reactos/boot/freeldr/freeldr/include/fs/ntfs.h
View file

@ -222,14 +222,6 @@ typedef struct
} NTFS_FILE_HANDLE, *PNTFS_FILE_HANDLE; } NTFS_FILE_HANDLE, *PNTFS_FILE_HANDLE;
#include <poppack.h> #include <poppack.h>
BOOLEAN NtfsOpenVolume(UCHAR DriveNumber, ULONGLONG VolumeStartSector, ULONGLONG PartitionSectorCount); const DEVVTBL* NtfsMount(ULONG DeviceId);
FILE* NtfsOpenFile(PCSTR FileName);
VOID NtfsCloseFile(FILE *FileHandle);
BOOLEAN NtfsReadFile(FILE *FileHandle, ULONG BytesToRead, ULONG* BytesRead, PVOID Buffer);
ULONG NtfsGetFileSize(FILE *FileHandle);
VOID NtfsSetFilePointer(FILE *FileHandle, ULONG NewFilePointer);
ULONG NtfsGetFilePointer(FILE *FileHandle);
extern const FS_VTBL NtfsVtbl;
#endif // #defined __NTFS_H #endif // #defined __NTFS_H

10
reactos/boot/freeldr/freeldr/include/machine.h
View file

@ -63,7 +63,7 @@ typedef struct tagMACHVTBL
ULONG (*GetMemoryMap)(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MaxMemoryMapSize); ULONG (*GetMemoryMap)(PBIOS_MEMORY_MAP BiosMemoryMap, ULONG MaxMemoryMapSize);
BOOLEAN (*DiskGetBootVolume)(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType); BOOLEAN (*DiskGetBootVolume)(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType);
BOOLEAN (*DiskGetSystemVolume)(char *SystemPath, char *RemainingPath, PULONG Device, PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG SectorCount, int *FsType); BOOLEAN (*DiskGetSystemVolume)(char *SystemPath, char *RemainingPath, PULONG Device);
BOOLEAN (*DiskGetBootPath)(char *BootPath, unsigned Size); BOOLEAN (*DiskGetBootPath)(char *BootPath, unsigned Size);
VOID (*DiskGetBootDevice)(PULONG BootDevice); VOID (*DiskGetBootDevice)(PULONG BootDevice);
BOOLEAN (*DiskBootingFromFloppy)(VOID); BOOLEAN (*DiskBootingFromFloppy)(VOID);
@ -104,11 +104,7 @@ BOOLEAN MachDiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONG
BOOLEAN BOOLEAN
MachDiskGetSystemVolume(char *SystemPath, MachDiskGetSystemVolume(char *SystemPath,
char *RemainingPath, char *RemainingPath,
PULONG Device, PULONG Device);
PULONG DriveNumber,
PULONGLONG StartSector,
PULONGLONG SectorCount,
int *FsType);
BOOLEAN MachDiskGetBootPath(char *BootPath, unsigned Size); BOOLEAN MachDiskGetBootPath(char *BootPath, unsigned Size);
VOID MachDiskGetBootDevice(PULONG BootDevice); VOID MachDiskGetBootDevice(PULONG BootDevice);
BOOLEAN MachDiskBootingFromFloppy(); BOOLEAN MachDiskBootingFromFloppy();
@ -140,7 +136,7 @@ VOID MachPrepareForReactOS(IN BOOLEAN Setup);
#define MachBeep() MachVtbl.Beep() #define MachBeep() MachVtbl.Beep()
#define MachPrepareForReactOS(a) MachVtbl.PrepareForReactOS(a) #define MachPrepareForReactOS(a) MachVtbl.PrepareForReactOS(a)
#define MachDiskGetBootVolume(Drv, Start, Cnt, FsType) MachVtbl.DiskGetBootVolume((Drv), (Start), (Cnt), (FsType)) #define MachDiskGetBootVolume(Drv, Start, Cnt, FsType) MachVtbl.DiskGetBootVolume((Drv), (Start), (Cnt), (FsType))
#define MachDiskGetSystemVolume(SysPath, RemPath, Dev, Drv, Start, Cnt, FsType) MachVtbl.DiskGetSystemVolume((SysPath), (RemPath), (Dev), (Drv), (Start), (Cnt), (FsType)) #define MachDiskGetSystemVolume(SysPath, RemPath, Dev) MachVtbl.DiskGetSystemVolume((SysPath), (RemPath), (Dev))
#define MachDiskGetBootPath(Path, Size) MachVtbl.DiskGetBootPath((Path), (Size)) #define MachDiskGetBootPath(Path, Size) MachVtbl.DiskGetBootPath((Path), (Size))
#define MachDiskGetBootDevice(BootDevice) MachVtbl.DiskGetBootDevice(BootDevice) #define MachDiskGetBootDevice(BootDevice) MachVtbl.DiskGetBootDevice(BootDevice)
#define MachDiskBootingFromFloppy() MachVtbl.DiskBootingFromFloppy() #define MachDiskBootingFromFloppy() MachVtbl.DiskBootingFromFloppy()

4
reactos/boot/freeldr/freeldr/linuxboot.c
View file

@ -73,9 +73,9 @@ VOID LoadAndBootLinux(PCSTR OperatingSystemName, PCSTR Description)
UiMessageBox("Invalid boot path"); UiMessageBox("Invalid boot path");
goto LinuxBootFailed; goto LinuxBootFailed;
} }
if (!FsOpenSystemVolume(LinuxBootPath, NULL, NULL)) if (!MachDiskGetSystemVolume(LinuxBootPath, NULL, NULL))
{ {
UiMessageBox("Failed to open boot drive."); UiMessageBox("Failed to get system volume.");
goto LinuxBootFailed; goto LinuxBootFailed;
} }

10
reactos/boot/freeldr/freeldr/machine.c
View file

@ -333,15 +333,9 @@ MachDiskGetBootVolume(PULONG DriveNumber, PULONGLONG StartSector, PULONGLONG Sec
BOOLEAN BOOLEAN
MachDiskGetSystemVolume(char *SystemPath, MachDiskGetSystemVolume(char *SystemPath,
char *RemainingPath, char *RemainingPath,
PULONG Device, PULONG Device)
PULONG DriveNumber,
PULONGLONG StartSector,
PULONGLONG SectorCount,
int *FsType)
{ {
return MachVtbl.DiskGetSystemVolume(SystemPath, RemainingPath, Device, return MachVtbl.DiskGetSystemVolume(SystemPath, RemainingPath, Device);
DriveNumber, StartSector, SectorCount,
FsType);
} }
BOOLEAN BOOLEAN

4
reactos/boot/freeldr/freeldr/miscboot.c
View file

@ -51,9 +51,9 @@ VOID LoadAndBootBootSector(PCSTR OperatingSystemName)
return; return;
} }
if (!FsOpenSystemVolume(FileName, FileName, NULL)) if (!MachDiskGetSystemVolume(FileName, FileName, NULL))
{ {
UiMessageBox("Failed to open boot drive."); UiMessageBox("Failed to get system volume.");
return; return;
} }

6
reactos/boot/freeldr/freeldr/reactos/reactos.c
View file

@ -756,11 +756,11 @@ LoadAndBootReactOS(PCSTR OperatingSystemName)
RamDiskSwitchFromBios(); RamDiskSwitchFromBios();
/* /*
* Try to open system drive * Try to get system volume
*/ */
if (!FsOpenSystemVolume(SystemPath, szBootPath, &LoaderBlock.BootDevice)) if (!MachDiskGetSystemVolume(SystemPath, szBootPath, &LoaderBlock.BootDevice))
{ {
UiMessageBox("Failed to open system drive."); UiMessageBox("Failed to get system volume.");
return; return;
} }

14
reactos/boot/freeldr/freeldr/reactos/setupldr.c
View file

@ -119,13 +119,6 @@ VOID LoadReactOSSetup(VOID)
/* set boot device */ /* set boot device */
MachDiskGetBootDevice(&LoaderBlock.BootDevice); MachDiskGetBootDevice(&LoaderBlock.BootDevice);
/* Open boot drive */
if (!FsOpenBootVolume())
{
UiMessageBox("Failed to open boot drive.");
return;
}
UiDrawStatusText("Loading txtsetup.sif..."); UiDrawStatusText("Loading txtsetup.sif...");
/* Open 'txtsetup.sif' */ /* Open 'txtsetup.sif' */
for (i = MachDiskBootingFromFloppy() ? 0 : 1; ; i++) for (i = MachDiskBootingFromFloppy() ? 0 : 1; ; i++)
@ -202,13 +195,6 @@ VOID LoadReactOSSetup(VOID)
{ {
UiMessageBox("Please insert \"ReactOS Boot Disk 2\" and press ENTER"); UiMessageBox("Please insert \"ReactOS Boot Disk 2\" and press ENTER");
/* Open boot drive */
if (!FsOpenBootVolume())
{
UiMessageBox("Failed to open boot drive.");
return;
}
/* FIXME: check volume label or disk marker file */ /* FIXME: check volume label or disk marker file */
} }

3
reactos/boot/freeldr/freeldr/windows/setupldr2.c
View file

@ -186,9 +186,6 @@ VOID LoadReactOSSetup2(VOID)
NULL NULL
}; };
/* Try to open system drive */
FsOpenBootVolume();
/* Open 'txtsetup.sif' from any of source paths */ /* Open 'txtsetup.sif' from any of source paths */
MachDiskGetBootPath(SystemPath, sizeof(SystemPath)); MachDiskGetBootPath(SystemPath, sizeof(SystemPath));
for (i = MachDiskBootingFromFloppy() ? 0 : 1; ; i++) for (i = MachDiskBootingFromFloppy() ? 0 : 1; ; i++)