fs.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tagDEVVTBL

Macros
#define	SECTOR_SIZE   512
#define	MAX_FDS   60
#define	INVALID_FILE_ID   ((ULONG)-1)

Typedefs
typedef struct tagDEVVTBL	DEVVTBL

Functions
ARC_STATUS	ArcOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
ARC_STATUS	ArcClose (_In_ ULONG FileId)
ARC_STATUS	ArcRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
ARC_STATUS	ArcSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
ARC_STATUS	ArcGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
VOID	FileSystemError (PCSTR ErrorString)
ARC_STATUS	FsOpenFile (IN PCSTR FileName, IN PCSTR DefaultPath OPTIONAL, IN OPENMODE OpenMode, OUT PULONG FileId)
ULONG	FsGetNumPathParts (PCSTR Path)
VOID	FsGetFirstNameFromPath (PCHAR Buffer, PCSTR Path)
VOID	FsRegisterDevice (_In_ PCSTR DeviceName, _In_ const DEVVTBL *FuncTable)
PCWSTR	FsGetServiceName (ULONG FileId)
VOID	FsSetDeviceSpecific (ULONG FileId, PVOID Specific)
PVOID	FsGetDeviceSpecific (ULONG FileId)
ULONG	FsGetDeviceId (ULONG FileId)
VOID	FsInit (VOID)

Macro Definition Documentation

INVALID_FILE_ID

#define INVALID_FILE_ID   ((ULONG)-1)

Definition at line 35 of file fs.h.

MAX_FDS

#define MAX_FDS   60

Definition at line 34 of file fs.h.

SECTOR_SIZE

#define SECTOR_SIZE   512

Definition at line 22 of file fs.h.

Typedef Documentation

DEVVTBL

typedef struct tagDEVVTBL DEVVTBL

Function Documentation

ArcClose()

ARC_STATUS ArcClose

(

_In_ ULONG

FileId

)

Definition at line 409 of file fs.c.

{
    ULONG DeviceId;
    DEVICE* pDevice;
 
    if (!IS_VALID_FILEID(FileId))
        return EBADF;
 
    /* Retrieve the parent device's ID if any, for later */
    DeviceId = FileData[FileId].DeviceId;
 
    /* Dereference the file and close it if needed */
    ASSERT(FileData[FileId].ReferenceCount > 0);
    if (--FileData[FileId].ReferenceCount == 0)
    {
        (void)FileData[FileId].FuncTable->Close(FileId);
        FileData[FileId].DeviceId = INVALID_FILE_ID;
        FileData[FileId].FuncTable = NULL;
        FileData[FileId].Specific = NULL;
    }
 
    /* Check whether this file actually references a device */
    pDevice = FsGetDeviceById(FileId);
    if (pDevice)
    {
        /* It does, dereference it */
        ASSERT(pDevice->ReferenceCount > 0);
        if (--pDevice->ReferenceCount == 0)
            pDevice->DeviceId = INVALID_FILE_ID;
    }
 
    /* And dereference the parent device too, if there is one */
    if (IS_VALID_FILEID(DeviceId))
        ArcClose(DeviceId);
 
    return ESUCCESS;
}

Referenced by ArcClose(), InfOpenFile(), IniFileInitialize(), InitOperatingSystemList(), PeLdrLoadImage(), RamDiskLoadVirtualFile(), RegLoadHiveLog(), SpiScanDevice(), WinLdrLoadModule(), WinLdrLoadNLSData(), and WinLdrLoadSystemHive().

ArcGetFileInformation()

ARC_STATUS ArcGetFileInformation	(	ULONG	FileId,
		FILEINFORMATION *	Information
	)

Definition at line 462 of file fs.c.

{
    if (!IS_VALID_FILEID(FileId))
        return EBADF;
    return FileData[FileId].FuncTable->GetFileInformation(FileId, Information);
}

Referenced by FatMount(), InfOpenFile(), IniFileInitialize(), RamDiskLoadVirtualFile(), RegLoadHiveLog(), WinLdrLoadModule(), WinLdrLoadNLSData(), and WinLdrLoadSystemHive().

