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)
ARC_STATUS	FsGetVolumeSize (_In_ ULONG DeviceId, _Out_ PULONGLONG VolumeSize)
	Returns the (useful) size of a file-system volume laid on the storage media device opened via DeviceId.
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(), PeLdrLoadImageEx(), 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 ((strlen(pDevice->DeviceName) == Length) && (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(), PeLdrLoadImageEx(), 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(), ExtMount(), ExtReadSuperBlock(), ExtReadVolumeSectors(), FatMount(), FatReadVolumeSectors(), InfOpenFile(), IniFileInitialize(), IopReadBootRecord(), IsoBufferDirectory(), IsoMount(), IsoRead(), NtfsDiskRead(), NtfsMount(), PeLdrLoadImageEx(), 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(), ExtMount(), ExtReadSuperBlock(), ExtReadVolumeSectors(), FatMount(), FatReadVolumeSectors(), IopReadBootRecord(), IsoBufferDirectory(), IsoMount(), IsoRead(), NtfsDiskRead(), NtfsMount(), PeLdrLoadImageEx(), RamDiskLoadVirtualFile(), and RegLoadHiveLog().

FileSystemError()

VOID FileSystemError

(

PCSTR

ErrorString

)

Definition at line 471 of file fs.c.

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

Referenced by ExtLookupFile(), ExtReadBlock(), ExtReadDirectory(), ExtReadFileBig(), ExtReadGroupDescriptors(), ExtReadInode(), ExtReadSuperBlock(), ExtSearchDirectoryBufferForFile(), FatOpenVolume(), and NtfsMount().

FsGetDeviceId()

ULONG FsGetDeviceId

(

ULONG

FileId

)

Definition at line 716 of file fs.c.

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

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

FsGetDeviceSpecific()

PVOID FsGetDeviceSpecific

(

ULONG

FileId

)

Definition at line 709 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(), ExtClose(), ExtGetFileInformation(), ExtRead(), ExtSeek(), 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 645 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 ExtLookupFile(), FatLookupFile(), IsoLookupFile(), and NtfsLookupFile().

FsGetNumPathParts()

ULONG FsGetNumPathParts

(

PCSTR

Path

)

Definition at line 617 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 ExtLookupFile(), FatLookupFile(), IsoLookupFile(), and NtfsLookupFile().

FsGetServiceName()

PCWSTR FsGetServiceName

(

ULONG

FileId

)

Definition at line 695 of file fs.c.

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

Referenced by WinLdrLoadSystemHive().

FsGetVolumeSize()

ARC_STATUS FsGetVolumeSize	(	_In_ ULONG	DeviceId,
		_Out_ PULONGLONG	VolumeSize
	)

Returns the (useful) size of a file-system volume laid on the storage media device opened via DeviceId.

Definition at line 541 of file fs.c.

{
    DEVICE* pDevice;
    const DEVVTBL* FuncTable;
    PCWSTR ServiceName;
    ULONGLONG (*pFsGetVolumeSize)(_In_ ULONG DeviceId);
 
    /* Check whether this file actually references a device */
    pDevice = FsGetDeviceById(DeviceId);
    if (!pDevice)
        return EBADF; /* It doesn't, fail */
 
    *VolumeSize = 0;
 
    // TODO: Mount the device, if not already done?
#if 1 // FIXME: TEMP HACK!
    if (!pDevice->FileFuncTable && (pDevice->ReferenceCount <= 1))
    {
        for (ULONG fs = 0; fs < _countof(FileSystems); ++fs)
        {
            pDevice->FileFuncTable = FileSystems[fs](DeviceId);
            if (pDevice->FileFuncTable)
                break;
        }
    }
#endif
    // TODO: Use a virtual table function member for easily handling other file systems.
 
    /* Check that the device is mounted (non-NULL FileFuncTable)
     * and there is an associated "service" (file-system) name. */
    FuncTable = pDevice->FileFuncTable;
    ServiceName = (FuncTable && FuncTable->ServiceName)
                    ? FuncTable->ServiceName : NULL;
    if (!ServiceName)
    {
        ERR("Non-mounted device %lu\n", DeviceId);
        return ENXIO;
    }
 
    /* HACK: Since we don't currently use a virtual table function member,
     * we instead do a manual lookup over the file-system name.
     * The ordering follows that of the FileSystems[] table. */
#ifndef _M_ARM
    if (!_wcsicmp(ServiceName, L"cdfs"))
        pFsGetVolumeSize = IsoGetVolumeSize;
    else
#endif
    if (!_wcsicmp(ServiceName, L"fastfat") || !_wcsicmp(ServiceName, L"vfatfs"))
        pFsGetVolumeSize = FatGetVolumeSize;
    else
    if (!_wcsicmp(ServiceName, L"btrfs"))
        pFsGetVolumeSize = BtrFsGetVolumeSize;
    else
#ifndef _M_ARM
    if (!_wcsicmp(ServiceName, L"ntfs"))
        pFsGetVolumeSize = NtfsGetVolumeSize;
    else
    if (!_wcsicmp(ServiceName, L"ext2fs"))
        pFsGetVolumeSize = ExtGetVolumeSize;
    else
#endif
    {
        ERR("Unsupported file system '%S' on storage device %lu\n", ServiceName, DeviceId);
        return EIO; // ENXIO;
    }
    *VolumeSize = pFsGetVolumeSize(DeviceId);
    return ESUCCESS;
}

Referenced by RamDiskLoadVirtualFile().

FsInit()

VOID FsInit

(

VOID

)

Definition at line 723 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 673 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 702 of file fs.c.

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

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