file.c File Reference

#include "bl.h"

Include dependency graph for file.c:

Go to the source code of this file.

Macros
#define	BL_FILE_PURGE_LIMIT   512

Functions
PWCHAR	FileIoCopyParentDirectoryPath (_In_ PWCHAR FilePath)
PWCHAR	FileIoCopyFileName (_In_ PWCHAR FilePath)
BOOLEAN	FileTableCompareWithSubsetAttributes (_In_ PVOID Entry, _In_ PVOID Argument1, _In_ PVOID Argument2, _In_ PVOID Argument3, _In_ PVOID Argument4)
BOOLEAN	FileTableCompareWithSameAttributes (_In_ PVOID Entry, _In_ PVOID Argument1, _In_ PVOID Argument2, _In_ PVOID Argument3, _In_ PVOID Argument4)
NTSTATUS	FileTableDestroyEntry (_In_ PBL_FILE_ENTRY FileEntry, _In_ ULONG Index)
NTSTATUS	FileTablePurgeEntry (_In_ PVOID Entry)
NTSTATUS	BlFileClose (_In_ ULONG FileId)
NTSTATUS	FileIoOpen (_In_ ULONG DeviceId, _In_ PWCHAR FileName, _In_ ULONG Flags, _In_ ULONG Unknown, _In_ PBL_TBL_LOOKUP_ROUTINE CompareRoutine, _Out_opt_ PBL_FILE_ENTRY *NewFileEntry)
NTSTATUS	BlFileOpen (_In_ ULONG DeviceId, _In_ PWCHAR FileName, _In_ ULONG Flags, _Out_ PULONG FileId)
NTSTATUS	BlFileSetInformation (_In_ ULONG FileId, _Out_ PBL_FILE_INFORMATION FileInfo)
NTSTATUS	BlFileGetInformation (_In_ ULONG FileId, _In_ PBL_FILE_INFORMATION FileInfo)
NTSTATUS	FileInformationCheck (_In_ PBL_FILE_INFORMATION FileInformation, _In_ BOOLEAN Write, _In_opt_ PULONG InputSize, _In_opt_ PULONG BytesReturned, _Out_opt_ PULONG RequiredSize)
NTSTATUS	BlFileReadEx (_In_ ULONG FileId, _Out_ PVOID Buffer, _In_ ULONG Size, _Out_ PULONG BytesReturned, _In_ ULONG Flags)
NTSTATUS	BlFileReadAtOffsetEx (_In_ ULONG FileId, _In_ ULONG Size, _In_ ULONGLONG ByteOffset, _In_ PVOID Buffer, _Out_ PULONG BytesReturned, _In_ ULONG Flags)
NTSTATUS	BlpFileRegisterFileSystem (_In_ PBL_FS_INIT_CALLBACK InitCallback, _In_ PBL_FS_DESTROY_CALLBACK DestroyCallback, _In_ PBL_FS_MOUNT_CALLBACK MountCallback, _In_ PBL_FS_PURGE_CALLBACK PurgeCallback, _In_ ULONG Flags)
NTSTATUS	BlpFileInitialize (VOID)

Variables
PVOID *	FileTable
ULONG	FileEntries
LIST_ENTRY	RegisteredFileSystems
BL_FILE_SYSTEM_REGISTRATION_TABLE	FatRegisterFunctionTable
BL_FILE_SYSTEM_REGISTRATION_TABLE	EtfsRegisterFunctionTable
ULONG	DmTableEntries
PVOID *	DmDeviceTable

Macro Definition Documentation

BL_FILE_PURGE_LIMIT

#define BL_FILE_PURGE_LIMIT   512

Definition at line 198 of file file.c.

Function Documentation

BlFileClose()

NTSTATUS BlFileClose

(

_In_ ULONG

FileId

)

Definition at line 220 of file file.c.