ArcOpen()

ARC_STATUS ArcOpen	(	CHAR *	Path,
		OPENMODE	OpenMode,
		ULONG *	FileId
	)

Definition at line 219 of file fs.c.

{
    ARC_STATUS Status;
    ULONG i;
    PLIST_ENTRY pEntry;
    DEVICE* pDevice;
    PCHAR DeviceName;
    PSTR FileName;
    SIZE_T Length;
    OPENMODE DeviceOpenMode;
    ULONG DeviceId;
 
    /* Print status message */
    TRACE("Opening file '%s'...\n", Path);
 
    *FileId = INVALID_FILE_ID;
 
    /* Search last ')', which delimits device and path */
    FileName = strrchr(Path, ')');
    if (!FileName)
        return EINVAL;
    ++FileName;
 
    /* Normalize the device name, replacing "()" by "(0)" if necessary */
    Length = FileName - Path;
    DeviceName = NormalizeArcDeviceName(Path, &Length);
    if (!DeviceName)
        return ENOMEM;
 
    if (OpenMode == OpenReadOnly || OpenMode == OpenWriteOnly)
        DeviceOpenMode = OpenMode;
    else
        DeviceOpenMode = OpenReadWrite;
 
    /* Search for the registered device */
    pDevice = NULL;
    for (pEntry = DeviceListHead.Flink;
         pEntry != &DeviceListHead;
         pEntry = pEntry->Flink)
    {
        pDevice = CONTAINING_RECORD(pEntry, DEVICE, ListEntry);
        if (strncmp(pDevice->DeviceName, DeviceName, Length) == 0)
            break;
    }
 
    /* Cleanup */
    if (DeviceName != Path)
        FrLdrTempFree(DeviceName, TAG_DEVICE_NAME);
    DeviceName = NULL;
 
    if (pEntry == &DeviceListHead)
        return ENODEV;
 
    /* OK, device found. Is it already opened? */
    if (pDevice->ReferenceCount == 0)
    {
        /* Find some room for the device */
        for (DeviceId = 0; ; ++DeviceId)
        {
            if (DeviceId >= _countof(FileData))
                return EMFILE;
            if (!FileData[DeviceId].FuncTable)
                break;
        }
 
        /* Try to open the device */
        FileData[DeviceId].ReferenceCount = 0;
        FileData[DeviceId].FuncTable = pDevice->FuncTable;
        Status = pDevice->FuncTable->Open(pDevice->DeviceName, DeviceOpenMode, &DeviceId);
        if (Status != ESUCCESS)
        {
            FileData[DeviceId].FuncTable = NULL;
            return Status;
        }
        pDevice->DeviceId = DeviceId;
    }
    else
    {
        /* Reuse the existing entry */
        DeviceId = pDevice->DeviceId;
        ASSERT(FileData[DeviceId].FuncTable == pDevice->FuncTable);
    }
 
    /* Done, increase the device reference count */
    pDevice->ReferenceCount++;
    FileData[DeviceId].ReferenceCount++;
 
    if (!*FileName)
    {
        /* The caller wanted to open the raw device: return its ID */
        *FileId = DeviceId;
        return ESUCCESS;
    }
 
 
    /*
     * We are opening a file.
     */
 
    /* Find some room for the file */
    for (i = 0; ; ++i)
    {
        if (i >= _countof(FileData))
        {
            Status = EMFILE;
            goto Done;
        }
        if (!FileData[i].FuncTable)
            break;
    }
 
    /* The device is accessed using filesystem semantics.
     * Try to detect the file system if not already done. */
    if (!pDevice->FileFuncTable && (pDevice->ReferenceCount <= 1))
    {
        for (ULONG fs = 0; fs < _countof(FileSystems); ++fs)
        {
            pDevice->FileFuncTable = FileSystems[fs](DeviceId);
            if (pDevice->FileFuncTable)
                break;
        }
    }
    if (!pDevice->FileFuncTable)
    {
        /* Error, unable to detect the file system */
        Status = ENOENT; // ENXIO;
        goto Done;
    }
 
    /*
     * At this point, the device is found and opened. Its file ID is stored
     * in DeviceId, and pDevice->FileFuncTable contains what needs to be
     * called to manipulate the file.
     */
 
    /* Open the file */
    FileData[i].DeviceId = DeviceId;
    FileData[i].ReferenceCount = 0;
    FileData[i].FuncTable = pDevice->FileFuncTable;
    *FileId = i;
    Status = FileData[i].FuncTable->Open(FileName, OpenMode, FileId);
    if (Status != ESUCCESS)
    {
        FileData[i].DeviceId = INVALID_FILE_ID;
        FileData[i].FuncTable = NULL;
        FileData[i].Specific = NULL;
        *FileId = INVALID_FILE_ID;
    }
    else
    {
        /* Reference the file */
        FileData[i].ReferenceCount++;
    }
 
Done:
    /* If we failed somewhere, dereference the device as well */
    if (Status != ESUCCESS)
    {
        // ArcClose(DeviceId);
        if (--FileData[DeviceId].ReferenceCount == 0)
        {
            (void)FileData[DeviceId].FuncTable->Close(DeviceId);
            FileData[DeviceId].DeviceId = INVALID_FILE_ID;
            FileData[DeviceId].FuncTable = NULL;
            FileData[DeviceId].Specific = NULL;
        }
        if (--pDevice->ReferenceCount == 0)
            pDevice->DeviceId = INVALID_FILE_ID;
    }
 
    return Status;
}

