Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-12-18 15:27:48 +01:00
Code Issues Packages Projects Releases Wiki Activity
2b84ee61a3
CloverBootloader/FileSystems/FatPkg/EnhancedFatDxe/Fat.h
Sergey Isakov 7c0aa811ec initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 
Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 12:58:42 +03:00

1291 lines
30 KiB
C
Raw Blame History

/*++
Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the Software
License Agreement which accompanies this distribution.
Module Name:
Fat.h
Abstract:
Main header file for EFI FAT file system driver
Revision History
--*/
#ifndef _FAT_H_
#define _FAT_H_
#include <Uefi.h>
#include <Guid/FileInfo.h>
#include <Guid/FileSystemInfo.h>
#include <Guid/FileSystemVolumeLabelInfo.h>
#include <Protocol/BlockIo.h>
#include <Protocol/DiskIo.h>
#include <Protocol/DiskIo2.h>
#include <Protocol/SimpleFileSystem.h>
#include <Protocol/UnicodeCollation.h>
#include <Library/PcdLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include "FatFileSystem.h"
//
// The FAT signature
//
#define FAT_VOLUME_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'v')
#define FAT_IFILE_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'i')
#define FAT_ODIR_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'd')
#define FAT_DIRENT_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'e')
#define FAT_OFILE_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'o')
#define FAT_TASK_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'T')
#define FAT_SUBTASK_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'S')
#define ASSERT_VOLUME_LOCKED(a) ASSERT_LOCKED (&FatFsLock)
#define IFILE_FROM_FHAND(a) CR (a, FAT_IFILE, Handle, FAT_IFILE_SIGNATURE)
#define DIRENT_FROM_LINK(a) CR (a, FAT_DIRENT, Link, FAT_DIRENT_SIGNATURE)
#define VOLUME_FROM_ROOT_DIRENT(a) CR (a, FAT_VOLUME, RootDirEnt, FAT_VOLUME_SIGNATURE)
#define VOLUME_FROM_VOL_INTERFACE(a) CR (a, FAT_VOLUME, VolumeInterface, FAT_VOLUME_SIGNATURE);
#define ODIR_FROM_DIRCACHELINK(a) CR (a, FAT_ODIR, DirCacheLink, FAT_ODIR_SIGNATURE)
#define OFILE_FROM_CHECKLINK(a) CR (a, FAT_OFILE, CheckLink, FAT_OFILE_SIGNATURE)
#define OFILE_FROM_CHILDLINK(a) CR (a, FAT_OFILE, ChildLink, FAT_OFILE_SIGNATURE)
//
// Minimum sector size is 512B, Maximum sector size is 4096B
// Max sectors per cluster is 128
//
#define MAX_BLOCK_ALIGNMENT 12
#define MIN_BLOCK_ALIGNMENT 9
#define MAX_SECTORS_PER_CLUSTER_ALIGNMENT 7
//
// Efi Time Definition
//
#define IS_LEAP_YEAR(a) (((a) % 4 == 0) && (((a) % 100 != 0) || ((a) % 400 == 0)))
//
// Minimum fat page size is 8K, maximum fat page alignment is 32K
// Minimum data page size is 8K, maximum fat page alignment is 64K
//
#define FAT_FATCACHE_PAGE_MIN_ALIGNMENT 13
#define FAT_FATCACHE_PAGE_MAX_ALIGNMENT 15
#define FAT_DATACACHE_PAGE_MIN_ALIGNMENT 13
#define FAT_DATACACHE_PAGE_MAX_ALIGNMENT 16
#define FAT_DATACACHE_GROUP_COUNT 64
#define FAT_FATCACHE_GROUP_MIN_COUNT 1
#define FAT_FATCACHE_GROUP_MAX_COUNT 16
//
// Used in 8.3 generation algorithm
//
#define MAX_SPEC_RETRY 4
#define SPEC_BASE_TAG_LEN 6
#define HASH_BASE_TAG_LEN 2
#define HASH_VALUE_TAG_LEN (SPEC_BASE_TAG_LEN - HASH_BASE_TAG_LEN)
//
// Path name separator is back slash
//
#define PATH_NAME_SEPARATOR L'\\'
#define EFI_PATH_STRING_LENGTH 260
#define EFI_FILE_STRING_LENGTH 255
#define FAT_MAX_ALLOCATE_SIZE 0xA00000
#define LC_ISO_639_2_ENTRY_SIZE 3
#define MAX_LANG_CODE_SIZE 100
#define FAT_MAX_DIR_CACHE_COUNT 8
#define FAT_MAX_DIRENTRY_COUNT 0xFFFF
typedef CHAR8 LC_ISO_639_2;
//
// The fat types we support
//
typedef enum {
FAT12,
FAT16,
FAT32,
FatUndefined
} FAT_VOLUME_TYPE;
typedef enum {
CACHE_FAT,
CACHE_DATA,
CACHE_MAX_TYPE
} CACHE_DATA_TYPE;
//
// Used in FatDiskIo
//
typedef enum {
READ_DISK = 0, // raw disk read
WRITE_DISK = 1, // raw disk write
READ_FAT = 2, // read fat cache
WRITE_FAT = 3, // write fat cache
READ_DATA = 6, // read data cache
WRITE_DATA = 7 // write data cache
} IO_MODE;
#define CACHE_ENABLED(a) ((a) >= 2)
#define RAW_ACCESS(a) ((IO_MODE)((a) & 0x1))
#define CACHE_TYPE(a) ((CACHE_DATA_TYPE)((a) >> 2))
//
// Disk cache tag
//
typedef struct {
UINTN PageNo;
UINTN RealSize;
BOOLEAN Dirty;
} CACHE_TAG;
typedef struct {
UINT64 BaseAddress;
UINT64 LimitAddress;
UINT8 *CacheBase;
BOOLEAN Dirty;
UINT8 PageAlignment;
UINTN GroupMask;
CACHE_TAG CacheTag[FAT_DATACACHE_GROUP_COUNT];
} DISK_CACHE;
//
// Hash table size
//
#define HASH_TABLE_SIZE 0x400
#define HASH_TABLE_MASK (HASH_TABLE_SIZE - 1)
//
// The directory entry for opened directory
//
typedef struct _FAT_DIRENT {
UINTN Signature;
UINT16 EntryPos; // The position of this directory entry in the parent directory file
UINT8 EntryCount; // The count of the directory entry in the parent directory file
BOOLEAN Invalid; // Indicate whether this directory entry is valid
CHAR16 *FileString; // The unicode long file name for this directory entry
struct _FAT_OFILE *OFile; // The OFile of the corresponding directory entry
struct _FAT_DIRENT *ShortNameForwardLink; // Hash successor link for short filename
struct _FAT_DIRENT *LongNameForwardLink; // Hash successor link for long filename
LIST_ENTRY Link; // Connection of every directory entry
FAT_DIRECTORY_ENTRY Entry; // The physical directory entry stored in disk
} FAT_DIRENT;
typedef struct _FAT_ODIR {
UINTN Signature;
UINT32 CurrentEndPos; // Current end position of the directory
UINT32 CurrentPos; // Current position of the directory
LIST_ENTRY *CurrentCursor; // Current directory entry pointer
LIST_ENTRY ChildList; // List of all directory entries
BOOLEAN EndOfDir; // Indicate whether we have reached the end of the directory
LIST_ENTRY DirCacheLink; // Linked in Volume->DirCacheList when discarded
UINTN DirCacheTag; // The identification of the directory when in directory cache
FAT_DIRENT *LongNameHashTable[HASH_TABLE_SIZE];
FAT_DIRENT *ShortNameHashTable[HASH_TABLE_SIZE];
} FAT_ODIR;
typedef struct {
UINTN Signature;
EFI_FILE_PROTOCOL Handle;
UINT64 Position;
BOOLEAN ReadOnly;
struct _FAT_OFILE *OFile;
LIST_ENTRY Tasks; // List of all FAT_TASKs
LIST_ENTRY Link; // Link to other IFiles
} FAT_IFILE;
typedef struct {
UINTN Signature;
EFI_FILE_IO_TOKEN *FileIoToken;
FAT_IFILE *IFile;
LIST_ENTRY Subtasks; // List of all FAT_SUBTASKs
LIST_ENTRY Link; // Link to other FAT_TASKs
} FAT_TASK;
typedef struct {
UINTN Signature;
EFI_DISK_IO2_TOKEN DiskIo2Token;
FAT_TASK *Task;
BOOLEAN Write;
UINT64 Offset;
VOID *Buffer;
UINTN BufferSize;
LIST_ENTRY Link;
} FAT_SUBTASK;
//
// FAT_OFILE - Each opened file
//
typedef struct _FAT_OFILE {
UINTN Signature;
struct _FAT_VOLUME *Volume;
//
// A permanant error code to return to all accesses to
// this opened file
//
EFI_STATUS Error;
//
// A list of the IFILE instances for this OFile
//
LIST_ENTRY Opens;
//
// The dynamic infomation
//
UINTN FileSize;
UINTN FileCluster;
UINTN FileCurrentCluster;
UINTN FileLastCluster;
//
// Dirty is set if there have been any updates to the
// file
// Archive is set if the archive attribute in the file's
// directory entry needs to be set when performing flush
// PreserveLastMod is set if the last modification of the
// file is specified by SetInfo API
//
BOOLEAN Dirty;
BOOLEAN IsFixedRootDir;
BOOLEAN PreserveLastModification;
BOOLEAN Archive;
//
// Set by an OFile SetPosition
//
UINTN Position; // within file
UINT64 PosDisk; // on the disk
UINTN PosRem; // remaining in this disk run
//
// The opened parent, full path length and currently opened child files
//
struct _FAT_OFILE *Parent;
UINTN FullPathLen;
LIST_ENTRY ChildHead;
LIST_ENTRY ChildLink;
//
// The opened directory structure for a directory; if this
// OFile represents a file, then ODir = NULL
//
FAT_ODIR *ODir;
//
// The directory entry for the Ofile
//
FAT_DIRENT *DirEnt;
//
// Link in Volume's reference list
//
LIST_ENTRY CheckLink;
} FAT_OFILE;
typedef struct _FAT_VOLUME {
UINTN Signature;
EFI_HANDLE Handle;
BOOLEAN Valid;
BOOLEAN DiskError;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL VolumeInterface;
//
// If opened, the parent handle and BlockIo interface
//
EFI_BLOCK_IO_PROTOCOL *BlockIo;
EFI_DISK_IO_PROTOCOL *DiskIo;
EFI_DISK_IO2_PROTOCOL *DiskIo2;
UINT32 MediaId;
BOOLEAN ReadOnly;
//
// Computed values from fat bpb info
//
UINT64 VolumeSize;
UINT64 FatPos; // Disk pos of fat tables
UINT64 RootPos; // Disk pos of root directory
UINT64 FirstClusterPos; // Disk pos of first cluster
UINTN FatSize; // Number of bytes in each fat
UINTN MaxCluster; // Max cluster number
UINTN ClusterSize; // Cluster size of fat partition
UINT8 ClusterAlignment; // Equal to log_2 (clustersize);
FAT_VOLUME_TYPE FatType;
//
// Current part of fat table that's present
//
UINT64 FatEntryPos; // Location of buffer
UINTN FatEntrySize; // Size of buffer
UINT32 FatEntryBuffer; // The buffer
FAT_INFO_SECTOR FatInfoSector; // Free cluster info
UINTN FreeInfoPos; // Pos with the free cluster info
BOOLEAN FreeInfoValid; // If free cluster info is valid
//
// Unpacked Fat BPB info
//
UINTN NumFats;
UINTN RootEntries; // < FAT32, root dir is fixed size
UINTN RootCluster; // >= FAT32, root cluster chain head
//
// info for marking the volume dirty or not
//
BOOLEAN FatDirty; // If fat-entries have been updated
UINT32 DirtyValue;
UINT32 NotDirtyValue;
//
// The root directory entry and opened root file
//
FAT_DIRENT RootDirEnt;
//
// File Name of root OFile, it is empty string
//
CHAR16 RootFileString[1];
struct _FAT_OFILE *Root;
//
// New OFiles are added to this list so they
// can be cleaned up if they aren't referenced.
//
LIST_ENTRY CheckRef;
//
// Directory cache List
//
LIST_ENTRY DirCacheList;
UINTN DirCacheCount;
//
// Disk Cache for this volume
//
VOID *CacheBuffer;
DISK_CACHE DiskCache[CACHE_MAX_TYPE];
} FAT_VOLUME;
//
// Function Prototypes
//
EFI_STATUS
EFIAPI
FatOpen (
IN EFI_FILE_PROTOCOL *FHand,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes
)
/*++
Routine Description:
Implements Open() of Simple File System Protocol.
Arguments:
FHand - File handle of the file serves as a starting reference point.
NewHandle - Handle of the file that is newly opened.
FileName - File name relative to FHand.
OpenMode - Open mode.
Attributes - Attributes to set if the file is created.
Returns:
EFI_INVALID_PARAMETER - The FileName is NULL or the file string is empty.
The OpenMode is not supported.
The Attributes is not the valid attributes.
EFI_OUT_OF_RESOURCES - Can not allocate the memory for file string.
EFI_SUCCESS - Open the file successfully.
Others - The status of open file.
--*/
;
EFI_STATUS
EFIAPI
FatOpenEx (
IN EFI_FILE_PROTOCOL *FHand,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes,
IN OUT EFI_FILE_IO_TOKEN *Token
)
/*++
Routine Description:
Implements OpenEx() of Simple File System Protocol.
Arguments:
FHand - File handle of the file serves as a starting reference point.
NewHandle - Handle of the file that is newly opened.
FileName - File name relative to FHand.
OpenMode - Open mode.
Attributes - Attributes to set if the file is created.
Token - A pointer to the token associated with the transaction.
Returns:
EFI_INVALID_PARAMETER - The FileName is NULL or the file string is empty.
The OpenMode is not supported.
The Attributes is not the valid attributes.
EFI_OUT_OF_RESOURCES - Can not allocate the memory for file string.
EFI_SUCCESS - Open the file successfully.
Others - The status of open file.
--*/
;
EFI_STATUS
EFIAPI
FatGetPosition (
IN EFI_FILE_PROTOCOL *FHand,
OUT UINT64 *Position
)
/*++
Routine Description:
Get the file's position of the file
Arguments:
FHand - The handle of file.
Position - The file's position of the file.
Returns:
EFI_SUCCESS - Get the info successfully.
EFI_DEVICE_ERROR - Can not find the OFile for the file.
EFI_UNSUPPORTED - The open file is not a file.
--*/
;
EFI_STATUS
EFIAPI
FatGetInfo (
IN EFI_FILE_PROTOCOL *FHand,
IN EFI_GUID *Type,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
/*++
Routine Description:
Get the some types info of the file into Buffer
Arguments:
FHand - The handle of file.
Type - The type of the info.
BufferSize - Size of Buffer.
Buffer - Buffer containing volume info.
Returns:
EFI_SUCCESS - Get the info successfully.
EFI_DEVICE_ERROR - Can not find the OFile for the file.
--*/
;
EFI_STATUS
EFIAPI
FatSetInfo (
IN EFI_FILE_PROTOCOL *FHand,
IN EFI_GUID *Type,
IN UINTN BufferSize,
IN VOID *Buffer
)
/*++
Routine Description:
Set the some types info of the file into Buffer
Arguments:
FHand - The handle of file.
Type - The type of the info.
BufferSize - Size of Buffer.
Buffer - Buffer containing volume info.
Returns:
EFI_SUCCESS - Set the info successfully.
EFI_DEVICE_ERROR - Can not find the OFile for the file.
--*/
;
EFI_STATUS
EFIAPI
FatFlush (
IN EFI_FILE_PROTOCOL *FHand
)
/*++
Routine Description:
Flushes all data associated with the file handle
Arguments:
FHand - Handle to file to flush
Returns:
EFI_SUCCESS - Flushed the file successfully
EFI_WRITE_PROTECTED - The volume is read only
EFI_ACCESS_DENIED - The volume is not read only
but the file is read only
Others - Flushing of the file is failed
--*/
;
EFI_STATUS
EFIAPI
FatFlushEx (
IN EFI_FILE_PROTOCOL *FHand,
IN EFI_FILE_IO_TOKEN *Token
)
/*++
Routine Description:
Flushes all data associated with the file handle.
Arguments:
FHand - Handle to file to flush.
Token - A pointer to the token associated with the transaction.
Returns:
EFI_SUCCESS - Flushed the file successfully.
EFI_WRITE_PROTECTED - The volume is read only.
EFI_ACCESS_DENIED - The file is read only.
Others - Flushing of the file failed.
--*/
;
EFI_STATUS
EFIAPI
FatClose (
IN EFI_FILE_PROTOCOL *FHand
)
/*++
Routine Description:
Flushes & Closes the file handle.
Arguments:
FHand - Handle to the file to delete.
Returns:
EFI_SUCCESS - Closed the file successfully.
--*/
;
EFI_STATUS
EFIAPI
FatDelete (
IN EFI_FILE_PROTOCOL *FHand
)
/*++
Routine Description:
Deletes the file & Closes the file handle.
Arguments:
FHand - Handle to the file to delete.
Returns:
EFI_SUCCESS - Delete the file successfully.
EFI_WARN_DELETE_FAILURE - Fail to delete the file.
--*/
;
EFI_STATUS
EFIAPI
FatSetPosition (
IN EFI_FILE_PROTOCOL *FHand,
IN UINT64 Position
)
/*++
Routine Description:
Set the file's position of the file
Arguments:
FHand - The handle of file
Position - The file's position of the file
Returns:
EFI_SUCCESS - Set the info successfully
EFI_DEVICE_ERROR - Can not find the OFile for the file
EFI_UNSUPPORTED - Set a directory with a not-zero position
--*/
;
EFI_STATUS
EFIAPI
FatRead (
IN EFI_FILE_PROTOCOL *FHand,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
/*++
Routine Description:
Get the file info.
Arguments:
FHand - The handle of the file.
BufferSize - Size of Buffer.
Buffer - Buffer containing read data.
Returns:
EFI_SUCCESS - Get the file info successfully.
EFI_DEVICE_ERROR - Can not find the OFile for the file.
EFI_VOLUME_CORRUPTED - The file type of open file is error.
other - An error occurred when operation the disk.
--*/
;
EFI_STATUS
EFIAPI
FatReadEx (
IN EFI_FILE_PROTOCOL *FHand,
IN OUT EFI_FILE_IO_TOKEN *Token
)
/*++
Routine Description:
Get the file info.
Arguments:
FHand - The handle of the file.
Token - A pointer to the token associated with the transaction.
Returns:
EFI_SUCCESS - Get the file info successfully.
EFI_DEVICE_ERROR - Can not find the OFile for the file.
EFI_VOLUME_CORRUPTED - The file type of open file is error.
other - An error occurred when operation the disk.
--*/
;
EFI_STATUS
EFIAPI
FatWrite (
IN EFI_FILE_PROTOCOL *FHand,
IN OUT UINTN *BufferSize,
IN VOID *Buffer
)
/*++
Routine Description:
Set the file info.
Arguments:
FHand - The handle of the file.
BufferSize - Size of Buffer.
Buffer - Buffer containing write data.
Returns:
EFI_SUCCESS - Set the file info successfully.
EFI_WRITE_PROTECTED - The disk is write protected.
EFI_ACCESS_DENIED - The file is read-only.
EFI_DEVICE_ERROR - The OFile is not valid.
EFI_UNSUPPORTED - The open file is not a file.
- The writing file size is larger than 4GB.
other - An error occurred when operation the disk.
--*/
;
EFI_STATUS
EFIAPI
FatWriteEx (
IN EFI_FILE_PROTOCOL *FHand,
IN OUT EFI_FILE_IO_TOKEN *Token
)
/*++
Routine Description:
Get the file info.
Arguments:
FHand - The handle of the file.
Token - A pointer to the token associated with the transaction.
Returns:
EFI_SUCCESS - Get the file info successfully.
EFI_DEVICE_ERROR - Can not find the OFile for the file.
EFI_VOLUME_CORRUPTED - The file type of open file is error.
other - An error occurred when operation the disk.
--*/
;
//
// DiskCache.c
//
EFI_STATUS
FatInitializeDiskCache (
IN FAT_VOLUME *Volume
);
EFI_STATUS
FatAccessCache (
IN FAT_VOLUME *Volume,
IN CACHE_DATA_TYPE CacheDataType,
IN IO_MODE IoMode,
IN UINT64 Offset,
IN UINTN BufferSize,
IN OUT UINT8 *Buffer,
IN FAT_TASK *Task
);
EFI_STATUS
FatVolumeFlushCache (
IN FAT_VOLUME *Volume,
IN FAT_TASK *Task
);
//
// Flush.c
//
EFI_STATUS
FatOFileFlush (
IN FAT_OFILE *OFile
);
BOOLEAN
FatCheckOFileRef (
IN FAT_OFILE *OFile
);
VOID
FatSetVolumeError (
IN FAT_OFILE *OFile,
IN EFI_STATUS Status
);
EFI_STATUS
FatIFileClose (
FAT_IFILE *IFile
);
EFI_STATUS
FatCleanupVolume (
IN FAT_VOLUME *Volume,
IN FAT_OFILE *OFile,
IN EFI_STATUS EfiStatus,
IN FAT_TASK *Task
);
//
// FileSpace.c
//
EFI_STATUS
FatShrinkEof (
IN FAT_OFILE *OFile
);
EFI_STATUS
FatGrowEof (
IN FAT_OFILE *OFile,
IN UINT64 NewSizeInBytes
);
UINTN
FatPhysicalDirSize (
IN FAT_VOLUME *Volume,
IN UINTN Cluster
);
UINT64
FatPhysicalFileSize (
IN FAT_VOLUME *Volume,
IN UINTN RealSize
);
EFI_STATUS
FatOFilePosition (
IN FAT_OFILE *OFile,
IN UINTN Position,
IN UINTN PosLimit
);
VOID
FatComputeFreeInfo (
IN FAT_VOLUME *Volume
);
//
// Init.c
//
EFI_STATUS
FatAllocateVolume (
IN EFI_HANDLE Handle,
IN EFI_DISK_IO_PROTOCOL *DiskIo,
IN EFI_DISK_IO2_PROTOCOL *DiskIo2,
IN EFI_BLOCK_IO_PROTOCOL *BlockIo
);
EFI_STATUS
FatOpenDevice (
IN OUT FAT_VOLUME *Volume
);
EFI_STATUS
FatAbandonVolume (
IN FAT_VOLUME *Volume
);
//
// Misc.c
//
FAT_TASK *
FatCreateTask (
FAT_IFILE *IFile,
EFI_FILE_IO_TOKEN *Token
);
VOID
FatDestroyTask (
FAT_TASK *Task
);
VOID
FatWaitNonblockingTask (
FAT_IFILE *IFile
);
LIST_ENTRY *
FatDestroySubtask (
FAT_SUBTASK *Subtask
);
EFI_STATUS
FatQueueTask (
IN FAT_IFILE *IFile,
IN FAT_TASK *Task
);
EFI_STATUS
FatAccessVolumeDirty (
IN FAT_VOLUME *Volume,
IN IO_MODE IoMode,
IN VOID *DirtyValue
);
EFI_STATUS
FatDiskIo (
IN FAT_VOLUME *Volume,
IN IO_MODE IoMode,
IN UINT64 Offset,
IN UINTN BufferSize,
IN OUT VOID *Buffer,
IN FAT_TASK *Task
);
VOID
FatAcquireLock (
VOID
);
VOID
FatReleaseLock (
VOID
);
EFI_STATUS
FatAcquireLockOrFail (
VOID
);
VOID
FatFreeDirEnt (
IN FAT_DIRENT *DirEnt
);
VOID
FatFreeVolume (
IN FAT_VOLUME *Volume
);
VOID
FatEfiTimeToFatTime (
IN EFI_TIME *ETime,
OUT FAT_DATE_TIME *FTime
);
VOID
FatFatTimeToEfiTime (
IN FAT_DATE_TIME *FTime,
OUT EFI_TIME *ETime
);
VOID
FatGetCurrentFatTime (
OUT FAT_DATE_TIME *FatTime
);
BOOLEAN
FatIsValidTime (
IN EFI_TIME *Time
);
//
// UnicodeCollation.c
//
EFI_STATUS
InitializeUnicodeCollationSupport (
IN EFI_HANDLE AgentHandle
);
VOID
FatFatToStr (
IN UINTN FatSize,
IN CHAR8 *Fat,
OUT CHAR16 *String
);
BOOLEAN
FatStrToFat (
IN CHAR16 *String,
IN UINTN FatSize,
OUT CHAR8 *Fat
);
VOID
FatStrLwr (
IN CHAR16 *Str
);
VOID
FatStrUpr (
IN CHAR16 *Str
);
INTN
FatStriCmp (
IN CHAR16 *Str1,
IN CHAR16 *Str2
);
//
// Open.c
//
EFI_STATUS
FatOFileOpen (
IN FAT_OFILE *OFile,
OUT FAT_IFILE **NewIFile,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT8 Attributes
);
EFI_STATUS
FatAllocateIFile (
IN FAT_OFILE *OFile,
OUT FAT_IFILE **PtrIFile
);
//
// OpenVolume.c
//
EFI_STATUS
EFIAPI
FatOpenVolume (
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **File
);
//
// ReadWrite.c
//
EFI_STATUS
FatAccessOFile (
IN FAT_OFILE *OFile,
IN IO_MODE IoMode,
IN UINTN Position,
IN UINTN *DataBufferSize,
IN UINT8 *UserBuffer,
IN FAT_TASK *Task
);
EFI_STATUS
FatExpandOFile (
IN FAT_OFILE *OFile,
IN UINT64 ExpandedSize
);
EFI_STATUS
FatWriteZeroPool (
IN FAT_OFILE *OFile,
IN UINTN WritePos
);
EFI_STATUS
FatTruncateOFile (
IN FAT_OFILE *OFile,
IN UINTN TruncatedSize
);
//
// DirectoryManage.c
//
VOID
FatResetODirCursor (
IN FAT_OFILE *OFile
);
EFI_STATUS
FatGetNextDirEnt (
IN FAT_OFILE *OFILE,
OUT FAT_DIRENT **PtrDirEnt
);
EFI_STATUS
FatRemoveDirEnt (
IN FAT_OFILE *OFile,
IN FAT_DIRENT *DirEnt
);
EFI_STATUS
FatStoreDirEnt (
IN FAT_OFILE *OFile,
IN FAT_DIRENT *DirEnt
);
EFI_STATUS
FatCreateDirEnt (
IN FAT_OFILE *OFile,
IN CHAR16 *FileName,
IN UINT8 Attributes,
OUT FAT_DIRENT **PtrDirEnt
);
BOOLEAN
FatIsDotDirEnt (
IN FAT_DIRENT *DirEnt
);
VOID
FatUpdateDirEntClusterSizeInfo (
IN FAT_OFILE *OFile
);
VOID
FatCloneDirEnt (
IN FAT_DIRENT *DirEnt1,
IN FAT_DIRENT *DirEnt2
);
EFI_STATUS
FatGetDirEntInfo (
IN FAT_VOLUME *Volume,
IN FAT_DIRENT *DirEnt,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
);
EFI_STATUS
FatOpenDirEnt (
IN FAT_OFILE *OFile,
IN FAT_DIRENT *DirEnt
);
EFI_STATUS
FatCreateDotDirEnts (
IN FAT_OFILE *OFile
);
VOID
FatCloseDirEnt (
IN FAT_DIRENT *DirEnt
);
EFI_STATUS
FatLocateOFile (
IN OUT FAT_OFILE **PtrOFile,
IN CHAR16 *FileName,
IN UINT8 Attributes,
OUT CHAR16 *NewFileName
);
EFI_STATUS
FatGetVolumeEntry (
IN FAT_VOLUME *Volume,
IN CHAR16 *Name
);
EFI_STATUS
FatSetVolumeEntry (
IN FAT_VOLUME *Volume,
IN CHAR16 *Name
);
//
// Hash.c
//
FAT_DIRENT **
FatLongNameHashSearch (
IN FAT_ODIR *ODir,
IN CHAR16 *LongNameString
);
FAT_DIRENT **
FatShortNameHashSearch (
IN FAT_ODIR *ODir,
IN CHAR8 *ShortNameString
);
VOID
FatInsertToHashTable (
IN FAT_ODIR *ODir,
IN FAT_DIRENT *DirEnt
);
VOID
FatDeleteFromHashTable (
IN FAT_ODIR *ODir,
IN FAT_DIRENT *DirEnt
);
//
// FileName.c
//
BOOLEAN
FatCheckIs8Dot3Name (
IN CHAR16 *FileName,
OUT CHAR8 *File8Dot3Name
);
VOID
FatCreate8Dot3Name (
IN FAT_OFILE *Parent,
IN FAT_DIRENT *DirEnt
);
VOID
FatNameToStr (
IN CHAR8 *FatName,
IN UINTN Len,
IN UINTN LowerCase,
IN CHAR16 *Str
);
VOID
FatSetCaseFlag (
IN FAT_DIRENT *DirEnt
);
VOID
FatGetFileNameViaCaseFlag (
IN FAT_DIRENT *DirEnt,
IN OUT CHAR16 *FileString,
IN UINTN FileStringMax
);
UINT8
FatCheckSum (
IN CHAR8 *ShortNameString
);
CHAR16*
FatGetNextNameComponent (
IN CHAR16 *Path,
OUT CHAR16 *Name
);
BOOLEAN
FatFileNameIsValid (
IN CHAR16 *InputFileName,
OUT CHAR16 *OutputFileName
);
//
// DirectoryCache.c
//
VOID
FatDiscardODir (
IN FAT_OFILE *OFile
);
VOID
FatRequestODir (
IN FAT_OFILE *OFile
);
VOID
FatCleanupODirCache (
IN FAT_VOLUME *Volume
);
//
// Global Variables
//
extern EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding;
extern EFI_COMPONENT_NAME_PROTOCOL gFatComponentName;
extern EFI_COMPONENT_NAME2_PROTOCOL gFatComponentName2;
extern EFI_LOCK FatFsLock;
extern EFI_LOCK FatTaskLock;
extern EFI_FILE_PROTOCOL FatFileInterface;
#endif
Reference in New Issue View Git Blame Copy Permalink