{
    PBL_FILE_ENTRY FileEntry;
 
    /* Validate the file ID */
    if (FileEntries <= FileId)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure a file entry actually exists */
    FileEntry = FileTable[FileId];
    if (!FileEntry)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* And that it's actually open */
    if (!(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Drop a reference, check if this was the last one */
    --FileEntry->ReferenceCount;
    if (!FileEntry->ReferenceCount)
    {
        /* File is no longer open */
        FileEntry->Flags &= ~BL_FILE_ENTRY_OPENED;
    }
 
    /* All good */
    return STATUS_SUCCESS;
}

Referenced by BlBsdInitializeLog(), BmFwInitializeBootDirectoryPath(), FileIoOpen(), and ImgpCloseFile().

BlFileGetInformation()

NTSTATUS BlFileGetInformation	(	_In_ ULONG	FileId,
		_In_ PBL_FILE_INFORMATION	FileInfo
	)

Definition at line 564 of file file.c.

{
    PBL_FILE_ENTRY FileEntry;
 
    /* Make sure caller passed this in */
    if (!FileInfo)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validate file ID */
    if (FileId > FileEntries)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure an opened file exits with this ID */
    FileEntry = FileTable[FileId];
    if (!(FileEntry) || !(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Do the I/O operation */
    return FileEntry->Callbacks.GetInfo(FileEntry, FileInfo);
}

Referenced by BlFileReadAtOffsetEx(), BlFileReadEx(), and ImgpGetFileSize().

BlFileOpen()

NTSTATUS BlFileOpen	(	_In_ ULONG	DeviceId,
		_In_ PWCHAR	FileName,
		_In_ ULONG	Flags,
		_Out_ PULONG	FileId
	)

Definition at line 477 of file file.c.

{
    NTSTATUS Status;
    PBL_FILE_ENTRY FileEntry;
    BL_DEVICE_INFORMATION DeviceInformation;
 
    /* Make sure we have a valid file name, access flags and parameters */
    if (!(FileName) ||
        (*FileName != OBJ_NAME_PATH_SEPARATOR) ||
        !(FileId) ||
        !(Flags & (BL_FILE_READ_ACCESS | BL_FILE_WRITE_ACCESS)))
    {
        EfiPrintf(L"Invalid file options\r\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get information on the underlying device */
    Status = BlDeviceGetInformation(DeviceId, &DeviceInformation);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Get device info failed: %lx\r\n", Status);
        return Status;
    }
 
    /* Make sure it's a device that can host files */
    if ((DeviceInformation.DeviceType != DiskDevice) &&
        (DeviceInformation.DeviceType != LegacyPartitionDevice) &&
        (DeviceInformation.DeviceType != UdpDevice))
    {
        EfiPrintf(L"Invalid device type\r\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Open a file on this device, creating one if needed */
    Status = FileIoOpen(DeviceId,
                        FileName,
                        Flags,
                        0,
                        FileTableCompareWithSameAttributes,
                        &FileEntry);
    if (NT_SUCCESS(Status))
    {
        /* Return the file ID back to the caller */
        *FileId = FileEntry->FileId;
    }
 
    /* All good */
    return Status;
}

Referenced by BlBsdInitializeLog(), BmFwInitializeBootDirectoryPath(), and ImgpOpenFile().

BlFileReadAtOffsetEx()

NTSTATUS BlFileReadAtOffsetEx	(	_In_ ULONG	FileId,
		_In_ ULONG	Size,
		_In_ ULONGLONG	ByteOffset,
		_In_ PVOID	Buffer,
		_Out_ PULONG	BytesReturned,
		_In_ ULONG	Flags
	)

Definition at line 788 of file file.c.

{
    NTSTATUS Status;
    BL_FILE_INFORMATION FileInfo;
    ULONG RequiredSize;
    ULONGLONG FileOffset;
 
    /* Get information on the specified file */
    Status = BlFileGetInformation(FileId, &FileInfo);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Save the current offset, and overwrite it with the one we want */
    FileOffset = FileInfo.Offset;
    FileInfo.Offset = ByteOffset;
 
    /* Check the validity of the read and the actual size to read */
    RequiredSize = Size;
    Status = FileInformationCheck(&FileInfo,
                                  FALSE,
                                  &RequiredSize,
                                  BytesReturned,
                                  &RequiredSize);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out if the read is invalid */
        EfiPrintf(L"File info check failure: %lx\r\n", Status);
        return Status;
    }
 
    /* Check if the offset we're requesting is not the current offset */
    if (FileInfo.Offset != FileOffset)
    {
        /* Set the new offset to use */
        Status = BlFileSetInformation(FileId, &FileInfo);
        if (!NT_SUCCESS(Status))
        {
            /* Can't do much if that failed */
            return Status;
        }
    }
 
    /* Do the read at the required offset now */
    Status = BlFileReadEx(FileId,
                          Buffer,
                          RequiredSize,
                          BytesReturned,
                          Flags);
    if (!NT_SUCCESS(Status))
    {
        /* The read failed -- had we modified the offset? */
        if (FileInfo.Offset != FileOffset)
        {
            /* Restore the offset back to its original value */
            FileInfo.Offset = FileOffset;
            BlFileSetInformation(FileId, &FileInfo);
        }
    }
 
    /* Return the status of the read */
    return Status;
}

Referenced by ImgpReadAtFileOffset().

BlFileReadEx()

NTSTATUS BlFileReadEx	(	_In_ ULONG	FileId,
		_Out_ PVOID	Buffer,
		_In_ ULONG	Size,
		_Out_ PULONG	BytesReturned,
		_In_ ULONG	Flags
	)

Definition at line 655 of file file.c.

{
    PBL_FILE_ENTRY FileEntry;
    NTSTATUS Status;
    ULONG OldUnknown, RequiredSize;
    BOOLEAN ChangedUnknown;
    BL_DEVICE_INFORMATION DeviceInfo;
    BL_FILE_INFORMATION fileInfo;
 
    /* Initialize variables */
    RtlZeroMemory(&DeviceInfo, sizeof(DeviceInfo));
    OldUnknown = 0;
    ChangedUnknown = FALSE;
 
    /* Bail out if there's no buffer */
    if (!Buffer)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Bail out of the file ID is invalid */
    if (FileId > FileEntries)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Bail out if there's no file opened for read access */
    FileEntry = FileTable[FileId];
    if (!(FileEntry) ||
        !(FileEntry->Flags & (BL_FILE_ENTRY_OPENED | BL_FILE_ENTRY_READ_ACCESS)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Bail out if we can't read the file's information */
    Status = BlFileGetInformation(FileId, &fileInfo);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Ensure the read attempt is valid, and fix up the size if needed */
    RequiredSize = Size;
    Status = FileInformationCheck(&fileInfo,
                                  FALSE,
                                  &RequiredSize,
                                  BytesReturned,
                                  &RequiredSize);
    if (!NT_SUCCESS(Status))
    {
        /* Invalid or illegal read attempt */
        return Status;
    }
 
    /* Is there anything left to read after all? */
    if (RequiredSize)
    {
        /* Check if flags 2 or 4 are set */
        if ((Flags & 2) || (Flags & 4))
        {
            /* Check if this is a disk or partition device */
            BlDeviceGetInformation(FileEntry->DeviceId, &DeviceInfo);
            if ((DeviceInfo.DeviceType == DiskDevice) ||
                (DeviceInfo.DeviceType == LegacyPartitionDevice))
            {
                /* Check if request flags are incompatible with device flags */
                if ((!(DeviceInfo.BlockDeviceInfo.Unknown & 1) && (Flags & 2)) ||
                    (!(DeviceInfo.BlockDeviceInfo.Unknown & 2) && (Flags & 4)))
                {
                    /* We're going to change the device flags */
                    ChangedUnknown = TRUE;
 
                    /* Set unknown flag 1 for request flag 2 */
                    if (Flags & 2)
                    {
                        DeviceInfo.BlockDeviceInfo.Unknown |= 1;
                    }
 
                    /* Set unknown flag 2 for request flag 4 */
                    if (Flags & 4)
                    {
                        DeviceInfo.BlockDeviceInfo.Unknown |= 2;
                    }
 
                    /* Save the new device flags */
                    BlDeviceSetInformation(FileEntry->DeviceId, &DeviceInfo);
                }
            }
        }
 
        /* Issue the read to the underlying file system */
        Status = FileEntry->Callbacks.Read(FileEntry,
                                           Buffer,
                                           RequiredSize,
                                           BytesReturned);
        if (!NT_SUCCESS(Status))
        {
            /* Don't update the bytes read on failure */
            RequiredSize = 0;
        }
    }
    else
    {
        /* There's nothing to do, return success and 0 bytes */
        Status = STATUS_SUCCESS;
        if (BytesReturned)
        {
            *BytesReturned = 0;
        }
    }
 
    /* Increment the number of bytes read */
    FileEntry->TotalBytesRead += RequiredSize;
 
    /* Check if the unknown flag on the device was changed during this routine */
    if (ChangedUnknown)
    {
        /* Reset it back to its original value */
        DeviceInfo.BlockDeviceInfo.Unknown = OldUnknown;
        BlDeviceSetInformation(FileEntry->DeviceId, &DeviceInfo);
    }
 
    /* Return the final status */
    return Status;
}

Referenced by BlFileReadAtOffsetEx().

BlFileSetInformation()

NTSTATUS BlFileSetInformation	(	_In_ ULONG	FileId,
		_Out_ PBL_FILE_INFORMATION	FileInfo
	)

Definition at line 533 of file file.c.

{
    PBL_FILE_ENTRY FileEntry;
 
    /* Make sure caller passed this in */
    if (!FileInfo)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validate file ID */
    if (FileId > FileEntries)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure an opened file exits with this ID */
    FileEntry = FileTable[FileId];
    if (!(FileEntry) || !(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Do the I/O operation */
    return FileEntry->Callbacks.SetInfo(FileEntry, FileInfo);
}

Referenced by BlFileReadAtOffsetEx().

BlpFileInitialize()

NTSTATUS BlpFileInitialize

(

VOID

)

Definition at line 908 of file file.c.

{
    NTSTATUS Status;
 
    /* Allocate the file table */
    FileEntries = 16;
    FileTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) * FileEntries);
    if (!FileTable)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Initialize it */
    RtlZeroMemory(FileTable, sizeof(PBL_FILE_ENTRY) * FileEntries);
    InitializeListHead(&RegisteredFileSystems);
 
#if 0
    /* Initialize the network file system */
    Status = BlpFileRegisterFileSystem(NetRegisterFunctionTable.Init,
                                       NetRegisterFunctionTable.Destroy,
                                       NetRegisterFunctionTable.Mount,
                                       NetRegisterFunctionTable.Purge,
                                       1);
    if (NT_SUCCESS(Status))
    {
        /* Initialize NTFS */
        Status = BlpFileRegisterFileSystem(NtfsRegisterFunctionTable.Init,
                                           NtfsRegisterFunctionTable.Destroy,
                                           NtfsRegisterFunctionTable.Mount,
                                           NtfsRegisterFunctionTable.Purge,
                                           0);
    }
 
    if (NT_SUCCESS(Status))
#endif
    {
        /* Initialize FAT */
        Status = BlpFileRegisterFileSystem(FatRegisterFunctionTable.Init,
                                           FatRegisterFunctionTable.Destroy,
                                           FatRegisterFunctionTable.Mount,
                                           FatRegisterFunctionTable.Purge,
                                           0);
    }
 
#if 0
    if (NT_SUCCESS(Status))
    {
        /* Initialize EXFAT (FatPlus) */
        Status = BlpFileRegisterFileSystem(FppRegisterFunctionTable.Init,
                                           FppRegisterFunctionTable.Destroy,
                                           FppRegisterFunctionTable.Mount,
                                           FppRegisterFunctionTable.Purge,
                                           0);
    }
 
    if (NT_SUCCESS(Status))
    {
        /* Initialize WIM */
        Status = BlpFileRegisterFileSystem(WimRegisterFunctionTable.Init,
                                           WimRegisterFunctionTable.Destroy,
                                           WimRegisterFunctionTable.Mount,
                                           WimRegisterFunctionTable.Purge,
                                           0);
    }
 
    if (NT_SUCCESS(Status))
    {
        /* Initialize UDFS */
        Status = BlpFileRegisterFileSystem(UdfsRegisterFunctionTable.Init,
                                           UdfsRegisterFunctionTable.Destroy,
                                           UdfsRegisterFunctionTable.Mount,
                                           UdfsRegisterFunctionTable.Purge,
                                           0);
    }
#endif
    if (NT_SUCCESS(Status))
    {
        /* Initialize El-Torito CDFS */
        Status = BlpFileRegisterFileSystem(EtfsRegisterFunctionTable.Init,
                                           EtfsRegisterFunctionTable.Destroy,
                                           EtfsRegisterFunctionTable.Mount,
                                           EtfsRegisterFunctionTable.Purge,
                                           0);
    }
 
    /* Destroy the file manager if any of the file systems didn't initialize */
    if (!NT_SUCCESS(Status))
    {
        if (FileTable)
        {
            //BlpFileDestroy();
        }
    }
    return Status;
}

Referenced by BlpIoInitialize().

BlpFileRegisterFileSystem()

NTSTATUS BlpFileRegisterFileSystem	(	_In_ PBL_FS_INIT_CALLBACK	InitCallback,
		_In_ PBL_FS_DESTROY_CALLBACK	DestroyCallback,
		_In_ PBL_FS_MOUNT_CALLBACK	MountCallback,
		_In_ PBL_FS_PURGE_CALLBACK	PurgeCallback,
		_In_ ULONG	Flags
	)

Definition at line 861 of file file.c.

{
    PBL_FILE_SYSTEM_ENTRY FsEntry;
    NTSTATUS Status;
 
    /* Allocate an entry */
    FsEntry = BlMmAllocateHeap(sizeof(*FsEntry));
    if (!FsEntry)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Initialize the file system */
    Status = InitCallback();
    if (!NT_SUCCESS(Status))
    {
        BlMmFreeHeap(FsEntry);
        return Status;
    }
 
    /* Register the callbacks */
    FsEntry->MountCallback = MountCallback;
    FsEntry->DestroyCallback = DestroyCallback;
    FsEntry->InitCallback = InitCallback;
    FsEntry->PurgeCallback = PurgeCallback;
 
    /* Insert in the right location in the list */
    if (Flags & BL_FS_REGISTER_AT_HEAD_FLAG)
    {
        InsertHeadList(&RegisteredFileSystems, &FsEntry->ListEntry);
    }
    else
    {
        InsertTailList(&RegisteredFileSystems, &FsEntry->ListEntry);
    }
 
    /* Return */
    return STATUS_SUCCESS;
}

Referenced by BlpFileInitialize().

FileInformationCheck()

NTSTATUS FileInformationCheck	(	_In_ PBL_FILE_INFORMATION	FileInformation,
		_In_ BOOLEAN	Write,
		_In_opt_ PULONG	InputSize,
		_In_opt_ PULONG	BytesReturned,
		_Out_opt_ PULONG	RequiredSize
	)

Definition at line 595 of file file.c.

{
    NTSTATUS Status;
    ULONG Size;
 
    /* Initialize variables */
    Status = STATUS_SUCCESS;
    Size = 0;
 
    /* Make sure we didn't overshoot */
    if (FileInformation->Offset > FileInformation->Size)
    {
        /* Bail out */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Compute the appropriate 32-bit size of this read, based on file size */
    Size = ULONG_MAX;
    if ((FileInformation->Size - FileInformation->Offset) <= ULONG_MAX)
    {
        Size = (ULONG)(FileInformation->Size) - (ULONG)(FileInformation->Offset);
    }
 
    /* Check if the caller has an input buffer */
    if (InputSize)
    {
        /* Is the size bigger than what the caller can handle? */
        if (Size >= *InputSize)
        {
            /* Yes, so cap it at the size of the caller's buffer */
            Size = *InputSize;
        }
        else if (!(BytesReturned) || (Write))
        {
            /* Caller's input buffer is too smaller is fatal for writes */
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
    }
 
Quickie:
    /* Does the caller want to know how big to make their buffer? */
    if (RequiredSize)
    {
        /* Let them know*/
        *RequiredSize = Size;
    }
 
    /* Return final status */
    return Status;
}

Referenced by BlFileReadAtOffsetEx(), and BlFileReadEx().

FileIoCopyFileName()

PWCHAR FileIoCopyFileName

(

_In_ PWCHAR

FilePath

)

Definition at line 79 of file file.c.

{
    PWCHAR Separator, FileCopy;
    SIZE_T PathSize;
 
    Separator = wcsrchr(FilePath, '\\');
    if (!Separator)
    {
        return NULL;
    }
 
    PathSize = wcslen(Separator) * sizeof(WCHAR);
 
    FileCopy = BlMmAllocateHeap(PathSize);
    if (!FileCopy)
    {
        return NULL;
    }
 
    wcsncpy(FileCopy, Separator + 1, PathSize / sizeof(WCHAR));
    return FileCopy;
}

Referenced by FileIoOpen().

FileIoCopyParentDirectoryPath()

PWCHAR FileIoCopyParentDirectoryPath

(

_In_ PWCHAR

FilePath

)

Definition at line 40 of file file.c.

{
    SIZE_T PathSize, PathSizeWithNull;
    PWCHAR Backslash, ParentCopy;
 
    PathSize = wcslen(FilePath) * sizeof(WCHAR);
 
    PathSizeWithNull = PathSize + sizeof(UNICODE_NULL);
    if (PathSizeWithNull < PathSize)
    {
        return NULL;
    }
 
    ParentCopy = BlMmAllocateHeap(PathSizeWithNull);
    if (!ParentCopy)
    {
        return NULL;
    }
    wcsncpy(ParentCopy, FilePath, PathSizeWithNull / sizeof(WCHAR));
 
    Backslash = wcsrchr(ParentCopy, '\\');
    if (!Backslash)
    {
        BlMmFreeHeap(ParentCopy);
        return NULL;
    }
 
    if (Backslash == ParentCopy)
    {
        ++Backslash;
    }
 
    *Backslash = UNICODE_NULL;
    return ParentCopy;
}

Referenced by FileIoOpen().

FileIoOpen()

NTSTATUS FileIoOpen	(	_In_ ULONG	DeviceId,
		_In_ PWCHAR	FileName,
		_In_ ULONG	Flags,
		_In_ ULONG	Unknown,
		_In_ PBL_TBL_LOOKUP_ROUTINE	CompareRoutine,
		_Out_opt_ PBL_FILE_ENTRY *	NewFileEntry
	)

Definition at line 258 of file file.c.

{
    PWCHAR FileNameCopy, ParentFileName;
    NTSTATUS Status;
    PBL_DEVICE_ENTRY DeviceEntry;
    PBL_FILE_SYSTEM_ENTRY FileSystem;
    ULONG FileId, CheckFlags;
    PBL_FILE_ENTRY DirectoryEntry, FileEntry;
    PLIST_ENTRY NextEntry, ListHead;
 
    /* Preinitialize variables for failure */
    DirectoryEntry = NULL;
    FileNameCopy = NULL;
    ParentFileName = NULL;
    Status = STATUS_SUCCESS;
 
    /* Bail out if the device ID is invalid */
    if (DmTableEntries <= DeviceId)
    {
        return STATUS_ACCESS_DENIED;
    }
 
    /* Bail out if there's no device entry */
    DeviceEntry = DmDeviceTable[DeviceId];
    if (!DeviceEntry)
    {
        return STATUS_ACCESS_DENIED;
    }
 
    /* Read access is always required for touching the device */
    CheckFlags = Flags | BL_FILE_READ_ACCESS;
 
    /* Check if the device is granting us read access */
    if ((CheckFlags & BL_FILE_READ_ACCESS) &&
        (!(DeviceEntry->Flags & BL_DEVICE_ENTRY_OPENED) ||
         !(DeviceEntry->Flags & BL_DEVICE_ENTRY_READ_ACCESS)))
    {
        EfiPrintf(L"Access denied\r\n");
        return STATUS_ACCESS_DENIED;
    }
 
    /* Check if the device is granting us write access */
    if ((CheckFlags & BL_FILE_WRITE_ACCESS) &&
        (!(DeviceEntry->Flags & BL_DEVICE_ENTRY_OPENED) ||
         !(DeviceEntry->Flags & BL_DEVICE_ENTRY_WRITE_ACCESS)))
    {
        EfiPrintf(L"Access denied2\r\n");
        return STATUS_ACCESS_DENIED;
    }
 
    /* Check if we already have this file open */
    FileEntry = (PBL_FILE_ENTRY )BlTblFindEntry(FileTable,
                                                FileEntries,
                                                &FileId,
                                                CompareRoutine,
                                                &DeviceId,
                                                FileName,
                                                &Flags,
                                                &Unknown);
    if (FileEntry)
    {
        goto FileOpened;
    }
 
    /* Check if we are opening the root drive or an actual file/directory */
    if ((*FileName != OBJ_NAME_PATH_SEPARATOR) || (FileName[1]))
    {
        /* Get the name of the directory */
        ParentFileName = FileIoCopyParentDirectoryPath(FileName);
        if (!ParentFileName)
        {
            Status = STATUS_NO_MEMORY;
            goto Quickie;
        }
 
        /* Open it */
        Status = FileIoOpen(DeviceId,
                            ParentFileName,
                            BL_FILE_READ_ACCESS | BL_DIRECTORY_ACCESS,
                            Unknown,
                            FileTableCompareWithSubsetAttributes,
                            &DirectoryEntry);
        if (!NT_SUCCESS(Status))
        {
            goto Quickie;
        }
 
        /* Now get the the file name itself */
        FileNameCopy = FileIoCopyFileName(FileName);
        if (!FileNameCopy)
        {
            Status = STATUS_NO_MEMORY;
            goto Quickie;
        }
 
        /* Open it */
        Status = DirectoryEntry->Callbacks.Open(DirectoryEntry,
                                                FileNameCopy,
                                                Flags,
                                                &FileEntry);
    }
    else
    {
        /* We're opening the root, scan through all the file systems */
        Status = STATUS_UNSUCCESSFUL;
        ListHead = &RegisteredFileSystems;
        NextEntry = ListHead->Flink;
        while (NextEntry != ListHead)
        {
            /* Try to mount this one */
            FileSystem = CONTAINING_RECORD(NextEntry, BL_FILE_SYSTEM_ENTRY, ListEntry);
            Status = FileSystem->MountCallback(DeviceId, Unknown, &FileEntry);
            if (NT_SUCCESS(Status))
            {
                /* Mount successful */
                break;
            }
 
            /* Try the next file system */
            NextEntry = NextEntry->Flink;
        }
 
        /* Nothing to free on this path */
        FileNameCopy = NULL;
    }
 
    /* Handle failure */
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Could not open file!: %lx\r\n", Status);
        goto Quickie;
    }
 
    /* Save the unknown */
    FileEntry->Unknown = Unknown;
 
    /* Convert open flags into entry flags */
    if (Flags & BL_FILE_READ_ACCESS)
    {
        FileEntry->Flags |= BL_FILE_ENTRY_READ_ACCESS;
    }
    if (Flags & BL_FILE_WRITE_ACCESS)
    {
        FileEntry->Flags |= BL_FILE_ENTRY_WRITE_ACCESS;
    }
 
    /* Save the file into the file table */
    Status = BlTblSetEntry(&FileTable,
                           &FileEntries,
                           (PVOID)FileEntry,
                           &FileId,
                           FileTablePurgeEntry);
    if (!NT_SUCCESS(Status))
    {
        /* Close it if that failed */
        FileEntry->Callbacks.Close(FileEntry);
        goto Quickie;
    }
 
    /* Add a reference on the device, and save our file ID  */
    ++DeviceEntry->ReferenceCount;
    Status = STATUS_SUCCESS;
    FileEntry->FileId = FileId;
 
FileOpened:
    /* Add a reference to the file entry, and see if this is the first one */
    if (++FileEntry->ReferenceCount == 1)
    {
        /* Reset unknowns */
        FileEntry->TotalBytesRead = 0;
        FileEntry->Unknown2 = 0;
    }
 
    /* Set the file as opened */
    FileEntry->Flags |= BL_FILE_ENTRY_OPENED;
 
    /* Not sure what this flag does */
    if (Flags & BL_UNKNOWN_ACCESS)
    {
        FileEntry->Flags |= BL_FILE_ENTRY_UNKNOWN_ACCESS;
    }
 
    /* If the caller wanted the entry back, return it */
    if (NewFileEntry)
    {
        *NewFileEntry = FileEntry;
    }
 
Quickie:
    /* Close the parent */
    if (DirectoryEntry)
    {
        BlFileClose(DirectoryEntry->FileId);
    }
 
    /* Free the parent name copy */
    if (ParentFileName)
    {
        BlMmFreeHeap(ParentFileName);
    }
 
    /* Free the file name copy */
    if (FileNameCopy)
    {
        BlMmFreeHeap(FileNameCopy);
    }
 
    /* Return back to caller */
    return Status;
}

Referenced by BlFileOpen(), and FileIoOpen().

FileTableCompareWithSameAttributes()

BOOLEAN FileTableCompareWithSameAttributes	(	_In_ PVOID	Entry,
		_In_ PVOID	Argument1,
		_In_ PVOID	Argument2,
		_In_ PVOID	Argument3,
		_In_ PVOID	Argument4
	)

Definition at line 138 of file file.c.

{
    PBL_FILE_ENTRY FileEntry = (PBL_FILE_ENTRY)Entry;
    ULONG DeviceId = *(PULONG)Argument1;
    PWCHAR FilePath = (PWCHAR)Argument2;
    ULONG Flags = *(PULONG)Argument3;
    ULONG Unknown = *(PULONG)Argument4;
    BOOLEAN Found;
 
    Found = FALSE;
 
    if ((FileEntry->DeviceId == DeviceId) &&
        !(_wcsicmp(FileEntry->FilePath, FilePath)) &&
        (FileEntry->Unknown == Unknown))
    {
        if ((!(Flags & 1) || (FileEntry->Flags & 2)) && ((Flags & 1) || !(FileEntry->Flags & 2)) && (!(Flags & 2) || (FileEntry->Flags & 4)) && ((Flags & 2) || !(FileEntry->Flags & 4)))
        {
            if ((!(Flags & 4) || (FileEntry->Flags & 0x10000)) && ((Flags & 4) || !(FileEntry->Flags & 0x10000)))
            {
                Found = TRUE;
            }
        }
    }
    return Found;
}

Referenced by BlFileOpen().

FileTableCompareWithSubsetAttributes()

BOOLEAN FileTableCompareWithSubsetAttributes	(	_In_ PVOID	Entry,
		_In_ PVOID	Argument1,
		_In_ PVOID	Argument2,
		_In_ PVOID	Argument3,
		_In_ PVOID	Argument4
	)

Definition at line 105 of file file.c.

{
    PBL_FILE_ENTRY FileEntry = (PBL_FILE_ENTRY)Entry;
    ULONG DeviceId = *(PULONG)Argument1;
    PWCHAR FilePath = (PWCHAR)Argument2;
    ULONG Flags = *(PULONG)Argument3;
    ULONG Unknown = *(PULONG)Argument4;
    BOOLEAN Found;
 
    Found = FALSE;
 
    if ((FileEntry->DeviceId == DeviceId) &&
        !(_wcsicmp(FileEntry->FilePath, FilePath)) &&
        (FileEntry->Unknown == Unknown))
    {
        if ((!(Flags & 1) || (FileEntry->Flags & 2)) && (!(Flags & 2) || (FileEntry->Flags & 4)))
        {
            if ((!(Flags & 4) || (FileEntry->Flags & 0x10000)) && ((Flags & 4) || !(FileEntry->Flags & 0x10000)))
            {
                Found = TRUE;
            }
        }
    }
    return Found;
}

Referenced by FileIoOpen().

FileTableDestroyEntry()

NTSTATUS FileTableDestroyEntry	(	_In_ PBL_FILE_ENTRY	FileEntry,
		_In_ ULONG	Index
	)

Definition at line 171 of file file.c.

{
    ULONG DeviceId;
    PBL_DEVICE_ENTRY DeviceEntry;
    NTSTATUS Status;
 
    DeviceId = FileEntry->DeviceId;
    if (DmTableEntries > DeviceId)
    {
        DeviceEntry = DmDeviceTable[DeviceId];
        if (DeviceEntry)
        {
            --DeviceEntry->ReferenceCount;
        }
    }
 
    Status = FileEntry->Callbacks.Close(FileEntry);
 
    BlMmFreeHeap(FileEntry);
 
    FileTable[Index] = NULL;
    return Status;
}

Referenced by FileTablePurgeEntry().

FileTablePurgeEntry()

NTSTATUS FileTablePurgeEntry

(

_In_ PVOID

Entry

)

Definition at line 201 of file file.c.

{
    PBL_FILE_ENTRY FileEntry = (PBL_FILE_ENTRY)Entry;
 
    /* Don't purge opened files, or if there's less than 512 files cached */
    if (((FileEntry->Flags & BL_FILE_ENTRY_OPENED) ||
        (FileEntry->Flags & 0x10000)) &&
        (FileEntries < BL_FILE_PURGE_LIMIT))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Purge the entry otherwise */
    return FileTableDestroyEntry(FileEntry, FileEntry->FileId);
}

Referenced by FileIoOpen().

Variable Documentation

DmDeviceTable

PVOID* DmDeviceTable

extern

Definition at line 24 of file device.c.

Referenced by BlDeviceClose(), BlDeviceGetInformation(), BlDeviceRead(), BlDeviceSetInformation(), BlpDeviceInitialize(), BlpDeviceOpen(), DeviceTableDestroyEntry(), FileIoOpen(), and FileTableDestroyEntry().

DmTableEntries

ULONG DmTableEntries

extern

Definition at line 22 of file device.c.

Referenced by BlDeviceClose(), BlDeviceGetInformation(), BlDeviceRead(), BlDeviceSetInformation(), BlpDeviceInitialize(), BlpDeviceOpen(), FileIoOpen(), and FileTableDestroyEntry().

EtfsRegisterFunctionTable

BL_FILE_SYSTEM_REGISTRATION_TABLE EtfsRegisterFunctionTable

Initial value:

=
{
    EtfsInitialize,
    NULL,
    EtfsMount,
    NULL
}

Definition at line 26 of file file.c.

Referenced by BlpFileInitialize().

FatRegisterFunctionTable

BL_FILE_SYSTEM_REGISTRATION_TABLE FatRegisterFunctionTable

Initial value:

=
{
    FatInitialize,
    NULL,
    FatMount,
    NULL
}

Definition at line 19 of file file.c.

Referenced by BlpFileInitialize().

FileEntries

ULONG FileEntries

Definition at line 16 of file file.c.

Referenced by BlFileClose(), BlFileGetInformation(), BlFileReadEx(), BlFileSetInformation(), BlpFileInitialize(), FileIoOpen(), and FileTablePurgeEntry().

FileTable

PVOID* FileTable

Definition at line 15 of file file.c.

Referenced by BlFileClose(), BlFileGetInformation(), BlFileReadEx(), BlFileSetInformation(), BlpFileInitialize(), FileIoOpen(), and FileTableDestroyEntry().

RegisteredFileSystems

LIST_ENTRY RegisteredFileSystems

Definition at line 18 of file file.c.

Referenced by BlpFileInitialize(), BlpFileRegisterFileSystem(), and FileIoOpen().