Referenced by FsOpenFile(), InfOpenFile(), InitOperatingSystemList(), PeLdrLoadImage(), RegLoadHiveLog(), SpiScanDevice(), WinLdrLoadModule(), WinLdrLoadNLSData(), and WinLdrLoadSystemHive().

ArcRead()

ARC_STATUS ArcRead	(	ULONG	FileId,
		VOID *	Buffer,
		ULONG	N,
		ULONG *	Count
	)

Definition at line 448 of file fs.c.

{
    if (!IS_VALID_FILEID(FileId))
        return EBADF;
    return FileData[FileId].FuncTable->Read(FileId, Buffer, N, Count);
}

Referenced by disk_read(), Ext2Mount(), Ext2ReadSuperBlock(), Ext2ReadVolumeSectors(), FatMount(), FatReadVolumeSectors(), InfOpenFile(), IniFileInitialize(), IopReadBootRecord(), IsoBufferDirectory(), IsoLookupFile(), IsoMount(), IsoRead(), NtfsDiskRead(), NtfsMount(), PeLdrLoadImage(), RamDiskLoadVirtualFile(), RegLoadHiveLog(), WinLdrLoadModule(), WinLdrLoadNLSData(), and WinLdrLoadSystemHive().

ArcSeek()

ARC_STATUS ArcSeek	(	ULONG	FileId,
		LARGE_INTEGER *	Position,
		SEEKMODE	SeekMode
	)

Definition at line 455 of file fs.c.

{
    if (!IS_VALID_FILEID(FileId))
        return EBADF;
    return FileData[FileId].FuncTable->Seek(FileId, Position, SeekMode);
}

Referenced by disk_read(), Ext2Mount(), Ext2ReadSuperBlock(), Ext2ReadVolumeSectors(), FatMount(), FatReadVolumeSectors(), IopReadBootRecord(), IsoBufferDirectory(), IsoLookupFile(), IsoMount(), IsoRead(), NtfsDiskRead(), NtfsMount(), PeLdrLoadImage(), RamDiskLoadVirtualFile(), and RegLoadHiveLog().

FileSystemError()

VOID FileSystemError

(

PCSTR

ErrorString

)

Definition at line 471 of file fs.c.

{
    ERR("%s\n", ErrorString);
    UiMessageBox(ErrorString);
}

