//\r
// EFI Component Name Functions\r
//\r
+\r
/**\r
Retrieves a Unicode string that is the user readable name of the driver.\r
\r
OUT CHAR16 **DriverName\r
);\r
\r
-\r
/**\r
Retrieves a Unicode string that is the user readable name of the controller\r
that is being managed by a driver.\r
EFI_STATUS\r
EFIAPI\r
FatComponentNameGetControllerName (\r
- IN EFI_COMPONENT_NAME_PROTOCOL *This,\r
- IN EFI_HANDLE ControllerHandle,\r
- IN EFI_HANDLE ChildHandle OPTIONAL,\r
- IN CHAR8 *Language,\r
- OUT CHAR16 **ControllerName\r
+ IN EFI_COMPONENT_NAME_PROTOCOL *This,\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN EFI_HANDLE ChildHandle OPTIONAL,\r
+ IN CHAR8 *Language,\r
+ OUT CHAR16 **ControllerName\r
);\r
\r
//\r
//\r
// EFI Component Name 2 Protocol\r
//\r
-GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gFatComponentName2 = {\r
- (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) FatComponentNameGetDriverName,\r
- (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) FatComponentNameGetControllerName,\r
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gFatComponentName2 = {\r
+ (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)FatComponentNameGetDriverName,\r
+ (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)FatComponentNameGetControllerName,\r
"en"\r
};\r
\r
-GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mFatDriverNameTable[] = {\r
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mFatDriverNameTable[] = {\r
{\r
"eng;en",\r
L"FAT File System Driver"\r
}\r
};\r
\r
-GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mFatControllerNameTable[] = {\r
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mFatControllerNameTable[] = {\r
{\r
"eng;en",\r
L"FAT File System"\r
}\r
};\r
\r
-\r
/**\r
Retrieves a Unicode string that is the user readable name of the driver.\r
\r
EFI_STATUS\r
EFIAPI\r
FatComponentNameGetControllerName (\r
- IN EFI_COMPONENT_NAME_PROTOCOL *This,\r
- IN EFI_HANDLE ControllerHandle,\r
- IN EFI_HANDLE ChildHandle OPTIONAL,\r
- IN CHAR8 *Language,\r
- OUT CHAR16 **ControllerName\r
+ IN EFI_COMPONENT_NAME_PROTOCOL *This,\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN EFI_HANDLE ChildHandle OPTIONAL,\r
+ IN CHAR8 *Language,\r
+ OUT CHAR16 **ControllerName\r
)\r
{\r
EFI_STATUS Status;\r
//\r
// FatFsLock - Global lock for synchronizing all requests.\r
//\r
-EFI_LOCK FatFsLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_CALLBACK);\r
+EFI_LOCK FatFsLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_CALLBACK);\r
\r
-EFI_LOCK FatTaskLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);\r
+EFI_LOCK FatTaskLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);\r
\r
//\r
// Filesystem interface functions\r
//\r
-EFI_FILE_PROTOCOL FatFileInterface = {\r
+EFI_FILE_PROTOCOL FatFileInterface = {\r
EFI_FILE_PROTOCOL_REVISION,\r
FatOpen,\r
FatClose,\r
Status = EFI_WRITE_PROTECTED;\r
goto Done;\r
}\r
+\r
//\r
// If the file is the root dir, then don't delete it\r
//\r
Status = EFI_ACCESS_DENIED;\r
goto Done;\r
}\r
+\r
//\r
// If the file has a permanent error, skip the delete\r
//\r
for (Round = 0; Round < 3; Round++) {\r
Status = FatGetNextDirEnt (OFile, &DirEnt);\r
if ((EFI_ERROR (Status)) ||\r
- ((Round < 2) && (DirEnt == NULL || !FatIsDotDirEnt (DirEnt))) ||\r
+ ((Round < 2) && ((DirEnt == NULL) || !FatIsDotDirEnt (DirEnt))) ||\r
((Round == 2) && (DirEnt != NULL))\r
- ) {\r
+ )\r
+ {\r
Status = EFI_ACCESS_DENIED;\r
goto Done;\r
}\r
}\r
}\r
+\r
//\r
// Return the file's space by setting its size to 0\r
//\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
}\r
+\r
//\r
// Set a permanent error for this OFile in case there\r
// are still opened IFiles attached\r
STATIC\r
VOID\r
FatFreeODir (\r
- IN FAT_ODIR *ODir\r
+ IN FAT_ODIR *ODir\r
)\r
{\r
FAT_DIRENT *DirEnt;\r
STATIC\r
FAT_ODIR *\r
FatAllocateODir (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
FAT_ODIR *ODir;\r
**/\r
VOID\r
FatDiscardODir (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
FAT_ODIR *ODir;\r
FAT_VOLUME *Volume;\r
\r
- Volume = OFile->Volume;\r
- ODir = OFile->ODir;\r
+ Volume = OFile->Volume;\r
+ ODir = OFile->ODir;\r
if (!OFile->DirEnt->Invalid) {\r
//\r
// If OFile does not represent a deleted file, then we will cache the directory\r
ODir = NULL;\r
}\r
}\r
+\r
//\r
// Release ODir Structure\r
//\r
**/\r
VOID\r
FatRequestODir (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
- UINTN DirCacheTag;\r
- FAT_VOLUME *Volume;\r
- FAT_ODIR *ODir;\r
- FAT_ODIR *CurrentODir;\r
- LIST_ENTRY *CurrentODirLink;\r
+ UINTN DirCacheTag;\r
+ FAT_VOLUME *Volume;\r
+ FAT_ODIR *ODir;\r
+ FAT_ODIR *CurrentODir;\r
+ LIST_ENTRY *CurrentODirLink;\r
\r
Volume = OFile->Volume;\r
ODir = NULL;\r
for (CurrentODirLink = Volume->DirCacheList.ForwardLink;\r
CurrentODirLink != &Volume->DirCacheList;\r
CurrentODirLink = CurrentODirLink->ForwardLink\r
- ) {\r
+ )\r
+ {\r
CurrentODir = ODIR_FROM_DIRCACHELINK (CurrentODirLink);\r
if (CurrentODir->DirCacheTag == DirCacheTag) {\r
RemoveEntryList (&CurrentODir->DirCacheLink);\r
**/\r
VOID\r
FatCleanupODirCache (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
FAT_ODIR *ODir;\r
+\r
while (Volume->DirCacheCount > 0) {\r
ODir = ODIR_FROM_DIRCACHELINK (Volume->DirCacheList.BackLink);\r
RemoveEntryList (&ODir->DirCacheLink);\r
STATIC\r
EFI_STATUS\r
FatAccessEntry (\r
- IN FAT_OFILE *Parent,\r
- IN IO_MODE IoMode,\r
- IN UINTN EntryPos,\r
- IN OUT VOID *Entry\r
+ IN FAT_OFILE *Parent,\r
+ IN IO_MODE IoMode,\r
+ IN UINTN EntryPos,\r
+ IN OUT VOID *Entry\r
)\r
{\r
- UINTN Position;\r
- UINTN BufferSize;\r
+ UINTN Position;\r
+ UINTN BufferSize;\r
\r
Position = EntryPos * sizeof (FAT_DIRECTORY_ENTRY);\r
if (Position >= Parent->FileSize) {\r
// End of directory\r
//\r
ASSERT (IoMode == ReadData);\r
- ((FAT_DIRECTORY_ENTRY *) Entry)->FileName[0] = EMPTY_ENTRY_MARK;\r
- ((FAT_DIRECTORY_ENTRY *) Entry)->Attributes = 0;\r
+ ((FAT_DIRECTORY_ENTRY *)Entry)->FileName[0] = EMPTY_ENTRY_MARK;\r
+ ((FAT_DIRECTORY_ENTRY *)Entry)->Attributes = 0;\r
return EFI_SUCCESS;\r
}\r
\r
**/\r
EFI_STATUS\r
FatStoreDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
- EFI_STATUS Status;\r
- FAT_DIRECTORY_LFN LfnEntry;\r
- UINTN EntryPos;\r
- CHAR16 *LfnBufferPointer;\r
- CHAR16 LfnBuffer[MAX_LFN_ENTRIES * LFN_CHAR_TOTAL + 1];\r
- UINT8 EntryCount;\r
- UINT8 LfnOrdinal;\r
+ EFI_STATUS Status;\r
+ FAT_DIRECTORY_LFN LfnEntry;\r
+ UINTN EntryPos;\r
+ CHAR16 *LfnBufferPointer;\r
+ CHAR16 LfnBuffer[MAX_LFN_ENTRIES * LFN_CHAR_TOTAL + 1];\r
+ UINT8 EntryCount;\r
+ UINT8 LfnOrdinal;\r
\r
EntryPos = DirEnt->EntryPos;\r
EntryCount = DirEnt->EntryCount;\r
)\r
{\r
CHAR16 *FileString;\r
+\r
FileString = DirEnt->FileString;\r
- if (StrCmp (FileString, L".") == 0 || StrCmp (FileString, L"..") == 0) {\r
+ if ((StrCmp (FileString, L".") == 0) || (StrCmp (FileString, L"..") == 0)) {\r
return TRUE;\r
}\r
\r
STATIC\r
VOID\r
FatSetDirEntCluster (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
UINTN Cluster;\r
\r
DirEnt = OFile->DirEnt;\r
Cluster = OFile->FileCluster;\r
- DirEnt->Entry.FileClusterHigh = (UINT16) (Cluster >> 16);\r
- DirEnt->Entry.FileCluster = (UINT16) Cluster;\r
+ DirEnt->Entry.FileClusterHigh = (UINT16)(Cluster >> 16);\r
+ DirEnt->Entry.FileCluster = (UINT16)Cluster;\r
}\r
\r
/**\r
**/\r
VOID\r
FatUpdateDirEntClusterSizeInfo (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
ASSERT (OFile->ODir == NULL);\r
- OFile->DirEnt->Entry.FileSize = (UINT32) OFile->FileSize;\r
+ OFile->DirEnt->Entry.FileSize = (UINT32)OFile->FileSize;\r
FatSetDirEntCluster (OFile);\r
}\r
\r
**/\r
VOID\r
FatCloneDirEnt (\r
- IN FAT_DIRENT *DirEnt1,\r
- IN FAT_DIRENT *DirEnt2\r
+ IN FAT_DIRENT *DirEnt1,\r
+ IN FAT_DIRENT *DirEnt2\r
)\r
{\r
- UINT8 *Entry1;\r
- UINT8 *Entry2;\r
- Entry1 = (UINT8 *) &DirEnt1->Entry;\r
- Entry2 = (UINT8 *) &DirEnt2->Entry;\r
+ UINT8 *Entry1;\r
+ UINT8 *Entry2;\r
+\r
+ Entry1 = (UINT8 *)&DirEnt1->Entry;\r
+ Entry2 = (UINT8 *)&DirEnt2->Entry;\r
CopyMem (\r
Entry1 + FAT_ENTRY_INFO_OFFSET,\r
Entry2 + FAT_ENTRY_INFO_OFFSET,\r
STATIC\r
VOID\r
FatLoadLongNameEntry (\r
- IN FAT_OFILE *Parent,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *Parent,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
- CHAR16 LfnBuffer[MAX_LFN_ENTRIES * LFN_CHAR_TOTAL + 1];\r
- CHAR16 *LfnBufferPointer;\r
- CHAR8 *File8Dot3Name;\r
- UINTN EntryPos;\r
- UINT8 LfnOrdinal;\r
- UINT8 LfnChecksum;\r
- FAT_DIRECTORY_LFN LfnEntry;\r
- EFI_STATUS Status;\r
-\r
- EntryPos = DirEnt->EntryPos;\r
- File8Dot3Name = DirEnt->Entry.FileName;\r
- LfnBufferPointer = LfnBuffer;\r
+ CHAR16 LfnBuffer[MAX_LFN_ENTRIES * LFN_CHAR_TOTAL + 1];\r
+ CHAR16 *LfnBufferPointer;\r
+ CHAR8 *File8Dot3Name;\r
+ UINTN EntryPos;\r
+ UINT8 LfnOrdinal;\r
+ UINT8 LfnChecksum;\r
+ FAT_DIRECTORY_LFN LfnEntry;\r
+ EFI_STATUS Status;\r
+\r
+ EntryPos = DirEnt->EntryPos;\r
+ File8Dot3Name = DirEnt->Entry.FileName;\r
+ LfnBufferPointer = LfnBuffer;\r
//\r
// Computes checksum for LFN\r
//\r
EntryPos--;\r
Status = FatAccessEntry (Parent, ReadData, EntryPos, &LfnEntry);\r
if (EFI_ERROR (Status) ||\r
- LfnEntry.Attributes != FAT_ATTRIBUTE_LFN ||\r
- LfnEntry.MustBeZero != 0 ||\r
- LfnEntry.Checksum != LfnChecksum ||\r
- (LfnEntry.Ordinal & (~FAT_LFN_LAST)) != LfnOrdinal ||\r
- LfnOrdinal > MAX_LFN_ENTRIES\r
- ) {\r
+ (LfnEntry.Attributes != FAT_ATTRIBUTE_LFN) ||\r
+ (LfnEntry.MustBeZero != 0) ||\r
+ (LfnEntry.Checksum != LfnChecksum) ||\r
+ ((LfnEntry.Ordinal & (~FAT_LFN_LAST)) != LfnOrdinal) ||\r
+ (LfnOrdinal > MAX_LFN_ENTRIES)\r
+ )\r
+ {\r
//\r
// The directory entry does not have a long file name or\r
// some error occurs when loading long file name for a directory entry,\r
LfnBufferPointer += LFN_CHAR3_LEN;\r
LfnOrdinal++;\r
} while ((LfnEntry.Ordinal & FAT_LFN_LAST) == 0);\r
+\r
DirEnt->EntryCount = LfnOrdinal;\r
//\r
// Terminate current Lfnbuffer\r
STATIC\r
VOID\r
FatAddDirEnt (\r
- IN FAT_ODIR *ODir,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_ODIR *ODir,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
if (DirEnt->Link.BackLink == NULL) {\r
DirEnt->Link.BackLink = &ODir->ChildList;\r
}\r
+\r
InsertTailList (DirEnt->Link.BackLink, &DirEnt->Link);\r
FatInsertToHashTable (ODir, DirEnt);\r
}\r
STATIC\r
EFI_STATUS\r
FatLoadNextDirEnt (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_DIRENT **PtrDirEnt\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_DIRENT **PtrDirEnt\r
)\r
{\r
- EFI_STATUS Status;\r
- FAT_DIRENT *DirEnt;\r
- FAT_ODIR *ODir;\r
- FAT_DIRECTORY_ENTRY Entry;\r
+ EFI_STATUS Status;\r
+ FAT_DIRENT *DirEnt;\r
+ FAT_ODIR *ODir;\r
+ FAT_DIRECTORY_ENTRY Entry;\r
\r
ODir = OFile->ODir;\r
//\r
ASSERT (!ODir->EndOfDir);\r
DirEnt = NULL;\r
\r
- for (;;) {\r
+ for ( ; ;) {\r
//\r
// Read the next directory entry until we find a valid directory entry (excluding lfn entry)\r
//\r
return Status;\r
}\r
\r
- if (((UINT8) Entry.FileName[0] != DELETE_ENTRY_MARK) && (Entry.Attributes & FAT_ATTRIBUTE_VOLUME_ID) == 0) {\r
+ if (((UINT8)Entry.FileName[0] != DELETE_ENTRY_MARK) && ((Entry.Attributes & FAT_ATTRIBUTE_VOLUME_ID) == 0)) {\r
//\r
// We get a valid directory entry, then handle it\r
//\r
//\r
// Remember the directory's entry position on disk\r
//\r
- DirEnt->EntryPos = (UINT16) ODir->CurrentEndPos;\r
+ DirEnt->EntryPos = (UINT16)ODir->CurrentEndPos;\r
CopyMem (&DirEnt->Entry, &Entry, sizeof (FAT_DIRECTORY_ENTRY));\r
FatLoadLongNameEntry (OFile, DirEnt);\r
if (DirEnt->FileString == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
}\r
+\r
//\r
// Add this directory entry to directory\r
//\r
**/\r
EFI_STATUS\r
FatGetDirEntInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_DIRENT *DirEnt,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_DIRENT *DirEnt,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
- UINTN Size;\r
- UINTN NameSize;\r
- UINTN ResultSize;\r
- UINTN Cluster;\r
- EFI_STATUS Status;\r
- EFI_FILE_INFO *Info;\r
- FAT_DIRECTORY_ENTRY *Entry;\r
- FAT_DATE_TIME FatLastAccess;\r
+ UINTN Size;\r
+ UINTN NameSize;\r
+ UINTN ResultSize;\r
+ UINTN Cluster;\r
+ EFI_STATUS Status;\r
+ EFI_FILE_INFO *Info;\r
+ FAT_DIRECTORY_ENTRY *Entry;\r
+ FAT_DATE_TIME FatLastAccess;\r
\r
ASSERT_VOLUME_LOCKED (Volume);\r
\r
- Size = SIZE_OF_EFI_FILE_INFO;\r
- NameSize = StrSize (DirEnt->FileString);\r
- ResultSize = Size + NameSize;\r
+ Size = SIZE_OF_EFI_FILE_INFO;\r
+ NameSize = StrSize (DirEnt->FileString);\r
+ ResultSize = Size + NameSize;\r
\r
- Status = EFI_BUFFER_TOO_SMALL;\r
+ Status = EFI_BUFFER_TOO_SMALL;\r
if (*BufferSize >= ResultSize) {\r
- Status = EFI_SUCCESS;\r
- Entry = &DirEnt->Entry;\r
- Info = Buffer;\r
- Info->Size = ResultSize;\r
+ Status = EFI_SUCCESS;\r
+ Entry = &DirEnt->Entry;\r
+ Info = Buffer;\r
+ Info->Size = ResultSize;\r
if ((Entry->Attributes & FAT_ATTRIBUTE_DIRECTORY) != 0) {\r
- Cluster = (Entry->FileClusterHigh << 16) | Entry->FileCluster;\r
- Info->PhysicalSize = FatPhysicalDirSize (Volume, Cluster);\r
- Info->FileSize = Info->PhysicalSize;\r
+ Cluster = (Entry->FileClusterHigh << 16) | Entry->FileCluster;\r
+ Info->PhysicalSize = FatPhysicalDirSize (Volume, Cluster);\r
+ Info->FileSize = Info->PhysicalSize;\r
} else {\r
- Info->FileSize = Entry->FileSize;\r
- Info->PhysicalSize = FatPhysicalFileSize (Volume, Entry->FileSize);\r
+ Info->FileSize = Entry->FileSize;\r
+ Info->PhysicalSize = FatPhysicalFileSize (Volume, Entry->FileSize);\r
}\r
\r
ZeroMem (&FatLastAccess.Time, sizeof (FatLastAccess.Time));\r
FatFatTimeToEfiTime (&Entry->FileCreateTime, &Info->CreateTime);\r
FatFatTimeToEfiTime (&Entry->FileModificationTime, &Info->ModificationTime);\r
Info->Attribute = Entry->Attributes & EFI_FILE_VALID_ATTR;\r
- CopyMem ((CHAR8 *) Buffer + Size, DirEnt->FileString, NameSize);\r
+ CopyMem ((CHAR8 *)Buffer + Size, DirEnt->FileString, NameSize);\r
}\r
\r
*BufferSize = ResultSize;\r
STATIC\r
EFI_STATUS\r
FatSearchODir (\r
- IN FAT_OFILE *OFile,\r
- IN CHAR16 *FileNameString,\r
- OUT FAT_DIRENT **PtrDirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN CHAR16 *FileNameString,\r
+ OUT FAT_DIRENT **PtrDirEnt\r
)\r
{\r
BOOLEAN PossibleShortName;\r
// Search the hash table first\r
//\r
DirEnt = *FatLongNameHashSearch (ODir, FileNameString);\r
- if (DirEnt == NULL && PossibleShortName) {\r
- DirEnt = *FatShortNameHashSearch (ODir, File8Dot3Name);\r
+ if ((DirEnt == NULL) && PossibleShortName) {\r
+ DirEnt = *FatShortNameHashSearch (ODir, File8Dot3Name);\r
}\r
+\r
if (DirEnt == NULL) {\r
//\r
// We fail to get the directory entry from hash table; we then\r
break;\r
}\r
\r
- if (PossibleShortName && CompareMem (File8Dot3Name, DirEnt->Entry.FileName, FAT_NAME_LEN) == 0) {\r
+ if (PossibleShortName && (CompareMem (File8Dot3Name, DirEnt->Entry.FileName, FAT_NAME_LEN) == 0)) {\r
break;\r
}\r
}\r
**/\r
VOID\r
FatResetODirCursor (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
FAT_ODIR *ODir;\r
**/\r
EFI_STATUS\r
FatGetNextDirEnt (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_DIRENT **PtrDirEnt\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_DIRENT **PtrDirEnt\r
)\r
{\r
EFI_STATUS Status;\r
//\r
// End of directory, return NULL\r
//\r
- DirEnt = NULL;\r
- ODir->CurrentPos = ODir->CurrentEndPos;\r
+ DirEnt = NULL;\r
+ ODir->CurrentPos = ODir->CurrentEndPos;\r
} else {\r
ODir->CurrentCursor = ODir->CurrentCursor->ForwardLink;\r
DirEnt = DIRENT_FROM_LINK (ODir->CurrentCursor);\r
STATIC\r
VOID\r
FatSetEntryCount (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
CHAR16 *FileString;\r
//\r
// Get new entry count and set the 8.3 name\r
//\r
- DirEnt->EntryCount = 1;\r
- FileString = DirEnt->FileString;\r
- File8Dot3Name = DirEnt->Entry.FileName;\r
+ DirEnt->EntryCount = 1;\r
+ FileString = DirEnt->FileString;\r
+ File8Dot3Name = DirEnt->Entry.FileName;\r
SetMem (File8Dot3Name, FAT_NAME_LEN, ' ');\r
if (StrCmp (FileString, L".") == 0) {\r
//\r
//\r
// ".." entry\r
//\r
- File8Dot3Name[0] = '.';\r
- File8Dot3Name[1] = '.';\r
+ File8Dot3Name[0] = '.';\r
+ File8Dot3Name[1] = '.';\r
FatCloneDirEnt (DirEnt, OFile->Parent->DirEnt);\r
} else {\r
//\r
STATIC\r
EFI_STATUS\r
FatSeekVolumeId (\r
- IN FAT_OFILE *Root,\r
- OUT FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *Root,\r
+ OUT FAT_DIRENT *DirEnt\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN EntryPos;\r
- FAT_DIRECTORY_ENTRY *Entry;\r
+ EFI_STATUS Status;\r
+ UINTN EntryPos;\r
+ FAT_DIRECTORY_ENTRY *Entry;\r
\r
EntryPos = 0;\r
Entry = &DirEnt->Entry;\r
return Status;\r
}\r
\r
- if (((UINT8) Entry->FileName[0] != DELETE_ENTRY_MARK) && (((Entry->Attributes) & (~FAT_ATTRIBUTE_ARCHIVE)) == FAT_ATTRIBUTE_VOLUME_ID)) {\r
- DirEnt->EntryPos = (UINT16) EntryPos;\r
+ if (((UINT8)Entry->FileName[0] != DELETE_ENTRY_MARK) && (((Entry->Attributes) & (~FAT_ATTRIBUTE_ARCHIVE)) == FAT_ATTRIBUTE_VOLUME_ID)) {\r
+ DirEnt->EntryPos = (UINT16)EntryPos;\r
DirEnt->EntryCount = 1;\r
DirEnt->Invalid = FALSE;\r
break;\r
\r
EntryPos++;\r
} while (Entry->FileName[0] != EMPTY_ENTRY_MARK);\r
+\r
return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
FatFirstFitInsertDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
- EFI_STATUS Status;\r
- FAT_ODIR *ODir;\r
- LIST_ENTRY *CurrentEntry;\r
- FAT_DIRENT *CurrentDirEnt;\r
- UINT32 CurrentPos;\r
- UINT32 LabelPos;\r
- UINT32 NewEntryPos;\r
- UINT16 EntryCount;\r
- FAT_DIRENT LabelDirEnt;\r
+ EFI_STATUS Status;\r
+ FAT_ODIR *ODir;\r
+ LIST_ENTRY *CurrentEntry;\r
+ FAT_DIRENT *CurrentDirEnt;\r
+ UINT32 CurrentPos;\r
+ UINT32 LabelPos;\r
+ UINT32 NewEntryPos;\r
+ UINT16 EntryCount;\r
+ FAT_DIRENT LabelDirEnt;\r
\r
LabelPos = 0;\r
if (OFile->Parent == NULL) {\r
for (CurrentEntry = ODir->ChildList.ForwardLink;\r
CurrentEntry != &ODir->ChildList;\r
CurrentEntry = CurrentEntry->ForwardLink\r
- ) {\r
+ )\r
+ {\r
CurrentDirEnt = DIRENT_FROM_LINK (CurrentEntry);\r
if (NewEntryPos + CurrentDirEnt->EntryCount <= CurrentDirEnt->EntryPos) {\r
- if (LabelPos > NewEntryPos || LabelPos <= CurrentPos) {\r
+ if ((LabelPos > NewEntryPos) || (LabelPos <= CurrentPos)) {\r
//\r
// first fit succeeded\r
//\r
}\r
\r
Done:\r
- DirEnt->EntryPos = (UINT16) NewEntryPos;\r
+ DirEnt->EntryPos = (UINT16)NewEntryPos;\r
DirEnt->Link.BackLink = CurrentEntry;\r
return EFI_SUCCESS;\r
}\r
STATIC\r
EFI_STATUS\r
FatNewEntryPos (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
EFI_STATUS Status;\r
return Status;\r
}\r
}\r
+\r
//\r
// We will append this entry to the end of directory\r
//\r
//\r
return FatFirstFitInsertDirEnt (OFile, DirEnt);\r
}\r
+\r
//\r
// We should allocate a new cluster for this directory\r
//\r
return Status;\r
}\r
}\r
+\r
//\r
// We append our directory entry at the end of directory file\r
//\r
ODir->CurrentEndPos = NewEndPos;\r
- DirEnt->EntryPos = (UINT16) (ODir->CurrentEndPos - 1);\r
+ DirEnt->EntryPos = (UINT16)(ODir->CurrentEndPos - 1);\r
return EFI_SUCCESS;\r
}\r
\r
**/\r
EFI_STATUS\r
FatGetVolumeEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN CHAR16 *Name\r
+ IN FAT_VOLUME *Volume,\r
+ IN CHAR16 *Name\r
)\r
{\r
EFI_STATUS Status;\r
FAT_DIRENT LabelDirEnt;\r
\r
- *Name = 0;\r
- Status = FatSeekVolumeId (Volume->Root, &LabelDirEnt);\r
+ *Name = 0;\r
+ Status = FatSeekVolumeId (Volume->Root, &LabelDirEnt);\r
if (!EFI_ERROR (Status)) {\r
if (!LabelDirEnt.Invalid) {\r
FatNameToStr (LabelDirEnt.Entry.FileName, FAT_NAME_LEN, FALSE, Name);\r
**/\r
EFI_STATUS\r
FatSetVolumeEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN CHAR16 *Name\r
+ IN FAT_VOLUME *Volume,\r
+ IN CHAR16 *Name\r
)\r
{\r
EFI_STATUS Status;\r
FAT_DIRENT LabelDirEnt;\r
FAT_OFILE *Root;\r
\r
- Root = Volume->Root;\r
- Status = FatSeekVolumeId (Volume->Root, &LabelDirEnt);\r
+ Root = Volume->Root;\r
+ Status = FatSeekVolumeId (Volume->Root, &LabelDirEnt);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
**/\r
EFI_STATUS\r
FatCreateDotDirEnts (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
EFI_STATUS Status;\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
+\r
//\r
// Create ".."\r
//\r
**/\r
EFI_STATUS\r
FatCreateDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN CHAR16 *FileName,\r
- IN UINT8 Attributes,\r
- OUT FAT_DIRENT **PtrDirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN CHAR16 *FileName,\r
+ IN UINT8 Attributes,\r
+ OUT FAT_DIRENT **PtrDirEnt\r
)\r
{\r
FAT_DIRENT *DirEnt;\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- DirEnt->Signature = FAT_DIRENT_SIGNATURE;\r
- DirEnt->FileString = AllocateCopyPool (StrSize (FileName), FileName);\r
+ DirEnt->Signature = FAT_DIRENT_SIGNATURE;\r
+ DirEnt->FileString = AllocateCopyPool (StrSize (FileName), FileName);\r
if (DirEnt->FileString == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
}\r
+\r
//\r
// Determine how many directory entries we need\r
//\r
**/\r
EFI_STATUS\r
FatRemoveDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
FAT_ODIR *ODir;\r
//\r
ODir->CurrentCursor = ODir->CurrentCursor->BackLink;\r
}\r
+\r
//\r
// Remove from directory entry list\r
//\r
**/\r
EFI_STATUS\r
FatOpenDirEnt (\r
- IN FAT_OFILE *Parent,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *Parent,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
FAT_OFILE *OFile;\r
//\r
// The newly created OFile is root\r
//\r
- Volume = VOLUME_FROM_ROOT_DIRENT (DirEnt);\r
- Volume->Root = OFile;\r
- OFile->FileCluster = Volume->RootCluster;\r
+ Volume = VOLUME_FROM_ROOT_DIRENT (DirEnt);\r
+ Volume->Root = OFile;\r
+ OFile->FileCluster = Volume->RootCluster;\r
if (Volume->FatType != Fat32) {\r
- OFile->IsFixedRootDir = TRUE;\r
+ OFile->IsFixedRootDir = TRUE;\r
}\r
}\r
\r
- OFile->FileCurrentCluster = OFile->FileCluster;\r
- OFile->Volume = Volume;\r
+ OFile->FileCurrentCluster = OFile->FileCluster;\r
+ OFile->Volume = Volume;\r
InsertHeadList (&Volume->CheckRef, &OFile->CheckLink);\r
\r
OFile->FileSize = DirEnt->Entry.FileSize;\r
**/\r
VOID\r
FatCloseDirEnt (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
FAT_OFILE *OFile;\r
FAT_VOLUME *Volume;\r
\r
- OFile = DirEnt->OFile;\r
+ OFile = DirEnt->OFile;\r
ASSERT (OFile != NULL);\r
- Volume = OFile->Volume;\r
+ Volume = OFile->Volume;\r
\r
if (OFile->ODir != NULL) {\r
FatDiscardODir (OFile);\r
**/\r
EFI_STATUS\r
FatLocateOFile (\r
- IN OUT FAT_OFILE **PtrOFile,\r
- IN CHAR16 *FileName,\r
- IN UINT8 Attributes,\r
- OUT CHAR16 *NewFileName\r
+ IN OUT FAT_OFILE **PtrOFile,\r
+ IN CHAR16 *FileName,\r
+ IN UINT8 Attributes,\r
+ OUT CHAR16 *NewFileName\r
)\r
{\r
EFI_STATUS Status;\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- OFile = *PtrOFile;\r
- Volume = OFile->Volume;\r
+ OFile = *PtrOFile;\r
+ Volume = OFile->Volume;\r
\r
DirIntended = FALSE;\r
if (FileName[FileNameLen - 1] == PATH_NAME_SEPARATOR) {\r
DirIntended = TRUE;\r
}\r
+\r
//\r
// If name starts with path name separator, then move to root OFile\r
//\r
FileName++;\r
FileNameLen--;\r
}\r
+\r
//\r
// Per FAT Spec the file name should meet the following criteria:\r
// C1. Length (FileLongName) <= 255\r
//\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
//\r
// Start at current location\r
//\r
Next = FileName;\r
- for (;;) {\r
+ for ( ; ;) {\r
//\r
// Get the next component name\r
//\r
// If end of the file name, we're done\r
//\r
if (ComponentName[0] == 0) {\r
- if (DirIntended && OFile->ODir == NULL) {\r
+ if (DirIntended && (OFile->ODir == NULL)) {\r
return EFI_NOT_FOUND;\r
}\r
\r
NewFileName[0] = 0;\r
break;\r
}\r
+\r
//\r
// If "dot", then current\r
//\r
if (StrCmp (ComponentName, L".") == 0) {\r
continue;\r
}\r
+\r
//\r
// If "dot dot", then parent\r
//\r
if (OFile->Parent == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
OFile = OFile->Parent;\r
continue;\r
}\r
if (!FatFileNameIsValid (ComponentName, NewFileName)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
//\r
// We have a component name, try to open it\r
//\r
//\r
return EFI_NOT_FOUND;\r
}\r
+\r
//\r
// Search the compName in the directory\r
//\r
return EFI_NOT_FOUND;\r
}\r
\r
- if (DirIntended && (Attributes & FAT_ATTRIBUTE_DIRECTORY) == 0) {\r
+ if (DirIntended && ((Attributes & FAT_ATTRIBUTE_DIRECTORY) == 0)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
//\r
// It's the last component name - return with the open\r
// path and the remaining name\r
STATIC\r
VOID\r
FatFlushDataCacheRange (\r
- IN FAT_VOLUME *Volume,\r
- IN IO_MODE IoMode,\r
- IN UINTN StartPageNo,\r
- IN UINTN EndPageNo,\r
- OUT UINT8 *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN IO_MODE IoMode,\r
+ IN UINTN StartPageNo,\r
+ IN UINTN EndPageNo,\r
+ OUT UINT8 *Buffer\r
)\r
{\r
UINTN PageNo;\r
PageSize = (UINTN)1 << PageAlignment;\r
\r
for (PageNo = StartPageNo; PageNo < EndPageNo; PageNo++) {\r
- GroupNo = PageNo & GroupMask;\r
- CacheTag = &DiskCache->CacheTag[GroupNo];\r
- if (CacheTag->RealSize > 0 && CacheTag->PageNo == PageNo) {\r
+ GroupNo = PageNo & GroupMask;\r
+ CacheTag = &DiskCache->CacheTag[GroupNo];\r
+ if ((CacheTag->RealSize > 0) && (CacheTag->PageNo == PageNo)) {\r
//\r
// When reading data form disk directly, if some dirty data\r
// in cache is in this rang, this data in the Buffer need to\r
STATIC\r
EFI_STATUS\r
FatExchangeCachePage (\r
- IN FAT_VOLUME *Volume,\r
- IN CACHE_DATA_TYPE DataType,\r
- IN IO_MODE IoMode,\r
- IN CACHE_TAG *CacheTag,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN CACHE_DATA_TYPE DataType,\r
+ IN IO_MODE IoMode,\r
+ IN CACHE_TAG *CacheTag,\r
+ IN FAT_TASK *Task\r
)\r
{\r
EFI_STATUS Status;\r
EntryPos = DiskCache->BaseAddress + LShiftU64 (PageNo, PageAlignment);\r
RealSize = CacheTag->RealSize;\r
if (IoMode == ReadDisk) {\r
- RealSize = (UINTN)1 << PageAlignment;\r
- MaxSize = DiskCache->LimitAddress - EntryPos;\r
+ RealSize = (UINTN)1 << PageAlignment;\r
+ MaxSize = DiskCache->LimitAddress - EntryPos;\r
if (MaxSize < RealSize) {\r
DEBUG ((DEBUG_INFO, "FatDiskIo: Cache Page OutBound occurred! \n"));\r
- RealSize = (UINTN) MaxSize;\r
+ RealSize = (UINTN)MaxSize;\r
}\r
}\r
\r
WriteCount = 1;\r
- if (DataType == CacheFat && IoMode == WriteDisk) {\r
+ if ((DataType == CacheFat) && (IoMode == WriteDisk)) {\r
WriteCount = Volume->NumFats;\r
}\r
\r
EntryPos += Volume->FatSize;\r
} while (--WriteCount > 0);\r
\r
- CacheTag->Dirty = FALSE;\r
- CacheTag->RealSize = RealSize;\r
+ CacheTag->Dirty = FALSE;\r
+ CacheTag->RealSize = RealSize;\r
return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
FatGetCachePage (\r
- IN FAT_VOLUME *Volume,\r
- IN CACHE_DATA_TYPE CacheDataType,\r
- IN UINTN PageNo,\r
- IN CACHE_TAG *CacheTag\r
+ IN FAT_VOLUME *Volume,\r
+ IN CACHE_DATA_TYPE CacheDataType,\r
+ IN UINTN PageNo,\r
+ IN CACHE_TAG *CacheTag\r
)\r
{\r
EFI_STATUS Status;\r
UINTN OldPageNo;\r
\r
OldPageNo = CacheTag->PageNo;\r
- if (CacheTag->RealSize > 0 && OldPageNo == PageNo) {\r
+ if ((CacheTag->RealSize > 0) && (OldPageNo == PageNo)) {\r
//\r
// Cache Hit occurred\r
//\r
//\r
// Write dirty cache page back to disk\r
//\r
- if (CacheTag->RealSize > 0 && CacheTag->Dirty) {\r
+ if ((CacheTag->RealSize > 0) && CacheTag->Dirty) {\r
Status = FatExchangeCachePage (Volume, CacheDataType, WriteDisk, CacheTag, NULL);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
}\r
+\r
//\r
// Load new data from disk;\r
//\r
- CacheTag->PageNo = PageNo;\r
- Status = FatExchangeCachePage (Volume, CacheDataType, ReadDisk, CacheTag, NULL);\r
+ CacheTag->PageNo = PageNo;\r
+ Status = FatExchangeCachePage (Volume, CacheDataType, ReadDisk, CacheTag, NULL);\r
\r
return Status;\r
}\r
STATIC\r
EFI_STATUS\r
FatAccessUnalignedCachePage (\r
- IN FAT_VOLUME *Volume,\r
- IN CACHE_DATA_TYPE CacheDataType,\r
- IN IO_MODE IoMode,\r
- IN UINTN PageNo,\r
- IN UINTN Offset,\r
- IN UINTN Length,\r
- IN OUT VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN CACHE_DATA_TYPE CacheDataType,\r
+ IN IO_MODE IoMode,\r
+ IN UINTN PageNo,\r
+ IN UINTN Offset,\r
+ IN UINTN Length,\r
+ IN OUT VOID *Buffer\r
)\r
{\r
EFI_STATUS Status;\r
Source = DiskCache->CacheBase + (GroupNo << DiskCache->PageAlignment) + Offset;\r
Destination = Buffer;\r
if (IoMode != ReadDisk) {\r
- CacheTag->Dirty = TRUE;\r
- DiskCache->Dirty = TRUE;\r
- Destination = Source;\r
- Source = Buffer;\r
+ CacheTag->Dirty = TRUE;\r
+ DiskCache->Dirty = TRUE;\r
+ Destination = Source;\r
+ Source = Buffer;\r
}\r
\r
CopyMem (Destination, Source, Length);\r
**/\r
EFI_STATUS\r
FatAccessCache (\r
- IN FAT_VOLUME *Volume,\r
- IN CACHE_DATA_TYPE CacheDataType,\r
- IN IO_MODE IoMode,\r
- IN UINT64 Offset,\r
- IN UINTN BufferSize,\r
- IN OUT UINT8 *Buffer,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN CACHE_DATA_TYPE CacheDataType,\r
+ IN IO_MODE IoMode,\r
+ IN UINT64 Offset,\r
+ IN UINTN BufferSize,\r
+ IN OUT UINT8 *Buffer,\r
+ IN FAT_TASK *Task\r
)\r
{\r
EFI_STATUS Status;\r
EntryPos = Offset - DiskCache->BaseAddress;\r
PageAlignment = DiskCache->PageAlignment;\r
PageSize = (UINTN)1 << PageAlignment;\r
- PageNo = (UINTN) RShiftU64 (EntryPos, PageAlignment);\r
- UnderRun = ((UINTN) EntryPos) & (PageSize - 1);\r
+ PageNo = (UINTN)RShiftU64 (EntryPos, PageAlignment);\r
+ UnderRun = ((UINTN)EntryPos) & (PageSize - 1);\r
\r
if (UnderRun > 0) {\r
Length = PageSize - UnderRun;\r
PageNo++;\r
}\r
\r
- AlignedPageCount = BufferSize >> PageAlignment;\r
- OverRunPageNo = PageNo + AlignedPageCount;\r
+ AlignedPageCount = BufferSize >> PageAlignment;\r
+ OverRunPageNo = PageNo + AlignedPageCount;\r
//\r
// The access of the Aligned data\r
//\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
+\r
//\r
// If these access data over laps the relative cache range, these cache pages need\r
// to be updated.\r
//\r
FatFlushDataCacheRange (Volume, IoMode, PageNo, OverRunPageNo, Buffer);\r
- Buffer += AlignedSize;\r
- BufferSize -= AlignedSize;\r
+ Buffer += AlignedSize;\r
+ BufferSize -= AlignedSize;\r
}\r
+\r
//\r
// The access of the OverRun data\r
//\r
**/\r
EFI_STATUS\r
FatVolumeFlushCache (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_TASK *Task\r
)\r
{\r
- EFI_STATUS Status;\r
- CACHE_DATA_TYPE CacheDataType;\r
- UINTN GroupIndex;\r
- UINTN GroupMask;\r
- DISK_CACHE *DiskCache;\r
- CACHE_TAG *CacheTag;\r
-\r
- for (CacheDataType = (CACHE_DATA_TYPE) 0; CacheDataType < CacheMaxType; CacheDataType++) {\r
+ EFI_STATUS Status;\r
+ CACHE_DATA_TYPE CacheDataType;\r
+ UINTN GroupIndex;\r
+ UINTN GroupMask;\r
+ DISK_CACHE *DiskCache;\r
+ CACHE_TAG *CacheTag;\r
+\r
+ for (CacheDataType = (CACHE_DATA_TYPE)0; CacheDataType < CacheMaxType; CacheDataType++) {\r
DiskCache = &Volume->DiskCache[CacheDataType];\r
if (DiskCache->Dirty) {\r
//\r
GroupMask = DiskCache->GroupMask;\r
for (GroupIndex = 0; GroupIndex <= GroupMask; GroupIndex++) {\r
CacheTag = &DiskCache->CacheTag[GroupIndex];\r
- if (CacheTag->RealSize > 0 && CacheTag->Dirty) {\r
+ if ((CacheTag->RealSize > 0) && CacheTag->Dirty) {\r
//\r
// Write back all Dirty Data Cache Page to disk\r
//\r
DiskCache->Dirty = FALSE;\r
}\r
}\r
+\r
//\r
// Flush the block device.\r
//\r
**/\r
EFI_STATUS\r
FatInitializeDiskCache (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
DISK_CACHE *DiskCache;\r
// Configure the parameters of disk cache\r
//\r
if (Volume->FatType == Fat12) {\r
- FatCacheGroupCount = FAT_FATCACHE_GROUP_MIN_COUNT;\r
+ FatCacheGroupCount = FAT_FATCACHE_GROUP_MIN_COUNT;\r
DiskCache[CacheFat].PageAlignment = FAT_FATCACHE_PAGE_MIN_ALIGNMENT;\r
DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MIN_ALIGNMENT;\r
} else {\r
- FatCacheGroupCount = FAT_FATCACHE_GROUP_MAX_COUNT;\r
+ FatCacheGroupCount = FAT_FATCACHE_GROUP_MAX_COUNT;\r
DiskCache[CacheFat].PageAlignment = FAT_FATCACHE_PAGE_MAX_ALIGNMENT;\r
DiskCache[CacheData].PageAlignment = FAT_DATACACHE_PAGE_MAX_ALIGNMENT;\r
}\r
\r
- DiskCache[CacheData].GroupMask = FAT_DATACACHE_GROUP_COUNT - 1;\r
- DiskCache[CacheData].BaseAddress = Volume->RootPos;\r
- DiskCache[CacheData].LimitAddress = Volume->VolumeSize;\r
- DiskCache[CacheFat].GroupMask = FatCacheGroupCount - 1;\r
- DiskCache[CacheFat].BaseAddress = Volume->FatPos;\r
- DiskCache[CacheFat].LimitAddress = Volume->FatPos + Volume->FatSize;\r
- FatCacheSize = FatCacheGroupCount << DiskCache[CacheFat].PageAlignment;\r
- DataCacheSize = FAT_DATACACHE_GROUP_COUNT << DiskCache[CacheData].PageAlignment;\r
+ DiskCache[CacheData].GroupMask = FAT_DATACACHE_GROUP_COUNT - 1;\r
+ DiskCache[CacheData].BaseAddress = Volume->RootPos;\r
+ DiskCache[CacheData].LimitAddress = Volume->VolumeSize;\r
+ DiskCache[CacheFat].GroupMask = FatCacheGroupCount - 1;\r
+ DiskCache[CacheFat].BaseAddress = Volume->FatPos;\r
+ DiskCache[CacheFat].LimitAddress = Volume->FatPos + Volume->FatSize;\r
+ FatCacheSize = FatCacheGroupCount << DiskCache[CacheFat].PageAlignment;\r
+ DataCacheSize = FAT_DATACACHE_GROUP_COUNT << DiskCache[CacheData].PageAlignment;\r
//\r
// Allocate the Fat Cache buffer\r
//\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- Volume->CacheBuffer = CacheBuffer;\r
+ Volume->CacheBuffer = CacheBuffer;\r
DiskCache[CacheFat].CacheBase = CacheBuffer;\r
DiskCache[CacheData].CacheBase = CacheBuffer + FatCacheSize;\r
return EFI_SUCCESS;\r
EFI_STATUS\r
EFIAPI\r
FatEntryPoint (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_SYSTEM_TABLE *SystemTable\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
);\r
\r
/**\r
EFI_STATUS\r
EFIAPI\r
FatUnload (\r
- IN EFI_HANDLE ImageHandle\r
+ IN EFI_HANDLE ImageHandle\r
);\r
\r
/**\r
//\r
// DriverBinding protocol instance\r
//\r
-EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding = {\r
+EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding = {\r
FatDriverBindingSupported,\r
FatDriverBindingStart,\r
FatDriverBindingStop,\r
EFI_STATUS\r
EFIAPI\r
FatEntryPoint (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_SYSTEM_TABLE *SystemTable\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
//\r
// Initialize the EFI Driver Library\r
if (ComponentName2 == NULL) {\r
Status = gBS->UninstallMultipleProtocolInterfaces (\r
ImageHandle,\r
- &gEfiDriverBindingProtocolGuid, &gFatDriverBinding,\r
+ &gEfiDriverBindingProtocolGuid,\r
+ &gFatDriverBinding,\r
NULL\r
);\r
} else {\r
Status = gBS->UninstallMultipleProtocolInterfaces (\r
ImageHandle,\r
- &gEfiDriverBindingProtocolGuid, &gFatDriverBinding,\r
- &gEfiComponentName2ProtocolGuid, ComponentName2,\r
+ &gEfiDriverBindingProtocolGuid,\r
+ &gFatDriverBinding,\r
+ &gEfiComponentName2ProtocolGuid,\r
+ ComponentName2,\r
NULL\r
);\r
}\r
if (ComponentName2 == NULL) {\r
Status = gBS->UninstallMultipleProtocolInterfaces (\r
ImageHandle,\r
- &gEfiDriverBindingProtocolGuid, &gFatDriverBinding,\r
- &gEfiComponentNameProtocolGuid, ComponentName,\r
+ &gEfiDriverBindingProtocolGuid,\r
+ &gFatDriverBinding,\r
+ &gEfiComponentNameProtocolGuid,\r
+ ComponentName,\r
NULL\r
);\r
} else {\r
Status = gBS->UninstallMultipleProtocolInterfaces (\r
ImageHandle,\r
- &gEfiDriverBindingProtocolGuid, &gFatDriverBinding,\r
- &gEfiComponentNameProtocolGuid, ComponentName,\r
- &gEfiComponentName2ProtocolGuid, ComponentName2,\r
+ &gEfiDriverBindingProtocolGuid,\r
+ &gFatDriverBinding,\r
+ &gEfiComponentNameProtocolGuid,\r
+ ComponentName,\r
+ &gEfiComponentName2ProtocolGuid,\r
+ ComponentName2,\r
NULL\r
);\r
}\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
&gEfiDiskIoProtocolGuid,\r
- (VOID **) &DiskIo,\r
+ (VOID **)&DiskIo,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_BY_DRIVER\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
+\r
//\r
// Close the I/O Abstraction(s) used to perform the supported test\r
//\r
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
- EFI_DISK_IO_PROTOCOL *DiskIo;\r
- EFI_DISK_IO2_PROTOCOL *DiskIo2;\r
- BOOLEAN LockedByMe;\r
+ EFI_STATUS Status;\r
+ EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
+ EFI_DISK_IO_PROTOCOL *DiskIo;\r
+ EFI_DISK_IO2_PROTOCOL *DiskIo2;\r
+ BOOLEAN LockedByMe;\r
\r
LockedByMe = FALSE;\r
//\r
if (EFI_ERROR (Status)) {\r
goto Exit;\r
}\r
+\r
//\r
// Open our required BlockIo and DiskIo\r
//\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
&gEfiBlockIoProtocolGuid,\r
- (VOID **) &BlockIo,\r
+ (VOID **)&BlockIo,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
&gEfiDiskIoProtocolGuid,\r
- (VOID **) &DiskIo,\r
+ (VOID **)&DiskIo,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_BY_DRIVER\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
&gEfiDiskIo2ProtocolGuid,\r
- (VOID **) &DiskIo2,\r
+ (VOID **)&DiskIo2,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_BY_DRIVER\r
if (LockedByMe) {\r
FatReleaseLock ();\r
}\r
+\r
return Status;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
FatDriverBindingStop (\r
- IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
- IN EFI_HANDLE ControllerHandle,\r
- IN UINTN NumberOfChildren,\r
- IN EFI_HANDLE *ChildHandleBuffer\r
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN UINTN NumberOfChildren,\r
+ IN EFI_HANDLE *ChildHandleBuffer\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;\r
- FAT_VOLUME *Volume;\r
- EFI_DISK_IO2_PROTOCOL *DiskIo2;\r
+ EFI_STATUS Status;\r
+ EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FileSystem;\r
+ FAT_VOLUME *Volume;\r
+ EFI_DISK_IO2_PROTOCOL *DiskIo2;\r
\r
DiskIo2 = NULL;\r
//\r
Status = gBS->OpenProtocol (\r
ControllerHandle,\r
&gEfiSimpleFileSystemProtocolGuid,\r
- (VOID **) &FileSystem,\r
+ (VOID **)&FileSystem,\r
This->DriverBindingHandle,\r
ControllerHandle,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
if (!EFI_ERROR (Status)) {\r
if (DiskIo2 != NULL) {\r
Status = gBS->CloseProtocol (\r
- ControllerHandle,\r
- &gEfiDiskIo2ProtocolGuid,\r
- This->DriverBindingHandle,\r
- ControllerHandle\r
- );\r
+ ControllerHandle,\r
+ &gEfiDiskIo2ProtocolGuid,\r
+ This->DriverBindingHandle,\r
+ ControllerHandle\r
+ );\r
ASSERT_EFI_ERROR (Status);\r
}\r
+\r
Status = gBS->CloseProtocol (\r
- ControllerHandle,\r
- &gEfiDiskIoProtocolGuid,\r
- This->DriverBindingHandle,\r
- ControllerHandle\r
- );\r
+ ControllerHandle,\r
+ &gEfiDiskIoProtocolGuid,\r
+ This->DriverBindingHandle,\r
+ ControllerHandle\r
+ );\r
ASSERT_EFI_ERROR (Status);\r
}\r
\r
//\r
// The FAT signature\r
//\r
-#define FAT_VOLUME_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'v')\r
-#define FAT_IFILE_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'i')\r
-#define FAT_ODIR_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'd')\r
-#define FAT_DIRENT_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'e')\r
-#define FAT_OFILE_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'o')\r
-#define FAT_TASK_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'T')\r
-#define FAT_SUBTASK_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'S')\r
+#define FAT_VOLUME_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'v')\r
+#define FAT_IFILE_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'i')\r
+#define FAT_ODIR_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'd')\r
+#define FAT_DIRENT_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'e')\r
+#define FAT_OFILE_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'o')\r
+#define FAT_TASK_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'T')\r
+#define FAT_SUBTASK_SIGNATURE SIGNATURE_32 ('f', 'a', 't', 'S')\r
\r
-#define ASSERT_VOLUME_LOCKED(a) ASSERT_LOCKED (&FatFsLock)\r
+#define ASSERT_VOLUME_LOCKED(a) ASSERT_LOCKED (&FatFsLock)\r
\r
-#define IFILE_FROM_FHAND(a) CR (a, FAT_IFILE, Handle, FAT_IFILE_SIGNATURE)\r
+#define IFILE_FROM_FHAND(a) CR (a, FAT_IFILE, Handle, FAT_IFILE_SIGNATURE)\r
\r
-#define DIRENT_FROM_LINK(a) CR (a, FAT_DIRENT, Link, FAT_DIRENT_SIGNATURE)\r
+#define DIRENT_FROM_LINK(a) CR (a, FAT_DIRENT, Link, FAT_DIRENT_SIGNATURE)\r
\r
-#define VOLUME_FROM_ROOT_DIRENT(a) CR (a, FAT_VOLUME, RootDirEnt, FAT_VOLUME_SIGNATURE)\r
+#define VOLUME_FROM_ROOT_DIRENT(a) CR (a, FAT_VOLUME, RootDirEnt, FAT_VOLUME_SIGNATURE)\r
\r
-#define VOLUME_FROM_VOL_INTERFACE(a) CR (a, FAT_VOLUME, VolumeInterface, FAT_VOLUME_SIGNATURE);\r
+#define VOLUME_FROM_VOL_INTERFACE(a) CR (a, FAT_VOLUME, VolumeInterface, FAT_VOLUME_SIGNATURE);\r
\r
-#define ODIR_FROM_DIRCACHELINK(a) CR (a, FAT_ODIR, DirCacheLink, FAT_ODIR_SIGNATURE)\r
+#define ODIR_FROM_DIRCACHELINK(a) CR (a, FAT_ODIR, DirCacheLink, FAT_ODIR_SIGNATURE)\r
\r
-#define OFILE_FROM_CHECKLINK(a) CR (a, FAT_OFILE, CheckLink, FAT_OFILE_SIGNATURE)\r
+#define OFILE_FROM_CHECKLINK(a) CR (a, FAT_OFILE, CheckLink, FAT_OFILE_SIGNATURE)\r
\r
-#define OFILE_FROM_CHILDLINK(a) CR (a, FAT_OFILE, ChildLink, FAT_OFILE_SIGNATURE)\r
+#define OFILE_FROM_CHILDLINK(a) CR (a, FAT_OFILE, ChildLink, FAT_OFILE_SIGNATURE)\r
\r
//\r
// Minimum sector size is 512B, Maximum sector size is 4096B\r
// Max sectors per cluster is 128\r
//\r
-#define MAX_BLOCK_ALIGNMENT 12\r
-#define MIN_BLOCK_ALIGNMENT 9\r
-#define MAX_SECTORS_PER_CLUSTER_ALIGNMENT 7\r
+#define MAX_BLOCK_ALIGNMENT 12\r
+#define MIN_BLOCK_ALIGNMENT 9\r
+#define MAX_SECTORS_PER_CLUSTER_ALIGNMENT 7\r
\r
//\r
// Efi Time Definition\r
//\r
-#define IS_LEAP_YEAR(a) (((a) % 4 == 0) && (((a) % 100 != 0) || ((a) % 400 == 0)))\r
+#define IS_LEAP_YEAR(a) (((a) % 4 == 0) && (((a) % 100 != 0) || ((a) % 400 == 0)))\r
\r
//\r
// Minimum fat page size is 8K, maximum fat page alignment is 32K\r
//\r
// Used in 8.3 generation algorithm\r
//\r
-#define MAX_SPEC_RETRY 4\r
-#define SPEC_BASE_TAG_LEN 6\r
-#define HASH_BASE_TAG_LEN 2\r
-#define HASH_VALUE_TAG_LEN (SPEC_BASE_TAG_LEN - HASH_BASE_TAG_LEN)\r
+#define MAX_SPEC_RETRY 4\r
+#define SPEC_BASE_TAG_LEN 6\r
+#define HASH_BASE_TAG_LEN 2\r
+#define HASH_VALUE_TAG_LEN (SPEC_BASE_TAG_LEN - HASH_BASE_TAG_LEN)\r
\r
//\r
// Path name separator is back slash\r
//\r
-#define PATH_NAME_SEPARATOR L'\\'\r
+#define PATH_NAME_SEPARATOR L'\\'\r
\r
+#define EFI_PATH_STRING_LENGTH 260\r
+#define EFI_FILE_STRING_LENGTH 255\r
+#define FAT_MAX_ALLOCATE_SIZE 0xA00000\r
+#define LC_ISO_639_2_ENTRY_SIZE 3\r
+#define MAX_LANG_CODE_SIZE 100\r
\r
-#define EFI_PATH_STRING_LENGTH 260\r
-#define EFI_FILE_STRING_LENGTH 255\r
-#define FAT_MAX_ALLOCATE_SIZE 0xA00000\r
-#define LC_ISO_639_2_ENTRY_SIZE 3\r
-#define MAX_LANG_CODE_SIZE 100\r
-\r
-#define FAT_MAX_DIR_CACHE_COUNT 8\r
-#define FAT_MAX_DIRENTRY_COUNT 0xFFFF\r
-typedef CHAR8 LC_ISO_639_2;\r
+#define FAT_MAX_DIR_CACHE_COUNT 8\r
+#define FAT_MAX_DIRENTRY_COUNT 0xFFFF\r
+typedef CHAR8 LC_ISO_639_2;\r
\r
//\r
// The fat types we support\r
// Used in FatDiskIo\r
//\r
typedef enum {\r
- ReadDisk = 0, // raw disk read\r
- WriteDisk = 1, // raw disk write\r
- ReadFat = 2, // read fat cache\r
- WriteFat = 3, // write fat cache\r
- ReadData = 6, // read data cache\r
- WriteData = 7 // write data cache\r
+ ReadDisk = 0, // raw disk read\r
+ WriteDisk = 1, // raw disk write\r
+ ReadFat = 2, // read fat cache\r
+ WriteFat = 3, // write fat cache\r
+ ReadData = 6, // read data cache\r
+ WriteData = 7 // write data cache\r
} IO_MODE;\r
\r
#define CACHE_ENABLED(a) ((a) >= 2)\r
// Disk cache tag\r
//\r
typedef struct {\r
- UINTN PageNo;\r
- UINTN RealSize;\r
- BOOLEAN Dirty;\r
+ UINTN PageNo;\r
+ UINTN RealSize;\r
+ BOOLEAN Dirty;\r
} CACHE_TAG;\r
\r
typedef struct {\r
- UINT64 BaseAddress;\r
- UINT64 LimitAddress;\r
- UINT8 *CacheBase;\r
- BOOLEAN Dirty;\r
- UINT8 PageAlignment;\r
- UINTN GroupMask;\r
- CACHE_TAG CacheTag[FAT_DATACACHE_GROUP_COUNT];\r
+ UINT64 BaseAddress;\r
+ UINT64 LimitAddress;\r
+ UINT8 *CacheBase;\r
+ BOOLEAN Dirty;\r
+ UINT8 PageAlignment;\r
+ UINTN GroupMask;\r
+ CACHE_TAG CacheTag[FAT_DATACACHE_GROUP_COUNT];\r
} DISK_CACHE;\r
\r
//\r
//\r
\r
typedef struct _FAT_DIRENT FAT_DIRENT;\r
-typedef struct _FAT_ODIR FAT_ODIR;\r
-typedef struct _FAT_OFILE FAT_OFILE;\r
+typedef struct _FAT_ODIR FAT_ODIR;\r
+typedef struct _FAT_OFILE FAT_OFILE;\r
typedef struct _FAT_VOLUME FAT_VOLUME;\r
\r
struct _FAT_DIRENT {\r
- UINTN Signature;\r
- UINT16 EntryPos; // The position of this directory entry in the parent directory file\r
- UINT8 EntryCount; // The count of the directory entry in the parent directory file\r
- BOOLEAN Invalid; // Indicate whether this directory entry is valid\r
- CHAR16 *FileString; // The unicode long file name for this directory entry\r
- FAT_OFILE *OFile; // The OFile of the corresponding directory entry\r
- FAT_DIRENT *ShortNameForwardLink; // Hash successor link for short filename\r
- FAT_DIRENT *LongNameForwardLink; // Hash successor link for long filename\r
- LIST_ENTRY Link; // Connection of every directory entry\r
- FAT_DIRECTORY_ENTRY Entry; // The physical directory entry stored in disk\r
+ UINTN Signature;\r
+ UINT16 EntryPos; // The position of this directory entry in the parent directory file\r
+ UINT8 EntryCount; // The count of the directory entry in the parent directory file\r
+ BOOLEAN Invalid; // Indicate whether this directory entry is valid\r
+ CHAR16 *FileString; // The unicode long file name for this directory entry\r
+ FAT_OFILE *OFile; // The OFile of the corresponding directory entry\r
+ FAT_DIRENT *ShortNameForwardLink; // Hash successor link for short filename\r
+ FAT_DIRENT *LongNameForwardLink; // Hash successor link for long filename\r
+ LIST_ENTRY Link; // Connection of every directory entry\r
+ FAT_DIRECTORY_ENTRY Entry; // The physical directory entry stored in disk\r
};\r
\r
struct _FAT_ODIR {\r
- UINTN Signature;\r
- UINT32 CurrentEndPos; // Current end position of the directory\r
- UINT32 CurrentPos; // Current position of the directory\r
- LIST_ENTRY *CurrentCursor; // Current directory entry pointer\r
- LIST_ENTRY ChildList; // List of all directory entries\r
- BOOLEAN EndOfDir; // Indicate whether we have reached the end of the directory\r
- LIST_ENTRY DirCacheLink; // Linked in Volume->DirCacheList when discarded\r
- UINTN DirCacheTag; // The identification of the directory when in directory cache\r
- FAT_DIRENT *LongNameHashTable[HASH_TABLE_SIZE];\r
- FAT_DIRENT *ShortNameHashTable[HASH_TABLE_SIZE];\r
+ UINTN Signature;\r
+ UINT32 CurrentEndPos; // Current end position of the directory\r
+ UINT32 CurrentPos; // Current position of the directory\r
+ LIST_ENTRY *CurrentCursor; // Current directory entry pointer\r
+ LIST_ENTRY ChildList; // List of all directory entries\r
+ BOOLEAN EndOfDir; // Indicate whether we have reached the end of the directory\r
+ LIST_ENTRY DirCacheLink; // Linked in Volume->DirCacheList when discarded\r
+ UINTN DirCacheTag; // The identification of the directory when in directory cache\r
+ FAT_DIRENT *LongNameHashTable[HASH_TABLE_SIZE];\r
+ FAT_DIRENT *ShortNameHashTable[HASH_TABLE_SIZE];\r
};\r
\r
typedef struct {\r
- UINTN Signature;\r
- EFI_FILE_PROTOCOL Handle;\r
- UINT64 Position;\r
- BOOLEAN ReadOnly;\r
- FAT_OFILE *OFile;\r
- LIST_ENTRY Tasks; // List of all FAT_TASKs\r
- LIST_ENTRY Link; // Link to other IFiles\r
+ UINTN Signature;\r
+ EFI_FILE_PROTOCOL Handle;\r
+ UINT64 Position;\r
+ BOOLEAN ReadOnly;\r
+ FAT_OFILE *OFile;\r
+ LIST_ENTRY Tasks; // List of all FAT_TASKs\r
+ LIST_ENTRY Link; // Link to other IFiles\r
} FAT_IFILE;\r
\r
typedef struct {\r
- UINTN Signature;\r
- EFI_FILE_IO_TOKEN *FileIoToken;\r
- FAT_IFILE *IFile;\r
- LIST_ENTRY Subtasks; // List of all FAT_SUBTASKs\r
- LIST_ENTRY Link; // Link to other FAT_TASKs\r
+ UINTN Signature;\r
+ EFI_FILE_IO_TOKEN *FileIoToken;\r
+ FAT_IFILE *IFile;\r
+ LIST_ENTRY Subtasks; // List of all FAT_SUBTASKs\r
+ LIST_ENTRY Link; // Link to other FAT_TASKs\r
} FAT_TASK;\r
\r
typedef struct {\r
- UINTN Signature;\r
- EFI_DISK_IO2_TOKEN DiskIo2Token;\r
- FAT_TASK *Task;\r
- BOOLEAN Write;\r
- UINT64 Offset;\r
- VOID *Buffer;\r
- UINTN BufferSize;\r
- LIST_ENTRY Link;\r
+ UINTN Signature;\r
+ EFI_DISK_IO2_TOKEN DiskIo2Token;\r
+ FAT_TASK *Task;\r
+ BOOLEAN Write;\r
+ UINT64 Offset;\r
+ VOID *Buffer;\r
+ UINTN BufferSize;\r
+ LIST_ENTRY Link;\r
} FAT_SUBTASK;\r
\r
//\r
// FAT_OFILE - Each opened file\r
//\r
struct _FAT_OFILE {\r
- UINTN Signature;\r
- FAT_VOLUME *Volume;\r
+ UINTN Signature;\r
+ FAT_VOLUME *Volume;\r
//\r
// A permanent error code to return to all accesses to\r
// this opened file\r
//\r
- EFI_STATUS Error;\r
+ EFI_STATUS Error;\r
//\r
// A list of the IFILE instances for this OFile\r
//\r
- LIST_ENTRY Opens;\r
+ LIST_ENTRY Opens;\r
\r
//\r
// The dynamic information\r
//\r
- UINTN FileSize;\r
- UINTN FileCluster;\r
- UINTN FileCurrentCluster;\r
- UINTN FileLastCluster;\r
+ UINTN FileSize;\r
+ UINTN FileCluster;\r
+ UINTN FileCurrentCluster;\r
+ UINTN FileLastCluster;\r
\r
//\r
// Dirty is set if there have been any updates to the\r
// PreserveLastMod is set if the last modification of the\r
// file is specified by SetInfo API\r
//\r
- BOOLEAN Dirty;\r
- BOOLEAN IsFixedRootDir;\r
- BOOLEAN PreserveLastModification;\r
- BOOLEAN Archive;\r
+ BOOLEAN Dirty;\r
+ BOOLEAN IsFixedRootDir;\r
+ BOOLEAN PreserveLastModification;\r
+ BOOLEAN Archive;\r
//\r
// Set by an OFile SetPosition\r
//\r
- UINTN Position; // within file\r
- UINT64 PosDisk; // on the disk\r
- UINTN PosRem; // remaining in this disk run\r
+ UINTN Position; // within file\r
+ UINT64 PosDisk; // on the disk\r
+ UINTN PosRem; // remaining in this disk run\r
//\r
// The opened parent, full path length and currently opened child files\r
//\r
- FAT_OFILE *Parent;\r
- UINTN FullPathLen;\r
- LIST_ENTRY ChildHead;\r
- LIST_ENTRY ChildLink;\r
+ FAT_OFILE *Parent;\r
+ UINTN FullPathLen;\r
+ LIST_ENTRY ChildHead;\r
+ LIST_ENTRY ChildLink;\r
\r
//\r
// The opened directory structure for a directory; if this\r
// OFile represents a file, then ODir = NULL\r
//\r
- FAT_ODIR *ODir;\r
+ FAT_ODIR *ODir;\r
//\r
// The directory entry for the Ofile\r
//\r
- FAT_DIRENT *DirEnt;\r
+ FAT_DIRENT *DirEnt;\r
\r
//\r
// Link in Volume's reference list\r
//\r
- LIST_ENTRY CheckLink;\r
+ LIST_ENTRY CheckLink;\r
};\r
\r
struct _FAT_VOLUME {\r
- UINTN Signature;\r
+ UINTN Signature;\r
\r
- EFI_HANDLE Handle;\r
- BOOLEAN Valid;\r
- BOOLEAN DiskError;\r
+ EFI_HANDLE Handle;\r
+ BOOLEAN Valid;\r
+ BOOLEAN DiskError;\r
\r
- EFI_SIMPLE_FILE_SYSTEM_PROTOCOL VolumeInterface;\r
+ EFI_SIMPLE_FILE_SYSTEM_PROTOCOL VolumeInterface;\r
\r
//\r
// If opened, the parent handle and BlockIo interface\r
//\r
- EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
- EFI_DISK_IO_PROTOCOL *DiskIo;\r
- EFI_DISK_IO2_PROTOCOL *DiskIo2;\r
- UINT32 MediaId;\r
- BOOLEAN ReadOnly;\r
+ EFI_BLOCK_IO_PROTOCOL *BlockIo;\r
+ EFI_DISK_IO_PROTOCOL *DiskIo;\r
+ EFI_DISK_IO2_PROTOCOL *DiskIo2;\r
+ UINT32 MediaId;\r
+ BOOLEAN ReadOnly;\r
\r
//\r
// Computed values from fat bpb info\r
//\r
- UINT64 VolumeSize;\r
- UINT64 FatPos; // Disk pos of fat tables\r
- UINT64 RootPos; // Disk pos of root directory\r
- UINT64 FirstClusterPos; // Disk pos of first cluster\r
- UINTN FatSize; // Number of bytes in each fat\r
- UINTN MaxCluster; // Max cluster number\r
- UINTN ClusterSize; // Cluster size of fat partition\r
- UINT8 ClusterAlignment; // Equal to log_2 (clustersize);\r
- FAT_VOLUME_TYPE FatType;\r
+ UINT64 VolumeSize;\r
+ UINT64 FatPos; // Disk pos of fat tables\r
+ UINT64 RootPos; // Disk pos of root directory\r
+ UINT64 FirstClusterPos; // Disk pos of first cluster\r
+ UINTN FatSize; // Number of bytes in each fat\r
+ UINTN MaxCluster; // Max cluster number\r
+ UINTN ClusterSize; // Cluster size of fat partition\r
+ UINT8 ClusterAlignment; // Equal to log_2 (clustersize);\r
+ FAT_VOLUME_TYPE FatType;\r
\r
//\r
// Current part of fat table that's present\r
//\r
- UINT64 FatEntryPos; // Location of buffer\r
- UINTN FatEntrySize; // Size of buffer\r
- UINT32 FatEntryBuffer; // The buffer\r
- FAT_INFO_SECTOR FatInfoSector; // Free cluster info\r
- UINTN FreeInfoPos; // Pos with the free cluster info\r
- BOOLEAN FreeInfoValid; // If free cluster info is valid\r
+ UINT64 FatEntryPos; // Location of buffer\r
+ UINTN FatEntrySize; // Size of buffer\r
+ UINT32 FatEntryBuffer; // The buffer\r
+ FAT_INFO_SECTOR FatInfoSector; // Free cluster info\r
+ UINTN FreeInfoPos; // Pos with the free cluster info\r
+ BOOLEAN FreeInfoValid; // If free cluster info is valid\r
//\r
// Unpacked Fat BPB info\r
//\r
- UINTN NumFats;\r
- UINTN RootEntries; // < FAT32, root dir is fixed size\r
- UINTN RootCluster; // >= FAT32, root cluster chain head\r
+ UINTN NumFats;\r
+ UINTN RootEntries; // < FAT32, root dir is fixed size\r
+ UINTN RootCluster; // >= FAT32, root cluster chain head\r
//\r
// info for marking the volume dirty or not\r
//\r
- BOOLEAN FatDirty; // If fat-entries have been updated\r
- UINT32 DirtyValue;\r
- UINT32 NotDirtyValue;\r
+ BOOLEAN FatDirty; // If fat-entries have been updated\r
+ UINT32 DirtyValue;\r
+ UINT32 NotDirtyValue;\r
\r
//\r
// The root directory entry and opened root file\r
//\r
- FAT_DIRENT RootDirEnt;\r
+ FAT_DIRENT RootDirEnt;\r
//\r
// File Name of root OFile, it is empty string\r
//\r
- CHAR16 RootFileString[1];\r
- FAT_OFILE *Root;\r
+ CHAR16 RootFileString[1];\r
+ FAT_OFILE *Root;\r
\r
//\r
// New OFiles are added to this list so they\r
// can be cleaned up if they aren't referenced.\r
//\r
- LIST_ENTRY CheckRef;\r
+ LIST_ENTRY CheckRef;\r
\r
//\r
// Directory cache List\r
//\r
- LIST_ENTRY DirCacheList;\r
- UINTN DirCacheCount;\r
+ LIST_ENTRY DirCacheList;\r
+ UINTN DirCacheCount;\r
\r
//\r
// Disk Cache for this volume\r
//\r
- VOID *CacheBuffer;\r
- DISK_CACHE DiskCache[CacheMaxType];\r
+ VOID *CacheBuffer;\r
+ DISK_CACHE DiskCache[CacheMaxType];\r
};\r
\r
//\r
EFI_STATUS\r
EFIAPI\r
FatOpen (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- OUT EFI_FILE_PROTOCOL **NewHandle,\r
- IN CHAR16 *FileName,\r
- IN UINT64 OpenMode,\r
- IN UINT64 Attributes\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ OUT EFI_FILE_PROTOCOL **NewHandle,\r
+ IN CHAR16 *FileName,\r
+ IN UINT64 OpenMode,\r
+ IN UINT64 Attributes\r
)\r
;\r
\r
EFI_STATUS\r
EFIAPI\r
FatOpenEx (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- OUT EFI_FILE_PROTOCOL **NewHandle,\r
- IN CHAR16 *FileName,\r
- IN UINT64 OpenMode,\r
- IN UINT64 Attributes,\r
- IN OUT EFI_FILE_IO_TOKEN *Token\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ OUT EFI_FILE_PROTOCOL **NewHandle,\r
+ IN CHAR16 *FileName,\r
+ IN UINT64 OpenMode,\r
+ IN UINT64 Attributes,\r
+ IN OUT EFI_FILE_IO_TOKEN *Token\r
)\r
;\r
\r
EFI_STATUS\r
EFIAPI\r
FatGetPosition (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- OUT UINT64 *Position\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ OUT UINT64 *Position\r
)\r
;\r
\r
EFI_STATUS\r
EFIAPI\r
FatGetInfo (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- IN EFI_GUID *Type,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ IN EFI_GUID *Type,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
;\r
\r
EFI_STATUS\r
EFIAPI\r
FatRead (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
;\r
\r
EFI_STATUS\r
EFIAPI\r
FatWrite (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- IN OUT UINTN *BufferSize,\r
- IN VOID *Buffer\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ IN OUT UINTN *BufferSize,\r
+ IN VOID *Buffer\r
)\r
;\r
\r
//\r
// DiskCache.c\r
//\r
+\r
/**\r
\r
Initialize the disk cache according to Volume's FatType.\r
**/\r
EFI_STATUS\r
FatInitializeDiskCache (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatAccessCache (\r
- IN FAT_VOLUME *Volume,\r
- IN CACHE_DATA_TYPE CacheDataType,\r
- IN IO_MODE IoMode,\r
- IN UINT64 Offset,\r
- IN UINTN BufferSize,\r
- IN OUT UINT8 *Buffer,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN CACHE_DATA_TYPE CacheDataType,\r
+ IN IO_MODE IoMode,\r
+ IN UINT64 Offset,\r
+ IN UINTN BufferSize,\r
+ IN OUT UINT8 *Buffer,\r
+ IN FAT_TASK *Task\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatVolumeFlushCache (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_TASK *Task\r
);\r
\r
//\r
// Flush.c\r
//\r
+\r
/**\r
\r
Flush the data associated with an open file.\r
**/\r
EFI_STATUS\r
FatOFileFlush (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
BOOLEAN\r
FatCheckOFileRef (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
VOID\r
FatSetVolumeError (\r
- IN FAT_OFILE *OFile,\r
- IN EFI_STATUS Status\r
+ IN FAT_OFILE *OFile,\r
+ IN EFI_STATUS Status\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatIFileClose (\r
- FAT_IFILE *IFile\r
+ FAT_IFILE *IFile\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatCleanupVolume (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_OFILE *OFile,\r
- IN EFI_STATUS EfiStatus,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_OFILE *OFile,\r
+ IN EFI_STATUS EfiStatus,\r
+ IN FAT_TASK *Task\r
);\r
\r
//\r
// FileSpace.c\r
//\r
+\r
/**\r
\r
Shrink the end of the open file base on the file size.\r
**/\r
EFI_STATUS\r
FatShrinkEof (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatGrowEof (\r
- IN FAT_OFILE *OFile,\r
- IN UINT64 NewSizeInBytes\r
+ IN FAT_OFILE *OFile,\r
+ IN UINT64 NewSizeInBytes\r
);\r
\r
/**\r
**/\r
UINTN\r
FatPhysicalDirSize (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Cluster\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Cluster\r
);\r
\r
/**\r
**/\r
UINT64\r
FatPhysicalFileSize (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN RealSize\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN RealSize\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatOFilePosition (\r
- IN FAT_OFILE *OFile,\r
- IN UINTN Position,\r
- IN UINTN PosLimit\r
+ IN FAT_OFILE *OFile,\r
+ IN UINTN Position,\r
+ IN UINTN PosLimit\r
);\r
\r
/**\r
**/\r
VOID\r
FatComputeFreeInfo (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
);\r
\r
//\r
// Init.c\r
//\r
+\r
/**\r
\r
Allocates volume structure, detects FAT file system, installs protocol,\r
**/\r
EFI_STATUS\r
FatAllocateVolume (\r
- IN EFI_HANDLE Handle,\r
- IN EFI_DISK_IO_PROTOCOL *DiskIo,\r
- IN EFI_DISK_IO2_PROTOCOL *DiskIo2,\r
- IN EFI_BLOCK_IO_PROTOCOL *BlockIo\r
+ IN EFI_HANDLE Handle,\r
+ IN EFI_DISK_IO_PROTOCOL *DiskIo,\r
+ IN EFI_DISK_IO2_PROTOCOL *DiskIo2,\r
+ IN EFI_BLOCK_IO_PROTOCOL *BlockIo\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatOpenDevice (\r
- IN OUT FAT_VOLUME *Volume\r
+ IN OUT FAT_VOLUME *Volume\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatAbandonVolume (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
);\r
\r
//\r
// Misc.c\r
//\r
+\r
/**\r
\r
Create the task\r
**/\r
FAT_TASK *\r
FatCreateTask (\r
- FAT_IFILE *IFile,\r
- EFI_FILE_IO_TOKEN *Token\r
+ FAT_IFILE *IFile,\r
+ EFI_FILE_IO_TOKEN *Token\r
);\r
\r
/**\r
**/\r
VOID\r
FatDestroyTask (\r
- FAT_TASK *Task\r
+ FAT_TASK *Task\r
);\r
\r
/**\r
**/\r
VOID\r
FatWaitNonblockingTask (\r
- FAT_IFILE *IFile\r
+ FAT_IFILE *IFile\r
);\r
\r
/**\r
**/\r
LIST_ENTRY *\r
FatDestroySubtask (\r
- FAT_SUBTASK *Subtask\r
+ FAT_SUBTASK *Subtask\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatQueueTask (\r
- IN FAT_IFILE *IFile,\r
- IN FAT_TASK *Task\r
+ IN FAT_IFILE *IFile,\r
+ IN FAT_TASK *Task\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatAccessVolumeDirty (\r
- IN FAT_VOLUME *Volume,\r
- IN IO_MODE IoMode,\r
- IN VOID *DirtyValue\r
+ IN FAT_VOLUME *Volume,\r
+ IN IO_MODE IoMode,\r
+ IN VOID *DirtyValue\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatDiskIo (\r
- IN FAT_VOLUME *Volume,\r
- IN IO_MODE IoMode,\r
- IN UINT64 Offset,\r
- IN UINTN BufferSize,\r
- IN OUT VOID *Buffer,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN IO_MODE IoMode,\r
+ IN UINT64 Offset,\r
+ IN UINTN BufferSize,\r
+ IN OUT VOID *Buffer,\r
+ IN FAT_TASK *Task\r
);\r
\r
/**\r
**/\r
VOID\r
FatFreeDirEnt (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
VOID\r
FatFreeVolume (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
);\r
\r
/**\r
**/\r
VOID\r
FatEfiTimeToFatTime (\r
- IN EFI_TIME *ETime,\r
- OUT FAT_DATE_TIME *FTime\r
+ IN EFI_TIME *ETime,\r
+ OUT FAT_DATE_TIME *FTime\r
);\r
\r
/**\r
**/\r
VOID\r
FatFatTimeToEfiTime (\r
- IN FAT_DATE_TIME *FTime,\r
- OUT EFI_TIME *ETime\r
+ IN FAT_DATE_TIME *FTime,\r
+ OUT EFI_TIME *ETime\r
);\r
\r
/**\r
**/\r
VOID\r
FatGetCurrentFatTime (\r
- OUT FAT_DATE_TIME *FatTime\r
+ OUT FAT_DATE_TIME *FatTime\r
);\r
\r
/**\r
**/\r
BOOLEAN\r
FatIsValidTime (\r
- IN EFI_TIME *Time\r
+ IN EFI_TIME *Time\r
);\r
\r
//\r
// UnicodeCollation.c\r
//\r
+\r
/**\r
Initialize Unicode Collation support.\r
\r
**/\r
EFI_STATUS\r
InitializeUnicodeCollationSupport (\r
- IN EFI_HANDLE AgentHandle\r
+ IN EFI_HANDLE AgentHandle\r
);\r
\r
/**\r
**/\r
VOID\r
FatFatToStr (\r
- IN UINTN FatSize,\r
- IN CHAR8 *Fat,\r
- OUT CHAR16 *String\r
+ IN UINTN FatSize,\r
+ IN CHAR8 *Fat,\r
+ OUT CHAR16 *String\r
);\r
\r
/**\r
**/\r
BOOLEAN\r
FatStrToFat (\r
- IN CHAR16 *String,\r
- IN UINTN FatSize,\r
- OUT CHAR8 *Fat\r
+ IN CHAR16 *String,\r
+ IN UINTN FatSize,\r
+ OUT CHAR8 *Fat\r
);\r
\r
/**\r
**/\r
VOID\r
FatStrLwr (\r
- IN CHAR16 *Str\r
+ IN CHAR16 *Str\r
);\r
\r
/**\r
**/\r
VOID\r
FatStrUpr (\r
- IN CHAR16 *Str\r
+ IN CHAR16 *Str\r
);\r
\r
/**\r
**/\r
INTN\r
FatStriCmp (\r
- IN CHAR16 *Str1,\r
- IN CHAR16 *Str2\r
+ IN CHAR16 *Str1,\r
+ IN CHAR16 *Str2\r
);\r
\r
//\r
**/\r
EFI_STATUS\r
FatOFileOpen (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_IFILE **NewIFile,\r
- IN CHAR16 *FileName,\r
- IN UINT64 OpenMode,\r
- IN UINT8 Attributes\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_IFILE **NewIFile,\r
+ IN CHAR16 *FileName,\r
+ IN UINT64 OpenMode,\r
+ IN UINT8 Attributes\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatAllocateIFile (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_IFILE **PtrIFile\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_IFILE **PtrIFile\r
);\r
\r
//\r
// OpenVolume.c\r
//\r
+\r
/**\r
\r
Implements Simple File System Protocol interface function OpenVolume().\r
EFI_STATUS\r
EFIAPI\r
FatOpenVolume (\r
- IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,\r
- OUT EFI_FILE_PROTOCOL **File\r
+ IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,\r
+ OUT EFI_FILE_PROTOCOL **File\r
);\r
\r
//\r
// ReadWrite.c\r
//\r
+\r
/**\r
\r
This function reads data from a file or writes data to a file.\r
**/\r
EFI_STATUS\r
FatAccessOFile (\r
- IN FAT_OFILE *OFile,\r
- IN IO_MODE IoMode,\r
- IN UINTN Position,\r
- IN UINTN *DataBufferSize,\r
- IN UINT8 *UserBuffer,\r
- IN FAT_TASK *Task\r
+ IN FAT_OFILE *OFile,\r
+ IN IO_MODE IoMode,\r
+ IN UINTN Position,\r
+ IN UINTN *DataBufferSize,\r
+ IN UINT8 *UserBuffer,\r
+ IN FAT_TASK *Task\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatExpandOFile (\r
- IN FAT_OFILE *OFile,\r
- IN UINT64 ExpandedSize\r
+ IN FAT_OFILE *OFile,\r
+ IN UINT64 ExpandedSize\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatWriteZeroPool (\r
- IN FAT_OFILE *OFile,\r
- IN UINTN WritePos\r
+ IN FAT_OFILE *OFile,\r
+ IN UINTN WritePos\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatTruncateOFile (\r
- IN FAT_OFILE *OFile,\r
- IN UINTN TruncatedSize\r
+ IN FAT_OFILE *OFile,\r
+ IN UINTN TruncatedSize\r
);\r
\r
//\r
// DirectoryManage.c\r
//\r
+\r
/**\r
\r
Set the OFile's current directory cursor to the list head.\r
**/\r
VOID\r
FatResetODirCursor (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatGetNextDirEnt (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_DIRENT **PtrDirEnt\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_DIRENT **PtrDirEnt\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatRemoveDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatStoreDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatCreateDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN CHAR16 *FileName,\r
- IN UINT8 Attributes,\r
- OUT FAT_DIRENT **PtrDirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN CHAR16 *FileName,\r
+ IN UINT8 Attributes,\r
+ OUT FAT_DIRENT **PtrDirEnt\r
);\r
\r
/**\r
**/\r
BOOLEAN\r
FatIsDotDirEnt (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
VOID\r
FatUpdateDirEntClusterSizeInfo (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
VOID\r
FatCloneDirEnt (\r
- IN FAT_DIRENT *DirEnt1,\r
- IN FAT_DIRENT *DirEnt2\r
+ IN FAT_DIRENT *DirEnt1,\r
+ IN FAT_DIRENT *DirEnt2\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatGetDirEntInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_DIRENT *DirEnt,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_DIRENT *DirEnt,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatOpenDirEnt (\r
- IN FAT_OFILE *OFile,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *OFile,\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatCreateDotDirEnts (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
VOID\r
FatCloseDirEnt (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatLocateOFile (\r
- IN OUT FAT_OFILE **PtrOFile,\r
- IN CHAR16 *FileName,\r
- IN UINT8 Attributes,\r
- OUT CHAR16 *NewFileName\r
+ IN OUT FAT_OFILE **PtrOFile,\r
+ IN CHAR16 *FileName,\r
+ IN UINT8 Attributes,\r
+ OUT CHAR16 *NewFileName\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatGetVolumeEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN CHAR16 *Name\r
+ IN FAT_VOLUME *Volume,\r
+ IN CHAR16 *Name\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatSetVolumeEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN CHAR16 *Name\r
+ IN FAT_VOLUME *Volume,\r
+ IN CHAR16 *Name\r
);\r
\r
//\r
// Hash.c\r
//\r
+\r
/**\r
\r
Search the long name hash table for the directory entry.\r
**/\r
FAT_DIRENT **\r
FatLongNameHashSearch (\r
- IN FAT_ODIR *ODir,\r
- IN CHAR16 *LongNameString\r
+ IN FAT_ODIR *ODir,\r
+ IN CHAR16 *LongNameString\r
);\r
\r
/**\r
**/\r
FAT_DIRENT **\r
FatShortNameHashSearch (\r
- IN FAT_ODIR *ODir,\r
- IN CHAR8 *ShortNameString\r
+ IN FAT_ODIR *ODir,\r
+ IN CHAR8 *ShortNameString\r
);\r
\r
/**\r
**/\r
VOID\r
FatInsertToHashTable (\r
- IN FAT_ODIR *ODir,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_ODIR *ODir,\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
VOID\r
FatDeleteFromHashTable (\r
- IN FAT_ODIR *ODir,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_ODIR *ODir,\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
//\r
// FileName.c\r
//\r
+\r
/**\r
\r
This function checks whether the input FileName is a valid 8.3 short name.\r
**/\r
BOOLEAN\r
FatCheckIs8Dot3Name (\r
- IN CHAR16 *FileName,\r
- OUT CHAR8 *File8Dot3Name\r
+ IN CHAR16 *FileName,\r
+ OUT CHAR8 *File8Dot3Name\r
);\r
\r
/**\r
**/\r
VOID\r
FatCreate8Dot3Name (\r
- IN FAT_OFILE *Parent,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *Parent,\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
VOID\r
FatNameToStr (\r
- IN CHAR8 *FatName,\r
- IN UINTN Len,\r
- IN UINTN LowerCase,\r
- IN CHAR16 *Str\r
+ IN CHAR8 *FatName,\r
+ IN UINTN Len,\r
+ IN UINTN LowerCase,\r
+ IN CHAR16 *Str\r
);\r
\r
/**\r
**/\r
VOID\r
FatSetCaseFlag (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
);\r
\r
/**\r
**/\r
VOID\r
FatGetFileNameViaCaseFlag (\r
- IN FAT_DIRENT *DirEnt,\r
- IN OUT CHAR16 *FileString,\r
- IN UINTN FileStringMax\r
+ IN FAT_DIRENT *DirEnt,\r
+ IN OUT CHAR16 *FileString,\r
+ IN UINTN FileStringMax\r
);\r
\r
/**\r
**/\r
UINT8\r
FatCheckSum (\r
- IN CHAR8 *ShortNameString\r
+ IN CHAR8 *ShortNameString\r
);\r
\r
/**\r
The position after Name in the Path\r
\r
**/\r
-CHAR16*\r
+CHAR16 *\r
FatGetNextNameComponent (\r
- IN CHAR16 *Path,\r
- OUT CHAR16 *Name\r
+ IN CHAR16 *Path,\r
+ OUT CHAR16 *Name\r
);\r
\r
/**\r
//\r
// DirectoryCache.c\r
//\r
+\r
/**\r
\r
Discard the directory structure when an OFile will be freed.\r
**/\r
VOID\r
FatDiscardODir (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
VOID\r
FatRequestODir (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
);\r
\r
/**\r
**/\r
VOID\r
FatCleanupODirCache (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
);\r
\r
//\r
// Global Variables\r
//\r
-extern EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding;\r
-extern EFI_COMPONENT_NAME_PROTOCOL gFatComponentName;\r
-extern EFI_COMPONENT_NAME2_PROTOCOL gFatComponentName2;\r
-extern EFI_LOCK FatFsLock;\r
-extern EFI_LOCK FatTaskLock;\r
-extern EFI_FILE_PROTOCOL FatFileInterface;\r
+extern EFI_DRIVER_BINDING_PROTOCOL gFatDriverBinding;\r
+extern EFI_COMPONENT_NAME_PROTOCOL gFatComponentName;\r
+extern EFI_COMPONENT_NAME2_PROTOCOL gFatComponentName2;\r
+extern EFI_LOCK FatFsLock;\r
+extern EFI_LOCK FatTaskLock;\r
+extern EFI_FILE_PROTOCOL FatFileInterface;\r
\r
#endif\r
//\r
// FAT entry values\r
//\r
-#define FAT_CLUSTER_SPECIAL_EXT (MAX_UINTN & (~0xF))\r
-#define FAT_CLUSTER_SPECIAL ((FAT_CLUSTER_SPECIAL_EXT) | 0x07)\r
-#define FAT_CLUSTER_FREE 0\r
-#define FAT_CLUSTER_RESERVED (FAT_CLUSTER_SPECIAL)\r
-#define FAT_CLUSTER_BAD (FAT_CLUSTER_SPECIAL)\r
-#define FAT_CLUSTER_LAST (-1)\r
-#define FAT_END_OF_FAT_CHAIN(Cluster) ((Cluster) > (FAT_CLUSTER_SPECIAL))\r
-#define FAT_MIN_CLUSTER 2\r
-#define FAT_MAX_FAT12_CLUSTER 0xFF5\r
-#define FAT_MAX_FAT16_CLUSTER 0xFFF5\r
-#define FAT_CLUSTER_SPECIAL_FAT12 0xFF7\r
-#define FAT_CLUSTER_SPECIAL_FAT16 0xFFF7\r
-#define FAT_CLUSTER_SPECIAL_FAT32 0x0FFFFFF7\r
-#define FAT_CLUSTER_MASK_FAT12 0xFFF\r
-#define FAT_CLUSTER_UNMASK_FAT12 0xF000\r
-#define FAT_CLUSTER_MASK_FAT32 0x0FFFFFFF\r
-#define FAT_CLUSTER_UNMASK_FAT32 0xF0000000\r
-#define FAT_POS_FAT12(a) ((a) * 3 / 2)\r
-#define FAT_POS_FAT16(a) ((a) * 2)\r
-#define FAT_POS_FAT32(a) ((a) * 4)\r
-#define FAT_ODD_CLUSTER_FAT12(a) (((a) & 1) != 0)\r
-\r
+#define FAT_CLUSTER_SPECIAL_EXT (MAX_UINTN & (~0xF))\r
+#define FAT_CLUSTER_SPECIAL ((FAT_CLUSTER_SPECIAL_EXT) | 0x07)\r
+#define FAT_CLUSTER_FREE 0\r
+#define FAT_CLUSTER_RESERVED (FAT_CLUSTER_SPECIAL)\r
+#define FAT_CLUSTER_BAD (FAT_CLUSTER_SPECIAL)\r
+#define FAT_CLUSTER_LAST (-1)\r
+#define FAT_END_OF_FAT_CHAIN(Cluster) ((Cluster) > (FAT_CLUSTER_SPECIAL))\r
+#define FAT_MIN_CLUSTER 2\r
+#define FAT_MAX_FAT12_CLUSTER 0xFF5\r
+#define FAT_MAX_FAT16_CLUSTER 0xFFF5\r
+#define FAT_CLUSTER_SPECIAL_FAT12 0xFF7\r
+#define FAT_CLUSTER_SPECIAL_FAT16 0xFFF7\r
+#define FAT_CLUSTER_SPECIAL_FAT32 0x0FFFFFF7\r
+#define FAT_CLUSTER_MASK_FAT12 0xFFF\r
+#define FAT_CLUSTER_UNMASK_FAT12 0xF000\r
+#define FAT_CLUSTER_MASK_FAT32 0x0FFFFFFF\r
+#define FAT_CLUSTER_UNMASK_FAT32 0xF0000000\r
+#define FAT_POS_FAT12(a) ((a) * 3 / 2)\r
+#define FAT_POS_FAT16(a) ((a) * 2)\r
+#define FAT_POS_FAT32(a) ((a) * 4)\r
+#define FAT_ODD_CLUSTER_FAT12(a) (((a) & 1) != 0)\r
\r
//\r
// FAT attribute define\r
//\r
-#define FAT_ATTRIBUTE_READ_ONLY 0x01\r
-#define FAT_ATTRIBUTE_HIDDEN 0x02\r
-#define FAT_ATTRIBUTE_SYSTEM 0x04\r
-#define FAT_ATTRIBUTE_VOLUME_ID 0x08\r
-#define FAT_ATTRIBUTE_DIRECTORY 0x10\r
-#define FAT_ATTRIBUTE_ARCHIVE 0x20\r
-#define FAT_ATTRIBUTE_DEVICE 0x40\r
-#define FAT_ATTRIBUTE_LFN 0x0F\r
+#define FAT_ATTRIBUTE_READ_ONLY 0x01\r
+#define FAT_ATTRIBUTE_HIDDEN 0x02\r
+#define FAT_ATTRIBUTE_SYSTEM 0x04\r
+#define FAT_ATTRIBUTE_VOLUME_ID 0x08\r
+#define FAT_ATTRIBUTE_DIRECTORY 0x10\r
+#define FAT_ATTRIBUTE_ARCHIVE 0x20\r
+#define FAT_ATTRIBUTE_DEVICE 0x40\r
+#define FAT_ATTRIBUTE_LFN 0x0F\r
//\r
// Some Long File Name definitions\r
//\r
-#define FAT_LFN_LAST 0x40 // Ordinal field\r
-#define MAX_LFN_ENTRIES 20\r
-#define LFN_CHAR1_LEN 5\r
-#define LFN_CHAR2_LEN 6\r
-#define LFN_CHAR3_LEN 2\r
-#define LFN_CHAR_TOTAL (LFN_CHAR1_LEN + LFN_CHAR2_LEN + LFN_CHAR3_LEN)\r
-#define LFN_ENTRY_NUMBER(a) (((a) + LFN_CHAR_TOTAL - 1) / LFN_CHAR_TOTAL)\r
+#define FAT_LFN_LAST 0x40 // Ordinal field\r
+#define MAX_LFN_ENTRIES 20\r
+#define LFN_CHAR1_LEN 5\r
+#define LFN_CHAR2_LEN 6\r
+#define LFN_CHAR3_LEN 2\r
+#define LFN_CHAR_TOTAL (LFN_CHAR1_LEN + LFN_CHAR2_LEN + LFN_CHAR3_LEN)\r
+#define LFN_ENTRY_NUMBER(a) (((a) + LFN_CHAR_TOTAL - 1) / LFN_CHAR_TOTAL)\r
//\r
// Some 8.3 File Name definitions\r
//\r
-#define FAT_MAIN_NAME_LEN 8\r
-#define FAT_EXTEND_NAME_LEN 3\r
-#define FAT_NAME_LEN (FAT_MAIN_NAME_LEN + FAT_EXTEND_NAME_LEN)\r
+#define FAT_MAIN_NAME_LEN 8\r
+#define FAT_EXTEND_NAME_LEN 3\r
+#define FAT_NAME_LEN (FAT_MAIN_NAME_LEN + FAT_EXTEND_NAME_LEN)\r
//\r
// Some directory entry information\r
//\r
-#define FAT_ENTRY_INFO_OFFSET 13\r
-#define DELETE_ENTRY_MARK 0xE5\r
-#define EMPTY_ENTRY_MARK 0x00\r
+#define FAT_ENTRY_INFO_OFFSET 13\r
+#define DELETE_ENTRY_MARK 0xE5\r
+#define EMPTY_ENTRY_MARK 0x00\r
\r
//\r
// Volume dirty Mask\r
//\r
-#define FAT16_DIRTY_MASK 0x7fff\r
-#define FAT32_DIRTY_MASK 0xf7ffffff\r
+#define FAT16_DIRTY_MASK 0x7fff\r
+#define FAT32_DIRTY_MASK 0xf7ffffff\r
//\r
// internal flag\r
//\r
-#define FAT_CASE_MIXED 0x01\r
-#define FAT_CASE_NAME_LOWER 0x08\r
-#define FAT_CASE_EXT_LOWER 0x10\r
+#define FAT_CASE_MIXED 0x01\r
+#define FAT_CASE_NAME_LOWER 0x08\r
+#define FAT_CASE_EXT_LOWER 0x10\r
\r
typedef struct {\r
- UINT8 Ia32Jump[3];\r
- CHAR8 OemId[8];\r
- UINT16 SectorSize;\r
- UINT8 SectorsPerCluster;\r
- UINT16 ReservedSectors;\r
- UINT8 NumFats;\r
- UINT16 RootEntries; // < FAT32, root dir is fixed size\r
- UINT16 Sectors;\r
- UINT8 Media;\r
- UINT16 SectorsPerFat; // < FAT32\r
- UINT16 SectorsPerTrack; // (ignored)\r
- UINT16 Heads; // (ignored)\r
- UINT32 HiddenSectors; // (ignored)\r
- UINT32 LargeSectors; // Used if Sectors==0\r
+ UINT8 Ia32Jump[3];\r
+ CHAR8 OemId[8];\r
+ UINT16 SectorSize;\r
+ UINT8 SectorsPerCluster;\r
+ UINT16 ReservedSectors;\r
+ UINT8 NumFats;\r
+ UINT16 RootEntries; // < FAT32, root dir is fixed size\r
+ UINT16 Sectors;\r
+ UINT8 Media;\r
+ UINT16 SectorsPerFat; // < FAT32\r
+ UINT16 SectorsPerTrack; // (ignored)\r
+ UINT16 Heads; // (ignored)\r
+ UINT32 HiddenSectors; // (ignored)\r
+ UINT32 LargeSectors; // Used if Sectors==0\r
} FAT_BOOT_SECTOR_BASIC;\r
\r
typedef struct {\r
- UINT8 PhysicalDriveNumber; // (ignored)\r
- UINT8 CurrentHead; // holds boot_sector_dirty bit\r
- UINT8 Signature; // (ignored)\r
- CHAR8 Id[4];\r
- CHAR8 FatLabel[11];\r
- CHAR8 SystemId[8];\r
+ UINT8 PhysicalDriveNumber; // (ignored)\r
+ UINT8 CurrentHead; // holds boot_sector_dirty bit\r
+ UINT8 Signature; // (ignored)\r
+ CHAR8 Id[4];\r
+ CHAR8 FatLabel[11];\r
+ CHAR8 SystemId[8];\r
} FAT_BOOT_SECTOR_EXT;\r
\r
typedef struct {\r
- UINT32 LargeSectorsPerFat; // FAT32\r
- UINT16 ExtendedFlags; // FAT32 (ignored)\r
- UINT16 FsVersion; // FAT32 (ignored)\r
- UINT32 RootDirFirstCluster; // FAT32\r
- UINT16 FsInfoSector; // FAT32\r
- UINT16 BackupBootSector; // FAT32\r
- UINT8 Reserved[12]; // FAT32 (ignored)\r
- UINT8 PhysicalDriveNumber; // (ignored)\r
- UINT8 CurrentHead; // holds boot_sector_dirty bit\r
- UINT8 Signature; // (ignored)\r
- CHAR8 Id[4];\r
- CHAR8 FatLabel[11];\r
- CHAR8 SystemId[8];\r
+ UINT32 LargeSectorsPerFat; // FAT32\r
+ UINT16 ExtendedFlags; // FAT32 (ignored)\r
+ UINT16 FsVersion; // FAT32 (ignored)\r
+ UINT32 RootDirFirstCluster; // FAT32\r
+ UINT16 FsInfoSector; // FAT32\r
+ UINT16 BackupBootSector; // FAT32\r
+ UINT8 Reserved[12]; // FAT32 (ignored)\r
+ UINT8 PhysicalDriveNumber; // (ignored)\r
+ UINT8 CurrentHead; // holds boot_sector_dirty bit\r
+ UINT8 Signature; // (ignored)\r
+ CHAR8 Id[4];\r
+ CHAR8 FatLabel[11];\r
+ CHAR8 SystemId[8];\r
} FAT32_BOOT_SECTOR_EXT;\r
\r
typedef union {\r
- FAT_BOOT_SECTOR_EXT FatBse;\r
- FAT32_BOOT_SECTOR_EXT Fat32Bse;\r
- } FAT_BSE;\r
+ FAT_BOOT_SECTOR_EXT FatBse;\r
+ FAT32_BOOT_SECTOR_EXT Fat32Bse;\r
+} FAT_BSE;\r
\r
typedef struct {\r
- FAT_BOOT_SECTOR_BASIC FatBsb;\r
- FAT_BSE FatBse;\r
+ FAT_BOOT_SECTOR_BASIC FatBsb;\r
+ FAT_BSE FatBse;\r
} FAT_BOOT_SECTOR;\r
\r
//\r
// FAT Info Structure\r
//\r
typedef struct {\r
- UINT32 ClusterCount;\r
- UINT32 NextCluster;\r
+ UINT32 ClusterCount;\r
+ UINT32 NextCluster;\r
} FAT_FREE_INFO;\r
\r
typedef struct {\r
- UINT32 Signature;\r
- UINT8 ExtraBootCode[480];\r
- UINT32 InfoBeginSignature;\r
- FAT_FREE_INFO FreeInfo;\r
- UINT8 Reserved[12];\r
- UINT32 InfoEndSignature;\r
+ UINT32 Signature;\r
+ UINT8 ExtraBootCode[480];\r
+ UINT32 InfoBeginSignature;\r
+ FAT_FREE_INFO FreeInfo;\r
+ UINT8 Reserved[12];\r
+ UINT32 InfoEndSignature;\r
} FAT_INFO_SECTOR;\r
\r
//\r
//\r
#define FAT_MAX_YEAR_FROM_1980 0x7f\r
typedef struct {\r
- UINT16 Day : 5;\r
- UINT16 Month : 4;\r
- UINT16 Year : 7; // From 1980\r
+ UINT16 Day : 5;\r
+ UINT16 Month : 4;\r
+ UINT16 Year : 7; // From 1980\r
} FAT_DATE;\r
\r
typedef struct {\r
- UINT16 DoubleSecond : 5;\r
- UINT16 Minute : 6;\r
- UINT16 Hour : 5;\r
+ UINT16 DoubleSecond : 5;\r
+ UINT16 Minute : 6;\r
+ UINT16 Hour : 5;\r
} FAT_TIME;\r
\r
typedef struct {\r
- FAT_TIME Time;\r
- FAT_DATE Date;\r
+ FAT_TIME Time;\r
+ FAT_DATE Date;\r
} FAT_DATE_TIME;\r
\r
typedef struct {\r
- CHAR8 FileName[11]; // 8.3 filename\r
- UINT8 Attributes;\r
- UINT8 CaseFlag;\r
- UINT8 CreateMillisecond; // (creation milliseconds - ignored)\r
- FAT_DATE_TIME FileCreateTime;\r
- FAT_DATE FileLastAccess;\r
- UINT16 FileClusterHigh; // >= FAT32\r
- FAT_DATE_TIME FileModificationTime;\r
- UINT16 FileCluster;\r
- UINT32 FileSize;\r
+ CHAR8 FileName[11]; // 8.3 filename\r
+ UINT8 Attributes;\r
+ UINT8 CaseFlag;\r
+ UINT8 CreateMillisecond; // (creation milliseconds - ignored)\r
+ FAT_DATE_TIME FileCreateTime;\r
+ FAT_DATE FileLastAccess;\r
+ UINT16 FileClusterHigh; // >= FAT32\r
+ FAT_DATE_TIME FileModificationTime;\r
+ UINT16 FileCluster;\r
+ UINT32 FileSize;\r
} FAT_DIRECTORY_ENTRY;\r
\r
typedef struct {\r
- UINT8 Ordinal;\r
- CHAR8 Name1[10]; // (Really 5 chars, but not WCHAR aligned)\r
- UINT8 Attributes;\r
- UINT8 Type;\r
- UINT8 Checksum;\r
- CHAR16 Name2[6];\r
- UINT16 MustBeZero;\r
- CHAR16 Name3[2];\r
+ UINT8 Ordinal;\r
+ CHAR8 Name1[10]; // (Really 5 chars, but not WCHAR aligned)\r
+ UINT8 Attributes;\r
+ UINT8 Type;\r
+ UINT8 Checksum;\r
+ CHAR16 Name2[6];\r
+ UINT16 MustBeZero;\r
+ CHAR16 Name3[2];\r
} FAT_DIRECTORY_LFN;\r
\r
#pragma pack()\r
**/\r
BOOLEAN\r
FatCheckIs8Dot3Name (\r
- IN CHAR16 *FileName,\r
- OUT CHAR8 *File8Dot3Name\r
+ IN CHAR16 *FileName,\r
+ OUT CHAR8 *File8Dot3Name\r
)\r
{\r
- BOOLEAN PossibleShortName;\r
- CHAR16 *TempName;\r
- CHAR16 *ExtendName;\r
- CHAR16 *SeparateDot;\r
- UINTN MainNameLen;\r
- UINTN ExtendNameLen;\r
+ BOOLEAN PossibleShortName;\r
+ CHAR16 *TempName;\r
+ CHAR16 *ExtendName;\r
+ CHAR16 *SeparateDot;\r
+ UINTN MainNameLen;\r
+ UINTN ExtendNameLen;\r
\r
PossibleShortName = TRUE;\r
SeparateDot = NULL;\r
ExtendName = SeparateDot + 1;\r
ExtendNameLen = TempName - ExtendName;\r
}\r
+\r
//\r
// We scan the filename for the second time\r
// to check if there exists any extra blanks and dots\r
//\r
while (--TempName >= FileName) {\r
- if ((*TempName == L'.' || *TempName == L' ') && (TempName != SeparateDot)) {\r
+ if (((*TempName == L'.') || (*TempName == L' ')) && (TempName != SeparateDot)) {\r
//\r
// There exist extra blanks and dots\r
//\r
STATIC\r
UINTN\r
FatTrimAsciiTrailingBlanks (\r
- IN CHAR8 *Name,\r
- IN UINTN Len\r
+ IN CHAR8 *Name,\r
+ IN UINTN Len\r
)\r
{\r
while (Len > 0 && Name[Len - 1] == ' ') {\r
**/\r
VOID\r
FatNameToStr (\r
- IN CHAR8 *FatName,\r
- IN UINTN Len,\r
- IN UINTN LowerCase,\r
- OUT CHAR16 *Str\r
+ IN CHAR8 *FatName,\r
+ IN UINTN Len,\r
+ IN UINTN LowerCase,\r
+ OUT CHAR16 *Str\r
)\r
{\r
//\r
**/\r
VOID\r
FatCreate8Dot3Name (\r
- IN FAT_OFILE *Parent,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_OFILE *Parent,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
- CHAR8 *ShortName;\r
- CHAR8 *ShortNameChar;\r
- UINTN BaseTagLen;\r
- UINTN Index;\r
- UINTN Retry;\r
- UINT8 Segment;\r
+ CHAR8 *ShortName;\r
+ CHAR8 *ShortNameChar;\r
+ UINTN BaseTagLen;\r
+ UINTN Index;\r
+ UINTN Retry;\r
+ UINT8 Segment;\r
+\r
union {\r
- UINT32 Crc;\r
+ UINT32 Crc;\r
struct HEX_DATA {\r
- UINT8 Segment : HASH_VALUE_TAG_LEN;\r
+ UINT8 Segment : HASH_VALUE_TAG_LEN;\r
} Hex[HASH_VALUE_TAG_LEN];\r
} HashValue;\r
//\r
if (BaseTagLen > SPEC_BASE_TAG_LEN) {\r
BaseTagLen = SPEC_BASE_TAG_LEN;\r
}\r
+\r
//\r
// We first use the algorithm described by spec.\r
//\r
- ShortNameChar = ShortName + BaseTagLen;\r
- *ShortNameChar++ = '~';\r
- *ShortNameChar = '1';\r
- Retry = 0;\r
+ ShortNameChar = ShortName + BaseTagLen;\r
+ *ShortNameChar++ = '~';\r
+ *ShortNameChar = '1';\r
+ Retry = 0;\r
while (*FatShortNameHashSearch (Parent->ODir, ShortName) != NULL) {\r
*ShortNameChar = (CHAR8)(*ShortNameChar + 1);\r
if (++Retry == MAX_SPEC_RETRY) {\r
}\r
}\r
\r
- *ShortNameChar++ = '~';\r
- *ShortNameChar = '1';\r
+ *ShortNameChar++ = '~';\r
+ *ShortNameChar = '1';\r
}\r
}\r
}\r
STATIC\r
UINT8\r
FatCheckNameCase (\r
- IN CHAR16 *Str,\r
- IN UINT8 InCaseFlag\r
+ IN CHAR16 *Str,\r
+ IN UINT8 InCaseFlag\r
)\r
{\r
CHAR16 Buffer[FAT_MAIN_NAME_LEN + 1 + FAT_EXTEND_NAME_LEN + 1];\r
if (StrCmp (Str, Buffer) == 0) {\r
OutCaseFlag = InCaseFlag;\r
}\r
+\r
//\r
// Upper case a copy of the string, if it matches the\r
// original then the string is upper case\r
**/\r
VOID\r
FatSetCaseFlag (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
CHAR16 LfnBuffer[FAT_MAIN_NAME_LEN + 1 + FAT_EXTEND_NAME_LEN + 1];\r
**/\r
VOID\r
FatGetFileNameViaCaseFlag (\r
- IN FAT_DIRENT *DirEnt,\r
- IN OUT CHAR16 *FileString,\r
- IN UINTN FileStringMax\r
+ IN FAT_DIRENT *DirEnt,\r
+ IN OUT CHAR16 *FileString,\r
+ IN UINTN FileStringMax\r
)\r
{\r
UINT8 CaseFlag;\r
CHAR8 *File8Dot3Name;\r
CHAR16 TempExt[1 + FAT_EXTEND_NAME_LEN + 1];\r
+\r
//\r
// Store file extension like ".txt"\r
//\r
IN CHAR8 *ShortNameString\r
)\r
{\r
- UINTN ShortNameLen;\r
- UINT8 Sum;\r
+ UINTN ShortNameLen;\r
+ UINT8 Sum;\r
+\r
Sum = 0;\r
for (ShortNameLen = FAT_NAME_LEN; ShortNameLen != 0; ShortNameLen--) {\r
Sum = (UINT8)((((Sum & 1) != 0) ? 0x80 : 0) + (Sum >> 1) + *ShortNameString++);\r
**/\r
CHAR16 *\r
FatGetNextNameComponent (\r
- IN CHAR16 *Path,\r
- OUT CHAR16 *Name\r
+ IN CHAR16 *Path,\r
+ OUT CHAR16 *Name\r
)\r
{\r
while (*Path != 0 && *Path != PATH_NAME_SEPARATOR) {\r
*Name++ = *Path++;\r
}\r
+\r
*Name = 0;\r
//\r
// Get off of trailing path name separator\r
{\r
CHAR16 *TempNamePointer;\r
CHAR16 TempChar;\r
+\r
//\r
// Trim Leading blanks\r
//\r
while (*InputFileName != 0) {\r
*TempNamePointer++ = *InputFileName++;\r
}\r
+\r
//\r
// Trim Trailing blanks and dots\r
//\r
while (TempNamePointer > OutputFileName) {\r
TempChar = *(TempNamePointer - 1);\r
- if (TempChar != L' ' && TempChar != L'.') {\r
+ if ((TempChar != L' ') && (TempChar != L'.')) {\r
break;\r
}\r
\r
if (TempNamePointer - OutputFileName > EFI_FILE_STRING_LENGTH) {\r
return FALSE;\r
}\r
+\r
//\r
// See if there is any illegal characters within the name\r
//\r
do {\r
- if (*OutputFileName < 0x20 ||\r
- *OutputFileName == '\"' ||\r
- *OutputFileName == '*' ||\r
- *OutputFileName == '/' ||\r
- *OutputFileName == ':' ||\r
- *OutputFileName == '<' ||\r
- *OutputFileName == '>' ||\r
- *OutputFileName == '?' ||\r
- *OutputFileName == '\\' ||\r
- *OutputFileName == '|'\r
- ) {\r
+ if ((*OutputFileName < 0x20) ||\r
+ (*OutputFileName == '\"') ||\r
+ (*OutputFileName == '*') ||\r
+ (*OutputFileName == '/') ||\r
+ (*OutputFileName == ':') ||\r
+ (*OutputFileName == '<') ||\r
+ (*OutputFileName == '>') ||\r
+ (*OutputFileName == '?') ||\r
+ (*OutputFileName == '\\') ||\r
+ (*OutputFileName == '|')\r
+ )\r
+ {\r
return FALSE;\r
}\r
\r
OutputFileName++;\r
} while (*OutputFileName != 0);\r
+\r
return TRUE;\r
}\r
\r
#include "Fat.h"\r
\r
-\r
/**\r
\r
Get the FAT entry of the volume, which is identified with the Index.\r
STATIC\r
VOID *\r
FatLoadFatEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Index\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Index\r
)\r
{\r
UINTN Pos;\r
EFI_STATUS Status;\r
\r
if (Index > (Volume->MaxCluster + 1)) {\r
- Volume->FatEntryBuffer = (UINT32) -1;\r
+ Volume->FatEntryBuffer = (UINT32)-1;\r
return &Volume->FatEntryBuffer;\r
}\r
+\r
//\r
// Compute buffer position needed\r
//\r
switch (Volume->FatType) {\r
- case Fat12:\r
- Pos = FAT_POS_FAT12 (Index);\r
- break;\r
+ case Fat12:\r
+ Pos = FAT_POS_FAT12 (Index);\r
+ break;\r
\r
- case Fat16:\r
- Pos = FAT_POS_FAT16 (Index);\r
- break;\r
+ case Fat16:\r
+ Pos = FAT_POS_FAT16 (Index);\r
+ break;\r
\r
- default:\r
- Pos = FAT_POS_FAT32 (Index);\r
+ default:\r
+ Pos = FAT_POS_FAT32 (Index);\r
}\r
+\r
//\r
// Set the position and read the buffer\r
//\r
Volume->FatEntryPos = Volume->FatPos + Pos;\r
- Status = FatDiskIo (\r
- Volume,\r
- ReadFat,\r
- Volume->FatEntryPos,\r
- Volume->FatEntrySize,\r
- &Volume->FatEntryBuffer,\r
- NULL\r
- );\r
+ Status = FatDiskIo (\r
+ Volume,\r
+ ReadFat,\r
+ Volume->FatEntryPos,\r
+ Volume->FatEntrySize,\r
+ &Volume->FatEntryBuffer,\r
+ NULL\r
+ );\r
if (EFI_ERROR (Status)) {\r
- Volume->FatEntryBuffer = (UINT32) -1;\r
+ Volume->FatEntryBuffer = (UINT32)-1;\r
}\r
\r
return &Volume->FatEntryBuffer;\r
STATIC\r
UINTN\r
FatGetFatEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Index\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Index\r
)\r
{\r
VOID *Pos;\r
Pos = FatLoadFatEntry (Volume, Index);\r
\r
if (Index > (Volume->MaxCluster + 1)) {\r
- return (UINTN) -1;\r
+ return (UINTN)-1;\r
}\r
\r
switch (Volume->FatType) {\r
- case Fat12:\r
- En12 = Pos;\r
- Accum = En12[0] | (En12[1] << 8);\r
- Accum = FAT_ODD_CLUSTER_FAT12 (Index) ? (Accum >> 4) : (Accum & FAT_CLUSTER_MASK_FAT12);\r
- Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT12) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
- break;\r
-\r
- case Fat16:\r
- En16 = Pos;\r
- Accum = *En16;\r
- Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT16) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
- break;\r
-\r
- default:\r
- En32 = Pos;\r
- Accum = *En32 & FAT_CLUSTER_MASK_FAT32;\r
- Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT32) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
+ case Fat12:\r
+ En12 = Pos;\r
+ Accum = En12[0] | (En12[1] << 8);\r
+ Accum = FAT_ODD_CLUSTER_FAT12 (Index) ? (Accum >> 4) : (Accum & FAT_CLUSTER_MASK_FAT12);\r
+ Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT12) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
+ break;\r
+\r
+ case Fat16:\r
+ En16 = Pos;\r
+ Accum = *En16;\r
+ Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT16) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
+ break;\r
+\r
+ default:\r
+ En32 = Pos;\r
+ Accum = *En32 & FAT_CLUSTER_MASK_FAT32;\r
+ Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT32) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
}\r
\r
return Accum;\r
STATIC\r
EFI_STATUS\r
FatSetFatEntry (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Index,\r
- IN UINTN Value\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Index,\r
+ IN UINTN Value\r
)\r
{\r
VOID *Pos;\r
}\r
\r
OriginalVal = FatGetFatEntry (Volume, Index);\r
- if (Value == FAT_CLUSTER_FREE && OriginalVal != FAT_CLUSTER_FREE) {\r
+ if ((Value == FAT_CLUSTER_FREE) && (OriginalVal != FAT_CLUSTER_FREE)) {\r
Volume->FatInfoSector.FreeInfo.ClusterCount += 1;\r
if (Index < Volume->FatInfoSector.FreeInfo.NextCluster) {\r
- Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32) Index;\r
+ Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32)Index;\r
}\r
- } else if (Value != FAT_CLUSTER_FREE && OriginalVal == FAT_CLUSTER_FREE) {\r
+ } else if ((Value != FAT_CLUSTER_FREE) && (OriginalVal == FAT_CLUSTER_FREE)) {\r
if (Volume->FatInfoSector.FreeInfo.ClusterCount != 0) {\r
Volume->FatInfoSector.FreeInfo.ClusterCount -= 1;\r
}\r
}\r
+\r
//\r
// Make sure the entry is in memory\r
//\r
// Update the value\r
//\r
switch (Volume->FatType) {\r
- case Fat12:\r
- En12 = Pos;\r
- Accum = En12[0] | (En12[1] << 8);\r
- Value = Value & FAT_CLUSTER_MASK_FAT12;\r
-\r
- if (FAT_ODD_CLUSTER_FAT12 (Index)) {\r
- Accum = (Value << 4) | (Accum & 0xF);\r
- } else {\r
- Accum = Value | (Accum & FAT_CLUSTER_UNMASK_FAT12);\r
- }\r
+ case Fat12:\r
+ En12 = Pos;\r
+ Accum = En12[0] | (En12[1] << 8);\r
+ Value = Value & FAT_CLUSTER_MASK_FAT12;\r
\r
- En12[0] = (UINT8) (Accum & 0xFF);\r
- En12[1] = (UINT8) (Accum >> 8);\r
- break;\r
+ if (FAT_ODD_CLUSTER_FAT12 (Index)) {\r
+ Accum = (Value << 4) | (Accum & 0xF);\r
+ } else {\r
+ Accum = Value | (Accum & FAT_CLUSTER_UNMASK_FAT12);\r
+ }\r
\r
- case Fat16:\r
- En16 = Pos;\r
- *En16 = (UINT16) Value;\r
- break;\r
+ En12[0] = (UINT8)(Accum & 0xFF);\r
+ En12[1] = (UINT8)(Accum >> 8);\r
+ break;\r
+\r
+ case Fat16:\r
+ En16 = Pos;\r
+ *En16 = (UINT16)Value;\r
+ break;\r
\r
- default:\r
- En32 = Pos;\r
- *En32 = (*En32 & FAT_CLUSTER_UNMASK_FAT32) | (UINT32) (Value & FAT_CLUSTER_MASK_FAT32);\r
+ default:\r
+ En32 = Pos;\r
+ *En32 = (*En32 & FAT_CLUSTER_UNMASK_FAT32) | (UINT32)(Value & FAT_CLUSTER_MASK_FAT32);\r
}\r
+\r
//\r
// If the volume's dirty bit is not set, set it now\r
//\r
- if (!Volume->FatDirty && Volume->FatType != Fat12) {\r
+ if (!Volume->FatDirty && (Volume->FatType != Fat12)) {\r
Volume->FatDirty = TRUE;\r
FatAccessVolumeDirty (Volume, WriteFat, &Volume->DirtyValue);\r
}\r
+\r
//\r
// Write the updated fat entry value to the volume\r
// The fat is the first fat, and other fat will be in sync\r
STATIC\r
EFI_STATUS\r
FatFreeClusters (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Cluster\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Cluster\r
)\r
{\r
- UINTN LastCluster;\r
+ UINTN LastCluster;\r
\r
while (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
- if (Cluster == FAT_CLUSTER_FREE || Cluster >= FAT_CLUSTER_SPECIAL) {\r
-\r
+ if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatShrinkEof: cluster chain corrupt\n"));\r
return EFI_VOLUME_CORRUPTED;\r
}\r
STATIC\r
UINTN\r
FatAllocateCluster (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
- UINTN Cluster;\r
+ UINTN Cluster;\r
\r
//\r
// Start looking at FatFreePos for the next unallocated cluster\r
//\r
if (Volume->DiskError) {\r
- return (UINTN) FAT_CLUSTER_LAST;\r
+ return (UINTN)FAT_CLUSTER_LAST;\r
}\r
\r
- for (;;) {\r
+ for ( ; ;) {\r
//\r
// If the end of the list, return no available cluster\r
//\r
if (Volume->FatInfoSector.FreeInfo.NextCluster > (Volume->MaxCluster + 1)) {\r
- if (Volume->FreeInfoValid && 0 < (INT32) (Volume->FatInfoSector.FreeInfo.ClusterCount)) {\r
+ if (Volume->FreeInfoValid && (0 < (INT32)(Volume->FatInfoSector.FreeInfo.ClusterCount))) {\r
Volume->FreeInfoValid = FALSE;\r
}\r
\r
FatComputeFreeInfo (Volume);\r
if (Volume->FatInfoSector.FreeInfo.NextCluster > (Volume->MaxCluster + 1)) {\r
- return (UINTN) FAT_CLUSTER_LAST;\r
+ return (UINTN)FAT_CLUSTER_LAST;\r
}\r
}\r
\r
if (Cluster == FAT_CLUSTER_FREE) {\r
break;\r
}\r
+\r
//\r
// Try the next cluster\r
//\r
Volume->FatInfoSector.FreeInfo.NextCluster += 1;\r
}\r
\r
- Cluster = Volume->FatInfoSector.FreeInfo.NextCluster;\r
+ Cluster = Volume->FatInfoSector.FreeInfo.NextCluster;\r
Volume->FatInfoSector.FreeInfo.NextCluster += 1;\r
return Cluster;\r
}\r
STATIC\r
UINTN\r
FatSizeToClusters (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Size\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Size\r
)\r
{\r
- UINTN Clusters;\r
+ UINTN Clusters;\r
\r
Clusters = Size >> Volume->ClusterAlignment;\r
if ((Size & (Volume->ClusterSize - 1)) > 0) {\r
**/\r
EFI_STATUS\r
FatShrinkEof (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
FAT_VOLUME *Volume;\r
UINTN Cluster;\r
UINTN LastCluster;\r
\r
- Volume = OFile->Volume;\r
+ Volume = OFile->Volume;\r
ASSERT_VOLUME_LOCKED (Volume);\r
\r
NewSize = FatSizeToClusters (Volume, OFile->FileSize);\r
LastCluster = FAT_CLUSTER_FREE;\r
\r
if (NewSize != 0) {\r
-\r
for (CurSize = 0; CurSize < NewSize; CurSize++) {\r
- if (Cluster == FAT_CLUSTER_FREE || Cluster >= FAT_CLUSTER_SPECIAL) {\r
-\r
+ if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatShrinkEof: cluster chain corrupt\n"));\r
return EFI_VOLUME_CORRUPTED;\r
}\r
Cluster = FatGetFatEntry (Volume, Cluster);\r
}\r
\r
- FatSetFatEntry (Volume, LastCluster, (UINTN) FAT_CLUSTER_LAST);\r
-\r
+ FatSetFatEntry (Volume, LastCluster, (UINTN)FAT_CLUSTER_LAST);\r
} else {\r
//\r
// Check to see if the file is already completely truncated\r
if (Cluster == FAT_CLUSTER_FREE) {\r
return EFI_SUCCESS;\r
}\r
+\r
//\r
// The file is being completely truncated.\r
//\r
- OFile->FileCluster = FAT_CLUSTER_FREE;\r
+ OFile->FileCluster = FAT_CLUSTER_FREE;\r
}\r
+\r
//\r
// Set CurrentCluster == FileCluster\r
// to force a recalculation of Position related stuffs\r
**/\r
EFI_STATUS\r
FatGrowEof (\r
- IN FAT_OFILE *OFile,\r
- IN UINT64 NewSizeInBytes\r
+ IN FAT_OFILE *OFile,\r
+ IN UINT64 NewSizeInBytes\r
)\r
{\r
FAT_VOLUME *Volume;\r
// If the file is already large enough, do nothing\r
//\r
CurSize = FatSizeToClusters (Volume, OFile->FileSize);\r
- NewSize = FatSizeToClusters (Volume, (UINTN) NewSizeInBytes);\r
+ NewSize = FatSizeToClusters (Volume, (UINTN)NewSizeInBytes);\r
\r
if (CurSize < NewSize) {\r
//\r
// If we haven't found the files last cluster do it now\r
//\r
if ((OFile->FileCluster != 0) && (OFile->FileLastCluster == 0)) {\r
- Cluster = OFile->FileCluster;\r
- ClusterCount = 0;\r
+ Cluster = OFile->FileCluster;\r
+ ClusterCount = 0;\r
\r
while (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
- if (Cluster < FAT_MIN_CLUSTER || Cluster > Volume->MaxCluster + 1) {\r
-\r
+ if ((Cluster < FAT_MIN_CLUSTER) || (Cluster > Volume->MaxCluster + 1)) {\r
DEBUG (\r
(DEBUG_INIT | DEBUG_ERROR,\r
- "FatGrowEof: cluster chain corrupt\n")\r
+ "FatGrowEof: cluster chain corrupt\n")\r
);\r
Status = EFI_VOLUME_CORRUPTED;\r
goto Done;\r
}\r
\r
ClusterCount++;\r
- OFile->FileLastCluster = Cluster;\r
- Cluster = FatGetFatEntry (Volume, Cluster);\r
+ OFile->FileLastCluster = Cluster;\r
+ Cluster = FatGetFatEntry (Volume, Cluster);\r
}\r
\r
if (ClusterCount != CurSize) {\r
DEBUG (\r
(DEBUG_INIT | DEBUG_ERROR,\r
- "FatGrowEof: cluster chain size does not match file size\n")\r
+ "FatGrowEof: cluster chain size does not match file size\n")\r
);\r
Status = EFI_VOLUME_CORRUPTED;\r
goto Done;\r
}\r
-\r
}\r
+\r
//\r
// Loop until we've allocated enough space\r
//\r
NewCluster = FatAllocateCluster (Volume);\r
if (FAT_END_OF_FAT_CHAIN (NewCluster)) {\r
if (LastCluster != FAT_CLUSTER_FREE) {\r
- FatSetFatEntry (Volume, LastCluster, (UINTN) FAT_CLUSTER_LAST);\r
+ FatSetFatEntry (Volume, LastCluster, (UINTN)FAT_CLUSTER_LAST);\r
OFile->FileLastCluster = LastCluster;\r
}\r
\r
goto Done;\r
}\r
\r
- if (NewCluster < FAT_MIN_CLUSTER || NewCluster > Volume->MaxCluster + 1) {\r
+ if ((NewCluster < FAT_MIN_CLUSTER) || (NewCluster > Volume->MaxCluster + 1)) {\r
Status = EFI_VOLUME_CORRUPTED;\r
goto Done;\r
}\r
}\r
\r
LastCluster = NewCluster;\r
- CurSize += 1;\r
+ CurSize += 1;\r
\r
//\r
// Terminate the cluster list\r
// a second time. There are other, less predictable scenarios\r
// where this could happen, as well.\r
//\r
- FatSetFatEntry (Volume, LastCluster, (UINTN) FAT_CLUSTER_LAST);\r
+ FatSetFatEntry (Volume, LastCluster, (UINTN)FAT_CLUSTER_LAST);\r
OFile->FileLastCluster = LastCluster;\r
}\r
}\r
\r
- OFile->FileSize = (UINTN) NewSizeInBytes;\r
+ OFile->FileSize = (UINTN)NewSizeInBytes;\r
OFile->Dirty = TRUE;\r
return EFI_SUCCESS;\r
\r
**/\r
EFI_STATUS\r
FatOFilePosition (\r
- IN FAT_OFILE *OFile,\r
- IN UINTN Position,\r
- IN UINTN PosLimit\r
+ IN FAT_OFILE *OFile,\r
+ IN UINTN Position,\r
+ IN UINTN PosLimit\r
)\r
{\r
FAT_VOLUME *Volume;\r
// from its fixed info in the fat bpb\r
//\r
if (OFile->IsFixedRootDir) {\r
- OFile->PosDisk = Volume->RootPos + Position;\r
- Run = OFile->FileSize - Position;\r
+ OFile->PosDisk = Volume->RootPos + Position;\r
+ Run = OFile->FileSize - Position;\r
} else {\r
//\r
// Run the file's cluster chain to find the current position\r
// when OFile->FileCluster is updated, so make a check of this\r
// and invalidate the original OFile->Position in this case\r
//\r
- Cluster = OFile->FileCurrentCluster;\r
- StartPos = OFile->Position;\r
- if (Position < StartPos || OFile->FileCluster == Cluster) {\r
- StartPos = 0;\r
- Cluster = OFile->FileCluster;\r
+ Cluster = OFile->FileCurrentCluster;\r
+ StartPos = OFile->Position;\r
+ if ((Position < StartPos) || (OFile->FileCluster == Cluster)) {\r
+ StartPos = 0;\r
+ Cluster = OFile->FileCluster;\r
}\r
\r
while (StartPos + ClusterSize <= Position) {\r
StartPos += ClusterSize;\r
- if (Cluster == FAT_CLUSTER_FREE || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
- DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatOFilePosition:"" cluster chain corrupt\n"));\r
+ if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
+ DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatOFilePosition:" " cluster chain corrupt\n"));\r
return EFI_VOLUME_CORRUPTED;\r
}\r
\r
Cluster = FatGetFatEntry (Volume, Cluster);\r
}\r
\r
- if (Cluster < FAT_MIN_CLUSTER || Cluster > Volume->MaxCluster + 1) {\r
+ if ((Cluster < FAT_MIN_CLUSTER) || (Cluster > Volume->MaxCluster + 1)) {\r
return EFI_VOLUME_CORRUPTED;\r
}\r
\r
- OFile->PosDisk = Volume->FirstClusterPos +\r
- LShiftU64 (Cluster - FAT_MIN_CLUSTER, Volume->ClusterAlignment) +\r
- Position - StartPos;\r
+ OFile->PosDisk = Volume->FirstClusterPos +\r
+ LShiftU64 (Cluster - FAT_MIN_CLUSTER, Volume->ClusterAlignment) +\r
+ Position - StartPos;\r
OFile->FileCurrentCluster = Cluster;\r
OFile->Position = StartPos;\r
\r
**/\r
UINTN\r
FatPhysicalDirSize (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN Cluster\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN Cluster\r
)\r
{\r
- UINTN Size;\r
+ UINTN Size;\r
+\r
ASSERT_VOLUME_LOCKED (Volume);\r
//\r
// Run the cluster chain for the OFile\r
//\r
if (Cluster != 0) {\r
while (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
- if (Cluster == FAT_CLUSTER_FREE || Cluster >= FAT_CLUSTER_SPECIAL) {\r
+ if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
DEBUG (\r
(DEBUG_INIT | DEBUG_ERROR,\r
- "FATDirSize: cluster chain corrupt\n")\r
+ "FATDirSize: cluster chain corrupt\n")\r
);\r
return 0;\r
}\r
\r
- Size += Volume->ClusterSize;\r
+ Size += Volume->ClusterSize;\r
Cluster = FatGetFatEntry (Volume, Cluster);\r
}\r
}\r
**/\r
UINT64\r
FatPhysicalFileSize (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN RealSize\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN RealSize\r
)\r
{\r
UINTN ClusterSizeMask;\r
UINT64 PhysicalSize;\r
+\r
ClusterSizeMask = Volume->ClusterSize - 1;\r
- PhysicalSize = (RealSize + ClusterSizeMask) & (~((UINT64) ClusterSizeMask));\r
+ PhysicalSize = (RealSize + ClusterSizeMask) & (~((UINT64)ClusterSizeMask));\r
return PhysicalSize;\r
}\r
\r
**/\r
VOID\r
FatComputeFreeInfo (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
- UINTN Index;\r
+ UINTN Index;\r
\r
//\r
// If we don't have valid info, compute it now\r
//\r
if (!Volume->FreeInfoValid) {\r
-\r
- Volume->FreeInfoValid = TRUE;\r
- Volume->FatInfoSector.FreeInfo.ClusterCount = 0;\r
+ Volume->FreeInfoValid = TRUE;\r
+ Volume->FatInfoSector.FreeInfo.ClusterCount = 0;\r
for (Index = Volume->MaxCluster + 1; Index >= FAT_MIN_CLUSTER; Index--) {\r
if (Volume->DiskError) {\r
break;\r
\r
if (FatGetFatEntry (Volume, Index) == FAT_CLUSTER_FREE) {\r
Volume->FatInfoSector.FreeInfo.ClusterCount += 1;\r
- Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32) Index;\r
+ Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32)Index;\r
}\r
}\r
\r
EFI_STATUS Status;\r
FAT_TASK *Task;\r
\r
- IFile = IFILE_FROM_FHAND (FHand);\r
- OFile = IFile->OFile;\r
- Volume = OFile->Volume;\r
- Task = NULL;\r
+ IFile = IFILE_FROM_FHAND (FHand);\r
+ OFile = IFile->OFile;\r
+ Volume = OFile->Volume;\r
+ Task = NULL;\r
\r
//\r
// If the file has a permanent error, return it\r
if (Volume->ReadOnly) {\r
return EFI_WRITE_PROTECTED;\r
}\r
+\r
//\r
// If read only, return error\r
//\r
if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
Task = FatCreateTask (IFile, Token);\r
if (Task == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
// Flush the OFile\r
//\r
FatAcquireLock ();\r
- Status = FatOFileFlush (OFile);\r
- Status = FatCleanupVolume (OFile->Volume, OFile, Status, Task);\r
+ Status = FatOFileFlush (OFile);\r
+ Status = FatCleanupVolume (OFile->Volume, OFile, Status, Task);\r
FatReleaseLock ();\r
\r
if (Token != NULL) {\r
FAT_OFILE *OFile;\r
FAT_VOLUME *Volume;\r
\r
- IFile = IFILE_FROM_FHAND (FHand);\r
- OFile = IFile->OFile;\r
- Volume = OFile->Volume;\r
+ IFile = IFILE_FROM_FHAND (FHand);\r
+ OFile = IFile->OFile;\r
+ Volume = OFile->Volume;\r
\r
//\r
// Lock the volume\r
**/\r
EFI_STATUS\r
FatIFileClose (\r
- FAT_IFILE *IFile\r
+ FAT_IFILE *IFile\r
)\r
{\r
FAT_OFILE *OFile;\r
FAT_VOLUME *Volume;\r
\r
- OFile = IFile->OFile;\r
- Volume = OFile->Volume;\r
+ OFile = IFile->OFile;\r
+ Volume = OFile->Volume;\r
\r
ASSERT_VOLUME_LOCKED (Volume);\r
\r
if (OFile->CheckLink.ForwardLink == NULL) {\r
InsertHeadList (&Volume->CheckRef, &OFile->CheckLink);\r
}\r
+\r
//\r
// Done. Free the open instance structure\r
//\r
**/\r
EFI_STATUS\r
FatOFileFlush (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
- EFI_STATUS Status;\r
- FAT_OFILE *Parent;\r
- FAT_DIRENT *DirEnt;\r
- FAT_DATE_TIME FatNow;\r
+ EFI_STATUS Status;\r
+ FAT_OFILE *Parent;\r
+ FAT_DIRENT *DirEnt;\r
+ FAT_DATE_TIME FatNow;\r
\r
//\r
// Flush each entry up the tree while dirty\r
return OFile->Error;\r
}\r
\r
- Parent = OFile->Parent;\r
- DirEnt = OFile->DirEnt;\r
+ Parent = OFile->Parent;\r
+ DirEnt = OFile->DirEnt;\r
if (OFile->Dirty) {\r
//\r
// Update the last modification time\r
OFile->PreserveLastModification = FALSE;\r
if (OFile->Archive) {\r
DirEnt->Entry.Attributes |= FAT_ATTRIBUTE_ARCHIVE;\r
- OFile->Archive = FALSE;\r
+ OFile->Archive = FALSE;\r
}\r
+\r
//\r
// Write the directory entry\r
//\r
- if (Parent != NULL && !DirEnt->Invalid) {\r
+ if ((Parent != NULL) && !DirEnt->Invalid) {\r
//\r
// Write the OFile's directory entry\r
//\r
\r
OFile->Dirty = FALSE;\r
}\r
+\r
//\r
// Check the parent\r
//\r
OFile = Parent;\r
} while (OFile != NULL);\r
+\r
return EFI_SUCCESS;\r
}\r
\r
**/\r
BOOLEAN\r
FatCheckOFileRef (\r
- IN FAT_OFILE *OFile\r
+ IN FAT_OFILE *OFile\r
)\r
{\r
//\r
//\r
return FALSE;\r
}\r
+\r
//\r
// Free the Ofile\r
//\r
STATIC\r
VOID\r
FatCheckVolumeRef (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
- FAT_OFILE *OFile;\r
- FAT_OFILE *Parent;\r
+ FAT_OFILE *OFile;\r
+ FAT_OFILE *Parent;\r
\r
//\r
// Check all files on the pending check list\r
// Go up the tree cleaning up any un-referenced OFiles\r
//\r
while (Parent != NULL) {\r
- OFile = Parent;\r
- Parent = OFile->Parent;\r
+ OFile = Parent;\r
+ Parent = OFile->Parent;\r
if (!FatCheckOFileRef (OFile)) {\r
break;\r
}\r
**/\r
EFI_STATUS\r
FatCleanupVolume (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_OFILE *OFile,\r
- IN EFI_STATUS EfiStatus,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_OFILE *OFile,\r
+ IN EFI_STATUS EfiStatus,\r
+ IN FAT_TASK *Task\r
)\r
{\r
EFI_STATUS Status;\r
+\r
//\r
// Flag the OFile\r
//\r
if (OFile != NULL) {\r
FatSetVolumeError (OFile, EfiStatus);\r
}\r
+\r
//\r
// Clean up any dangling OFiles that don't have IFiles\r
// we don't check return status here because we want the\r
return Status;\r
}\r
}\r
+\r
//\r
// Update that the volume is not dirty\r
//\r
- if (Volume->FatDirty && Volume->FatType != Fat12) {\r
- Volume->FatDirty = FALSE;\r
- Status = FatAccessVolumeDirty (Volume, WriteFat, &Volume->NotDirtyValue);\r
+ if (Volume->FatDirty && (Volume->FatType != Fat12)) {\r
+ Volume->FatDirty = FALSE;\r
+ Status = FatAccessVolumeDirty (Volume, WriteFat, &Volume->NotDirtyValue);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
}\r
+\r
//\r
// Flush all dirty cache entries to disk\r
//\r
return Status;\r
}\r
}\r
+\r
//\r
// If the volume is cleared , remove it.\r
// The only time volume be invalidated is in DriverBindingStop.\r
//\r
- if (Volume->Root == NULL && !Volume->Valid) {\r
+ if ((Volume->Root == NULL) && !Volume->Valid) {\r
//\r
// Free the volume structure\r
//\r
**/\r
VOID\r
FatSetVolumeError (\r
- IN FAT_OFILE *OFile,\r
- IN EFI_STATUS Status\r
+ IN FAT_OFILE *OFile,\r
+ IN EFI_STATUS Status\r
)\r
{\r
- LIST_ENTRY *Link;\r
- FAT_OFILE *ChildOFile;\r
+ LIST_ENTRY *Link;\r
+ FAT_OFILE *ChildOFile;\r
\r
//\r
// If this OFile doesn't already have an error, set one\r
if (!EFI_ERROR (OFile->Error)) {\r
OFile->Error = Status;\r
}\r
+\r
//\r
// Set the error on each child OFile\r
//\r
STATIC\r
UINT32\r
FatHashLongName (\r
- IN CHAR16 *LongNameString\r
+ IN CHAR16 *LongNameString\r
)\r
{\r
UINT32 HashValue;\r
CHAR16 UpCasedLongFileName[EFI_PATH_STRING_LENGTH];\r
+\r
StrnCpyS (\r
UpCasedLongFileName,\r
ARRAY_SIZE (UpCasedLongFileName),\r
STATIC\r
UINT32\r
FatHashShortName (\r
- IN CHAR8 *ShortNameString\r
+ IN CHAR8 *ShortNameString\r
)\r
{\r
UINT32 HashValue;\r
+\r
gBS->CalculateCrc32 (ShortNameString, FAT_NAME_LEN, &HashValue);\r
return (HashValue & HASH_TABLE_MASK);\r
}\r
**/\r
FAT_DIRENT **\r
FatLongNameHashSearch (\r
- IN FAT_ODIR *ODir,\r
- IN CHAR16 *LongNameString\r
+ IN FAT_ODIR *ODir,\r
+ IN CHAR16 *LongNameString\r
)\r
{\r
FAT_DIRENT **PreviousHashNode;\r
+\r
for (PreviousHashNode = &ODir->LongNameHashTable[FatHashLongName (LongNameString)];\r
*PreviousHashNode != NULL;\r
PreviousHashNode = &(*PreviousHashNode)->LongNameForwardLink\r
- ) {\r
+ )\r
+ {\r
if (FatStriCmp (LongNameString, (*PreviousHashNode)->FileString) == 0) {\r
break;\r
}\r
**/\r
FAT_DIRENT **\r
FatShortNameHashSearch (\r
- IN FAT_ODIR *ODir,\r
- IN CHAR8 *ShortNameString\r
+ IN FAT_ODIR *ODir,\r
+ IN CHAR8 *ShortNameString\r
)\r
{\r
FAT_DIRENT **PreviousHashNode;\r
+\r
for (PreviousHashNode = &ODir->ShortNameHashTable[FatHashShortName (ShortNameString)];\r
*PreviousHashNode != NULL;\r
PreviousHashNode = &(*PreviousHashNode)->ShortNameForwardLink\r
- ) {\r
+ )\r
+ {\r
if (CompareMem (ShortNameString, (*PreviousHashNode)->Entry.FileName, FAT_NAME_LEN) == 0) {\r
break;\r
}\r
**/\r
VOID\r
FatInsertToHashTable (\r
- IN FAT_ODIR *ODir,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_ODIR *ODir,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
FAT_DIRENT **HashTable;\r
//\r
// Insert hash table index for short name\r
//\r
- HashTableIndex = FatHashShortName (DirEnt->Entry.FileName);\r
- HashTable = ODir->ShortNameHashTable;\r
- DirEnt->ShortNameForwardLink = HashTable[HashTableIndex];\r
- HashTable[HashTableIndex] = DirEnt;\r
+ HashTableIndex = FatHashShortName (DirEnt->Entry.FileName);\r
+ HashTable = ODir->ShortNameHashTable;\r
+ DirEnt->ShortNameForwardLink = HashTable[HashTableIndex];\r
+ HashTable[HashTableIndex] = DirEnt;\r
//\r
// Insert hash table index for long name\r
//\r
- HashTableIndex = FatHashLongName (DirEnt->FileString);\r
- HashTable = ODir->LongNameHashTable;\r
- DirEnt->LongNameForwardLink = HashTable[HashTableIndex];\r
- HashTable[HashTableIndex] = DirEnt;\r
+ HashTableIndex = FatHashLongName (DirEnt->FileString);\r
+ HashTable = ODir->LongNameHashTable;\r
+ DirEnt->LongNameForwardLink = HashTable[HashTableIndex];\r
+ HashTable[HashTableIndex] = DirEnt;\r
}\r
\r
/**\r
**/\r
VOID\r
FatDeleteFromHashTable (\r
- IN FAT_ODIR *ODir,\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_ODIR *ODir,\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
*FatShortNameHashSearch (ODir, DirEnt->Entry.FileName) = DirEnt->ShortNameForwardLink;\r
**/\r
EFI_STATUS\r
FatGetVolumeInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatSetVolumeInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN BufferSize,\r
- IN VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN BufferSize,\r
+ IN VOID *Buffer\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatSetOrGetInfo (\r
- IN BOOLEAN IsSet,\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- IN EFI_GUID *Type,\r
- IN OUT UINTN *BufferSize,\r
- IN OUT VOID *Buffer\r
+ IN BOOLEAN IsSet,\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ IN EFI_GUID *Type,\r
+ IN OUT UINTN *BufferSize,\r
+ IN OUT VOID *Buffer\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
FatGetFileInfo (\r
- IN FAT_OFILE *OFile,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_OFILE *OFile,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
return FatGetDirEntInfo (OFile->Volume, OFile->DirEnt, BufferSize, Buffer);\r
**/\r
EFI_STATUS\r
FatGetVolumeInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
UINTN Size;\r
EFI_FILE_SYSTEM_INFO *Info;\r
UINT8 ClusterAlignment;\r
\r
- Size = SIZE_OF_EFI_FILE_SYSTEM_INFO;\r
- Status = FatGetVolumeEntry (Volume, Name);\r
- NameSize = StrSize (Name);\r
- ResultSize = Size + NameSize;\r
- ClusterAlignment = Volume->ClusterAlignment;\r
+ Size = SIZE_OF_EFI_FILE_SYSTEM_INFO;\r
+ Status = FatGetVolumeEntry (Volume, Name);\r
+ NameSize = StrSize (Name);\r
+ ResultSize = Size + NameSize;\r
+ ClusterAlignment = Volume->ClusterAlignment;\r
\r
//\r
// If we don't have valid info, compute it now\r
\r
Status = EFI_BUFFER_TOO_SMALL;\r
if (*BufferSize >= ResultSize) {\r
- Status = EFI_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
\r
- Info = Buffer;\r
+ Info = Buffer;\r
ZeroMem (Info, SIZE_OF_EFI_FILE_SYSTEM_INFO);\r
\r
- Info->Size = ResultSize;\r
- Info->ReadOnly = Volume->ReadOnly;\r
- Info->BlockSize = (UINT32) Volume->ClusterSize;\r
- Info->VolumeSize = LShiftU64 (Volume->MaxCluster, ClusterAlignment);\r
- Info->FreeSpace = LShiftU64 (\r
- Volume->FatInfoSector.FreeInfo.ClusterCount,\r
- ClusterAlignment\r
- );\r
- CopyMem ((CHAR8 *) Buffer + Size, Name, NameSize);\r
+ Info->Size = ResultSize;\r
+ Info->ReadOnly = Volume->ReadOnly;\r
+ Info->BlockSize = (UINT32)Volume->ClusterSize;\r
+ Info->VolumeSize = LShiftU64 (Volume->MaxCluster, ClusterAlignment);\r
+ Info->FreeSpace = LShiftU64 (\r
+ Volume->FatInfoSector.FreeInfo.ClusterCount,\r
+ ClusterAlignment\r
+ );\r
+ CopyMem ((CHAR8 *)Buffer + Size, Name, NameSize);\r
}\r
\r
*BufferSize = ResultSize;\r
**/\r
EFI_STATUS\r
FatGetVolumeLabelInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
- UINTN Size;\r
- UINTN NameSize;\r
- UINTN ResultSize;\r
- CHAR16 Name[FAT_NAME_LEN + 1];\r
- EFI_STATUS Status;\r
-\r
- Size = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL;\r
- Status = FatGetVolumeEntry (Volume, Name);\r
- NameSize = StrSize (Name);\r
- ResultSize = Size + NameSize;\r
-\r
- Status = EFI_BUFFER_TOO_SMALL;\r
+ UINTN Size;\r
+ UINTN NameSize;\r
+ UINTN ResultSize;\r
+ CHAR16 Name[FAT_NAME_LEN + 1];\r
+ EFI_STATUS Status;\r
+\r
+ Size = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL;\r
+ Status = FatGetVolumeEntry (Volume, Name);\r
+ NameSize = StrSize (Name);\r
+ ResultSize = Size + NameSize;\r
+\r
+ Status = EFI_BUFFER_TOO_SMALL;\r
if (*BufferSize >= ResultSize) {\r
- Status = EFI_SUCCESS;\r
- CopyMem ((CHAR8 *) Buffer + Size, Name, NameSize);\r
+ Status = EFI_SUCCESS;\r
+ CopyMem ((CHAR8 *)Buffer + Size, Name, NameSize);\r
}\r
\r
*BufferSize = ResultSize;\r
**/\r
EFI_STATUS\r
FatSetVolumeInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN BufferSize,\r
- IN VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN BufferSize,\r
+ IN VOID *Buffer\r
)\r
{\r
EFI_FILE_SYSTEM_INFO *Info;\r
\r
- Info = (EFI_FILE_SYSTEM_INFO *) Buffer;\r
+ Info = (EFI_FILE_SYSTEM_INFO *)Buffer;\r
\r
- if (BufferSize < SIZE_OF_EFI_FILE_SYSTEM_INFO + 2 || Info->Size > BufferSize) {\r
+ if ((BufferSize < SIZE_OF_EFI_FILE_SYSTEM_INFO + 2) || (Info->Size > BufferSize)) {\r
return EFI_BAD_BUFFER_SIZE;\r
}\r
\r
**/\r
EFI_STATUS\r
FatSetVolumeLabelInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN UINTN BufferSize,\r
- IN VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN UINTN BufferSize,\r
+ IN VOID *Buffer\r
)\r
{\r
- EFI_FILE_SYSTEM_VOLUME_LABEL *Info;\r
+ EFI_FILE_SYSTEM_VOLUME_LABEL *Info;\r
\r
- Info = (EFI_FILE_SYSTEM_VOLUME_LABEL *) Buffer;\r
+ Info = (EFI_FILE_SYSTEM_VOLUME_LABEL *)Buffer;\r
\r
if (BufferSize < SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL + 2) {\r
return EFI_BAD_BUFFER_SIZE;\r
**/\r
EFI_STATUS\r
FatSetFileInfo (\r
- IN FAT_VOLUME *Volume,\r
- IN FAT_IFILE *IFile,\r
- IN FAT_OFILE *OFile,\r
- IN UINTN BufferSize,\r
- IN VOID *Buffer\r
+ IN FAT_VOLUME *Volume,\r
+ IN FAT_IFILE *IFile,\r
+ IN FAT_OFILE *OFile,\r
+ IN UINTN BufferSize,\r
+ IN VOID *Buffer\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_FILE_INFO *NewInfo;\r
- FAT_OFILE *DotOFile;\r
- FAT_OFILE *Parent;\r
- CHAR16 NewFileName[EFI_PATH_STRING_LENGTH];\r
- EFI_TIME ZeroTime;\r
- FAT_DIRENT *DirEnt;\r
- FAT_DIRENT *TempDirEnt;\r
- UINT8 NewAttribute;\r
- BOOLEAN ReadOnly;\r
+ EFI_STATUS Status;\r
+ EFI_FILE_INFO *NewInfo;\r
+ FAT_OFILE *DotOFile;\r
+ FAT_OFILE *Parent;\r
+ CHAR16 NewFileName[EFI_PATH_STRING_LENGTH];\r
+ EFI_TIME ZeroTime;\r
+ FAT_DIRENT *DirEnt;\r
+ FAT_DIRENT *TempDirEnt;\r
+ UINT8 NewAttribute;\r
+ BOOLEAN ReadOnly;\r
\r
ZeroMem (&ZeroTime, sizeof (EFI_TIME));\r
- Parent = OFile->Parent;\r
- DirEnt = OFile->DirEnt;\r
+ Parent = OFile->Parent;\r
+ DirEnt = OFile->DirEnt;\r
//\r
// If this is the root directory, we can't make any updates\r
//\r
if (Parent == NULL) {\r
return EFI_ACCESS_DENIED;\r
}\r
+\r
//\r
// Make sure there's a valid input buffer\r
//\r
NewInfo = Buffer;\r
- if (BufferSize < SIZE_OF_EFI_FILE_INFO + 2 || NewInfo->Size > BufferSize) {\r
+ if ((BufferSize < SIZE_OF_EFI_FILE_INFO + 2) || (NewInfo->Size > BufferSize)) {\r
return EFI_BAD_BUFFER_SIZE;\r
}\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- NewAttribute = (UINT8) NewInfo->Attribute;\r
+ NewAttribute = (UINT8)NewInfo->Attribute;\r
//\r
// Can not change the directory attribute bit\r
//\r
if ((NewAttribute ^ DirEnt->Entry.Attributes) & EFI_FILE_DIRECTORY) {\r
return EFI_ACCESS_DENIED;\r
}\r
+\r
//\r
// Set the current attributes even if the IFile->ReadOnly is TRUE\r
//\r
- DirEnt->Entry.Attributes = (UINT8) ((DirEnt->Entry.Attributes &~EFI_FILE_VALID_ATTR) | NewAttribute);\r
+ DirEnt->Entry.Attributes = (UINT8)((DirEnt->Entry.Attributes &~EFI_FILE_VALID_ATTR) | NewAttribute);\r
//\r
// Open the filename and see if it refers to an existing file\r
//\r
// File was not found. We do not allow rename of the current directory if\r
// there are open files below the current directory\r
//\r
- if (!IsListEmpty (&OFile->ChildHead) || Parent == OFile) {\r
+ if (!IsListEmpty (&OFile->ChildHead) || (Parent == OFile)) {\r
return EFI_ACCESS_DENIED;\r
}\r
\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
+\r
//\r
// Create new dirent\r
//\r
ASSERT (OFile->Parent != NULL);\r
for (DotOFile = OFile; DotOFile != OFile->Parent->Parent; DotOFile = DotOFile->Parent) {\r
Status = FatGetNextDirEnt (OFile, &DirEnt);\r
- if (EFI_ERROR (Status) || DirEnt == NULL || !FatIsDotDirEnt (DirEnt)) {\r
+ if (EFI_ERROR (Status) || (DirEnt == NULL) || !FatIsDotDirEnt (DirEnt)) {\r
return EFI_VOLUME_CORRUPTED;\r
}\r
\r
}\r
}\r
}\r
+\r
//\r
// If the file is renamed, we should append the ARCHIVE attribute\r
//\r
//\r
return EFI_ACCESS_DENIED;\r
}\r
+\r
//\r
// If the file size has changed, apply it\r
//\r
if (NewInfo->FileSize != OFile->FileSize) {\r
- if (OFile->ODir != NULL || ReadOnly) {\r
+ if ((OFile->ODir != NULL) || ReadOnly) {\r
//\r
// If this is a directory or the file is read only, we can't change the file size\r
//\r
if (NewInfo->FileSize > OFile->FileSize) {\r
Status = FatExpandOFile (OFile, NewInfo->FileSize);\r
} else {\r
- Status = FatTruncateOFile (OFile, (UINTN) NewInfo->FileSize);\r
+ Status = FatTruncateOFile (OFile, (UINTN)NewInfo->FileSize);\r
}\r
\r
if (EFI_ERROR (Status)) {\r
FAT_VOLUME *Volume;\r
EFI_STATUS Status;\r
\r
- IFile = IFILE_FROM_FHAND (FHand);\r
- OFile = IFile->OFile;\r
- Volume = OFile->Volume;\r
+ IFile = IFILE_FROM_FHAND (FHand);\r
+ OFile = IFile->OFile;\r
+ Volume = OFile->Volume;\r
\r
- Status = OFile->Error;\r
+ Status = OFile->Error;\r
if (Status == EFI_NOT_FOUND) {\r
return EFI_DEVICE_ERROR;\r
}\r
EFI_STATUS\r
EFIAPI\r
FatGetInfo (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- IN EFI_GUID *Type,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ IN EFI_GUID *Type,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
return FatSetOrGetInfo (FALSE, FHand, Type, BufferSize, Buffer);\r
**/\r
EFI_STATUS\r
FatAllocateVolume (\r
- IN EFI_HANDLE Handle,\r
- IN EFI_DISK_IO_PROTOCOL *DiskIo,\r
- IN EFI_DISK_IO2_PROTOCOL *DiskIo2,\r
- IN EFI_BLOCK_IO_PROTOCOL *BlockIo\r
+ IN EFI_HANDLE Handle,\r
+ IN EFI_DISK_IO_PROTOCOL *DiskIo,\r
+ IN EFI_DISK_IO2_PROTOCOL *DiskIo2,\r
+ IN EFI_BLOCK_IO_PROTOCOL *BlockIo\r
)\r
{\r
EFI_STATUS Status;\r
//\r
// Initialize the structure\r
//\r
- Volume->Signature = FAT_VOLUME_SIGNATURE;\r
- Volume->Handle = Handle;\r
- Volume->DiskIo = DiskIo;\r
- Volume->DiskIo2 = DiskIo2;\r
- Volume->BlockIo = BlockIo;\r
- Volume->MediaId = BlockIo->Media->MediaId;\r
- Volume->ReadOnly = BlockIo->Media->ReadOnly;\r
- Volume->VolumeInterface.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;\r
- Volume->VolumeInterface.OpenVolume = FatOpenVolume;\r
+ Volume->Signature = FAT_VOLUME_SIGNATURE;\r
+ Volume->Handle = Handle;\r
+ Volume->DiskIo = DiskIo;\r
+ Volume->DiskIo2 = DiskIo2;\r
+ Volume->BlockIo = BlockIo;\r
+ Volume->MediaId = BlockIo->Media->MediaId;\r
+ Volume->ReadOnly = BlockIo->Media->ReadOnly;\r
+ Volume->VolumeInterface.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;\r
+ Volume->VolumeInterface.OpenVolume = FatOpenVolume;\r
InitializeListHead (&Volume->CheckRef);\r
InitializeListHead (&Volume->DirCacheList);\r
//\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
}\r
+\r
//\r
// Initialize cache\r
//\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
}\r
+\r
//\r
// Install our protocol interfaces on the device's handle\r
//\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
}\r
+\r
//\r
// Volume installed\r
//\r
**/\r
EFI_STATUS\r
FatAbandonVolume (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
EFI_STATUS Status;\r
if (!EFI_ERROR (Status)) {\r
LockedByMe = TRUE;\r
}\r
+\r
//\r
// The volume is still being used. Hence, set error flag for all OFiles still in\r
// use. In two cases, we could get here. One is EFI_MEDIA_CHANGED, the other is\r
**/\r
EFI_STATUS\r
FatOpenDevice (\r
- IN OUT FAT_VOLUME *Volume\r
+ IN OUT FAT_VOLUME *Volume\r
)\r
{\r
EFI_STATUS Status;\r
// This is the only part of FAT code that uses parent DiskIo,\r
// Others use FatDiskIo which utilizes a Cache.\r
//\r
- DiskIo = Volume->DiskIo;\r
- Status = DiskIo->ReadDisk (DiskIo, Volume->MediaId, 0, sizeof (FatBs), &FatBs);\r
+ DiskIo = Volume->DiskIo;\r
+ Status = DiskIo->ReadDisk (DiskIo, Volume->MediaId, 0, sizeof (FatBs), &FatBs);\r
\r
if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_INIT, "FatOpenDevice: read of part_lba failed %r\n", Status));\r
SectorsPerFat = FatBs.FatBse.Fat32Bse.LargeSectorsPerFat;\r
FatType = Fat32;\r
}\r
+\r
//\r
// Is boot sector a fat sector?\r
// (Note that so far we only know if the sector is FAT32 or not, we don't\r
// know if the sector is Fat16 or Fat12 until later when we can compute\r
// the volume size)\r
//\r
- if (FatBs.FatBsb.ReservedSectors == 0 || FatBs.FatBsb.NumFats == 0 || Sectors == 0) {\r
+ if ((FatBs.FatBsb.ReservedSectors == 0) || (FatBs.FatBsb.NumFats == 0) || (Sectors == 0)) {\r
return EFI_UNSUPPORTED;\r
}\r
\r
return EFI_UNSUPPORTED;\r
}\r
\r
- BlockAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorSize);\r
- if (BlockAlignment > MAX_BLOCK_ALIGNMENT || BlockAlignment < MIN_BLOCK_ALIGNMENT) {\r
+ BlockAlignment = (UINT8)HighBitSet32 (FatBs.FatBsb.SectorSize);\r
+ if ((BlockAlignment > MAX_BLOCK_ALIGNMENT) || (BlockAlignment < MIN_BLOCK_ALIGNMENT)) {\r
return EFI_UNSUPPORTED;\r
}\r
\r
return EFI_UNSUPPORTED;\r
}\r
\r
- SectorsPerClusterAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorsPerCluster);\r
+ SectorsPerClusterAlignment = (UINT8)HighBitSet32 (FatBs.FatBsb.SectorsPerCluster);\r
if (SectorsPerClusterAlignment > MAX_SECTORS_PER_CLUSTER_ALIGNMENT) {\r
return EFI_UNSUPPORTED;\r
}\r
\r
- if (FatBs.FatBsb.Media <= 0xf7 &&\r
- FatBs.FatBsb.Media != 0xf0 &&\r
- FatBs.FatBsb.Media != 0x00 &&\r
- FatBs.FatBsb.Media != 0x01\r
- ) {\r
+ if ((FatBs.FatBsb.Media <= 0xf7) &&\r
+ (FatBs.FatBsb.Media != 0xf0) &&\r
+ (FatBs.FatBsb.Media != 0x00) &&\r
+ (FatBs.FatBsb.Media != 0x01)\r
+ )\r
+ {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Initialize fields the volume information for this FatType\r
//\r
if (FatBs.FatBsb.RootEntries == 0) {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Unpack fat12, fat16 info\r
//\r
//\r
// If this is fat32, refuse to mount mirror-disabled volumes\r
//\r
- if ((SectorsPerFat == 0 || FatBs.FatBse.Fat32Bse.FsVersion != 0) || (FatBs.FatBse.Fat32Bse.ExtendedFlags & 0x80)) {\r
+ if (((SectorsPerFat == 0) || (FatBs.FatBse.Fat32Bse.FsVersion != 0)) || (FatBs.FatBse.Fat32Bse.ExtendedFlags & 0x80)) {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Unpack fat32 info\r
//\r
Volume->RootCluster = FatBs.FatBse.Fat32Bse.RootDirFirstCluster;\r
}\r
\r
- Volume->NumFats = FatBs.FatBsb.NumFats;\r
+ Volume->NumFats = FatBs.FatBsb.NumFats;\r
//\r
// Compute some fat locations\r
//\r
- BlockSize = FatBs.FatBsb.SectorSize;\r
- RootDirSectors = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (BlockSize - 1)) / BlockSize;\r
+ BlockSize = FatBs.FatBsb.SectorSize;\r
+ RootDirSectors = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (BlockSize - 1)) / BlockSize;\r
\r
- FatLba = FatBs.FatBsb.ReservedSectors;\r
- RootLba = FatBs.FatBsb.NumFats * SectorsPerFat + FatLba;\r
- FirstClusterLba = RootLba + RootDirSectors;\r
+ FatLba = FatBs.FatBsb.ReservedSectors;\r
+ RootLba = FatBs.FatBsb.NumFats * SectorsPerFat + FatLba;\r
+ FirstClusterLba = RootLba + RootDirSectors;\r
\r
- Volume->FatPos = FatLba * BlockSize;\r
- Volume->FatSize = SectorsPerFat * BlockSize;\r
+ Volume->FatPos = FatLba * BlockSize;\r
+ Volume->FatSize = SectorsPerFat * BlockSize;\r
\r
- Volume->VolumeSize = LShiftU64 (Sectors, BlockAlignment);\r
- Volume->RootPos = LShiftU64 (RootLba, BlockAlignment);\r
- Volume->FirstClusterPos = LShiftU64 (FirstClusterLba, BlockAlignment);\r
- Volume->MaxCluster = (Sectors - FirstClusterLba) >> SectorsPerClusterAlignment;\r
- Volume->ClusterAlignment = (UINT8)(BlockAlignment + SectorsPerClusterAlignment);\r
- Volume->ClusterSize = (UINTN)1 << (Volume->ClusterAlignment);\r
+ Volume->VolumeSize = LShiftU64 (Sectors, BlockAlignment);\r
+ Volume->RootPos = LShiftU64 (RootLba, BlockAlignment);\r
+ Volume->FirstClusterPos = LShiftU64 (FirstClusterLba, BlockAlignment);\r
+ Volume->MaxCluster = (Sectors - FirstClusterLba) >> SectorsPerClusterAlignment;\r
+ Volume->ClusterAlignment = (UINT8)(BlockAlignment + SectorsPerClusterAlignment);\r
+ Volume->ClusterSize = (UINTN)1 << (Volume->ClusterAlignment);\r
\r
//\r
// If this is not a fat32, determine if it's a fat16 or fat12\r
if (Volume->MaxCluster < FAT_MAX_FAT16_CLUSTER) {\r
return EFI_VOLUME_CORRUPTED;\r
}\r
+\r
//\r
// fat32 fat-entries are 4 bytes\r
//\r
Volume->FatEntrySize = sizeof (UINT32);\r
DirtyMask = FAT32_DIRTY_MASK;\r
}\r
+\r
//\r
// Get the DirtyValue and NotDirtyValue\r
// We should keep the initial value as the NotDirtyValue\r
\r
Volume->DirtyValue = Volume->NotDirtyValue & DirtyMask;\r
}\r
+\r
//\r
// If present, read the fat hint info\r
//\r
Volume->FreeInfoPos = FatBs.FatBse.Fat32Bse.FsInfoSector * BlockSize;\r
if (FatBs.FatBse.Fat32Bse.FsInfoSector != 0) {\r
FatDiskIo (Volume, ReadDisk, Volume->FreeInfoPos, sizeof (FAT_INFO_SECTOR), &Volume->FatInfoSector, NULL);\r
- if (Volume->FatInfoSector.Signature == FAT_INFO_SIGNATURE &&\r
- Volume->FatInfoSector.InfoBeginSignature == FAT_INFO_BEGIN_SIGNATURE &&\r
- Volume->FatInfoSector.InfoEndSignature == FAT_INFO_END_SIGNATURE &&\r
- Volume->FatInfoSector.FreeInfo.ClusterCount <= Volume->MaxCluster\r
- ) {\r
+ if ((Volume->FatInfoSector.Signature == FAT_INFO_SIGNATURE) &&\r
+ (Volume->FatInfoSector.InfoBeginSignature == FAT_INFO_BEGIN_SIGNATURE) &&\r
+ (Volume->FatInfoSector.InfoEndSignature == FAT_INFO_END_SIGNATURE) &&\r
+ (Volume->FatInfoSector.FreeInfo.ClusterCount <= Volume->MaxCluster)\r
+ )\r
+ {\r
Volume->FreeInfoValid = TRUE;\r
}\r
}\r
}\r
+\r
//\r
// Just make up a FreeInfo.NextCluster for use by allocate cluster\r
//\r
- if (FAT_MIN_CLUSTER > Volume->FatInfoSector.FreeInfo.NextCluster ||\r
- Volume->FatInfoSector.FreeInfo.NextCluster > Volume->MaxCluster + 1\r
- ) {\r
+ if ((FAT_MIN_CLUSTER > Volume->FatInfoSector.FreeInfo.NextCluster) ||\r
+ (Volume->FatInfoSector.FreeInfo.NextCluster > Volume->MaxCluster + 1)\r
+ )\r
+ {\r
Volume->FatInfoSector.FreeInfo.NextCluster = FAT_MIN_CLUSTER;\r
}\r
+\r
//\r
// We are now defining FAT Type\r
//\r
**/\r
FAT_TASK *\r
FatCreateTask (\r
- FAT_IFILE *IFile,\r
- EFI_FILE_IO_TOKEN *Token\r
+ FAT_IFILE *IFile,\r
+ EFI_FILE_IO_TOKEN *Token\r
)\r
{\r
- FAT_TASK *Task;\r
+ FAT_TASK *Task;\r
\r
Task = AllocateZeroPool (sizeof (*Task));\r
if (Task != NULL) {\r
InitializeListHead (&Task->Subtasks);\r
InitializeListHead (&Task->Link);\r
}\r
+\r
return Task;\r
}\r
\r
**/\r
VOID\r
FatDestroyTask (\r
- FAT_TASK *Task\r
+ FAT_TASK *Task\r
)\r
{\r
- LIST_ENTRY *Link;\r
- FAT_SUBTASK *Subtask;\r
+ LIST_ENTRY *Link;\r
+ FAT_SUBTASK *Subtask;\r
\r
Link = GetFirstNode (&Task->Subtasks);\r
while (!IsNull (&Task->Subtasks, Link)) {\r
Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);\r
- Link = FatDestroySubtask (Subtask);\r
+ Link = FatDestroySubtask (Subtask);\r
}\r
+\r
FreePool (Task);\r
}\r
\r
**/\r
VOID\r
FatWaitNonblockingTask (\r
- FAT_IFILE *IFile\r
+ FAT_IFILE *IFile\r
)\r
{\r
- BOOLEAN TaskQueueEmpty;\r
+ BOOLEAN TaskQueueEmpty;\r
\r
do {\r
EfiAcquireLock (&FatTaskLock);\r
**/\r
LIST_ENTRY *\r
FatDestroySubtask (\r
- FAT_SUBTASK *Subtask\r
+ FAT_SUBTASK *Subtask\r
)\r
{\r
- LIST_ENTRY *Link;\r
+ LIST_ENTRY *Link;\r
\r
gBS->CloseEvent (Subtask->DiskIo2Token.Event);\r
\r
**/\r
EFI_STATUS\r
FatQueueTask (\r
- IN FAT_IFILE *IFile,\r
- IN FAT_TASK *Task\r
+ IN FAT_IFILE *IFile,\r
+ IN FAT_TASK *Task\r
)\r
{\r
- EFI_STATUS Status;\r
- LIST_ENTRY *Link;\r
- LIST_ENTRY *NextLink;\r
- FAT_SUBTASK *Subtask;\r
+ EFI_STATUS Status;\r
+ LIST_ENTRY *Link;\r
+ LIST_ENTRY *NextLink;\r
+ FAT_SUBTASK *Subtask;\r
\r
//\r
// Sometimes the Task doesn't contain any subtasks, signal the event directly.\r
// handle list elements being removed during the traverse.\r
//\r
for ( Link = GetFirstNode (&Task->Subtasks), NextLink = GetNextNode (&Task->Subtasks, Link)\r
- ; Link != &Task->Subtasks\r
- ; Link = NextLink, NextLink = Link->ForwardLink\r
- ) {\r
+ ; Link != &Task->Subtasks\r
+ ; Link = NextLink, NextLink = Link->ForwardLink\r
+ )\r
+ {\r
Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);\r
if (Subtask->Write) {\r
-\r
Status = IFile->OFile->Volume->DiskIo2->WriteDiskEx (\r
IFile->OFile->Volume->DiskIo2,\r
IFile->OFile->Volume->MediaId,\r
Subtask->Buffer\r
);\r
}\r
+\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
//\r
while (!IsNull (&Task->Subtasks, Link)) {\r
Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);\r
- Link = FatDestroySubtask (Subtask);\r
+ Link = FatDestroySubtask (Subtask);\r
}\r
\r
if (IsListEmpty (&Task->Subtasks)) {\r
**/\r
EFI_STATUS\r
FatAccessVolumeDirty (\r
- IN FAT_VOLUME *Volume,\r
- IN IO_MODE IoMode,\r
- IN VOID *DirtyValue\r
+ IN FAT_VOLUME *Volume,\r
+ IN IO_MODE IoMode,\r
+ IN VOID *DirtyValue\r
)\r
{\r
- UINTN WriteCount;\r
+ UINTN WriteCount;\r
\r
WriteCount = Volume->FatEntrySize;\r
return FatDiskIo (Volume, IoMode, Volume->FatPos + WriteCount, WriteCount, DirtyValue, NULL);\r
VOID\r
EFIAPI\r
FatOnAccessComplete (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
)\r
{\r
- EFI_STATUS Status;\r
- FAT_SUBTASK *Subtask;\r
- FAT_TASK *Task;\r
+ EFI_STATUS Status;\r
+ FAT_SUBTASK *Subtask;\r
+ FAT_TASK *Task;\r
\r
//\r
// Avoid someone in future breaks the below assumption.\r
//\r
ASSERT (EfiGetCurrentTpl () == FatTaskLock.Tpl);\r
\r
- Subtask = (FAT_SUBTASK *) Context;\r
+ Subtask = (FAT_SUBTASK *)Context;\r
Task = Subtask->Task;\r
Status = Subtask->DiskIo2Token.TransactionStatus;\r
\r
**/\r
EFI_STATUS\r
FatDiskIo (\r
- IN FAT_VOLUME *Volume,\r
- IN IO_MODE IoMode,\r
- IN UINT64 Offset,\r
- IN UINTN BufferSize,\r
- IN OUT VOID *Buffer,\r
- IN FAT_TASK *Task\r
+ IN FAT_VOLUME *Volume,\r
+ IN IO_MODE IoMode,\r
+ IN UINT64 Offset,\r
+ IN UINTN BufferSize,\r
+ IN OUT VOID *Buffer,\r
+ IN FAT_TASK *Task\r
)\r
{\r
EFI_STATUS Status;\r
//\r
// Blocking access\r
//\r
- DiskIo = Volume->DiskIo;\r
- IoFunction = (IoMode == ReadDisk) ? DiskIo->ReadDisk : DiskIo->WriteDisk;\r
- Status = IoFunction (DiskIo, Volume->MediaId, Offset, BufferSize, Buffer);\r
+ DiskIo = Volume->DiskIo;\r
+ IoFunction = (IoMode == ReadDisk) ? DiskIo->ReadDisk : DiskIo->WriteDisk;\r
+ Status = IoFunction (DiskIo, Volume->MediaId, Offset, BufferSize, Buffer);\r
} else {\r
//\r
// Non-blocking access\r
//\r
Subtask = AllocateZeroPool (sizeof (*Subtask));\r
if (Subtask == NULL) {\r
- Status = EFI_OUT_OF_RESOURCES;\r
+ Status = EFI_OUT_OF_RESOURCES;\r
} else {\r
Subtask->Signature = FAT_SUBTASK_SIGNATURE;\r
Subtask->Task = Task;\r
- Subtask->Write = (BOOLEAN) (IoMode == WriteDisk);\r
+ Subtask->Write = (BOOLEAN)(IoMode == WriteDisk);\r
Subtask->Offset = Offset;\r
Subtask->Buffer = Buffer;\r
Subtask->BufferSize = BufferSize;\r
- Status = gBS->CreateEvent (\r
- EVT_NOTIFY_SIGNAL,\r
- TPL_NOTIFY,\r
- FatOnAccessComplete,\r
- Subtask,\r
- &Subtask->DiskIo2Token.Event\r
- );\r
+ Status = gBS->CreateEvent (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_NOTIFY,\r
+ FatOnAccessComplete,\r
+ Subtask,\r
+ &Subtask->DiskIo2Token.Event\r
+ );\r
if (!EFI_ERROR (Status)) {\r
InsertTailList (&Task->Subtasks, &Subtask->Link);\r
} else {\r
**/\r
VOID\r
FatFreeDirEnt (\r
- IN FAT_DIRENT *DirEnt\r
+ IN FAT_DIRENT *DirEnt\r
)\r
{\r
if (DirEnt->FileString != NULL) {\r
**/\r
VOID\r
FatFreeVolume (\r
- IN FAT_VOLUME *Volume\r
+ IN FAT_VOLUME *Volume\r
)\r
{\r
//\r
if (Volume->CacheBuffer != NULL) {\r
FreePool (Volume->CacheBuffer);\r
}\r
+\r
//\r
// Free directory cache\r
//\r
**/\r
VOID\r
FatEfiTimeToFatTime (\r
- IN EFI_TIME *ETime,\r
- OUT FAT_DATE_TIME *FTime\r
+ IN EFI_TIME *ETime,\r
+ OUT FAT_DATE_TIME *FTime\r
)\r
{\r
//\r
// ignores timezone info in source ETime\r
//\r
if (ETime->Year > 1980) {\r
- FTime->Date.Year = (UINT16) (ETime->Year - 1980);\r
+ FTime->Date.Year = (UINT16)(ETime->Year - 1980);\r
}\r
\r
if (ETime->Year >= 1980 + FAT_MAX_YEAR_FROM_1980) {\r
FTime->Date.Year = FAT_MAX_YEAR_FROM_1980;\r
}\r
\r
- FTime->Date.Month = ETime->Month;\r
- FTime->Date.Day = ETime->Day;\r
- FTime->Time.Hour = ETime->Hour;\r
- FTime->Time.Minute = ETime->Minute;\r
- FTime->Time.DoubleSecond = (UINT16) (ETime->Second / 2);\r
+ FTime->Date.Month = ETime->Month;\r
+ FTime->Date.Day = ETime->Day;\r
+ FTime->Time.Hour = ETime->Hour;\r
+ FTime->Time.Minute = ETime->Minute;\r
+ FTime->Time.DoubleSecond = (UINT16)(ETime->Second / 2);\r
}\r
\r
/**\r
**/\r
VOID\r
FatFatTimeToEfiTime (\r
- IN FAT_DATE_TIME *FTime,\r
- OUT EFI_TIME *ETime\r
+ IN FAT_DATE_TIME *FTime,\r
+ OUT EFI_TIME *ETime\r
)\r
{\r
- ETime->Year = (UINT16) (FTime->Date.Year + 1980);\r
- ETime->Month = (UINT8) FTime->Date.Month;\r
- ETime->Day = (UINT8) FTime->Date.Day;\r
- ETime->Hour = (UINT8) FTime->Time.Hour;\r
- ETime->Minute = (UINT8) FTime->Time.Minute;\r
- ETime->Second = (UINT8) (FTime->Time.DoubleSecond * 2);\r
+ ETime->Year = (UINT16)(FTime->Date.Year + 1980);\r
+ ETime->Month = (UINT8)FTime->Date.Month;\r
+ ETime->Day = (UINT8)FTime->Date.Day;\r
+ ETime->Hour = (UINT8)FTime->Time.Hour;\r
+ ETime->Minute = (UINT8)FTime->Time.Minute;\r
+ ETime->Second = (UINT8)(FTime->Time.DoubleSecond * 2);\r
ETime->Nanosecond = 0;\r
ETime->TimeZone = EFI_UNSPECIFIED_TIMEZONE;\r
ETime->Daylight = 0;\r
**/\r
VOID\r
FatGetCurrentFatTime (\r
- OUT FAT_DATE_TIME *FatNow\r
+ OUT FAT_DATE_TIME *FatNow\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_TIME Now;\r
+ EFI_STATUS Status;\r
+ EFI_TIME Now;\r
\r
Status = gRT->GetTime (&Now, NULL);\r
if (!EFI_ERROR (Status)) {\r
FatEfiTimeToFatTime (&Now, FatNow);\r
} else {\r
ZeroMem (&Now, sizeof (EFI_TIME));\r
- Now.Year = 1980;\r
+ Now.Year = 1980;\r
Now.Month = 1;\r
- Now.Day = 1;\r
+ Now.Day = 1;\r
FatEfiTimeToFatTime (&Now, FatNow);\r
}\r
}\r
**/\r
BOOLEAN\r
FatIsValidTime (\r
- IN EFI_TIME *Time\r
+ IN EFI_TIME *Time\r
)\r
{\r
- UINTN Day;\r
- BOOLEAN ValidTime;\r
+ UINTN Day;\r
+ BOOLEAN ValidTime;\r
\r
ValidTime = TRUE;\r
\r
// Check the fields for range problems\r
// Fat can only support from 1980\r
//\r
- if (Time->Year < 1980 ||\r
- Time->Month < 1 ||\r
- Time->Month > 12 ||\r
- Time->Day < 1 ||\r
- Time->Day > 31 ||\r
- Time->Hour > 23 ||\r
- Time->Minute > 59 ||\r
- Time->Second > 59 ||\r
- Time->Nanosecond > 999999999\r
- ) {\r
-\r
+ if ((Time->Year < 1980) ||\r
+ (Time->Month < 1) ||\r
+ (Time->Month > 12) ||\r
+ (Time->Day < 1) ||\r
+ (Time->Day > 31) ||\r
+ (Time->Hour > 23) ||\r
+ (Time->Minute > 59) ||\r
+ (Time->Second > 59) ||\r
+ (Time->Nanosecond > 999999999)\r
+ )\r
+ {\r
ValidTime = FALSE;\r
-\r
} else {\r
//\r
// Perform a more specific check of the day of the month\r
//\r
Day = mMonthDays[Time->Month - 1];\r
- if (Time->Month == 2 && IS_LEAP_YEAR (Time->Year)) {\r
+ if ((Time->Month == 2) && IS_LEAP_YEAR (Time->Year)) {\r
Day += 1;\r
//\r
// 1 extra day this month\r
//\r
}\r
+\r
if (Time->Day > Day) {\r
ValidTime = FALSE;\r
}\r
**/\r
EFI_STATUS\r
FatAllocateIFile (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_IFILE **PtrIFile\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_IFILE **PtrIFile\r
)\r
{\r
- FAT_IFILE *IFile;\r
+ FAT_IFILE *IFile;\r
\r
ASSERT_VOLUME_LOCKED (OFile->Volume);\r
\r
**/\r
EFI_STATUS\r
FatOFileOpen (\r
- IN FAT_OFILE *OFile,\r
- OUT FAT_IFILE **NewIFile,\r
- IN CHAR16 *FileName,\r
- IN UINT64 OpenMode,\r
- IN UINT8 Attributes\r
+ IN FAT_OFILE *OFile,\r
+ OUT FAT_IFILE **NewIFile,\r
+ IN CHAR16 *FileName,\r
+ IN UINT64 OpenMode,\r
+ IN UINT8 Attributes\r
)\r
{\r
FAT_VOLUME *Volume;\r
DirEnt = NULL;\r
Volume = OFile->Volume;\r
ASSERT_VOLUME_LOCKED (Volume);\r
- WriteMode = (BOOLEAN) (OpenMode & EFI_FILE_MODE_WRITE);\r
+ WriteMode = (BOOLEAN)(OpenMode & EFI_FILE_MODE_WRITE);\r
if (Volume->ReadOnly && WriteMode) {\r
return EFI_WRITE_PROTECTED;\r
}\r
+\r
//\r
// Verify the source file handle isn't in an error state\r
//\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
+\r
//\r
// Get new OFile for the file\r
//\r
}\r
}\r
}\r
+\r
//\r
// If the file's attribute is read only, and the open is for\r
// read-write, then the access is denied.\r
//\r
FileAttributes = OFile->DirEnt->Entry.Attributes;\r
- if ((FileAttributes & EFI_FILE_READ_ONLY) != 0 && (FileAttributes & FAT_ATTRIBUTE_DIRECTORY) == 0 && WriteMode) {\r
+ if (((FileAttributes & EFI_FILE_READ_ONLY) != 0) && ((FileAttributes & FAT_ATTRIBUTE_DIRECTORY) == 0) && WriteMode) {\r
return EFI_ACCESS_DENIED;\r
}\r
+\r
//\r
// Create an open instance of the OFile\r
//\r
return Status;\r
}\r
\r
- (*NewIFile)->ReadOnly = (BOOLEAN)!WriteMode;\r
+ (*NewIFile)->ReadOnly = (BOOLEAN) !WriteMode;\r
\r
DEBUG ((DEBUG_INFO, "FSOpen: Open '%S' %r\n", FileName, Status));\r
return FatOFileFlush (OFile);\r
EFI_STATUS\r
EFIAPI\r
FatOpenEx (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- OUT EFI_FILE_PROTOCOL **NewHandle,\r
- IN CHAR16 *FileName,\r
- IN UINT64 OpenMode,\r
- IN UINT64 Attributes,\r
- IN OUT EFI_FILE_IO_TOKEN *Token\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ OUT EFI_FILE_PROTOCOL **NewHandle,\r
+ IN CHAR16 *FileName,\r
+ IN UINT64 OpenMode,\r
+ IN UINT64 Attributes,\r
+ IN OUT EFI_FILE_IO_TOKEN *Token\r
)\r
{\r
FAT_IFILE *IFile;\r
if (FileName == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
+\r
//\r
// Check for a valid mode\r
//\r
switch (OpenMode) {\r
- case EFI_FILE_MODE_READ:\r
- case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:\r
- case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE:\r
- break;\r
+ case EFI_FILE_MODE_READ:\r
+ case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:\r
+ case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE:\r
+ break;\r
\r
- default:\r
- return EFI_INVALID_PARAMETER;\r
+ default:\r
+ return EFI_INVALID_PARAMETER;\r
}\r
\r
//\r
// Check for valid Attributes for file creation case.\r
//\r
- if (((OpenMode & EFI_FILE_MODE_CREATE) != 0) && (Attributes & (EFI_FILE_READ_ONLY | (~EFI_FILE_VALID_ATTR))) != 0) {\r
+ if (((OpenMode & EFI_FILE_MODE_CREATE) != 0) && ((Attributes & (EFI_FILE_READ_ONLY | (~EFI_FILE_VALID_ATTR))) != 0)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
Task = FatCreateTask (IFile, Token);\r
if (Task == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
//\r
// Open the file\r
//\r
- Status = FatOFileOpen (OFile, &NewIFile, FileName, OpenMode, (UINT8) Attributes);\r
+ Status = FatOFileOpen (OFile, &NewIFile, FileName, OpenMode, (UINT8)Attributes);\r
\r
//\r
// If the file was opened, return the handle to the caller\r
if (!EFI_ERROR (Status)) {\r
*NewHandle = &NewIFile->Handle;\r
}\r
+\r
//\r
// Unlock\r
//\r
EFI_STATUS\r
EFIAPI\r
FatOpen (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- OUT EFI_FILE_PROTOCOL **NewHandle,\r
- IN CHAR16 *FileName,\r
- IN UINT64 OpenMode,\r
- IN UINT64 Attributes\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ OUT EFI_FILE_PROTOCOL **NewHandle,\r
+ IN CHAR16 *FileName,\r
+ IN UINT64 OpenMode,\r
+ IN UINT64 Attributes\r
)\r
{\r
return FatOpenEx (FHand, NewHandle, FileName, OpenMode, Attributes, NULL);\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
}\r
+\r
//\r
// Open a new instance to the root\r
//\r
EFI_STATUS\r
EFIAPI\r
FatGetPosition (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- OUT UINT64 *Position\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ OUT UINT64 *Position\r
)\r
{\r
- FAT_IFILE *IFile;\r
- FAT_OFILE *OFile;\r
+ FAT_IFILE *IFile;\r
+ FAT_OFILE *OFile;\r
\r
IFile = IFILE_FROM_FHAND (FHand);\r
OFile = IFile->OFile;\r
IN UINT64 Position\r
)\r
{\r
- FAT_IFILE *IFile;\r
- FAT_OFILE *OFile;\r
+ FAT_IFILE *IFile;\r
+ FAT_OFILE *OFile;\r
\r
IFile = IFILE_FROM_FHAND (FHand);\r
OFile = IFile->OFile;\r
\r
FatResetODirCursor (OFile);\r
}\r
+\r
//\r
// Set the position\r
//\r
if (Position == (UINT64)-1) {\r
Position = OFile->FileSize;\r
}\r
+\r
//\r
// Set the position\r
//\r
**/\r
EFI_STATUS\r
FatIFileReadDir (\r
- IN FAT_IFILE *IFile,\r
- IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ IN FAT_IFILE *IFile,\r
+ IN OUT UINTN *BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
EFI_STATUS Status;\r
FAT_DIRENT *DirEnt;\r
UINT32 CurrentPos;\r
\r
- OFile = IFile->OFile;\r
- ODir = OFile->ODir;\r
- CurrentPos = ((UINT32) IFile->Position) / sizeof (FAT_DIRECTORY_ENTRY);\r
+ OFile = IFile->OFile;\r
+ ODir = OFile->ODir;\r
+ CurrentPos = ((UINT32)IFile->Position) / sizeof (FAT_DIRECTORY_ENTRY);\r
\r
//\r
// We need to relocate the directory\r
//\r
FatResetODirCursor (OFile);\r
}\r
+\r
//\r
// We seek the next directory entry's position\r
//\r
do {\r
Status = FatGetNextDirEnt (OFile, &DirEnt);\r
- if (EFI_ERROR (Status) || DirEnt == NULL) {\r
+ if (EFI_ERROR (Status) || (DirEnt == NULL)) {\r
//\r
// Something error occurred or reach the end of directory,\r
// return 0 buffersize\r
goto Done;\r
}\r
} while (ODir->CurrentPos <= CurrentPos);\r
+\r
Status = FatGetDirEntInfo (OFile->Volume, DirEnt, BufferSize, Buffer);\r
\r
Done:\r
**/\r
EFI_STATUS\r
FatIFileAccess (\r
- IN EFI_FILE_PROTOCOL *FHand,\r
- IN IO_MODE IoMode,\r
- IN OUT UINTN *BufferSize,\r
- IN OUT VOID *Buffer,\r
- IN EFI_FILE_IO_TOKEN *Token\r
+ IN EFI_FILE_PROTOCOL *FHand,\r
+ IN IO_MODE IoMode,\r
+ IN OUT UINTN *BufferSize,\r
+ IN OUT VOID *Buffer,\r
+ IN EFI_FILE_IO_TOKEN *Token\r
)\r
{\r
EFI_STATUS Status;\r
if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {\r
return EFI_UNSUPPORTED;\r
}\r
+\r
Task = FatCreateTask (IFile, Token);\r
if (Task == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
//\r
ASSERT (IoMode == ReadData);\r
Status = FatIFileReadDir (IFile, BufferSize, Buffer);\r
- OFile = NULL;\r
+ OFile = NULL;\r
} else {\r
//\r
// Access a file\r
//\r
// Adjust the actual size read\r
//\r
- *BufferSize -= (UINTN) EndPosition - OFile->FileSize;\r
+ *BufferSize -= (UINTN)EndPosition - OFile->FileSize;\r
} else {\r
//\r
// We expand the file size of OFile\r
}\r
}\r
\r
- Status = FatAccessOFile (OFile, IoMode, (UINTN) IFile->Position, BufferSize, Buffer, Task);\r
+ Status = FatAccessOFile (OFile, IoMode, (UINTN)IFile->Position, BufferSize, Buffer, Task);\r
IFile->Position += *BufferSize;\r
}\r
}\r
FatRead (\r
IN EFI_FILE_PROTOCOL *FHand,\r
IN OUT UINTN *BufferSize,\r
- OUT VOID *Buffer\r
+ OUT VOID *Buffer\r
)\r
{\r
return FatIFileAccess (FHand, ReadData, BufferSize, Buffer, NULL);\r
**/\r
EFI_STATUS\r
FatAccessOFile (\r
- IN FAT_OFILE *OFile,\r
- IN IO_MODE IoMode,\r
- IN UINTN Position,\r
- IN OUT UINTN *DataBufferSize,\r
- IN OUT UINT8 *UserBuffer,\r
- IN FAT_TASK *Task\r
+ IN FAT_OFILE *OFile,\r
+ IN IO_MODE IoMode,\r
+ IN UINTN Position,\r
+ IN OUT UINTN *DataBufferSize,\r
+ IN OUT UINT8 *UserBuffer,\r
+ IN FAT_TASK *Task\r
)\r
{\r
FAT_VOLUME *Volume;\r
EFI_STATUS Status;\r
UINTN BufferSize;\r
\r
- BufferSize = *DataBufferSize;\r
- Volume = OFile->Volume;\r
+ BufferSize = *DataBufferSize;\r
+ Volume = OFile->Volume;\r
ASSERT_VOLUME_LOCKED (Volume);\r
\r
Status = EFI_SUCCESS;\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
+\r
//\r
// Clip length to block run\r
//\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
+\r
//\r
// Data was successfully accessed\r
//\r
UserBuffer += Len;\r
BufferSize -= Len;\r
if (IoMode == WriteData) {\r
- OFile->Dirty = TRUE;\r
- OFile->Archive = TRUE;\r
+ OFile->Dirty = TRUE;\r
+ OFile->Archive = TRUE;\r
}\r
+\r
//\r
// Make sure no outbound occurred\r
//\r
ASSERT (Position <= OFile->FileSize);\r
}\r
+\r
//\r
// Update the number of bytes accessed\r
//\r
**/\r
EFI_STATUS\r
FatExpandOFile (\r
- IN FAT_OFILE *OFile,\r
- IN UINT64 ExpandedSize\r
+ IN FAT_OFILE *OFile,\r
+ IN UINT64 ExpandedSize\r
)\r
{\r
EFI_STATUS Status;\r
UINTN WritePos;\r
\r
- WritePos = OFile->FileSize;\r
- Status = FatGrowEof (OFile, ExpandedSize);\r
+ WritePos = OFile->FileSize;\r
+ Status = FatGrowEof (OFile, ExpandedSize);\r
if (!EFI_ERROR (Status)) {\r
Status = FatWriteZeroPool (OFile, WritePos);\r
}\r
UINTN BufferSize;\r
UINTN WriteSize;\r
\r
- AppendedSize = OFile->FileSize - WritePos;\r
- BufferSize = AppendedSize;\r
+ AppendedSize = OFile->FileSize - WritePos;\r
+ BufferSize = AppendedSize;\r
if (AppendedSize > FAT_MAX_ALLOCATE_SIZE) {\r
//\r
// If the appended size is larger, maybe we can not allocate the whole\r
}\r
\r
do {\r
- WriteSize = AppendedSize > BufferSize ? BufferSize : (UINTN) AppendedSize;\r
+ WriteSize = AppendedSize > BufferSize ? BufferSize : (UINTN)AppendedSize;\r
AppendedSize -= WriteSize;\r
- Status = FatAccessOFile (OFile, WriteData, WritePos, &WriteSize, ZeroBuffer, NULL);\r
+ Status = FatAccessOFile (OFile, WriteData, WritePos, &WriteSize, ZeroBuffer, NULL);\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
**/\r
EFI_STATUS\r
FatTruncateOFile (\r
- IN FAT_OFILE *OFile,\r
- IN UINTN TruncatedSize\r
+ IN FAT_OFILE *OFile,\r
+ IN UINTN TruncatedSize\r
)\r
{\r
OFile->FileSize = TruncatedSize;\r
**/\r
EFI_STATUS\r
InitializeUnicodeCollationSupportWorker (\r
- IN EFI_HANDLE AgentHandle,\r
- IN EFI_GUID *ProtocolGuid,\r
- IN CONST CHAR16 *VariableName,\r
- IN CONST CHAR8 *DefaultLanguage\r
+ IN EFI_HANDLE AgentHandle,\r
+ IN EFI_GUID *ProtocolGuid,\r
+ IN CONST CHAR16 *VariableName,\r
+ IN CONST CHAR8 *DefaultLanguage\r
)\r
{\r
EFI_STATUS ReturnStatus;\r
return Status;\r
}\r
\r
- Iso639Language = (BOOLEAN) (ProtocolGuid == &gEfiUnicodeCollationProtocolGuid);\r
- GetEfiGlobalVariable2 (VariableName, (VOID**) &Language, NULL);\r
+ Iso639Language = (BOOLEAN)(ProtocolGuid == &gEfiUnicodeCollationProtocolGuid);\r
+ GetEfiGlobalVariable2 (VariableName, (VOID **)&Language, NULL);\r
\r
ReturnStatus = EFI_UNSUPPORTED;\r
for (Index = 0; Index < NumHandles; Index++) {\r
Status = gBS->OpenProtocol (\r
Handles[Index],\r
ProtocolGuid,\r
- (VOID **) &Uci,\r
+ (VOID **)&Uci,\r
AgentHandle,\r
NULL,\r
EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
if (BestLanguage != NULL) {\r
FreePool (BestLanguage);\r
mUnicodeCollationInterface = Uci;\r
- ReturnStatus = EFI_SUCCESS;\r
+ ReturnStatus = EFI_SUCCESS;\r
break;\r
}\r
}\r
**/\r
EFI_STATUS\r
InitializeUnicodeCollationSupport (\r
- IN EFI_HANDLE AgentHandle\r
+ IN EFI_HANDLE AgentHandle\r
)\r
{\r
-\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
Status = EFI_UNSUPPORTED;\r
\r
AgentHandle,\r
&gEfiUnicodeCollation2ProtocolGuid,\r
L"PlatformLang",\r
- (CONST CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang)\r
+ (CONST CHAR8 *)PcdGetPtr (PcdUefiVariableDefaultPlatformLang)\r
);\r
//\r
// If the attempt to use Unicode Collation 2 Protocol fails, then we fall back\r
AgentHandle,\r
&gEfiUnicodeCollationProtocolGuid,\r
L"Lang",\r
- (CONST CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultLang)\r
+ (CONST CHAR8 *)PcdGetPtr (PcdUefiVariableDefaultLang)\r
);\r
}\r
\r
return Status;\r
}\r
\r
-\r
/**\r
Performs a case-insensitive comparison of two Null-terminated Unicode strings.\r
\r
**/\r
INTN\r
FatStriCmp (\r
- IN CHAR16 *S1,\r
- IN CHAR16 *S2\r
+ IN CHAR16 *S1,\r
+ IN CHAR16 *S2\r
)\r
{\r
ASSERT (StrSize (S1) != 0);\r
);\r
}\r
\r
-\r
/**\r
Uppercase a string.\r
\r
**/\r
VOID\r
FatStrUpr (\r
- IN OUT CHAR16 *String\r
+ IN OUT CHAR16 *String\r
)\r
{\r
ASSERT (StrSize (String) != 0);\r
mUnicodeCollationInterface->StrUpr (mUnicodeCollationInterface, String);\r
}\r
\r
-\r
/**\r
Lowercase a string\r
\r
**/\r
VOID\r
FatStrLwr (\r
- IN OUT CHAR16 *String\r
+ IN OUT CHAR16 *String\r
)\r
{\r
ASSERT (StrSize (String) != 0);\r
mUnicodeCollationInterface->StrLwr (mUnicodeCollationInterface, String);\r
}\r
\r
-\r
/**\r
Convert FAT string to unicode string.\r
\r
**/\r
VOID\r
FatFatToStr (\r
- IN UINTN FatSize,\r
- IN CHAR8 *Fat,\r
- OUT CHAR16 *String\r
+ IN UINTN FatSize,\r
+ IN CHAR8 *Fat,\r
+ OUT CHAR16 *String\r
)\r
{\r
ASSERT (Fat != NULL);\r
ASSERT (String != NULL);\r
- ASSERT (((UINTN) String & 0x01) == 0);\r
+ ASSERT (((UINTN)String & 0x01) == 0);\r
ASSERT (mUnicodeCollationInterface != NULL);\r
\r
mUnicodeCollationInterface->FatToStr (mUnicodeCollationInterface, FatSize, Fat, String);\r
}\r
\r
-\r
/**\r
Convert unicode string to Fat string.\r
\r
**/\r
BOOLEAN\r
FatStrToFat (\r
- IN CHAR16 *String,\r
- IN UINTN FatSize,\r
- OUT CHAR8 *Fat\r
+ IN CHAR16 *String,\r
+ IN UINTN FatSize,\r
+ OUT CHAR8 *Fat\r
)\r
{\r
ASSERT (Fat != NULL);\r
**/\r
BOOLEAN\r
FatFindEltoritoPartitions (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
)\r
{\r
- EFI_STATUS Status;\r
- BOOLEAN Found;\r
- PEI_FAT_BLOCK_DEVICE *BlockDev;\r
- PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
- UINT32 VolDescriptorLba;\r
- UINT32 Lba;\r
- CDROM_VOLUME_DESCRIPTOR *VolDescriptor;\r
- ELTORITO_CATALOG *Catalog;\r
- UINTN Check;\r
- UINTN Index;\r
- UINTN MaxIndex;\r
- UINT16 *CheckBuffer;\r
- UINT32 SubBlockSize;\r
- UINT32 SectorCount;\r
- UINT32 VolSpaceSize;\r
+ EFI_STATUS Status;\r
+ BOOLEAN Found;\r
+ PEI_FAT_BLOCK_DEVICE *BlockDev;\r
+ PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
+ UINT32 VolDescriptorLba;\r
+ UINT32 Lba;\r
+ CDROM_VOLUME_DESCRIPTOR *VolDescriptor;\r
+ ELTORITO_CATALOG *Catalog;\r
+ UINTN Check;\r
+ UINTN Index;\r
+ UINTN MaxIndex;\r
+ UINT16 *CheckBuffer;\r
+ UINT32 SubBlockSize;\r
+ UINT32 SectorCount;\r
+ UINT32 VolSpaceSize;\r
\r
if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {\r
return FALSE;\r
}\r
\r
- Found = FALSE;\r
- ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
- VolSpaceSize = 0;\r
+ Found = FALSE;\r
+ ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
+ VolSpaceSize = 0;\r
\r
//\r
// CD_ROM has the fixed block size as 2048 bytes\r
return FALSE;\r
}\r
\r
- VolDescriptor = (CDROM_VOLUME_DESCRIPTOR *) PrivateData->BlockData;\r
- Catalog = (ELTORITO_CATALOG *) VolDescriptor;\r
+ VolDescriptor = (CDROM_VOLUME_DESCRIPTOR *)PrivateData->BlockData;\r
+ Catalog = (ELTORITO_CATALOG *)VolDescriptor;\r
\r
//\r
// the ISO-9660 volume descriptor starts at 32k on the media\r
// Loop: handle one volume descriptor per time\r
//\r
while (TRUE) {\r
-\r
VolDescriptorLba += 1;\r
if (VolDescriptorLba > ParentBlockDev->LastBlock) {\r
//\r
}\r
\r
Status = FatReadBlock (\r
- PrivateData,\r
- ParentBlockDevNo,\r
- VolDescriptorLba,\r
- ParentBlockDev->BlockSize,\r
- VolDescriptor\r
- );\r
+ PrivateData,\r
+ ParentBlockDevNo,\r
+ VolDescriptorLba,\r
+ ParentBlockDev->BlockSize,\r
+ VolDescriptor\r
+ );\r
if (EFI_ERROR (Status)) {\r
break;\r
}\r
+\r
//\r
// Check for valid volume descriptor signature\r
//\r
- if (VolDescriptor->Unknown.Type == CDVOL_TYPE_END ||\r
- CompareMem (VolDescriptor->Unknown.Id, CDVOL_ID, sizeof (VolDescriptor->Unknown.Id)) != 0\r
- ) {\r
+ if ((VolDescriptor->Unknown.Type == CDVOL_TYPE_END) ||\r
+ (CompareMem (VolDescriptor->Unknown.Id, CDVOL_ID, sizeof (VolDescriptor->Unknown.Id)) != 0)\r
+ )\r
+ {\r
//\r
// end of Volume descriptor list\r
//\r
break;\r
}\r
+\r
//\r
// Read the Volume Space Size from Primary Volume Descriptor 81-88 byte\r
//\r
if (VolDescriptor->Unknown.Type == CDVOL_TYPE_CODED) {\r
VolSpaceSize = VolDescriptor->PrimaryVolume.VolSpaceSize[1];\r
}\r
+\r
//\r
// Is it an El Torito volume descriptor?\r
//\r
VolDescriptor->BootRecordVolume.SystemId,\r
CDVOL_ELTORITO_ID,\r
sizeof (CDVOL_ELTORITO_ID) - 1\r
- ) != 0) {\r
+ ) != 0)\r
+ {\r
continue;\r
}\r
+\r
//\r
// Read in the boot El Torito boot catalog\r
//\r
}\r
\r
Status = FatReadBlock (\r
- PrivateData,\r
- ParentBlockDevNo,\r
- Lba,\r
- ParentBlockDev->BlockSize,\r
- Catalog\r
- );\r
+ PrivateData,\r
+ ParentBlockDevNo,\r
+ Lba,\r
+ ParentBlockDev->BlockSize,\r
+ Catalog\r
+ );\r
if (EFI_ERROR (Status)) {\r
continue;\r
}\r
+\r
//\r
// We don't care too much about the Catalog header's contents, but we do want\r
// to make sure it looks like a Catalog header\r
//\r
- if (Catalog->Catalog.Indicator != ELTORITO_ID_CATALOG || Catalog->Catalog.Id55AA != 0xAA55) {\r
+ if ((Catalog->Catalog.Indicator != ELTORITO_ID_CATALOG) || (Catalog->Catalog.Id55AA != 0xAA55)) {\r
continue;\r
}\r
\r
Check = 0;\r
- CheckBuffer = (UINT16 *) Catalog;\r
+ CheckBuffer = (UINT16 *)Catalog;\r
for (Index = 0; Index < sizeof (ELTORITO_CATALOG) / sizeof (UINT16); Index += 1) {\r
Check += CheckBuffer[Index];\r
}\r
//\r
// Check this entry\r
//\r
- if (Catalog->Boot.Indicator != ELTORITO_ID_SECTION_BOOTABLE || Catalog->Boot.Lba == 0) {\r
+ if ((Catalog->Boot.Indicator != ELTORITO_ID_SECTION_BOOTABLE) || (Catalog->Boot.Lba == 0)) {\r
continue;\r
}\r
\r
- SubBlockSize = 512;\r
- SectorCount = Catalog->Boot.SectorCount;\r
+ SubBlockSize = 512;\r
+ SectorCount = Catalog->Boot.SectorCount;\r
\r
switch (Catalog->Boot.MediaType) {\r
-\r
- case ELTORITO_NO_EMULATION:\r
- SubBlockSize = ParentBlockDev->BlockSize;\r
- SectorCount = Catalog->Boot.SectorCount;\r
- break;\r
-\r
- case ELTORITO_HARD_DISK:\r
- break;\r
-\r
- case ELTORITO_12_DISKETTE:\r
- SectorCount = 0x50 * 0x02 * 0x0F;\r
- break;\r
-\r
- case ELTORITO_14_DISKETTE:\r
- SectorCount = 0x50 * 0x02 * 0x12;\r
- break;\r
-\r
- case ELTORITO_28_DISKETTE:\r
- SectorCount = 0x50 * 0x02 * 0x24;\r
- break;\r
-\r
- default:\r
- SectorCount = 0;\r
- SubBlockSize = ParentBlockDev->BlockSize;\r
- break;\r
+ case ELTORITO_NO_EMULATION:\r
+ SubBlockSize = ParentBlockDev->BlockSize;\r
+ SectorCount = Catalog->Boot.SectorCount;\r
+ break;\r
+\r
+ case ELTORITO_HARD_DISK:\r
+ break;\r
+\r
+ case ELTORITO_12_DISKETTE:\r
+ SectorCount = 0x50 * 0x02 * 0x0F;\r
+ break;\r
+\r
+ case ELTORITO_14_DISKETTE:\r
+ SectorCount = 0x50 * 0x02 * 0x12;\r
+ break;\r
+\r
+ case ELTORITO_28_DISKETTE:\r
+ SectorCount = 0x50 * 0x02 * 0x24;\r
+ break;\r
+\r
+ default:\r
+ SectorCount = 0;\r
+ SubBlockSize = ParentBlockDev->BlockSize;\r
+ break;\r
}\r
\r
if (SectorCount < 2) {\r
- SectorCount = (VolSpaceSize > ParentBlockDev->LastBlock + 1) ? (UINT32) (ParentBlockDev->LastBlock - Catalog->Boot.Lba + 1) : (UINT32) (VolSpaceSize - Catalog->Boot.Lba);\r
+ SectorCount = (VolSpaceSize > ParentBlockDev->LastBlock + 1) ? (UINT32)(ParentBlockDev->LastBlock - Catalog->Boot.Lba + 1) : (UINT32)(VolSpaceSize - Catalog->Boot.Lba);\r
}\r
+\r
//\r
// Register this partition\r
//\r
if (PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE) {\r
+ Found = TRUE;\r
\r
- Found = TRUE;\r
-\r
- BlockDev = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);\r
+ BlockDev = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);\r
\r
- BlockDev->BlockSize = SubBlockSize;\r
- BlockDev->LastBlock = SectorCount - 1;\r
- BlockDev->IoAlign = ParentBlockDev->IoAlign;\r
- BlockDev->Logical = TRUE;\r
- BlockDev->PartitionChecked = FALSE;\r
- BlockDev->StartingPos = MultU64x32 (Catalog->Boot.Lba, ParentBlockDev->BlockSize);\r
- BlockDev->ParentDevNo = ParentBlockDevNo;\r
+ BlockDev->BlockSize = SubBlockSize;\r
+ BlockDev->LastBlock = SectorCount - 1;\r
+ BlockDev->IoAlign = ParentBlockDev->IoAlign;\r
+ BlockDev->Logical = TRUE;\r
+ BlockDev->PartitionChecked = FALSE;\r
+ BlockDev->StartingPos = MultU64x32 (Catalog->Boot.Lba, ParentBlockDev->BlockSize);\r
+ BlockDev->ParentDevNo = ParentBlockDevNo;\r
\r
PrivateData->BlockDeviceCount++;\r
}\r
ParentBlockDev->PartitionChecked = TRUE;\r
\r
return Found;\r
-\r
}\r
\r
#include "FatLitePeim.h"\r
\r
-\r
/**\r
Check if there is a valid FAT in the corresponding Block device\r
of the volume and if yes, fill in the relevant fields for the\r
// Read in the BPB\r
//\r
Status = FatReadDisk (\r
- PrivateData,\r
- Volume->BlockDeviceNo,\r
- 0,\r
- sizeof (PEI_FAT_BOOT_SECTOR_EX),\r
- &BpbEx\r
- );\r
+ PrivateData,\r
+ Volume->BlockDeviceNo,\r
+ 0,\r
+ sizeof (PEI_FAT_BOOT_SECTOR_EX),\r
+ &BpbEx\r
+ );\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
\r
CopyMem (\r
- (UINT8 *) (&Bpb),\r
- (UINT8 *) (&BpbEx),\r
+ (UINT8 *)(&Bpb),\r
+ (UINT8 *)(&BpbEx),\r
sizeof (PEI_FAT_BOOT_SECTOR)\r
);\r
\r
Volume->FatType = FatUnknown;\r
\r
- Sectors = Bpb.Sectors;\r
+ Sectors = Bpb.Sectors;\r
if (Sectors == 0) {\r
Sectors = Bpb.LargeSectors;\r
}\r
SectorsPerFat = BpbEx.LargeSectorsPerFat;\r
Volume->FatType = Fat32;\r
}\r
+\r
//\r
// Filter out those not a FAT\r
//\r
- if (Bpb.Ia32Jump[0] != 0xe9 && Bpb.Ia32Jump[0] != 0xeb && Bpb.Ia32Jump[0] != 0x49) {\r
+ if ((Bpb.Ia32Jump[0] != 0xe9) && (Bpb.Ia32Jump[0] != 0xeb) && (Bpb.Ia32Jump[0] != 0x49)) {\r
return EFI_NOT_FOUND;\r
}\r
\r
- if (Bpb.ReservedSectors == 0 || Bpb.NoFats == 0 || Sectors == 0) {\r
+ if ((Bpb.ReservedSectors == 0) || (Bpb.NoFats == 0) || (Sectors == 0)) {\r
return EFI_NOT_FOUND;\r
}\r
\r
- if (Bpb.SectorsPerCluster != 1 &&\r
- Bpb.SectorsPerCluster != 2 &&\r
- Bpb.SectorsPerCluster != 4 &&\r
- Bpb.SectorsPerCluster != 8 &&\r
- Bpb.SectorsPerCluster != 16 &&\r
- Bpb.SectorsPerCluster != 32 &&\r
- Bpb.SectorsPerCluster != 64 &&\r
- Bpb.SectorsPerCluster != 128\r
- ) {\r
+ if ((Bpb.SectorsPerCluster != 1) &&\r
+ (Bpb.SectorsPerCluster != 2) &&\r
+ (Bpb.SectorsPerCluster != 4) &&\r
+ (Bpb.SectorsPerCluster != 8) &&\r
+ (Bpb.SectorsPerCluster != 16) &&\r
+ (Bpb.SectorsPerCluster != 32) &&\r
+ (Bpb.SectorsPerCluster != 64) &&\r
+ (Bpb.SectorsPerCluster != 128)\r
+ )\r
+ {\r
return EFI_NOT_FOUND;\r
}\r
\r
- if (Volume->FatType == Fat32 && (SectorsPerFat == 0 || BpbEx.FsVersion != 0)) {\r
+ if ((Volume->FatType == Fat32) && ((SectorsPerFat == 0) || (BpbEx.FsVersion != 0))) {\r
return EFI_NOT_FOUND;\r
}\r
\r
- if (Bpb.Media != 0xf0 &&\r
- Bpb.Media != 0xf8 &&\r
- Bpb.Media != 0xf9 &&\r
- Bpb.Media != 0xfb &&\r
- Bpb.Media != 0xfc &&\r
- Bpb.Media != 0xfd &&\r
- Bpb.Media != 0xfe &&\r
- Bpb.Media != 0xff &&\r
+ if ((Bpb.Media != 0xf0) &&\r
+ (Bpb.Media != 0xf8) &&\r
+ (Bpb.Media != 0xf9) &&\r
+ (Bpb.Media != 0xfb) &&\r
+ (Bpb.Media != 0xfc) &&\r
+ (Bpb.Media != 0xfd) &&\r
+ (Bpb.Media != 0xfe) &&\r
+ (Bpb.Media != 0xff) &&\r
//\r
// FujitsuFMR\r
//\r
- Bpb.Media != 0x00 &&\r
- Bpb.Media != 0x01 &&\r
- Bpb.Media != 0xfa\r
- ) {\r
+ (Bpb.Media != 0x00) &&\r
+ (Bpb.Media != 0x01) &&\r
+ (Bpb.Media != 0xfa)\r
+ )\r
+ {\r
return EFI_NOT_FOUND;\r
}\r
\r
- if (Volume->FatType != Fat32 && Bpb.RootEntries == 0) {\r
+ if ((Volume->FatType != Fat32) && (Bpb.RootEntries == 0)) {\r
return EFI_NOT_FOUND;\r
}\r
+\r
//\r
// If this is fat32, refuse to mount mirror-disabled volumes\r
//\r
- if (Volume->FatType == Fat32 && ((BpbEx.ExtendedFlags & 0x80) != 0)) {\r
+ if ((Volume->FatType == Fat32) && ((BpbEx.ExtendedFlags & 0x80) != 0)) {\r
return EFI_NOT_FOUND;\r
}\r
+\r
//\r
// Fill in the volume structure fields\r
// (Sectors & SectorsPerFat is computed earlier already)\r
\r
RootDirSectors = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (Volume->SectorSize - 1)) / Volume->SectorSize;\r
\r
- FatLba = Bpb.ReservedSectors;\r
- RootLba = Bpb.NoFats * SectorsPerFat + FatLba;\r
- FirstClusterLba = RootLba + RootDirSectors;\r
+ FatLba = Bpb.ReservedSectors;\r
+ RootLba = Bpb.NoFats * SectorsPerFat + FatLba;\r
+ FirstClusterLba = RootLba + RootDirSectors;\r
\r
Volume->VolumeSize = MultU64x32 (Sectors, Volume->SectorSize);\r
Volume->FatPos = MultU64x32 (FatLba, Volume->SectorSize);\r
Volume->RootDirPos = MultU64x32 (RootLba, Volume->SectorSize);\r
Volume->FirstClusterPos = MultU64x32 (FirstClusterLba, Volume->SectorSize);\r
- Volume->MaxCluster = (UINT32) (Sectors - FirstClusterLba) / Bpb.SectorsPerCluster;\r
+ Volume->MaxCluster = (UINT32)(Sectors - FirstClusterLba) / Bpb.SectorsPerCluster;\r
Volume->RootDirCluster = BpbEx.RootDirFirstCluster;\r
\r
//\r
// If this is not a fat32, determine if it's a fat16 or fat12\r
//\r
if (Volume->FatType != Fat32) {\r
-\r
if (Volume->MaxCluster >= 65525) {\r
return EFI_NOT_FOUND;\r
}\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Gets the next cluster in the cluster chain\r
\r
if (Volume->FatType == Fat32) {\r
FatEntryPos = Volume->FatPos + MultU64x32 (4, Cluster);\r
\r
- Status = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 4, NextCluster);\r
+ Status = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 4, NextCluster);\r
*NextCluster &= 0x0fffffff;\r
\r
//\r
if ((*NextCluster) >= 0x0ffffff7) {\r
*NextCluster |= (-1 &~0xf);\r
}\r
-\r
} else if (Volume->FatType == Fat16) {\r
FatEntryPos = Volume->FatPos + MultU64x32 (2, Cluster);\r
\r
- Status = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 2, NextCluster);\r
+ Status = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 2, NextCluster);\r
\r
//\r
// Pad high bits for our FAT_CLUSTER_... macro definitions to work\r
if ((*NextCluster) >= 0xfff7) {\r
*NextCluster |= (-1 &~0xf);\r
}\r
-\r
} else {\r
FatEntryPos = Volume->FatPos + DivU64x32Remainder (MultU64x32 (3, Cluster), 2, &Dummy);\r
\r
- Status = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 2, NextCluster);\r
+ Status = FatReadDisk (PrivateData, Volume->BlockDeviceNo, FatEntryPos, 2, NextCluster);\r
\r
if ((Cluster & 0x01) != 0) {\r
*NextCluster = (*NextCluster) >> 4;\r
} else {\r
*NextCluster = (*NextCluster) & 0x0fff;\r
}\r
+\r
//\r
// Pad high bits for our FAT_CLUSTER_... macro definitions to work\r
//\r
}\r
\r
return EFI_SUCCESS;\r
-\r
}\r
\r
-\r
/**\r
Set a file's CurrentPos and CurrentCluster, then compute StraightReadAmount.\r
\r
UINT32 PrevCluster;\r
\r
if (File->IsFixedRootDir) {\r
-\r
if (Pos >= MultU64x32 (File->Volume->RootEntries, 32) - File->CurrentPos) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- File->CurrentPos += Pos;\r
- File->StraightReadAmount = (UINT32) (MultU64x32 (File->Volume->RootEntries, 32) - File->CurrentPos);\r
-\r
+ File->CurrentPos += Pos;\r
+ File->StraightReadAmount = (UINT32)(MultU64x32 (File->Volume->RootEntries, 32) - File->CurrentPos);\r
} else {\r
-\r
DivU64x32Remainder (File->CurrentPos, File->Volume->ClusterSize, &Offset);\r
- AlignedPos = (UINT32) File->CurrentPos - (UINT32) Offset;\r
+ AlignedPos = (UINT32)File->CurrentPos - (UINT32)Offset;\r
\r
while\r
(\r
- !FAT_CLUSTER_FUNCTIONAL (File->CurrentCluster) &&\r
- AlignedPos + File->Volume->ClusterSize <= File->CurrentPos + Pos\r
- ) {\r
+ !FAT_CLUSTER_FUNCTIONAL (File->CurrentCluster) &&\r
+ AlignedPos + File->Volume->ClusterSize <= File->CurrentPos + Pos\r
+ )\r
+ {\r
AlignedPos += File->Volume->ClusterSize;\r
- Status = FatGetNextCluster (\r
- PrivateData,\r
- File->Volume,\r
- File->CurrentCluster,\r
- &File->CurrentCluster\r
- );\r
+ Status = FatGetNextCluster (\r
+ PrivateData,\r
+ File->Volume,\r
+ File->CurrentCluster,\r
+ &File->CurrentCluster\r
+ );\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
// Calculate the amount of consecutive cluster occupied by the file.\r
// FatReadFile() will use it to read these blocks once.\r
//\r
- File->StraightReadAmount = 0;\r
- Cluster = File->CurrentCluster;\r
+ File->StraightReadAmount = 0;\r
+ Cluster = File->CurrentCluster;\r
while (!FAT_CLUSTER_FUNCTIONAL (Cluster)) {\r
File->StraightReadAmount += File->Volume->ClusterSize;\r
- PrevCluster = Cluster;\r
- Status = FatGetNextCluster (PrivateData, File->Volume, Cluster, &Cluster);\r
+ PrevCluster = Cluster;\r
+ Status = FatGetNextCluster (PrivateData, File->Volume, Cluster, &Cluster);\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
}\r
\r
DivU64x32Remainder (File->CurrentPos, File->Volume->ClusterSize, &Offset);\r
- File->StraightReadAmount -= (UINT32) Offset;\r
-\r
+ File->StraightReadAmount -= (UINT32)Offset;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Reads file data. Updates the file's CurrentPos.\r
\r
}\r
\r
Status = FatReadDisk (\r
- PrivateData,\r
- File->Volume->BlockDeviceNo,\r
- File->Volume->RootDirPos + File->CurrentPos,\r
- Size,\r
- Buffer\r
- );\r
- File->CurrentPos += (UINT32) Size;\r
+ PrivateData,\r
+ File->Volume->BlockDeviceNo,\r
+ File->Volume->RootDirPos + File->CurrentPos,\r
+ Size,\r
+ Buffer\r
+ );\r
+ File->CurrentPos += (UINT32)Size;\r
return Status;\r
-\r
} else {\r
-\r
if ((File->Attributes & FAT_ATTR_DIRECTORY) == 0) {\r
Size = Size < (File->FileSize - File->CurrentPos) ? Size : (File->FileSize - File->CurrentPos);\r
}\r
+\r
//\r
// This is a normal cluster based file\r
//\r
while (Size != 0) {\r
DivU64x32Remainder (File->CurrentPos, File->Volume->ClusterSize, &Offset);\r
- PhysicalAddr = File->Volume->FirstClusterPos + MultU64x32 (File->Volume->ClusterSize, File->CurrentCluster - 2);\r
+ PhysicalAddr = File->Volume->FirstClusterPos + MultU64x32 (File->Volume->ClusterSize, File->CurrentCluster - 2);\r
\r
- Amount = File->StraightReadAmount;\r
- Amount = Size > Amount ? Amount : Size;\r
+ Amount = File->StraightReadAmount;\r
+ Amount = Size > Amount ? Amount : Size;\r
Status = FatReadDisk (\r
- PrivateData,\r
- File->Volume->BlockDeviceNo,\r
- PhysicalAddr + Offset,\r
- Amount,\r
- BufferPtr\r
- );\r
+ PrivateData,\r
+ File->Volume->BlockDeviceNo,\r
+ PhysicalAddr + Offset,\r
+ Amount,\r
+ BufferPtr\r
+ );\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
+\r
//\r
// Advance the file's current pos and current cluster\r
//\r
- FatSetFilePos (PrivateData, File, (UINT32) Amount);\r
+ FatSetFilePos (PrivateData, File, (UINT32)Amount);\r
\r
BufferPtr += Amount;\r
- Size -= Amount;\r
+ Size -= Amount;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
}\r
\r
-\r
/**\r
This function reads the next item in the parent directory and\r
initializes the output parameter SubFile (CurrentPos is initialized to 0).\r
OUT PEI_FAT_FILE *SubFile\r
)\r
{\r
- EFI_STATUS Status;\r
- FAT_DIRECTORY_ENTRY DirEntry;\r
- CHAR16 *Pos;\r
- CHAR16 BaseName[9];\r
- CHAR16 Ext[4];\r
+ EFI_STATUS Status;\r
+ FAT_DIRECTORY_ENTRY DirEntry;\r
+ CHAR16 *Pos;\r
+ CHAR16 BaseName[9];\r
+ CHAR16 Ext[4];\r
\r
- ZeroMem ((UINT8 *) SubFile, sizeof (PEI_FAT_FILE));\r
+ ZeroMem ((UINT8 *)SubFile, sizeof (PEI_FAT_FILE));\r
\r
//\r
// Pick a valid directory entry\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
+\r
//\r
// We only search for *FILE* in root directory\r
// Long file name entry is *NOT* supported\r
if (((DirEntry.Attributes & FAT_ATTR_DIRECTORY) == FAT_ATTR_DIRECTORY) || (DirEntry.Attributes == FAT_ATTR_LFN)) {\r
continue;\r
}\r
+\r
//\r
// if this is a terminator dir entry, just return EFI_NOT_FOUND\r
//\r
if (DirEntry.FileName[0] == EMPTY_ENTRY_MARK) {\r
return EFI_NOT_FOUND;\r
}\r
+\r
//\r
// If this not an invalid entry neither an empty entry, this is what we want.\r
// otherwise we will start a new loop to continue to find something meaningful\r
//\r
- if ((UINT8) DirEntry.FileName[0] != DELETE_ENTRY_MARK) {\r
+ if ((UINT8)DirEntry.FileName[0] != DELETE_ENTRY_MARK) {\r
break;\r
}\r
}\r
+\r
//\r
// fill in the output parameter\r
//\r
EngFatToStr (8, DirEntry.FileName, BaseName);\r
EngFatToStr (3, DirEntry.FileName + 8, Ext);\r
\r
- Pos = (UINT16 *) SubFile->FileName;\r
- SetMem ((UINT8 *) Pos, FAT_MAX_FILE_NAME_LENGTH, 0);\r
- CopyMem ((UINT8 *) Pos, (UINT8 *) BaseName, 2 * (StrLen (BaseName) + 1));\r
+ Pos = (UINT16 *)SubFile->FileName;\r
+ SetMem ((UINT8 *)Pos, FAT_MAX_FILE_NAME_LENGTH, 0);\r
+ CopyMem ((UINT8 *)Pos, (UINT8 *)BaseName, 2 * (StrLen (BaseName) + 1));\r
\r
if (Ext[0] != 0) {\r
Pos += StrLen (BaseName);\r
*Pos = '.';\r
Pos++;\r
- CopyMem ((UINT8 *) Pos, (UINT8 *) Ext, 2 * (StrLen (Ext) + 1));\r
+ CopyMem ((UINT8 *)Pos, (UINT8 *)Ext, 2 * (StrLen (Ext) + 1));\r
}\r
\r
SubFile->Attributes = DirEntry.Attributes;\r
SubFile->CurrentCluster |= DirEntry.FileClusterHigh << 16;\r
}\r
\r
- SubFile->CurrentPos = 0;\r
- SubFile->FileSize = DirEntry.FileSize;\r
- SubFile->StartingCluster = SubFile->CurrentCluster;\r
- SubFile->Volume = ParentDir->Volume;\r
+ SubFile->CurrentPos = 0;\r
+ SubFile->FileSize = DirEntry.FileSize;\r
+ SubFile->StartingCluster = SubFile->CurrentCluster;\r
+ SubFile->Volume = ParentDir->Volume;\r
\r
//\r
// in Pei phase, time parameters do not need to be filled for minimum use.\r
IN VOID *Ppi\r
);\r
\r
-\r
/**\r
Discover all the block I/O devices to find the FAT volume.\r
\r
**/\r
EFI_STATUS\r
UpdateBlocksAndVolumes (\r
- IN OUT PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN BOOLEAN BlockIo2\r
+ IN OUT PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN BOOLEAN BlockIo2\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_PEI_PPI_DESCRIPTOR *TempPpiDescriptor;\r
- UINTN BlockIoPpiInstance;\r
- EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi;\r
- EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi;\r
- UINTN NumberBlockDevices;\r
- UINTN Index;\r
- EFI_PEI_BLOCK_IO_MEDIA Media;\r
- EFI_PEI_BLOCK_IO2_MEDIA Media2;\r
- PEI_FAT_VOLUME Volume;\r
- EFI_PEI_SERVICES **PeiServices;\r
-\r
- PeiServices = (EFI_PEI_SERVICES **) GetPeiServicesTablePointer ();\r
+ EFI_STATUS Status;\r
+ EFI_PEI_PPI_DESCRIPTOR *TempPpiDescriptor;\r
+ UINTN BlockIoPpiInstance;\r
+ EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIoPpi;\r
+ EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2Ppi;\r
+ UINTN NumberBlockDevices;\r
+ UINTN Index;\r
+ EFI_PEI_BLOCK_IO_MEDIA Media;\r
+ EFI_PEI_BLOCK_IO2_MEDIA Media2;\r
+ PEI_FAT_VOLUME Volume;\r
+ EFI_PEI_SERVICES **PeiServices;\r
+\r
+ PeiServices = (EFI_PEI_SERVICES **)GetPeiServicesTablePointer ();\r
BlockIo2Ppi = NULL;\r
BlockIoPpi = NULL;\r
//\r
for (BlockIoPpiInstance = 0; BlockIoPpiInstance < PEI_FAT_MAX_BLOCK_IO_PPI; BlockIoPpiInstance++) {\r
if (BlockIo2) {\r
Status = PeiServicesLocatePpi (\r
- &gEfiPeiVirtualBlockIo2PpiGuid,\r
- BlockIoPpiInstance,\r
- &TempPpiDescriptor,\r
- (VOID **) &BlockIo2Ppi\r
- );\r
+ &gEfiPeiVirtualBlockIo2PpiGuid,\r
+ BlockIoPpiInstance,\r
+ &TempPpiDescriptor,\r
+ (VOID **)&BlockIo2Ppi\r
+ );\r
} else {\r
Status = PeiServicesLocatePpi (\r
- &gEfiPeiVirtualBlockIoPpiGuid,\r
- BlockIoPpiInstance,\r
- &TempPpiDescriptor,\r
- (VOID **) &BlockIoPpi\r
- );\r
+ &gEfiPeiVirtualBlockIoPpiGuid,\r
+ BlockIoPpiInstance,\r
+ &TempPpiDescriptor,\r
+ (VOID **)&BlockIoPpi\r
+ );\r
}\r
+\r
if (EFI_ERROR (Status)) {\r
//\r
// Done with all Block Io Ppis\r
&NumberBlockDevices\r
);\r
}\r
+\r
if (EFI_ERROR (Status)) {\r
continue;\r
}\r
\r
for (Index = 1; Index <= NumberBlockDevices && PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE; Index++) {\r
-\r
if (BlockIo2) {\r
Status = BlockIo2Ppi->GetBlockDeviceMediaInfo (\r
PeiServices,\r
if (EFI_ERROR (Status) || !Media2.MediaPresent) {\r
continue;\r
}\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo2 = BlockIo2Ppi;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].InterfaceType = Media2.InterfaceType;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media2.LastBlock;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = Media2.BlockSize;\r
+\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo2 = BlockIo2Ppi;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].InterfaceType = Media2.InterfaceType;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media2.LastBlock;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = Media2.BlockSize;\r
} else {\r
Status = BlockIoPpi->GetBlockDeviceMediaInfo (\r
PeiServices,\r
if (EFI_ERROR (Status) || !Media.MediaPresent) {\r
continue;\r
}\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo = BlockIoPpi;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].DevType = Media.DeviceType;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media.LastBlock;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = (UINT32) Media.BlockSize;\r
+\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockIo = BlockIoPpi;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].DevType = Media.DeviceType;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].LastBlock = Media.LastBlock;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].BlockSize = (UINT32)Media.BlockSize;\r
}\r
\r
PrivateData->BlockDevice[PrivateData->BlockDeviceCount].IoAlign = 0;\r
//\r
// Not used here\r
//\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].Logical = FALSE;\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PartitionChecked = FALSE;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].Logical = FALSE;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PartitionChecked = FALSE;\r
\r
- PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PhysicalDevNo = (UINT8) Index;\r
+ PrivateData->BlockDevice[PrivateData->BlockDeviceCount].PhysicalDevNo = (UINT8)Index;\r
PrivateData->BlockDeviceCount++;\r
}\r
}\r
+\r
//\r
// Find out all logical devices\r
//\r
//\r
PrivateData->VolumeCount = 0;\r
for (Index = 0; Index < PrivateData->BlockDeviceCount; Index++) {\r
- Volume.BlockDeviceNo = Index;\r
- Status = FatGetBpbInfo (PrivateData, &Volume);\r
+ Volume.BlockDeviceNo = Index;\r
+ Status = FatGetBpbInfo (PrivateData, &Volume);\r
if (Status == EFI_SUCCESS) {\r
//\r
// Add the detected volume to the volume array\r
//\r
CopyMem (\r
- (UINT8 *) &(PrivateData->Volume[PrivateData->VolumeCount]),\r
- (UINT8 *) &Volume,\r
+ (UINT8 *)&(PrivateData->Volume[PrivateData->VolumeCount]),\r
+ (UINT8 *)&Volume,\r
sizeof (PEI_FAT_VOLUME)\r
);\r
PrivateData->VolumeCount += 1;\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
BlockIo installation notification function. Find out all the current BlockIO\r
PPIs in the system and add them into private data. Assume there is\r
} else {\r
UpdateBlocksAndVolumes (mPrivateData, FALSE);\r
}\r
+\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Installs the Device Recovery Module PPI, Initialize BlockIo Ppi\r
installation notification\r
EFI_STATUS\r
EFIAPI\r
FatPeimEntry (\r
- IN EFI_PEI_FILE_HANDLE FileHandle,\r
- IN CONST EFI_PEI_SERVICES **PeiServices\r
+ IN EFI_PEI_FILE_HANDLE FileHandle,\r
+ IN CONST EFI_PEI_SERVICES **PeiServices\r
)\r
{\r
EFI_STATUS Status;\r
}\r
\r
Status = PeiServicesAllocatePages (\r
- EfiBootServicesCode,\r
- (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMORY_PAGE_SIZE + 1,\r
- &Address\r
- );\r
+ EfiBootServicesCode,\r
+ (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMORY_PAGE_SIZE + 1,\r
+ &Address\r
+ );\r
if (EFI_ERROR (Status)) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- PrivateData = (PEI_FAT_PRIVATE_DATA *) (UINTN) Address;\r
+ PrivateData = (PEI_FAT_PRIVATE_DATA *)(UINTN)Address;\r
\r
//\r
// Initialize Private Data (to zero, as is required by subsequent operations)\r
//\r
- ZeroMem ((UINT8 *) PrivateData, sizeof (PEI_FAT_PRIVATE_DATA));\r
+ ZeroMem ((UINT8 *)PrivateData, sizeof (PEI_FAT_PRIVATE_DATA));\r
\r
PrivateData->Signature = PEI_FAT_PRIVATE_DATA_SIGNATURE;\r
\r
//\r
// Installs Ppi\r
//\r
- PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules;\r
- PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo;\r
- PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule;\r
+ PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules;\r
+ PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo;\r
+ PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule;\r
\r
- PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);\r
- PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid;\r
- PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi;\r
+ PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);\r
+ PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid;\r
+ PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi;\r
\r
Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor);\r
if (EFI_ERROR (Status)) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
+\r
//\r
// Other initializations\r
//\r
//\r
PrivateData->NotifyDescriptor[0].Flags =\r
(\r
- EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK\r
+ EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK\r
);\r
- PrivateData->NotifyDescriptor[0].Guid = &gEfiPeiVirtualBlockIoPpiGuid;\r
- PrivateData->NotifyDescriptor[0].Notify = BlockIoNotifyEntry;\r
+ PrivateData->NotifyDescriptor[0].Guid = &gEfiPeiVirtualBlockIoPpiGuid;\r
+ PrivateData->NotifyDescriptor[0].Notify = BlockIoNotifyEntry;\r
PrivateData->NotifyDescriptor[1].Flags =\r
(\r
- EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK |\r
- EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST\r
+ EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK |\r
+ EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST\r
);\r
- PrivateData->NotifyDescriptor[1].Guid = &gEfiPeiVirtualBlockIo2PpiGuid;\r
- PrivateData->NotifyDescriptor[1].Notify = BlockIoNotifyEntry;\r
+ PrivateData->NotifyDescriptor[1].Guid = &gEfiPeiVirtualBlockIo2PpiGuid;\r
+ PrivateData->NotifyDescriptor[1].Notify = BlockIoNotifyEntry;\r
return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor[0]);\r
}\r
\r
-\r
/**\r
Returns the number of DXE capsules residing on the device.\r
\r
EFI_STATUS\r
EFIAPI\r
GetNumberRecoveryCapsules (\r
- IN EFI_PEI_SERVICES **PeiServices,\r
- IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
- OUT UINTN *NumberRecoveryCapsules\r
+ IN EFI_PEI_SERVICES **PeiServices,\r
+ IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
+ OUT UINTN *NumberRecoveryCapsules\r
)\r
{\r
EFI_STATUS Status;\r
//\r
RecoveryCapsuleCount = 0;\r
for (Index = 0; Index < PrivateData->VolumeCount; Index++) {\r
- Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr(PcdRecoveryFileName), &Handle);\r
+ Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);\r
if (EFI_ERROR (Status)) {\r
continue;\r
}\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Returns the size and type of the requested recovery capsule.\r
\r
EFI_STATUS\r
EFIAPI\r
GetRecoveryCapsuleInfo (\r
- IN EFI_PEI_SERVICES **PeiServices,\r
- IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
- IN UINTN CapsuleInstance,\r
- OUT UINTN *Size,\r
- OUT EFI_GUID *CapsuleType\r
+ IN EFI_PEI_SERVICES **PeiServices,\r
+ IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
+ IN UINTN CapsuleInstance,\r
+ OUT UINTN *Size,\r
+ OUT EFI_GUID *CapsuleType\r
)\r
{\r
EFI_STATUS Status;\r
//\r
RecoveryCapsuleCount = 0;\r
for (Index = 0; Index < PrivateData->VolumeCount; Index++) {\r
- Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr(PcdRecoveryFileName), &Handle);\r
+ Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);\r
\r
if (EFI_ERROR (Status)) {\r
continue;\r
//\r
// Get file size\r
//\r
- *Size = (UINTN) (((PEI_FAT_FILE *) Handle)->FileSize);\r
+ *Size = (UINTN)(((PEI_FAT_FILE *)Handle)->FileSize);\r
\r
//\r
// Find corresponding physical block device\r
while (PrivateData->BlockDevice[BlockDeviceNo].Logical && BlockDeviceNo < PrivateData->BlockDeviceCount) {\r
BlockDeviceNo = PrivateData->BlockDevice[BlockDeviceNo].ParentDevNo;\r
}\r
+\r
//\r
// Fill in the Capsule Type GUID according to the block device type\r
//\r
if (BlockDeviceNo < PrivateData->BlockDeviceCount) {\r
if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo2 != NULL) {\r
switch (PrivateData->BlockDevice[BlockDeviceNo].InterfaceType) {\r
- case MSG_ATAPI_DP:\r
- CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);\r
- break;\r
+ case MSG_ATAPI_DP:\r
+ CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);\r
+ break;\r
\r
- case MSG_USB_DP:\r
- CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);\r
- break;\r
+ case MSG_USB_DP:\r
+ CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);\r
+ break;\r
\r
- case MSG_NVME_NAMESPACE_DP:\r
- CopyGuid (CapsuleType, &gRecoveryOnFatNvmeDiskGuid);\r
- break;\r
+ case MSG_NVME_NAMESPACE_DP:\r
+ CopyGuid (CapsuleType, &gRecoveryOnFatNvmeDiskGuid);\r
+ break;\r
\r
- default:\r
- break;\r
+ default:\r
+ break;\r
}\r
}\r
+\r
if (PrivateData->BlockDevice[BlockDeviceNo].BlockIo != NULL) {\r
switch (PrivateData->BlockDevice[BlockDeviceNo].DevType) {\r
- case LegacyFloppy:\r
- CopyGuid (CapsuleType, &gRecoveryOnFatFloppyDiskGuid);\r
- break;\r
+ case LegacyFloppy:\r
+ CopyGuid (CapsuleType, &gRecoveryOnFatFloppyDiskGuid);\r
+ break;\r
\r
- case IdeCDROM:\r
- case IdeLS120:\r
- CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);\r
- break;\r
+ case IdeCDROM:\r
+ case IdeLS120:\r
+ CopyGuid (CapsuleType, &gRecoveryOnFatIdeDiskGuid);\r
+ break;\r
\r
- case UsbMassStorage:\r
- CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);\r
- break;\r
+ case UsbMassStorage:\r
+ CopyGuid (CapsuleType, &gRecoveryOnFatUsbDiskGuid);\r
+ break;\r
\r
- default:\r
- break;\r
+ default:\r
+ break;\r
}\r
}\r
}\r
return EFI_NOT_FOUND;\r
}\r
\r
-\r
/**\r
Loads a DXE capsule from some media into memory.\r
\r
EFI_STATUS\r
EFIAPI\r
LoadRecoveryCapsule (\r
- IN EFI_PEI_SERVICES **PeiServices,\r
- IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
- IN UINTN CapsuleInstance,\r
- OUT VOID *Buffer\r
+ IN EFI_PEI_SERVICES **PeiServices,\r
+ IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
+ IN UINTN CapsuleInstance,\r
+ OUT VOID *Buffer\r
)\r
{\r
EFI_STATUS Status;\r
//\r
RecoveryCapsuleCount = 0;\r
for (Index = 0; Index < PrivateData->VolumeCount; Index++) {\r
- Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr(PcdRecoveryFileName), &Handle);\r
+ Status = FindRecoveryFile (PrivateData, Index, (CHAR16 *)PcdGetPtr (PcdRecoveryFileName), &Handle);\r
if (EFI_ERROR (Status)) {\r
continue;\r
}\r
\r
if (CapsuleInstance - 1 == RecoveryCapsuleCount) {\r
-\r
Status = FatReadFile (\r
- PrivateData,\r
- Handle,\r
- (UINTN) (((PEI_FAT_FILE *) Handle)->FileSize),\r
- Buffer\r
- );\r
+ PrivateData,\r
+ Handle,\r
+ (UINTN)(((PEI_FAT_FILE *)Handle)->FileSize),\r
+ Buffer\r
+ );\r
return Status;\r
}\r
\r
return EFI_NOT_FOUND;\r
}\r
\r
-\r
/**\r
Finds the recovery file on a FAT volume.\r
This function finds the recovery file named FileName on a specified FAT volume and returns\r
// Construct root directory file\r
//\r
ZeroMem (&Parent, sizeof (PEI_FAT_FILE));\r
- Parent.IsFixedRootDir = (BOOLEAN) ((PrivateData->Volume[VolumeIndex].FatType == Fat32) ? FALSE : TRUE);\r
- Parent.Attributes = FAT_ATTR_DIRECTORY;\r
- Parent.CurrentPos = 0;\r
- Parent.CurrentCluster = Parent.IsFixedRootDir ? 0 : PrivateData->Volume[VolumeIndex].RootDirCluster;\r
- Parent.StartingCluster = Parent.CurrentCluster;\r
- Parent.Volume = &PrivateData->Volume[VolumeIndex];\r
-\r
- Status = FatSetFilePos (PrivateData, &Parent, 0);\r
+ Parent.IsFixedRootDir = (BOOLEAN)((PrivateData->Volume[VolumeIndex].FatType == Fat32) ? FALSE : TRUE);\r
+ Parent.Attributes = FAT_ATTR_DIRECTORY;\r
+ Parent.CurrentPos = 0;\r
+ Parent.CurrentCluster = Parent.IsFixedRootDir ? 0 : PrivateData->Volume[VolumeIndex].RootDirCluster;\r
+ Parent.StartingCluster = Parent.CurrentCluster;\r
+ Parent.Volume = &PrivateData->Volume[VolumeIndex];\r
+\r
+ Status = FatSetFilePos (PrivateData, &Parent, 0);\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
+\r
//\r
// Search for recovery capsule in root directory\r
//\r
*Handle = File;\r
\r
return EFI_SUCCESS;\r
-\r
}\r
//\r
// API data structures\r
//\r
-typedef VOID *PEI_FILE_HANDLE;\r
+typedef VOID *PEI_FILE_HANDLE;\r
\r
typedef enum {\r
Fat12,\r
//\r
// Definitions\r
//\r
-#define FAT_ATTR_READ_ONLY 0x01\r
-#define FAT_ATTR_HIDDEN 0x02\r
-#define FAT_ATTR_SYSTEM 0x04\r
-#define FAT_ATTR_VOLUME_ID 0x08\r
-#define FAT_ATTR_DIRECTORY 0x10\r
-#define FAT_ATTR_ARCHIVE 0x20\r
-#define FAT_ATTR_LFN (FAT_ATTR_READ_ONLY | FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM | FAT_ATTR_VOLUME_ID)\r
-\r
-#define FAT_CLUSTER_SPECIAL ((MAX_UINT32 &~0xF) | 0x7)\r
-#define FAT_CLUSTER_FREE 0\r
-#define FAT_CLUSTER_RESERVED (FAT_CLUSTER_SPECIAL)\r
-#define FAT_CLUSTER_BAD (FAT_CLUSTER_SPECIAL)\r
-#define FAT_CLUSTER_LAST (-1)\r
-\r
-#define DELETE_ENTRY_MARK 0xE5\r
-#define EMPTY_ENTRY_MARK 0x00\r
-\r
-#define FAT_CLUSTER_FUNCTIONAL(Cluster) (((Cluster) == 0) || ((Cluster) >= FAT_CLUSTER_SPECIAL))\r
-#define FAT_CLUSTER_END_OF_CHAIN(Cluster) ((Cluster) > (FAT_CLUSTER_SPECIAL))\r
+#define FAT_ATTR_READ_ONLY 0x01\r
+#define FAT_ATTR_HIDDEN 0x02\r
+#define FAT_ATTR_SYSTEM 0x04\r
+#define FAT_ATTR_VOLUME_ID 0x08\r
+#define FAT_ATTR_DIRECTORY 0x10\r
+#define FAT_ATTR_ARCHIVE 0x20\r
+#define FAT_ATTR_LFN (FAT_ATTR_READ_ONLY | FAT_ATTR_HIDDEN | FAT_ATTR_SYSTEM | FAT_ATTR_VOLUME_ID)\r
+\r
+#define FAT_CLUSTER_SPECIAL ((MAX_UINT32 &~0xF) | 0x7)\r
+#define FAT_CLUSTER_FREE 0\r
+#define FAT_CLUSTER_RESERVED (FAT_CLUSTER_SPECIAL)\r
+#define FAT_CLUSTER_BAD (FAT_CLUSTER_SPECIAL)\r
+#define FAT_CLUSTER_LAST (-1)\r
+\r
+#define DELETE_ENTRY_MARK 0xE5\r
+#define EMPTY_ENTRY_MARK 0x00\r
+\r
+#define FAT_CLUSTER_FUNCTIONAL(Cluster) (((Cluster) == 0) || ((Cluster) >= FAT_CLUSTER_SPECIAL))\r
+#define FAT_CLUSTER_END_OF_CHAIN(Cluster) ((Cluster) > (FAT_CLUSTER_SPECIAL))\r
\r
//\r
// Directory Entry\r
#pragma pack(1)\r
\r
typedef struct {\r
- UINT16 Day : 5;\r
- UINT16 Month : 4;\r
- UINT16 Year : 7; // From 1980\r
+ UINT16 Day : 5;\r
+ UINT16 Month : 4;\r
+ UINT16 Year : 7; // From 1980\r
} FAT_DATE;\r
\r
typedef struct {\r
- UINT16 DoubleSecond : 5;\r
- UINT16 Minute : 6;\r
- UINT16 Hour : 5;\r
+ UINT16 DoubleSecond : 5;\r
+ UINT16 Minute : 6;\r
+ UINT16 Hour : 5;\r
} FAT_TIME;\r
\r
typedef struct {\r
- FAT_TIME Time;\r
- FAT_DATE Date;\r
+ FAT_TIME Time;\r
+ FAT_DATE Date;\r
} FAT_DATE_TIME;\r
\r
typedef struct {\r
- CHAR8 FileName[11]; // 8.3 filename\r
- UINT8 Attributes;\r
- UINT8 CaseFlag;\r
- UINT8 CreateMillisecond; // (creation milliseconds - ignored)\r
- FAT_DATE_TIME FileCreateTime;\r
- FAT_DATE FileLastAccess;\r
- UINT16 FileClusterHigh; // >= FAT32\r
- FAT_DATE_TIME FileModificationTime;\r
- UINT16 FileCluster;\r
- UINT32 FileSize;\r
+ CHAR8 FileName[11]; // 8.3 filename\r
+ UINT8 Attributes;\r
+ UINT8 CaseFlag;\r
+ UINT8 CreateMillisecond; // (creation milliseconds - ignored)\r
+ FAT_DATE_TIME FileCreateTime;\r
+ FAT_DATE FileLastAccess;\r
+ UINT16 FileClusterHigh; // >= FAT32\r
+ FAT_DATE_TIME FileModificationTime;\r
+ UINT16 FileCluster;\r
+ UINT32 FileSize;\r
} FAT_DIRECTORY_ENTRY;\r
\r
#pragma pack()\r
#pragma pack(1)\r
\r
typedef struct {\r
-\r
- UINT8 Ia32Jump[3];\r
- CHAR8 OemId[8];\r
-\r
- UINT16 SectorSize;\r
- UINT8 SectorsPerCluster;\r
- UINT16 ReservedSectors;\r
- UINT8 NoFats;\r
- UINT16 RootEntries; // < FAT32, root dir is fixed size\r
- UINT16 Sectors;\r
- UINT8 Media; // (ignored)\r
- UINT16 SectorsPerFat; // < FAT32\r
- UINT16 SectorsPerTrack; // (ignored)\r
- UINT16 Heads; // (ignored)\r
- UINT32 HiddenSectors; // (ignored)\r
- UINT32 LargeSectors; // => FAT32\r
- UINT8 PhysicalDriveNumber; // (ignored)\r
- UINT8 CurrentHead; // holds boot_sector_dirty bit\r
- UINT8 Signature; // (ignored)\r
- CHAR8 Id[4];\r
- CHAR8 FatLabel[11];\r
- CHAR8 SystemId[8];\r
-\r
+ UINT8 Ia32Jump[3];\r
+ CHAR8 OemId[8];\r
+\r
+ UINT16 SectorSize;\r
+ UINT8 SectorsPerCluster;\r
+ UINT16 ReservedSectors;\r
+ UINT8 NoFats;\r
+ UINT16 RootEntries; // < FAT32, root dir is fixed size\r
+ UINT16 Sectors;\r
+ UINT8 Media; // (ignored)\r
+ UINT16 SectorsPerFat; // < FAT32\r
+ UINT16 SectorsPerTrack; // (ignored)\r
+ UINT16 Heads; // (ignored)\r
+ UINT32 HiddenSectors; // (ignored)\r
+ UINT32 LargeSectors; // => FAT32\r
+ UINT8 PhysicalDriveNumber; // (ignored)\r
+ UINT8 CurrentHead; // holds boot_sector_dirty bit\r
+ UINT8 Signature; // (ignored)\r
+ CHAR8 Id[4];\r
+ CHAR8 FatLabel[11];\r
+ CHAR8 SystemId[8];\r
} PEI_FAT_BOOT_SECTOR;\r
\r
typedef struct {\r
-\r
- UINT8 Ia32Jump[3];\r
- CHAR8 OemId[8];\r
-\r
- UINT16 SectorSize;\r
- UINT8 SectorsPerCluster;\r
- UINT16 ReservedSectors;\r
- UINT8 NoFats;\r
- UINT16 RootEntries; // < FAT32, root dir is fixed size\r
- UINT16 Sectors;\r
- UINT8 Media; // (ignored)\r
- UINT16 SectorsPerFat; // < FAT32\r
- UINT16 SectorsPerTrack; // (ignored)\r
- UINT16 Heads; // (ignored)\r
- UINT32 HiddenSectors; // (ignored)\r
- UINT32 LargeSectors; // Used if Sectors==0\r
- UINT32 LargeSectorsPerFat; // FAT32\r
- UINT16 ExtendedFlags; // FAT32 (ignored)\r
- UINT16 FsVersion; // FAT32 (ignored)\r
- UINT32 RootDirFirstCluster; // FAT32\r
- UINT16 FsInfoSector; // FAT32\r
- UINT16 BackupBootSector; // FAT32\r
- UINT8 Reserved[12]; // FAT32 (ignored)\r
- UINT8 PhysicalDriveNumber; // (ignored)\r
- UINT8 CurrentHead; // holds boot_sector_dirty bit\r
- UINT8 Signature; // (ignored)\r
- CHAR8 Id[4];\r
- CHAR8 FatLabel[11];\r
- CHAR8 SystemId[8];\r
-\r
+ UINT8 Ia32Jump[3];\r
+ CHAR8 OemId[8];\r
+\r
+ UINT16 SectorSize;\r
+ UINT8 SectorsPerCluster;\r
+ UINT16 ReservedSectors;\r
+ UINT8 NoFats;\r
+ UINT16 RootEntries; // < FAT32, root dir is fixed size\r
+ UINT16 Sectors;\r
+ UINT8 Media; // (ignored)\r
+ UINT16 SectorsPerFat; // < FAT32\r
+ UINT16 SectorsPerTrack; // (ignored)\r
+ UINT16 Heads; // (ignored)\r
+ UINT32 HiddenSectors; // (ignored)\r
+ UINT32 LargeSectors; // Used if Sectors==0\r
+ UINT32 LargeSectorsPerFat; // FAT32\r
+ UINT16 ExtendedFlags; // FAT32 (ignored)\r
+ UINT16 FsVersion; // FAT32 (ignored)\r
+ UINT32 RootDirFirstCluster; // FAT32\r
+ UINT16 FsInfoSector; // FAT32\r
+ UINT16 BackupBootSector; // FAT32\r
+ UINT8 Reserved[12]; // FAT32 (ignored)\r
+ UINT8 PhysicalDriveNumber; // (ignored)\r
+ UINT8 CurrentHead; // holds boot_sector_dirty bit\r
+ UINT8 Signature; // (ignored)\r
+ CHAR8 Id[4];\r
+ CHAR8 FatLabel[11];\r
+ CHAR8 SystemId[8];\r
} PEI_FAT_BOOT_SECTOR_EX;\r
\r
#pragma pack()\r
\r
#include "FatLitePeim.h"\r
\r
-\r
#define CHAR_FAT_VALID 0x01\r
\r
-\r
/**\r
Converts a union code character to upper case.\r
This functions converts a unicode character to upper case.\r
**/\r
CHAR16\r
ToUpper (\r
- IN CHAR16 Letter\r
+ IN CHAR16 Letter\r
)\r
{\r
- if ('a' <= Letter && Letter <= 'z') {\r
- Letter = (CHAR16) (Letter - 0x20);\r
+ if (('a' <= Letter) && (Letter <= 'z')) {\r
+ Letter = (CHAR16)(Letter - 0x20);\r
}\r
\r
return Letter;\r
}\r
\r
-\r
/**\r
Reads a block of data from the block device by calling\r
underlying Block I/O service.\r
**/\r
EFI_STATUS\r
FatReadBlock (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN BlockDeviceNo,\r
- IN EFI_PEI_LBA Lba,\r
- IN UINTN BufferSize,\r
- OUT VOID *Buffer\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN BlockDeviceNo,\r
+ IN EFI_PEI_LBA Lba,\r
+ IN UINTN BufferSize,\r
+ OUT VOID *Buffer\r
)\r
{\r
EFI_STATUS Status;\r
return EFI_DEVICE_ERROR;\r
}\r
\r
- Status = EFI_SUCCESS;\r
- BlockDev = &(PrivateData->BlockDevice[BlockDeviceNo]);\r
+ Status = EFI_SUCCESS;\r
+ BlockDev = &(PrivateData->BlockDevice[BlockDeviceNo]);\r
\r
if (BufferSize > MultU64x32 (BlockDev->LastBlock - Lba + 1, BlockDev->BlockSize)) {\r
return EFI_DEVICE_ERROR;\r
//\r
if (BlockDev->BlockIo2 != NULL) {\r
Status = BlockDev->BlockIo2->ReadBlocks (\r
- (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),\r
- BlockDev->BlockIo2,\r
+ (EFI_PEI_SERVICES **)GetPeiServicesTablePointer (),\r
+ BlockDev->BlockIo2,\r
+ BlockDev->PhysicalDevNo,\r
+ Lba,\r
+ BufferSize,\r
+ Buffer\r
+ );\r
+ } else {\r
+ Status = BlockDev->BlockIo->ReadBlocks (\r
+ (EFI_PEI_SERVICES **)GetPeiServicesTablePointer (),\r
+ BlockDev->BlockIo,\r
BlockDev->PhysicalDevNo,\r
Lba,\r
BufferSize,\r
Buffer\r
);\r
- } else {\r
- Status = BlockDev->BlockIo->ReadBlocks (\r
- (EFI_PEI_SERVICES **) GetPeiServicesTablePointer (),\r
- BlockDev->BlockIo,\r
- BlockDev->PhysicalDevNo,\r
- Lba,\r
- BufferSize,\r
- Buffer\r
- );\r
}\r
-\r
} else {\r
Status = FatReadDisk (\r
- PrivateData,\r
- BlockDev->ParentDevNo,\r
- BlockDev->StartingPos + MultU64x32 (Lba, BlockDev->BlockSize),\r
- BufferSize,\r
- Buffer\r
- );\r
+ PrivateData,\r
+ BlockDev->ParentDevNo,\r
+ BlockDev->StartingPos + MultU64x32 (Lba, BlockDev->BlockSize),\r
+ BufferSize,\r
+ Buffer\r
+ );\r
}\r
\r
return Status;\r
}\r
\r
-\r
/**\r
Find a cache block designated to specific Block device and Lba.\r
If not found, invalidate an oldest one and use it. (LRU cache)\r
//\r
for (Index = 0; Index < PEI_FAT_CACHE_SIZE; Index++) {\r
CacheBuffer = &(PrivateData->CacheBuffer[Index]);\r
- if (CacheBuffer->Valid && CacheBuffer->BlockDeviceNo == BlockDeviceNo && CacheBuffer->Lba == Lba) {\r
+ if (CacheBuffer->Valid && (CacheBuffer->BlockDeviceNo == BlockDeviceNo) && (CacheBuffer->Lba == Lba)) {\r
break;\r
}\r
}\r
\r
if (Index < PEI_FAT_CACHE_SIZE) {\r
- *CachePtr = (CHAR8 *) CacheBuffer->Buffer;\r
+ *CachePtr = (CHAR8 *)CacheBuffer->Buffer;\r
return EFI_SUCCESS;\r
}\r
+\r
//\r
// We have to find an invalid cache buffer\r
//\r
break;\r
}\r
}\r
+\r
//\r
// Use the cache buffer\r
//\r
return EFI_DEVICE_ERROR;\r
}\r
\r
- CacheBuffer = &(PrivateData->CacheBuffer[Index]);\r
+ CacheBuffer = &(PrivateData->CacheBuffer[Index]);\r
\r
- CacheBuffer->BlockDeviceNo = BlockDeviceNo;\r
- CacheBuffer->Lba = Lba;\r
- CacheBuffer->Size = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;\r
+ CacheBuffer->BlockDeviceNo = BlockDeviceNo;\r
+ CacheBuffer->Lba = Lba;\r
+ CacheBuffer->Size = PrivateData->BlockDevice[BlockDeviceNo].BlockSize;\r
\r
//\r
// Read in the data\r
//\r
Status = FatReadBlock (\r
- PrivateData,\r
- BlockDeviceNo,\r
- Lba,\r
- CacheBuffer->Size,\r
- CacheBuffer->Buffer\r
- );\r
+ PrivateData,\r
+ BlockDeviceNo,\r
+ Lba,\r
+ CacheBuffer->Size,\r
+ CacheBuffer->Buffer\r
+ );\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
\r
- CacheBuffer->Valid = TRUE;\r
- *CachePtr = (CHAR8 *) CacheBuffer->Buffer;\r
+ CacheBuffer->Valid = TRUE;\r
+ *CachePtr = (CHAR8 *)CacheBuffer->Buffer;\r
\r
return Status;\r
}\r
\r
-\r
/**\r
Disk reading.\r
\r
//\r
// Read underrun\r
//\r
- Lba = DivU64x32Remainder (StartingAddress, BlockSize, &Offset);\r
- Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, Lba, &CachePtr);\r
+ Lba = DivU64x32Remainder (StartingAddress, BlockSize, &Offset);\r
+ Status = FatGetCacheBlock (PrivateData, BlockDeviceNo, Lba, &CachePtr);\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
}\r
return EFI_SUCCESS;\r
}\r
\r
- Size -= Amount;\r
- BufferPtr += Amount;\r
+ Size -= Amount;\r
+ BufferPtr += Amount;\r
StartingAddress += Amount;\r
- Lba += 1;\r
+ Lba += 1;\r
\r
//\r
// Read aligned parts\r
//\r
OverRunLba = Lba + DivU64x32Remainder (Size, BlockSize, &Offset);\r
\r
- Size -= Offset;\r
+ Size -= Offset;\r
Status = FatReadBlock (PrivateData, BlockDeviceNo, Lba, Size, BufferPtr);\r
if (EFI_ERROR (Status)) {\r
return EFI_DEVICE_ERROR;\r
return Status;\r
}\r
\r
-\r
/**\r
This version is different from the version in Unicode collation\r
protocol in that this version strips off trailing blanks.\r
**/\r
VOID\r
EngFatToStr (\r
- IN UINTN FatSize,\r
- IN CHAR8 *Fat,\r
- OUT CHAR16 *Str\r
+ IN UINTN FatSize,\r
+ IN CHAR8 *Fat,\r
+ OUT CHAR16 *Str\r
)\r
{\r
CHAR16 *String;\r
if (*Fat == ' ') {\r
break;\r
}\r
- *String = *Fat;\r
- String += 1;\r
- Fat += 1;\r
+\r
+ *String = *Fat;\r
+ String += 1;\r
+ Fat += 1;\r
FatSize -= 1;\r
}\r
\r
*String = 0;\r
}\r
\r
-\r
/**\r
Performs a case-insensitive comparison of two Null-terminated Unicode strings.\r
\r
UpperS2 = ToUpper (*Str2);\r
}\r
\r
- return (BOOLEAN) ((*Str2 != 0) ? FALSE : TRUE);\r
+ return (BOOLEAN)((*Str2 != 0) ? FALSE : TRUE);\r
}\r
// Definitions\r
//\r
\r
-#define PEI_FAT_CACHE_SIZE 4\r
-#define PEI_FAT_MAX_BLOCK_SIZE 8192\r
-#define FAT_MAX_FILE_NAME_LENGTH 128\r
-#define PEI_FAT_MAX_BLOCK_DEVICE 64\r
-#define PEI_FAT_MAX_BLOCK_IO_PPI 32\r
-#define PEI_FAT_MAX_VOLUME 64\r
+#define PEI_FAT_CACHE_SIZE 4\r
+#define PEI_FAT_MAX_BLOCK_SIZE 8192\r
+#define FAT_MAX_FILE_NAME_LENGTH 128\r
+#define PEI_FAT_MAX_BLOCK_DEVICE 64\r
+#define PEI_FAT_MAX_BLOCK_IO_PPI 32\r
+#define PEI_FAT_MAX_VOLUME 64\r
\r
-#define PEI_FAT_MEMORY_PAGE_SIZE 0x1000\r
+#define PEI_FAT_MEMORY_PAGE_SIZE 0x1000\r
\r
//\r
// Data Structures\r
// The block device\r
//\r
typedef struct {\r
-\r
- UINT32 BlockSize;\r
- UINT64 LastBlock;\r
- UINT32 IoAlign;\r
- BOOLEAN Logical;\r
- BOOLEAN PartitionChecked;\r
+ UINT32 BlockSize;\r
+ UINT64 LastBlock;\r
+ UINT32 IoAlign;\r
+ BOOLEAN Logical;\r
+ BOOLEAN PartitionChecked;\r
\r
//\r
// Following fields only valid for logical device\r
//\r
- CHAR8 PartitionFlag[8];\r
- UINT64 StartingPos;\r
- UINTN ParentDevNo;\r
+ CHAR8 PartitionFlag[8];\r
+ UINT64 StartingPos;\r
+ UINTN ParentDevNo;\r
\r
//\r
// Following fields only valid for physical device\r
//\r
- EFI_PEI_BLOCK_DEVICE_TYPE DevType;\r
- UINT8 InterfaceType;\r
+ EFI_PEI_BLOCK_DEVICE_TYPE DevType;\r
+ UINT8 InterfaceType;\r
//\r
// EFI_PEI_READ_BLOCKS ReadFunc;\r
//\r
- EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIo;\r
- EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2;\r
- UINT8 PhysicalDevNo;\r
+ EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlockIo;\r
+ EFI_PEI_RECOVERY_BLOCK_IO2_PPI *BlockIo2;\r
+ UINT8 PhysicalDevNo;\r
} PEI_FAT_BLOCK_DEVICE;\r
\r
//\r
// the Volume structure\r
//\r
typedef struct {\r
-\r
- UINTN BlockDeviceNo;\r
- UINTN VolumeNo;\r
- UINT64 VolumeSize;\r
- UINTN MaxCluster;\r
- CHAR16 VolumeLabel[FAT_MAX_FILE_NAME_LENGTH];\r
- PEI_FAT_TYPE FatType;\r
- UINT64 FatPos;\r
- UINT32 SectorSize;\r
- UINT32 ClusterSize;\r
- UINT64 FirstClusterPos;\r
- UINT64 RootDirPos;\r
- UINT32 RootEntries;\r
- UINT32 RootDirCluster;\r
-\r
+ UINTN BlockDeviceNo;\r
+ UINTN VolumeNo;\r
+ UINT64 VolumeSize;\r
+ UINTN MaxCluster;\r
+ CHAR16 VolumeLabel[FAT_MAX_FILE_NAME_LENGTH];\r
+ PEI_FAT_TYPE FatType;\r
+ UINT64 FatPos;\r
+ UINT32 SectorSize;\r
+ UINT32 ClusterSize;\r
+ UINT64 FirstClusterPos;\r
+ UINT64 RootDirPos;\r
+ UINT32 RootEntries;\r
+ UINT32 RootDirCluster;\r
} PEI_FAT_VOLUME;\r
\r
//\r
// File instance\r
//\r
typedef struct {\r
+ PEI_FAT_VOLUME *Volume;\r
+ CHAR16 FileName[FAT_MAX_FILE_NAME_LENGTH];\r
\r
- PEI_FAT_VOLUME *Volume;\r
- CHAR16 FileName[FAT_MAX_FILE_NAME_LENGTH];\r
-\r
- BOOLEAN IsFixedRootDir;\r
+ BOOLEAN IsFixedRootDir;\r
\r
- UINT32 StartingCluster;\r
- UINT32 CurrentPos;\r
- UINT32 StraightReadAmount;\r
- UINT32 CurrentCluster;\r
-\r
- UINT8 Attributes;\r
- UINT32 FileSize;\r
+ UINT32 StartingCluster;\r
+ UINT32 CurrentPos;\r
+ UINT32 StraightReadAmount;\r
+ UINT32 CurrentCluster;\r
\r
+ UINT8 Attributes;\r
+ UINT32 FileSize;\r
} PEI_FAT_FILE;\r
\r
//\r
// Cache Buffer\r
//\r
typedef struct {\r
-\r
- BOOLEAN Valid;\r
- UINTN BlockDeviceNo;\r
- UINT64 Lba;\r
- UINT32 Lru;\r
- UINT64 Buffer[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
- UINTN Size;\r
-\r
+ BOOLEAN Valid;\r
+ UINTN BlockDeviceNo;\r
+ UINT64 Lba;\r
+ UINT32 Lru;\r
+ UINT64 Buffer[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
+ UINTN Size;\r
} PEI_FAT_CACHE_BUFFER;\r
\r
//\r
#define PEI_FAT_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('p', 'f', 'a', 't')\r
\r
typedef struct {\r
-\r
- UINTN Signature;\r
- EFI_PEI_DEVICE_RECOVERY_MODULE_PPI DeviceRecoveryPpi;\r
- EFI_PEI_PPI_DESCRIPTOR PpiDescriptor;\r
- EFI_PEI_NOTIFY_DESCRIPTOR NotifyDescriptor[2];\r
-\r
- UINT8 UnicodeCaseMap[0x300];\r
- CHAR8 *EngUpperMap;\r
- CHAR8 *EngLowerMap;\r
- CHAR8 *EngInfoMap;\r
-\r
- UINT64 BlockData[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
- UINTN BlockDeviceCount;\r
- PEI_FAT_BLOCK_DEVICE BlockDevice[PEI_FAT_MAX_BLOCK_DEVICE];\r
- UINTN VolumeCount;\r
- PEI_FAT_VOLUME Volume[PEI_FAT_MAX_VOLUME];\r
- PEI_FAT_FILE File;\r
- PEI_FAT_CACHE_BUFFER CacheBuffer[PEI_FAT_CACHE_SIZE];\r
-\r
+ UINTN Signature;\r
+ EFI_PEI_DEVICE_RECOVERY_MODULE_PPI DeviceRecoveryPpi;\r
+ EFI_PEI_PPI_DESCRIPTOR PpiDescriptor;\r
+ EFI_PEI_NOTIFY_DESCRIPTOR NotifyDescriptor[2];\r
+\r
+ UINT8 UnicodeCaseMap[0x300];\r
+ CHAR8 *EngUpperMap;\r
+ CHAR8 *EngLowerMap;\r
+ CHAR8 *EngInfoMap;\r
+\r
+ UINT64 BlockData[PEI_FAT_MAX_BLOCK_SIZE / 8];\r
+ UINTN BlockDeviceCount;\r
+ PEI_FAT_BLOCK_DEVICE BlockDevice[PEI_FAT_MAX_BLOCK_DEVICE];\r
+ UINTN VolumeCount;\r
+ PEI_FAT_VOLUME Volume[PEI_FAT_MAX_VOLUME];\r
+ PEI_FAT_FILE File;\r
+ PEI_FAT_CACHE_BUFFER CacheBuffer[PEI_FAT_CACHE_SIZE];\r
} PEI_FAT_PRIVATE_DATA;\r
\r
#define PEI_FAT_PRIVATE_DATA_FROM_THIS(a) \\r
#define UNPACK_UINT32(a) \\r
(UINT32) ((((UINT8 *) a)[0] << 0) | (((UINT8 *) a)[1] << 8) | (((UINT8 *) a)[2] << 16) | (((UINT8 *) a)[3] << 24))\r
\r
-\r
//\r
// API functions\r
//\r
OUT PEI_FILE_HANDLE *Handle\r
);\r
\r
-\r
/**\r
Returns the number of DXE capsules residing on the device.\r
This function, by whatever mechanism, searches for DXE capsules from the associated device and\r
EFI_STATUS\r
EFIAPI\r
GetNumberRecoveryCapsules (\r
- IN EFI_PEI_SERVICES **PeiServices,\r
- IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
- OUT UINTN *NumberRecoveryCapsules\r
+ IN EFI_PEI_SERVICES **PeiServices,\r
+ IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
+ OUT UINTN *NumberRecoveryCapsules\r
);\r
\r
-\r
/**\r
Returns the size and type of the requested recovery capsule.\r
This function returns the size and type of the capsule specified by CapsuleInstance.\r
EFI_STATUS\r
EFIAPI\r
GetRecoveryCapsuleInfo (\r
- IN EFI_PEI_SERVICES **PeiServices,\r
- IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
- IN UINTN CapsuleInstance,\r
- OUT UINTN *Size,\r
- OUT EFI_GUID *CapsuleType\r
+ IN EFI_PEI_SERVICES **PeiServices,\r
+ IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
+ IN UINTN CapsuleInstance,\r
+ OUT UINTN *Size,\r
+ OUT EFI_GUID *CapsuleType\r
);\r
\r
-\r
/**\r
Loads a DXE capsule from some media into memory.\r
\r
EFI_STATUS\r
EFIAPI\r
LoadRecoveryCapsule (\r
- IN EFI_PEI_SERVICES **PeiServices,\r
- IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
- IN UINTN CapsuleInstance,\r
- OUT VOID *Buffer\r
+ IN EFI_PEI_SERVICES **PeiServices,\r
+ IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This,\r
+ IN UINTN CapsuleInstance,\r
+ OUT VOID *Buffer\r
);\r
\r
-\r
/**\r
This version is different from the version in Unicode collation\r
protocol in that this version strips off trailing blanks.\r
**/\r
VOID\r
EngFatToStr (\r
- IN UINTN FatSize,\r
- IN CHAR8 *Fat,\r
- OUT CHAR16 *Str\r
+ IN UINTN FatSize,\r
+ IN CHAR8 *Fat,\r
+ OUT CHAR16 *Str\r
);\r
\r
-\r
/**\r
Performs a case-insensitive comparison of two Null-terminated Unicode strings.\r
\r
IN CHAR16 *Str2\r
);\r
\r
-\r
/**\r
Reads a block of data from the block device by calling\r
underlying Block I/O service.\r
**/\r
EFI_STATUS\r
FatReadBlock (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN BlockDeviceNo,\r
- IN EFI_PEI_LBA Lba,\r
- IN UINTN BufferSize,\r
- OUT VOID *Buffer\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN BlockDeviceNo,\r
+ IN EFI_PEI_LBA Lba,\r
+ IN UINTN BufferSize,\r
+ OUT VOID *Buffer\r
);\r
\r
-\r
/**\r
Check if there is a valid FAT in the corresponding Block device\r
of the volume and if yes, fill in the relevant fields for the\r
IN OUT PEI_FAT_VOLUME *Volume\r
);\r
\r
-\r
/**\r
Gets the next cluster in the cluster chain.\r
\r
OUT UINT32 *NextCluster\r
);\r
\r
-\r
/**\r
Disk reading.\r
\r
OUT VOID *Buffer\r
);\r
\r
-\r
/**\r
Set a file's CurrentPos and CurrentCluster, then compute StraightReadAmount.\r
\r
IN UINT32 Pos\r
);\r
\r
-\r
/**\r
Reads file data. Updates the file's CurrentPos.\r
\r
OUT VOID *Buffer\r
);\r
\r
-\r
/**\r
This function reads the next item in the parent directory and\r
initializes the output parameter SubFile (CurrentPos is initialized to 0).\r
OUT PEI_FAT_FILE *SubFile\r
);\r
\r
-\r
/**\r
This function finds partitions (logical devices) in physical block devices.\r
\r
// GPT Partition Entry Status\r
//\r
typedef struct {\r
- BOOLEAN OutOfRange;\r
- BOOLEAN Overlap;\r
- BOOLEAN OsSpecific;\r
+ BOOLEAN OutOfRange;\r
+ BOOLEAN Overlap;\r
+ BOOLEAN OsSpecific;\r
} EFI_PARTITION_ENTRY_STATUS;\r
\r
/**\r
IN EFI_PARTITION_TABLE_HEADER *PartHeader\r
)\r
{\r
- UINT32 GptHdrCrc;\r
- UINT32 Crc;\r
+ UINT32 GptHdrCrc;\r
+ UINT32 Crc;\r
\r
GptHdrCrc = PartHeader->Header.CRC32;\r
\r
return (GptHdrCrc == Crc);\r
}\r
\r
-\r
/**\r
Check if the CRC field in the Partition table header is valid\r
for Partition entry array.\r
**/\r
BOOLEAN\r
PartitionCheckGptEntryArrayCRC (\r
- IN EFI_PARTITION_TABLE_HEADER *PartHeader,\r
- IN EFI_PARTITION_ENTRY *PartEntry\r
+ IN EFI_PARTITION_TABLE_HEADER *PartHeader,\r
+ IN EFI_PARTITION_ENTRY *PartEntry\r
)\r
{\r
- UINT32 Crc;\r
- UINTN Size;\r
+ UINT32 Crc;\r
+ UINTN Size;\r
\r
- Size = (UINTN)MultU64x32(PartHeader->NumberOfPartitionEntries, PartHeader->SizeOfPartitionEntry);\r
+ Size = (UINTN)MultU64x32 (PartHeader->NumberOfPartitionEntries, PartHeader->SizeOfPartitionEntry);\r
Crc = CalculateCrc32 (PartEntry, Size);\r
\r
- return (BOOLEAN) (PartHeader->PartitionEntryArrayCRC32 == Crc);\r
+ return (BOOLEAN)(PartHeader->PartitionEntryArrayCRC32 == Crc);\r
}\r
\r
/**\r
IN EFI_PARTITION_TABLE_HEADER *PartHdr\r
)\r
{\r
- PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
- EFI_PEI_LBA Lba;\r
- EFI_PEI_LBA AlternateLba;\r
- EFI_PEI_LBA EntryArrayLastLba;\r
+ PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
+ EFI_PEI_LBA Lba;\r
+ EFI_PEI_LBA AlternateLba;\r
+ EFI_PEI_LBA EntryArrayLastLba;\r
\r
- UINT64 PartitionEntryArraySize;\r
- UINT64 PartitionEntryBlockNumb;\r
- UINT32 EntryArraySizeRemainder;\r
+ UINT64 PartitionEntryArraySize;\r
+ UINT64 PartitionEntryBlockNumb;\r
+ UINT32 EntryArraySizeRemainder;\r
\r
ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
\r
AlternateLba = PRIMARY_PART_HEADER_LBA;\r
}\r
\r
- if ( (PartHdr->Header.Signature != EFI_PTAB_HEADER_ID) ||\r
- (PartHdr->Header.Revision != 0x00010000) ||\r
- (PartHdr->Header.HeaderSize < 92) ||\r
- (PartHdr->Header.HeaderSize > ParentBlockDev->BlockSize) ||\r
- (!PartitionCheckGptHeaderCRC (PartHdr)) ||\r
- (PartHdr->Header.Reserved != 0)\r
- ) {\r
+ if ((PartHdr->Header.Signature != EFI_PTAB_HEADER_ID) ||\r
+ (PartHdr->Header.Revision != 0x00010000) ||\r
+ (PartHdr->Header.HeaderSize < 92) ||\r
+ (PartHdr->Header.HeaderSize > ParentBlockDev->BlockSize) ||\r
+ (!PartitionCheckGptHeaderCRC (PartHdr)) ||\r
+ (PartHdr->Header.Reserved != 0)\r
+ )\r
+ {\r
DEBUG ((DEBUG_ERROR, "Invalid efi partition table header\n"));\r
return FALSE;\r
}\r
// 5. Must be remain 128*128 bytes for backup entry array.\r
// 6. SizeOfPartitionEntry must be equals to 128 * 2^n.\r
//\r
- if ( (PartHdr->MyLBA != Lba) ||\r
- (PartHdr->AlternateLBA != AlternateLba) ||\r
- (PartHdr->FirstUsableLBA < 2 + EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||\r
- (PartHdr->LastUsableLBA > ParentBlockDev->LastBlock - 1 - EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||\r
- (PartHdr->FirstUsableLBA > PartHdr->LastUsableLBA) ||\r
- (PartHdr->PartitionEntryLBA < 2) ||\r
- (PartHdr->PartitionEntryLBA > ParentBlockDev->LastBlock - 1) ||\r
- (PartHdr->PartitionEntryLBA >= PartHdr->FirstUsableLBA && PartHdr->PartitionEntryLBA <= PartHdr->LastUsableLBA) ||\r
- (PartHdr->SizeOfPartitionEntry%128 != 0) ||\r
- (PartHdr->SizeOfPartitionEntry != sizeof (EFI_PARTITION_ENTRY))\r
- ) {\r
+ if ((PartHdr->MyLBA != Lba) ||\r
+ (PartHdr->AlternateLBA != AlternateLba) ||\r
+ (PartHdr->FirstUsableLBA < 2 + EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||\r
+ (PartHdr->LastUsableLBA > ParentBlockDev->LastBlock - 1 - EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||\r
+ (PartHdr->FirstUsableLBA > PartHdr->LastUsableLBA) ||\r
+ (PartHdr->PartitionEntryLBA < 2) ||\r
+ (PartHdr->PartitionEntryLBA > ParentBlockDev->LastBlock - 1) ||\r
+ ((PartHdr->PartitionEntryLBA >= PartHdr->FirstUsableLBA) && (PartHdr->PartitionEntryLBA <= PartHdr->LastUsableLBA)) ||\r
+ (PartHdr->SizeOfPartitionEntry%128 != 0) ||\r
+ (PartHdr->SizeOfPartitionEntry != sizeof (EFI_PARTITION_ENTRY))\r
+ )\r
+ {\r
DEBUG ((DEBUG_ERROR, "Invalid efi partition table header\n"));\r
return FALSE;\r
}\r
IN EFI_PARTITION_TABLE_HEADER *PartHdr\r
)\r
{\r
- EFI_STATUS Status;\r
- PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
- PEI_FAT_BLOCK_DEVICE *BlockDevPtr;\r
+ EFI_STATUS Status;\r
+ PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
+ PEI_FAT_BLOCK_DEVICE *BlockDevPtr;\r
\r
- UINT64 PartitionEntryArraySize;\r
- UINT64 PartitionEntryBlockNumb;\r
- UINT32 EntryArraySizeRemainder;\r
+ UINT64 PartitionEntryArraySize;\r
+ UINT64 PartitionEntryBlockNumb;\r
+ UINT32 EntryArraySizeRemainder;\r
\r
- EFI_PARTITION_ENTRY *PartitionEntryBuffer;\r
- EFI_PARTITION_ENTRY_STATUS *PartitionEntryStatus;\r
+ EFI_PARTITION_ENTRY *PartitionEntryBuffer;\r
+ EFI_PARTITION_ENTRY_STATUS *PartitionEntryStatus;\r
\r
- BOOLEAN Found;\r
- EFI_LBA StartingLBA;\r
- EFI_LBA EndingLBA;\r
- UINTN Index;\r
- UINTN Index1;\r
- UINTN Index2;\r
- EFI_PARTITION_ENTRY *Entry;\r
+ BOOLEAN Found;\r
+ EFI_LBA StartingLBA;\r
+ EFI_LBA EndingLBA;\r
+ UINTN Index;\r
+ UINTN Index1;\r
+ UINTN Index2;\r
+ EFI_PARTITION_ENTRY *Entry;\r
\r
PartitionEntryBuffer = NULL;\r
PartitionEntryStatus = NULL;\r
\r
- ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
- Found = FALSE;\r
+ ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
+ Found = FALSE;\r
\r
PartitionEntryArraySize = MultU64x32 (PartHdr->NumberOfPartitionEntries, PartHdr->SizeOfPartitionEntry);\r
EntryArraySizeRemainder = 0;\r
if (EntryArraySizeRemainder != 0) {\r
PartitionEntryBlockNumb++;\r
}\r
+\r
PartitionEntryArraySize = MultU64x32 (PartitionEntryBlockNumb, ParentBlockDev->BlockSize);\r
\r
- PartitionEntryBuffer = (EFI_PARTITION_ENTRY *) AllocatePages (EFI_SIZE_TO_PAGES ((UINTN)PartitionEntryArraySize));\r
+ PartitionEntryBuffer = (EFI_PARTITION_ENTRY *)AllocatePages (EFI_SIZE_TO_PAGES ((UINTN)PartitionEntryArraySize));\r
if (PartitionEntryBuffer == NULL) {\r
DEBUG ((DEBUG_ERROR, "Allocate memory error!\n"));\r
goto EXIT;\r
}\r
\r
- PartitionEntryStatus = (EFI_PARTITION_ENTRY_STATUS *) AllocatePages (EFI_SIZE_TO_PAGES (PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS)));\r
+ PartitionEntryStatus = (EFI_PARTITION_ENTRY_STATUS *)AllocatePages (EFI_SIZE_TO_PAGES (PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS)));\r
if (PartitionEntryStatus == NULL) {\r
DEBUG ((DEBUG_ERROR, "Allocate memory error!\n"));\r
goto EXIT;\r
}\r
+\r
ZeroMem (PartitionEntryStatus, PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS));\r
\r
Status = FatReadBlock (\r
}\r
\r
for (Index1 = 0; Index1 < PartHdr->NumberOfPartitionEntries; Index1++) {\r
- Entry = (EFI_PARTITION_ENTRY *) ((UINT8 *) PartitionEntryBuffer + Index1 * PartHdr->SizeOfPartitionEntry);\r
+ Entry = (EFI_PARTITION_ENTRY *)((UINT8 *)PartitionEntryBuffer + Index1 * PartHdr->SizeOfPartitionEntry);\r
if (CompareGuid (&Entry->PartitionTypeGUID, &gEfiPartTypeUnusedGuid)) {\r
continue;\r
}\r
\r
StartingLBA = Entry->StartingLBA;\r
EndingLBA = Entry->EndingLBA;\r
- if (StartingLBA > EndingLBA ||\r
- StartingLBA < PartHdr->FirstUsableLBA ||\r
- StartingLBA > PartHdr->LastUsableLBA ||\r
- EndingLBA < PartHdr->FirstUsableLBA ||\r
- EndingLBA > PartHdr->LastUsableLBA\r
- ) {\r
+ if ((StartingLBA > EndingLBA) ||\r
+ (StartingLBA < PartHdr->FirstUsableLBA) ||\r
+ (StartingLBA > PartHdr->LastUsableLBA) ||\r
+ (EndingLBA < PartHdr->FirstUsableLBA) ||\r
+ (EndingLBA > PartHdr->LastUsableLBA)\r
+ )\r
+ {\r
PartitionEntryStatus[Index1].OutOfRange = TRUE;\r
continue;\r
}\r
}\r
\r
for (Index2 = Index1 + 1; Index2 < PartHdr->NumberOfPartitionEntries; Index2++) {\r
- Entry = (EFI_PARTITION_ENTRY *) ((UINT8 *) PartitionEntryBuffer + Index2 * PartHdr->SizeOfPartitionEntry);\r
+ Entry = (EFI_PARTITION_ENTRY *)((UINT8 *)PartitionEntryBuffer + Index2 * PartHdr->SizeOfPartitionEntry);\r
if (CompareGuid (&Entry->PartitionTypeGUID, &gEfiPartTypeUnusedGuid)) {\r
continue;\r
}\r
\r
- if (Entry->EndingLBA >= StartingLBA && Entry->StartingLBA <= EndingLBA) {\r
+ if ((Entry->EndingLBA >= StartingLBA) && (Entry->StartingLBA <= EndingLBA)) {\r
//\r
// This region overlaps with the Index1'th region\r
//\r
- PartitionEntryStatus[Index1].Overlap = TRUE;\r
- PartitionEntryStatus[Index2].Overlap = TRUE;\r
+ PartitionEntryStatus[Index1].Overlap = TRUE;\r
+ PartitionEntryStatus[Index2].Overlap = TRUE;\r
continue;\r
}\r
}\r
}\r
\r
for (Index = 0; Index < PartHdr->NumberOfPartitionEntries; Index++) {\r
- if (CompareGuid (&PartitionEntryBuffer[Index].PartitionTypeGUID, &gEfiPartTypeUnusedGuid)||\r
+ if (CompareGuid (&PartitionEntryBuffer[Index].PartitionTypeGUID, &gEfiPartTypeUnusedGuid) ||\r
PartitionEntryStatus[Index].OutOfRange ||\r
PartitionEntryStatus[Index].Overlap ||\r
- PartitionEntryStatus[Index].OsSpecific) {\r
+ PartitionEntryStatus[Index].OsSpecific)\r
+ {\r
//\r
// Don't use null EFI Partition Entries, Invalid Partition Entries or OS specific\r
// partition Entries\r
break;\r
}\r
\r
- Found = TRUE;\r
- BlockDevPtr = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);\r
+ Found = TRUE;\r
+ BlockDevPtr = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);\r
\r
BlockDevPtr->BlockSize = ParentBlockDev->BlockSize;\r
BlockDevPtr->LastBlock = PartitionEntryBuffer[Index].EndingLBA;\r
PartitionEntryBuffer[Index].StartingLBA,\r
ParentBlockDev->BlockSize\r
);\r
- BlockDevPtr->ParentDevNo = ParentBlockDevNo;\r
+ BlockDevPtr->ParentDevNo = ParentBlockDevNo;\r
\r
PrivateData->BlockDeviceCount++;\r
\r
- DEBUG ((DEBUG_INFO, "Find GPT Partition [0x%lx", PartitionEntryBuffer[Index].StartingLBA, BlockDevPtr->LastBlock));\r
+ DEBUG ((DEBUG_INFO, "Find GPT Partition [0x%lx", PartitionEntryBuffer[Index].StartingLBA, BlockDevPtr->LastBlock));\r
DEBUG ((DEBUG_INFO, ", 0x%lx]\n", BlockDevPtr->LastBlock));\r
- DEBUG ((DEBUG_INFO, " BlockSize %x\n", BlockDevPtr->BlockSize));\r
+ DEBUG ((DEBUG_INFO, " BlockSize %x\n", BlockDevPtr->BlockSize));\r
}\r
\r
EXIT:\r
**/\r
BOOLEAN\r
PartitionCheckGptStructure (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo,\r
- IN BOOLEAN IsPrimary\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo,\r
+ IN BOOLEAN IsPrimary\r
)\r
{\r
- EFI_STATUS Status;\r
- PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
- EFI_PARTITION_TABLE_HEADER *PartHdr;\r
- EFI_PEI_LBA GptHeaderLBA;\r
+ EFI_STATUS Status;\r
+ PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
+ EFI_PARTITION_TABLE_HEADER *PartHdr;\r
+ EFI_PEI_LBA GptHeaderLBA;\r
\r
- ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
- PartHdr = (EFI_PARTITION_TABLE_HEADER *) PrivateData->BlockData;\r
+ ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
+ PartHdr = (EFI_PARTITION_TABLE_HEADER *)PrivateData->BlockData;\r
\r
if (IsPrimary) {\r
GptHeaderLBA = PRIMARY_PART_HEADER_LBA;\r
**/\r
BOOLEAN\r
PartitionCheckProtectiveMbr (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
)\r
{\r
- EFI_STATUS Status;\r
- MASTER_BOOT_RECORD *ProtectiveMbr;\r
- MBR_PARTITION_RECORD *MbrPartition;\r
- PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
- UINTN Index;\r
+ EFI_STATUS Status;\r
+ MASTER_BOOT_RECORD *ProtectiveMbr;\r
+ MBR_PARTITION_RECORD *MbrPartition;\r
+ PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
+ UINTN Index;\r
\r
- ProtectiveMbr = (MASTER_BOOT_RECORD *) PrivateData->BlockData;\r
- ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
+ ProtectiveMbr = (MASTER_BOOT_RECORD *)PrivateData->BlockData;\r
+ ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
\r
//\r
// Read Protective MBR\r
//\r
for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {\r
MbrPartition = (MBR_PARTITION_RECORD *)&ProtectiveMbr->Partition[Index];\r
- if (MbrPartition->BootIndicator == 0x00 &&\r
- MbrPartition->StartSector == 0x02 &&\r
- MbrPartition->OSIndicator == PMBR_GPT_PARTITION &&\r
- UNPACK_UINT32 (MbrPartition->StartingLBA) == 1\r
- ) {\r
+ if ((MbrPartition->BootIndicator == 0x00) &&\r
+ (MbrPartition->StartSector == 0x02) &&\r
+ (MbrPartition->OSIndicator == PMBR_GPT_PARTITION) &&\r
+ (UNPACK_UINT32 (MbrPartition->StartingLBA) == 1)\r
+ )\r
+ {\r
return TRUE;\r
}\r
}\r
**/\r
BOOLEAN\r
FatFindGptPartitions (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
)\r
{\r
- BOOLEAN Found;\r
- PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
+ BOOLEAN Found;\r
+ PEI_FAT_BLOCK_DEVICE *ParentBlockDev;\r
\r
if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {\r
return FALSE;\r
}\r
\r
- ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
+ ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
if (ParentBlockDev->BlockSize > PEI_FAT_MAX_BLOCK_SIZE) {\r
DEBUG ((DEBUG_ERROR, "Device BlockSize %x exceed FAT_MAX_BLOCK_SIZE\n", ParentBlockDev->BlockSize));\r
return FALSE;\r
**/\r
BOOLEAN\r
PartitionValidMbr (\r
- IN MASTER_BOOT_RECORD *Mbr,\r
- IN EFI_PEI_LBA LastLba\r
+ IN MASTER_BOOT_RECORD *Mbr,\r
+ IN EFI_PEI_LBA LastLba\r
)\r
{\r
- UINT32 StartingLBA;\r
- UINT32 EndingLBA;\r
- UINT32 NewEndingLBA;\r
- INTN Index1;\r
- INTN Index2;\r
- BOOLEAN MbrValid;\r
+ UINT32 StartingLBA;\r
+ UINT32 EndingLBA;\r
+ UINT32 NewEndingLBA;\r
+ INTN Index1;\r
+ INTN Index2;\r
+ BOOLEAN MbrValid;\r
\r
if (Mbr->Signature != MBR_SIGNATURE) {\r
return FALSE;\r
}\r
+\r
//\r
// The BPB also has this signature, so it can not be used alone.\r
//\r
MbrValid = FALSE;\r
for (Index1 = 0; Index1 < MAX_MBR_PARTITIONS; Index1++) {\r
- if (Mbr->Partition[Index1].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) == 0) {\r
+ if ((Mbr->Partition[Index1].OSIndicator == 0x00) || (UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) == 0)) {\r
continue;\r
}\r
\r
}\r
\r
for (Index2 = Index1 + 1; Index2 < MAX_MBR_PARTITIONS; Index2++) {\r
- if (Mbr->Partition[Index2].OSIndicator == 0x00 || UNPACK_INT32 (Mbr->Partition[Index2].SizeInLBA) == 0) {\r
+ if ((Mbr->Partition[Index2].OSIndicator == 0x00) || (UNPACK_INT32 (Mbr->Partition[Index2].SizeInLBA) == 0)) {\r
continue;\r
}\r
\r
NewEndingLBA = UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) + UNPACK_UINT32 (Mbr->Partition[Index2].SizeInLBA) - 1;\r
- if (NewEndingLBA >= StartingLBA && UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) <= EndingLBA) {\r
+ if ((NewEndingLBA >= StartingLBA) && (UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) <= EndingLBA)) {\r
//\r
// This region overlaps with the Index1'th region\r
//\r
}\r
}\r
}\r
+\r
//\r
// Non of the regions overlapped so MBR is O.K.\r
//\r
**/\r
BOOLEAN\r
FatFindMbrPartitions (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
)\r
{\r
EFI_STATUS Status;\r
return FALSE;\r
}\r
\r
- ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
+ ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);\r
\r
if (ParentBlockDev->BlockSize > PEI_FAT_MAX_BLOCK_SIZE) {\r
- DEBUG((DEBUG_ERROR, "Device BlockSize %x exceeds FAT_MAX_BLOCK_SIZE\n", ParentBlockDev->BlockSize));\r
+ DEBUG ((DEBUG_ERROR, "Device BlockSize %x exceeds FAT_MAX_BLOCK_SIZE\n", ParentBlockDev->BlockSize));\r
return FALSE;\r
}\r
\r
- Found = FALSE;\r
- Mbr = (MASTER_BOOT_RECORD *) PrivateData->BlockData;\r
+ Found = FALSE;\r
+ Mbr = (MASTER_BOOT_RECORD *)PrivateData->BlockData;\r
\r
Status = FatReadBlock (\r
- PrivateData,\r
- ParentBlockDevNo,\r
- 0,\r
- ParentBlockDev->BlockSize,\r
- Mbr\r
- );\r
+ PrivateData,\r
+ ParentBlockDevNo,\r
+ 0,\r
+ ParentBlockDev->BlockSize,\r
+ Mbr\r
+ );\r
\r
if (EFI_ERROR (Status) || !PartitionValidMbr (Mbr, ParentBlockDev->LastBlock)) {\r
goto Done;\r
}\r
+\r
//\r
// We have a valid mbr - add each partition\r
//\r
for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {\r
- if (Mbr->Partition[Index].OSIndicator == 0x00 || UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) == 0) {\r
+ if ((Mbr->Partition[Index].OSIndicator == 0x00) || (UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) == 0)) {\r
//\r
// Don't use null MBR entries\r
//\r
continue;\r
}\r
+\r
//\r
// Register this partition\r
//\r
if (PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE) {\r
-\r
- Found = TRUE;\r
-\r
- BlockDev = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);\r
-\r
- BlockDev->BlockSize = MBR_SIZE;\r
- BlockDev->LastBlock = UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) - 1;\r
- BlockDev->IoAlign = ParentBlockDev->IoAlign;\r
- BlockDev->Logical = TRUE;\r
- BlockDev->PartitionChecked = FALSE;\r
- BlockDev->StartingPos = MultU64x32 (\r
- UNPACK_INT32 (Mbr->Partition[Index].StartingLBA),\r
- ParentBlockDev->BlockSize\r
- );\r
+ Found = TRUE;\r
+\r
+ BlockDev = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);\r
+\r
+ BlockDev->BlockSize = MBR_SIZE;\r
+ BlockDev->LastBlock = UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) - 1;\r
+ BlockDev->IoAlign = ParentBlockDev->IoAlign;\r
+ BlockDev->Logical = TRUE;\r
+ BlockDev->PartitionChecked = FALSE;\r
+ BlockDev->StartingPos = MultU64x32 (\r
+ UNPACK_INT32 (Mbr->Partition[Index].StartingLBA),\r
+ ParentBlockDev->BlockSize\r
+ );\r
BlockDev->ParentDevNo = ParentBlockDevNo;\r
\r
PrivateData->BlockDeviceCount++;\r
**/\r
BOOLEAN\r
FatFindEltoritoPartitions (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
);\r
\r
/**\r
**/\r
BOOLEAN\r
FatFindMbrPartitions (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
);\r
\r
/**\r
**/\r
BOOLEAN\r
FatFindGptPartitions (\r
- IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
- IN UINTN ParentBlockDevNo\r
+ IN PEI_FAT_PRIVATE_DATA *PrivateData,\r
+ IN UINTN ParentBlockDevNo\r
);\r
\r
/**\r
IN PEI_FAT_PRIVATE_DATA *PrivateData\r
)\r
{\r
- BOOLEAN Found;\r
- UINTN Index;\r
+ BOOLEAN Found;\r
+ UINTN Index;\r
\r
do {\r
Found = FALSE;\r
projects / mirror_edk2.git / commitdiff