You've already forked slimbootloader
mirror of
https://github.com/Dasharo/slimbootloader.git
synced 2026-03-06 15:26:20 -08:00
497e66eadb
FileSystemLib provides generic interfaces to access file system and its files as a abstraction of FatLib/ExtLib. - Added CloseFileSystem If there are opened files in a specific filesystem, those files will be de-allocated in CloseFileSystem. - Added OpenFile/GetFileSize/ReadFile/CloseFile The ReadFile() does not allocate any memory for the file content. The caller of OpenFile() MUST allocate necessary memory before calling ReadFile(). Signed-off-by: Aiden Park <aiden.park@intel.com>
418 lines
13 KiB
C
418 lines
13 KiB
C
/** @file
|
|
File system level API library interface
|
|
|
|
Copyright (c) 2017 - 2019, Intel Corporation. All rights reserved.<BR>
|
|
|
|
This program and the accompanying materials are licensed and made available
|
|
under the terms and conditions of the BSD License which accompanies this
|
|
distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
#include <PiPei.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/FileSystemLib.h>
|
|
#include <Library/PcdLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/FatLib.h>
|
|
#include <Library/Ext23Lib.h>
|
|
|
|
#define FILE_SYSTEM_CB_SIGNATURE SIGNATURE_32( 'F', 'S', 'C', 'B' )
|
|
#define FILE_CB_SIGNATURE SIGNATURE_32( 'F', 'I', 'C', 'B' )
|
|
|
|
typedef struct {
|
|
UINTN Signature;
|
|
EFI_HANDLE FsHandle;
|
|
LIST_ENTRY OpenFiles;
|
|
} FILE_SYSTEM_CONTROL_BLOCK;
|
|
|
|
typedef struct {
|
|
LIST_ENTRY Link;
|
|
UINTN Signature;
|
|
EFI_HANDLE FileHandle;
|
|
EFI_HANDLE FileSystemControlBlock;
|
|
} FILE_CONTROL_BLOCK;
|
|
|
|
STATIC BOOLEAN mFileSystemRegistered = FALSE;
|
|
STATIC FILE_SYSTEM_FUNC mFileSystemFuncs[EnumFileSystemTypeAuto];
|
|
|
|
STATIC
|
|
VOID
|
|
RegisterFileSystems (
|
|
VOID
|
|
)
|
|
{
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
|
|
if (mFileSystemRegistered == FALSE) {
|
|
ZeroMem (&mFileSystemFuncs, sizeof (mFileSystemFuncs));
|
|
|
|
FsType = EnumFileSystemTypeFat;
|
|
if (FixedPcdGet32 (PcdSupportedFileSystemMask) & (1 << FsType)) {
|
|
mFileSystemFuncs[FsType].InitFileSystem = FatInitFileSystem;
|
|
mFileSystemFuncs[FsType].CloseFileSystem = FatCloseFileSystem;
|
|
mFileSystemFuncs[FsType].OpenFile = FatFsOpenFile;
|
|
mFileSystemFuncs[FsType].GetFileSize = FatFsGetFileSize;
|
|
mFileSystemFuncs[FsType].ReadFile = FatFsReadFile;
|
|
mFileSystemFuncs[FsType].CloseFile = FatFsCloseFile;
|
|
}
|
|
|
|
FsType = EnumFileSystemTypeExt2;
|
|
if (FixedPcdGet32 (PcdSupportedFileSystemMask) & (1 << FsType)) {
|
|
mFileSystemFuncs[FsType].InitFileSystem = ExtInitFileSystem;
|
|
mFileSystemFuncs[FsType].CloseFileSystem = ExtCloseFileSystem;
|
|
mFileSystemFuncs[FsType].OpenFile = ExtFsOpenFile;
|
|
mFileSystemFuncs[FsType].GetFileSize = ExtFsGetFileSize;
|
|
mFileSystemFuncs[FsType].ReadFile = ExtFsReadFile;
|
|
mFileSystemFuncs[FsType].CloseFile = ExtFsCloseFile;
|
|
}
|
|
mFileSystemRegistered = TRUE;
|
|
}
|
|
}
|
|
|
|
STATIC
|
|
OS_FILE_SYSTEM_TYPE
|
|
EFIAPI
|
|
GetFileSystemType (
|
|
IN EFI_HANDLE FsHandle
|
|
)
|
|
{
|
|
UINTN Signature;
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
|
|
FsType = EnumFileSystemMax;
|
|
if (FsHandle != NULL) {
|
|
Signature = *(UINTN *)FsHandle;
|
|
if (Signature == FS_FAT_SIGNATURE) {
|
|
FsType = EnumFileSystemTypeFat;
|
|
} else if (Signature == FS_EXT_SIGNATURE) {
|
|
FsType = EnumFileSystemTypeExt2;
|
|
}
|
|
}
|
|
return FsType;
|
|
}
|
|
|
|
/**
|
|
Initialize file systems.
|
|
|
|
@param[in] SwPart Software partition index.
|
|
@param[in] FsType Filesystem type.
|
|
@param[in] PartHandle Partition handle.
|
|
@param[out] FsHandle FAT file system handle.
|
|
|
|
@retval EFI_SUCCESS The file system was initialized successfully.
|
|
@retval EFI_INVALID_PARAMETER Parameter is not valid.
|
|
@retval EFI_NOT_FOUND FAT file system was not detected on this partition.
|
|
@retval EFI_OUT_OF_RESOURCES Insufficant memory resource pool.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
InitFileSystem (
|
|
IN UINT32 SwPart,
|
|
IN UINT32 FsType,
|
|
IN EFI_HANDLE PartHandle,
|
|
OUT EFI_HANDLE *FsHandle
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT32 Type;
|
|
EFI_HANDLE Handle;
|
|
FILE_SYSTEM_CONTROL_BLOCK *FileSystemControlBlock;
|
|
|
|
Status = EFI_INVALID_PARAMETER;
|
|
|
|
if (FsType >= EnumFileSystemMax) {
|
|
return Status;
|
|
}
|
|
|
|
RegisterFileSystems ();
|
|
|
|
for (Type = EnumFileSystemTypeFat; Type < EnumFileSystemTypeAuto; Type++) {
|
|
if (mFileSystemFuncs[Type].InitFileSystem == NULL) {
|
|
continue;
|
|
}
|
|
if ((FsType == EnumFileSystemTypeAuto) || (FsType == Type)) {
|
|
Handle = NULL;
|
|
Status = mFileSystemFuncs[Type].InitFileSystem (SwPart, PartHandle, &Handle);
|
|
if (!EFI_ERROR (Status)) {
|
|
break;
|
|
}
|
|
|
|
if (Handle != NULL) {
|
|
mFileSystemFuncs[Type].CloseFileSystem (Handle);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!EFI_ERROR (Status)) {
|
|
FileSystemControlBlock = (FILE_SYSTEM_CONTROL_BLOCK *) AllocatePool (sizeof (FILE_SYSTEM_CONTROL_BLOCK));
|
|
FileSystemControlBlock->Signature = FILE_SYSTEM_CB_SIGNATURE;
|
|
FileSystemControlBlock->FsHandle = Handle;
|
|
InitializeListHead (&FileSystemControlBlock->OpenFiles);
|
|
|
|
*FsHandle = (EFI_HANDLE)FileSystemControlBlock;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Clean-up allocated memory/etc. for file system
|
|
|
|
@param[in] FsHandle File system handle to clean-up.
|
|
|
|
@retval none
|
|
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
CloseFileSystem (
|
|
IN EFI_HANDLE FsHandle
|
|
)
|
|
{
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
FILE_SYSTEM_CONTROL_BLOCK *FileSystemControlBlock;
|
|
FILE_CONTROL_BLOCK *FileControlBlock;
|
|
LIST_ENTRY *Node;
|
|
|
|
FileSystemControlBlock = (FILE_SYSTEM_CONTROL_BLOCK *)FsHandle;
|
|
if (FileSystemControlBlock == NULL) {
|
|
return;
|
|
}
|
|
|
|
FsType = GetFileSystemType (FileSystemControlBlock->FsHandle);
|
|
if (FsType >= EnumFileSystemTypeAuto) {
|
|
return;
|
|
}
|
|
|
|
Node = GetFirstNode (&FileSystemControlBlock->OpenFiles);
|
|
while (!IsNull (&FileSystemControlBlock->OpenFiles, Node)) {
|
|
FileControlBlock = (FILE_CONTROL_BLOCK *)Node;
|
|
if (FileControlBlock->Signature == FILE_CB_SIGNATURE) {
|
|
DEBUG ((DEBUG_INFO, " Close file handle 0x%p\n", FileControlBlock->FileHandle));
|
|
CloseFile (FileControlBlock);
|
|
}
|
|
Node = GetNextNode (&FileSystemControlBlock->OpenFiles, Node);
|
|
}
|
|
|
|
if (mFileSystemFuncs[FsType].CloseFileSystem == NULL) {
|
|
return;
|
|
}
|
|
|
|
mFileSystemFuncs[FsType].CloseFileSystem (FileSystemControlBlock->FsHandle);
|
|
FreePool (FileSystemControlBlock);
|
|
DEBUG ((DEBUG_INFO, "CloseFileSystem: FsType %d\n", FsType));
|
|
}
|
|
|
|
/**
|
|
Open a file by its name and return its file handle.
|
|
|
|
@param[in] FsHandle file system handle.
|
|
@param[in] FileName The file name to get.
|
|
@param[out] FileHandle file handle
|
|
|
|
@retval EFI_SUCCESS The file opened correctly.
|
|
@retval EFI_INVALID_PARAMETER Parameter is not valid.
|
|
@retval EFI_DEVICE_ERROR A device error occurred.
|
|
@retval EFI_NOT_FOUND A requested file cannot be found.
|
|
@retval EFI_OUT_OF_RESOURCES Insufficant memory resource pool.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
OpenFile (
|
|
IN EFI_HANDLE FsHandle,
|
|
IN CHAR16 *FileName,
|
|
OUT EFI_HANDLE *FileHandle
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
EFI_HANDLE FsFileHandle;
|
|
FILE_SYSTEM_CONTROL_BLOCK *FileSystemControlBlock;
|
|
FILE_CONTROL_BLOCK *FileControlBlock;
|
|
|
|
FileSystemControlBlock = (FILE_SYSTEM_CONTROL_BLOCK *)FsHandle;
|
|
ASSERT (FileSystemControlBlock != NULL);
|
|
if (FileSystemControlBlock == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
FsType = GetFileSystemType (FileSystemControlBlock->FsHandle);
|
|
if (FsType >= EnumFileSystemTypeAuto) {
|
|
return EFI_NOT_READY;
|
|
}
|
|
|
|
if (mFileSystemFuncs[FsType].OpenFile == NULL) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
Status = mFileSystemFuncs[FsType].OpenFile (FileSystemControlBlock->FsHandle, FileName, &FsFileHandle);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
FileControlBlock = (FILE_CONTROL_BLOCK *) AllocatePool (sizeof (FILE_CONTROL_BLOCK));
|
|
if (FileControlBlock == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
FileControlBlock->Signature = FILE_CB_SIGNATURE;
|
|
FileControlBlock->FileHandle = FsFileHandle;
|
|
FileControlBlock->FileSystemControlBlock = FileSystemControlBlock;
|
|
InsertTailList (&FileSystemControlBlock->OpenFiles, &FileControlBlock->Link);
|
|
|
|
*FileHandle = (EFI_HANDLE) FileControlBlock;
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Get file size by opened file handle.
|
|
|
|
@param[in] FileHandle file handle
|
|
@param[out] FileSize Pointer to file buffer size.
|
|
|
|
@retval EFI_SUCCESS The file was loaded correctly.
|
|
@retval EFI_INVALID_PARAMETER Parameter is not valid.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
GetFileSize (
|
|
IN EFI_HANDLE FileHandle,
|
|
OUT UINTN *FileSize
|
|
)
|
|
{
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
FILE_SYSTEM_CONTROL_BLOCK *FileSystemControlBlock;
|
|
FILE_CONTROL_BLOCK *FileControlBlock;
|
|
|
|
FileControlBlock = (FILE_CONTROL_BLOCK *)FileHandle;
|
|
ASSERT (FileControlBlock != NULL);
|
|
if (FileControlBlock == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
ASSERT (FileControlBlock->Signature == FILE_CB_SIGNATURE);
|
|
|
|
FileSystemControlBlock = (FILE_SYSTEM_CONTROL_BLOCK *)FileControlBlock->FileSystemControlBlock;
|
|
ASSERT (FileSystemControlBlock->Signature == FILE_SYSTEM_CB_SIGNATURE);
|
|
|
|
FsType = GetFileSystemType (FileSystemControlBlock->FsHandle);
|
|
if (FsType >= EnumFileSystemTypeAuto) {
|
|
return EFI_NOT_READY;
|
|
}
|
|
|
|
if (mFileSystemFuncs[FsType].GetFileSize == NULL) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
return mFileSystemFuncs[FsType].GetFileSize (FileControlBlock->FileHandle, FileSize);
|
|
}
|
|
|
|
/**
|
|
Read file into memory by opened file handle.
|
|
|
|
@param[in] FileHandle file handle
|
|
@param[out] FileBufferPtr Allocated file buffer pointer.
|
|
@param[out] FileSize Pointer to file buffer size.
|
|
|
|
@retval EFI_SUCCESS The file was loaded correctly.
|
|
@retval EFI_INVALID_PARAMETER Parameter is not valid.
|
|
@retval EFI_DEVICE_ERROR A device error occurred.
|
|
@retval EFI_NOT_FOUND A requested file cannot be found.
|
|
@retval EFI_OUT_OF_RESOURCES Insufficant memory resource pool.
|
|
@retval EFI_BUFFER_TOO_SMALL Buffer size is too small.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ReadFile (
|
|
IN EFI_HANDLE FileHandle,
|
|
OUT VOID **FileBuffer,
|
|
OUT UINTN *FileSize
|
|
)
|
|
{
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
FILE_SYSTEM_CONTROL_BLOCK *FileSystemControlBlock;
|
|
FILE_CONTROL_BLOCK *FileControlBlock;
|
|
|
|
ASSERT (FileHandle != NULL);
|
|
if (FileHandle == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
ASSERT (*FileBuffer != NULL);
|
|
if (*FileBuffer == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
FileControlBlock = (FILE_CONTROL_BLOCK *)FileHandle;
|
|
ASSERT (FileControlBlock->Signature == FILE_CB_SIGNATURE);
|
|
|
|
FileSystemControlBlock = (FILE_SYSTEM_CONTROL_BLOCK *)FileControlBlock->FileSystemControlBlock;
|
|
ASSERT (FileSystemControlBlock->Signature == FILE_SYSTEM_CB_SIGNATURE);
|
|
|
|
FsType = GetFileSystemType (FileSystemControlBlock->FsHandle);
|
|
if (FsType >= EnumFileSystemTypeAuto) {
|
|
return EFI_NOT_READY;
|
|
}
|
|
|
|
if (mFileSystemFuncs[FsType].ReadFile == NULL) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
return mFileSystemFuncs[FsType].ReadFile (FileSystemControlBlock->FsHandle, FileControlBlock->FileHandle, FileBuffer, FileSize);
|
|
}
|
|
|
|
/**
|
|
Close a file by opened file handle
|
|
|
|
@param[in] FileHandle file handle
|
|
|
|
@retval none
|
|
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
CloseFile (
|
|
IN EFI_HANDLE FileHandle
|
|
)
|
|
{
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
FILE_SYSTEM_CONTROL_BLOCK *FileSystemControlBlock;
|
|
FILE_CONTROL_BLOCK *FileControlBlock;
|
|
|
|
FileControlBlock = (FILE_CONTROL_BLOCK *)FileHandle;
|
|
ASSERT (FileControlBlock != NULL);
|
|
ASSERT (FileControlBlock->Signature == FILE_CB_SIGNATURE);
|
|
if (FileControlBlock == NULL || FileControlBlock->Signature != FILE_CB_SIGNATURE) {
|
|
return;
|
|
}
|
|
|
|
FileSystemControlBlock = (FILE_SYSTEM_CONTROL_BLOCK *)FileControlBlock->FileSystemControlBlock;
|
|
ASSERT (FileSystemControlBlock != NULL);
|
|
ASSERT (FileSystemControlBlock->Signature == FILE_SYSTEM_CB_SIGNATURE);
|
|
if (FileSystemControlBlock == NULL) {
|
|
return;
|
|
}
|
|
|
|
FsType = GetFileSystemType (FileSystemControlBlock->FsHandle);
|
|
if (FsType >= EnumFileSystemTypeAuto) {
|
|
return;
|
|
}
|
|
|
|
if (mFileSystemFuncs[FsType].CloseFile == NULL) {
|
|
return;
|
|
}
|
|
|
|
RemoveEntryList (&FileControlBlock->Link);
|
|
mFileSystemFuncs[FsType].CloseFile (FileControlBlock->FileHandle);
|
|
FreePool (FileControlBlock);
|
|
}
|