Referenced by Ext2LookupFile(), Ext2ReadBlock(), Ext2ReadDirectory(), Ext2ReadFileBig(), Ext2ReadGroupDescriptors(), Ext2ReadInode(), Ext2ReadSuperBlock(), Ext2SearchDirectoryBufferForFile(), FatOpenVolume(), and NtfsMount().

FsGetDeviceId()

ULONG FsGetDeviceId

(

ULONG

FileId

)

Definition at line 639 of file fs.c.

{
    if (FileId >= _countof(FileData)) // !IS_VALID_FILEID(FileId)
        return INVALID_FILE_ID;
    return FileData[FileId].DeviceId;
}

Referenced by BtrFsOpen(), Ext2Open(), FatOpen(), IsoOpen(), IsoRead(), and NtfsOpen().

FsGetDeviceSpecific()

PVOID FsGetDeviceSpecific

(

ULONG

FileId

)

Definition at line 632 of file fs.c.

{
    if (!IS_VALID_FILEID(FileId))
        return NULL;
    return FileData[FileId].Specific;
}

Referenced by BtrFsClose(), BtrFsGetFileInformation(), BtrFsRead(), BtrFsSeek(), DiskClose(), DiskGetFileInformation(), DiskRead(), DiskSeek(), Ext2Close(), Ext2GetFileInformation(), Ext2Read(), Ext2Seek(), FatClose(), FatGetFileInformation(), FatRead(), FatSeek(), IsoClose(), IsoGetFileInformation(), IsoRead(), IsoSeek(), NtfsClose(), NtfsGetFileInformation(), NtfsRead(), NtfsSeek(), UefiDiskClose(), UefiDiskGetFileInformation(), UefiDiskRead(), and UefiDiskSeek().

FsGetFirstNameFromPath()

VOID FsGetFirstNameFromPath	(	PCHAR	Buffer,
		PCSTR	Path
	)

Definition at line 568 of file fs.c.

{
    size_t i;
    size_t len;
 
    len = strlen(Path);
 
    // Copy all the characters up to the end of the
    // string or until we hit a '\' character
    // and put them in Buffer
    for (i = 0; i < len; i++)
    {
        if ((Path[i] == '\\') || (Path[i] == '/'))
        {
            break;
        }
        else
        {
            Buffer[i] = Path[i];
        }
    }
 
    Buffer[i] = 0;
 
    TRACE("FsGetFirstNameFromPath() Path = %s FirstName = %s\n", Path, Buffer);
}

Referenced by Ext2LookupFile(), FatLookupFile(), IsoLookupFile(), and NtfsLookupFile().

FsGetNumPathParts()

ULONG FsGetNumPathParts

(

PCSTR

Path

)

Definition at line 540 of file fs.c.

{
    size_t i;
    size_t len;
    ULONG  num;
 
    len = strlen(Path);
 
    for (i = 0, num = 0; i < len; i++)
    {
        if ((Path[i] == '\\') || (Path[i] == '/'))
        {
            num++;
        }
    }
    num++;
 
    TRACE("FsGetNumPathParts() Path = %s NumPathParts = %d\n", Path, num);
 
    return num;
}

Referenced by Ext2LookupFile(), FatLookupFile(), IsoLookupFile(), and NtfsLookupFile().

FsGetServiceName()

PCWSTR FsGetServiceName

(

ULONG

FileId

)

Definition at line 618 of file fs.c.

{
    if (!IS_VALID_FILEID(FileId))
        return NULL;
    return FileData[FileId].FuncTable->ServiceName;
}

Referenced by WinLdrLoadSystemHive().

FsInit()

VOID FsInit

(

VOID

)

Definition at line 646 of file fs.c.

{
    ULONG i;
 
    RtlZeroMemory(FileData, sizeof(FileData));
    for (i = 0; i < _countof(FileData); ++i)
        FileData[i].DeviceId = INVALID_FILE_ID;
 
    InitializeListHead(&DeviceListHead);
}

Referenced by BootMain(), and EfiEntry().

FsOpenFile()

ARC_STATUS FsOpenFile	(	IN PCSTR	FileName,
		IN PCSTR DefaultPath	OPTIONAL,
		IN OPENMODE	OpenMode,
		OUT PULONG	FileId
	)

Definition at line 478 of file fs.c.

{
    NTSTATUS Status;
    SIZE_T cchPathLen;
    CHAR FullPath[MAX_PATH] = "";
 
    /*
     * Check whether FileName is a full path and if not, create a full
     * file name using the user-provided default path (if present).
     *
     * See ArcOpen(): Search last ')', which delimits device and path.
     */
    if (strrchr(FileName, ')') == NULL)
    {
        /* This is not a full path: prepend the user-provided default path */
        if (DefaultPath)
        {
            Status = RtlStringCbCopyA(FullPath, sizeof(FullPath), DefaultPath);
            if (!NT_SUCCESS(Status))
                return ENAMETOOLONG;
        }
 
        /* Append a path separator if needed */
 
        cchPathLen = min(sizeof(FullPath)/sizeof(CHAR), strlen(FullPath));
        if (cchPathLen >= sizeof(FullPath)/sizeof(CHAR))
            return ENAMETOOLONG;
 
        if ((*FileName != '\\' && *FileName != '/') &&
            cchPathLen > 0 && (FullPath[cchPathLen-1] != '\\' && FullPath[cchPathLen-1] != '/'))
        {
            /* FileName does not start with '\' and FullPath does not end with '\' */
            Status = RtlStringCbCatA(FullPath, sizeof(FullPath), "\\");
            if (!NT_SUCCESS(Status))
                return ENAMETOOLONG;
        }
        else if ((*FileName == '\\' || *FileName == '/') &&
                 cchPathLen > 0 && (FullPath[cchPathLen-1] == '\\' || FullPath[cchPathLen-1] == '/'))
        {
            /* FileName starts with '\' and FullPath ends with '\' */
            while (*FileName == '\\' || *FileName == '/')
                ++FileName; // Skip any backslash
        }
    }
    /* Append (or just copy) the remaining file name */
    Status = RtlStringCbCatA(FullPath, sizeof(FullPath), FileName);
    if (!NT_SUCCESS(Status))
        return ENAMETOOLONG;
 
    /* Open the file */
    return ArcOpen(FullPath, OpenMode, FileId);
}

Referenced by IniFileInitialize(), and RamDiskLoadVirtualFile().

FsRegisterDevice()

VOID FsRegisterDevice	(	_In_ PCSTR	DeviceName,
		_In_ const DEVVTBL *	FuncTable
	)

Definition at line 596 of file fs.c.

{
    DEVICE* pNewEntry;
    SIZE_T Length;
 
    TRACE("FsRegisterDevice(%s)\n", DeviceName);
 
    Length = strlen(DeviceName) + 1;
    pNewEntry = FrLdrTempAlloc(sizeof(DEVICE) + Length, TAG_DEVICE);
    if (!pNewEntry)
        return;
    pNewEntry->FuncTable = FuncTable;
    pNewEntry->DeviceId = INVALID_FILE_ID;
    pNewEntry->ReferenceCount = 0;
    pNewEntry->DeviceName = (PSTR)(pNewEntry + 1);
    RtlCopyMemory(pNewEntry->DeviceName, DeviceName, Length);
 
    InsertHeadList(&DeviceListHead, &pNewEntry->ListEntry);
}

Referenced by GetHarddiskInformation(), PcInitializeBootDevices(), PxeInit(), RamDiskInitialize(), SpiScanAdapter(), SpiScanDevice(), and UefiInitializeBootDevices().

FsSetDeviceSpecific()

VOID FsSetDeviceSpecific	(	ULONG	FileId,
		PVOID	Specific
	)

Definition at line 625 of file fs.c.

{
    if (!IS_VALID_FILEID(FileId))
        return;
    FileData[FileId].Specific = Specific;
}

Referenced by BtrFsOpen(), DiskOpen(), Ext2Open(), FatOpen(), IsoOpen(), NtfsOpen(), and UefiDiskOpen().