diff options
Diffstat (limited to 'Core/EM/Recovery/FsRecovery.c')
| -rw-r--r-- | Core/EM/Recovery/FsRecovery.c | 3193 |
1 files changed, 3193 insertions, 0 deletions
diff --git a/Core/EM/Recovery/FsRecovery.c b/Core/EM/Recovery/FsRecovery.c new file mode 100644 index 0000000..b16d7b0 --- /dev/null +++ b/Core/EM/Recovery/FsRecovery.c @@ -0,0 +1,3193 @@ +//********************************************************************** +//********************************************************************** +//** ** +//** (C)Copyright 1985-2009, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//********************************************************************** +//********************************************************************** +// $Header: /Alaska/SOURCE/Core/Modules/Recovery/FsRecovery.c 22 8/09/12 11:13a Pats $ +// +// $Revision: 22 $ +// +// $Date: 8/09/12 11:13a $ +//********************************************************************** +// Revision History +// ---------------- +// $Log: /Alaska/SOURCE/Core/Modules/Recovery/FsRecovery.c $ +// +// 22 8/09/12 11:13a Pats +// [TAG] - EIP 80780 +// [Category] - Function Request +// [Description] - Support for recovery from media formatted with the +// EXT(x) file system. +// [Files] Recovery.c, Recovery.mak, Recovery.sdl, RecoveryCsp.h (bin), +// and FsRecovery.c (source) +// +// 21 4/24/12 11:43a Pats +// [TAG] EIP87223 +// [Category] Bug Fix +// [Symptom] After update EIP#81131 solution, the MBR recovery function +// would fail +// [RootCause] Pointer *Root not being updated correctly in function +// AmiGetFileListFromNtfsVolume(). +// [Solution] Correct updating of pointer *Root. +// +// [Files] FsRecovery.c +// +// 20 1/25/12 2:49p Pats +// [TAG] - EIP 26909 +// [Category] - Function Request +// [Description] - Support for recovery from media formatted with the NTFS +// file system. This of necessity includes detection of GPT partitions, +// which may contain any file system. +// [Files] Recovery.c, Recovery.mak, Recovery.sdl, RecoveryCsp.h (bin), +// and FsRecovery.c (source) +// +// 19 5/13/11 5:07p Artems +// Added secure flash update support +// +// 18 2/05/11 3:22p Artems +// EIP 39463: Added support to override GetFileName function for custom +// recovery capsule name +// +// 17 6/11/10 11:36a Artems +// Added porting hooks for GetRecoveryCapsuleFileName and +// IsRecoveryCapsuleValid +// +// 16 1/05/10 11:59a Robert +// Fixed bug in calculation of byte offset of the beginning of a file on a +// FAT file system. The old code could not handle a file starting address +// above 4GB. It now uses a UINT64 calculation so it can handle it +// +// 15 11/25/09 4:53p Felixp +// sAmiRomFile renamed to RecoveryFileName +// FlashSize renamed ro RecoveryImageSize +// +// 14 8/11/09 2:27p Robert +// - EIP 24689: There was a bug in the wildcard search with FAT that +// caused it not to identify the file properly. +// - The code was expecting string termination. Switched to filename +// length instead. Updated both the FAT file search and the ISO9660 +// search with this. +// - Also added a check for the FAT file system that checks for the 0xE5 +// character that defines an invalid or deleted file. +// +// 13 7/09/09 12:54p Artems +// Removed PeiTrace debugging calls +// +// 12 7/07/09 2:05p Robert +// - Added functionality to search for recovery files that fit one of many +// comma separated pattern strings. +// - Function header updates +// +// 11 7/01/09 4:18p Rameshr +// Coding Standard and File header updated. +// +// 10 6/16/09 5:21p Artems +// EIP 21169 Added Eltorito support +// +// 7 4/13/07 5:37p Ambikas +// Coding standards changes: Added AMI_PHDRs for every function; split +// multiple declarations on a line into single line statements. +// +// 6 10/13/06 11:07a Felixp +// 1. el Torito support added +// 2. Correct partition handling +// +// 5 9/26/06 9:22a Ambikas +// +// 4 6/04/06 9:29p Ambikas +// +// 3 4/13/06 2:02p Ambikas +// +// 1 12/01/05 9:45a Felixp +// +// 4 11/18/05 3:55p Felixp +// bug fix in ReadFileData +// +// 3 6/06/05 1:27p Felixp +// Type parameter removed from AllocatePages to match PEI CIS 0.91 +// +// 2 3/25/05 5:41p Felixp +// small bug fix +// +// 1 3/24/05 3:37p Felixp +// +//********************************************************************** + +//<AMI_FHDR_START> +//---------------------------------------------------------------------- +// +// Name: FsRecovery.c +// +// Description: Recovery Filesytem support +// +//---------------------------------------------------------------------- +//<AMI_FHDR_END> + +#include <AmiPeiLib.h> +#include <Token.h> +#include "Recovery.h" +#include "RecoveryCsp.h" + +#define FAT_FILE_NAME_SIZE 11 + +extern BOOLEAN CdRecoverySupport; +extern BOOLEAN FatRecoverySupport; +extern BOOLEAN NtfsRecoverySupport; +extern BOOLEAN ExtRecoverySupport; + +UINT8 *ReadBuffer = NULL; +UINTN BufferSize = 0; + +UINT8 *FatBuffer = NULL; +UINTN FatBufferSize = 0; + +UINT8 *RootBuffer = NULL; +UINTN RootBufferSize = 0; +UINT32 RootEntries = 0; +UINT32 RootSize = 0; + +DIR_ENTRY *FatRecoveryFiles[10]; +DIR_RECORD *CdRecoveryFiles[10]; +#if NTFS_RECOVERY_SUPPORT +INDEX_ENTRY *NtfsRecoveryFiles[10]; + +//UINT8 MFTRunList[256]; +//UINT8 RootRunList[128]; +//UINT8 ResidentIndex[256]; +BOOLEAN ResidentPresent; +UINT32 ResidentSize; +#endif +#if EXT_RECOVERY_SUPPORT +DIR_ENTRY_EXT *ExtRecoveryFiles[10]; +UINT32 InodeBlock; // First block of inode table +UINT8 Indirect; +UINT32 *BlockList; +UINT32 *BlockList2; +#endif + +UINTN PartCount; +BOOLEAN IsMbr; +UINT32 GpeCount; +UINT32 PartSector; +//MASTER_BOOT_RECORD Mbr; +MEMORY_BLOCK *MemBlk; + +EFI_PEI_SERVICES **ThisPeiServices; +#if SEARCH_FAT_PATH +RC_VOL_INFO *ThisVolume; // Saved volume info for path search +#endif + +//*************************************************************************** + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: toupper +// +// Description: +// Converts lower case characters to upper case +// +// Input: +// IN CHAR8 c - character to convert +// +// Output: +// CHAR8 - converted character value +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +CHAR8 toupper( + IN CHAR8 c ) +{ + return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FileCompare +// +// Description: +// This function takes a filename and a filename pattern and tries to make +// a match. It can account for Wild characters * and ? in the pattern. Also, +// the pattern can be multiple comma separated patterns. +// +// Input: +// IN CHAR8 *RecoveryFileName - recover file pattern string comma separated +// IN CHAR8 *FsFilename - file name to check against the pattern string +// IN BOOLEAN IgnoreSpacesInFilename - If true, ignore spaces in FsFilename when pattern string is a period +// +// Output: +// TRUE - Pattern matches filename +// FALSE - Pattern doesn't match filename +// +// Notes: +// RecoveryFileNamePattern is taken from the RECOVERY_ROM token and should look +// like this: *.rom,ab??rt??.bio,123.bin etc. +// The Parameter IgnoreSpacesInFilename is for use with file systems that pad +// spaces into filenames and don't use periods. If TRUE, it matches a period +// in the pattern to any number of spaces in the filename. +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN FileCompare( + IN CHAR8 *RecoveryFileNamePattern, + IN CHAR8 *FsFilename, + IN BOOLEAN IgnoreSpacesInFilename, + IN UINT32 FileNameLength) +{ + CHAR8 ch1, ch; + UINTN len1, len2; + + for (; ;) { + // check length of string + len1 = Strlen(FsFilename); + len2 = Strlen(RecoveryFileNamePattern); + + // if len1 is 0 then at end of filename + if(!len1 || !FileNameLength) + { + // if len2 is 0 then also at end of pattern so file name is + // equal to a pattern + if(!len2 ) + return TRUE; + else + { + // if len2 is a comma, then it is the same as len2 == 0 so + // file name is equal to a pattern + ch1 = *RecoveryFileNamePattern; + if (ch1 == ',') + { + return TRUE; + } + // if not a comma or 0, then file does not fit the pattern + return FALSE; + } + } + + // get next character of the pattern + ch1 = *RecoveryFileNamePattern; + RecoveryFileNamePattern ++; + + switch (ch1) + { + case ',': + return TRUE; + break; + + case 0: // reached string terminator + return TRUE; + break; + + // wild character, it must deal with any number of matching characters + // in the file name string + case '*': + while (*FsFilename) + { + if (FileCompare (RecoveryFileNamePattern, FsFilename, IgnoreSpacesInFilename, FileNameLength)) + { + return TRUE; + } + FsFilename ++; + FileNameLength--; + } + return FileCompare (RecoveryFileNamePattern, FsFilename, IgnoreSpacesInFilename, FileNameLength); + break; + + // wild character, it must deal with a matching character in the file name string + case '?': + if (!*FsFilename) + { + return FALSE; + } + + FsFilename ++; + FileNameLength--; + break; + + // in this case statement the case '.' must be directly above the default case. + // if IgnoreSpacesInFilename is FALSE, it is supposed to fall through into default. + // If IgnoreSpacesInFilenameis TRUE, process the period as a check for spaces character. + // then once we skip over all spaces, if there are any, then it moves to the + // next character in the pattern + case '.': + // FAT, spaces added to file name to make 8 3 -- no period in the filename either + if (IgnoreSpacesInFilename == TRUE) + { + ch = *FsFilename; + + while ((ch == ' ') && (ch != 0)) + { + FsFilename ++; + FileNameLength--; + ch = *FsFilename; + } + break; + } + // CDFS, no spaces and there is a period. Let it fall through to the default case + default: + ch = *FsFilename; + if (toupper(ch) != toupper(ch1)) + { + return FALSE; + } + FsFilename ++; + FileNameLength--; + break; + } + } +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FileSearch +// +// Description: +// Wrapper function for parsing through a pattern string with multiple entries +// Each entry is comma separated and can include wild characters like * and ? +// The Function can handle CDFS and FAT file systems. +// +// Input: +// IN CHAR8 *RecoveryFileName - recover file pattern string comma separated +// IN CHAR8 *FsFilename - file name to check against the pattern string +// IN BOOLEAN IgnoreSpacesInFilename - If true, ignore spaces in FsFilename when pattern string is a period +// +// Output: +// EFI_SUCCESS - File name fits one of the Pattern strings in RecoveryFileName +// EFI_INVALID_PARAMETER - one of the strings is NULL or file name doesn't fit pattern string +// +// Notes: +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS FileSearch( + IN CHAR8 *RecoveryFileName, + IN CHAR8 *FsFilename, + IN BOOLEAN IgnoreSpacesInFilename, + IN UINT32 FileNameLength) +{ + CHAR8 *RecStrPtr = RecoveryFileName; + CHAR8 *FilenamePtr = FsFilename; + + if (*RecStrPtr == 0) + { + return EFI_INVALID_PARAMETER; + } + + if (*FsFilename == 0) + { + return EFI_INVALID_PARAMETER; + } + + if (FileNameLength == 0 ) + { + return EFI_INVALID_PARAMETER; + } + + + // loop until all possibilities listed in the RecoveryFileName are exhausted + do { + // Now compare the current possiblity to the current filename + FilenamePtr = FsFilename; + + if (*RecStrPtr == ',') + RecStrPtr++; + + if (FileCompare(RecStrPtr, FsFilename, IgnoreSpacesInFilename, FileNameLength) == TRUE) + return EFI_SUCCESS; + + while (*RecStrPtr != ',' && *RecStrPtr != 0) + RecStrPtr ++; + + } while (*RecStrPtr != 0); + + return EFI_INVALID_PARAMETER; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ConvertToFatFileName +// +// Description: +// Converts file name from "XXXXX.XXX" form to FAT form +// +// Input: +// IN CHAR8 *inFileName - pointer to input file name +// OUT CHAR8 *outFileName - pointer to output file name +// +// Output: None +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID ConvertToFatFileName( + IN CHAR8 *inFileName, + OUT CHAR8 *outFileName ) +{ + UINT32 i = 0; + UINT32 j = 0; + + for ( i = 0; inFileName[i] && inFileName[i] != '.'; i++ ) { + outFileName[i] = toupper( inFileName[i] ); + } + j = i; + + for (; i < 8; i++ ) { + outFileName[i] = ' '; + } + + if ( inFileName[j] == '.' ) { + for ( j++; inFileName[j]; i++, j++ ) { + outFileName[i] = toupper( inFileName[j] ); + } + } + + for (; i < 11; i++ ) { + outFileName[i] = ' '; + } + outFileName[i] = 0; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ReadDevice +// +// Description: Reads data from Block device +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN RC_VOL_INFO *Volume - pointer to volume description structure +// IN UINT64 Start - starting offset in bytes +// IN UINTN Size - size of the data to read +// VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_SUCCESS +// Errors +// - returns either the error status from Allocate Pages or Read Blocks +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ReadDevice( + IN EFI_PEI_SERVICES **PeiServices, + IN RC_VOL_INFO *Volume, + IN UINT64 Start, + IN UINTN Size, + OUT VOID *Buffer ) +{ + UINT64 StartLba; + UINTN ActualSize; + UINTN ActualPages; + UINT32 StartOffset; + EFI_STATUS Status; + EFI_PHYSICAL_ADDRESS Allocate; + + Start += Volume->PartitionOffset; + + if ( Volume->BlockSize == 4096 ) { + StartLba = Shr64( Start, 12 ); + StartOffset = (UINT32)( Start & 0xfff ); + } else if ( Volume->BlockSize == 2048 ) { + StartLba = Shr64( Start, 11 ); + StartOffset = (UINT32)( Start & 0x7ff ); + } else { + StartLba = Shr64( Start, 9 ); + StartOffset = (UINT32)( Start & 0x1ff ); + } + + ActualSize = ((StartOffset + Size + Volume->BlockSize - 1) / Volume->BlockSize) * Volume->BlockSize; + ActualPages = EFI_SIZE_TO_PAGES( ActualSize ); + + if ( BufferSize < EFI_PAGES_TO_SIZE( ActualPages )) { + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, ActualPages, &Allocate ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + ReadBuffer = (UINT8*)((UINTN)Allocate); + BufferSize = EFI_PAGES_TO_SIZE( ActualPages ); + } + + Status = Volume->BlkIo->ReadBlocks( PeiServices, + Volume->BlkIo, + Volume->Device, + StartLba, + ActualSize, + ReadBuffer ); + + if ( !EFI_ERROR( Status )) { + MemCpy( Buffer, ReadBuffer + StartOffset, Size ); + } + + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsFat +// +// Description: +// Checks if given data block describes FAT structure +// +// Input: +// BOOT_SECTOR *pBpb - pointer to data block to check +// +// Output: +// TRUE - data block is a FAT structure +// FALSE - data block is not a FAT structure +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN IsFat( + IN BOOT_SECTOR *pBpb ) +{ + return pBpb->BytsPerSec <= 4096 + && pBpb->SecPerClus && pBpb->SecPerClus <= 128 + && pBpb->RsvdSecCnt + && pBpb->NumFATs + && pBpb->Signature == 0xAA55 + && (pBpb->jmp[0] == 0xEB || pBpb->jmp[0] == 0xE9); +} + +#if NTFS_RECOVERY_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsNtfs +// +// Description: +// Checks if given data block describes NTFS structure +// +// Input: +// BOOT_SECTOR *pBpb - pointer to data block to check +// +// Output: +// TRUE - data block is a NTFS structure +// FALSE - data block is not a NTFS structure +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN IsNtfs( + IN BOOT_SECTOR *pBpb ) +{ + return pBpb->NumFATs == 0 + && pBpb->TotSec16 == 0 + && pBpb->TotSec32 == 0 + && pBpb->Fat.Ntfs.TotSec64 != 0 + && pBpb->OEMName[0] == 0x4E // Name must be "NTFS" + && pBpb->OEMName[1] == 0x54 + && pBpb->OEMName[2] == 0x46 + && pBpb->OEMName[3] == 0x53 + && pBpb->Signature == 0xAA55 + && (pBpb->jmp[0] == 0xEB || pBpb->jmp[0] == 0xE9); +} +#endif + +#if EXT_RECOVERY_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: IsExt +// +// Description: +// Checks if given data block describes EXT Superblock structure +// +// Input: +// VOLUME_SB *pSb - pointer to data block to check +// +// Output: +// TRUE - data block is a EXT Superblock structure +// FALSE - data block is not a EXT Superblock structure +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +BOOLEAN IsExt( + IN VOLUME_SB *pSb ) +{ + return pSb->SB_Magic == 0xEF53 + && pSb->SB_BlockSize < 4 + && pSb->SB_FirstBlock < 2 + && pSb->SB_FreeBlocks < pSb->SB_TotalBlocks + && pSb->SB_FreeInodes < pSb->SB_TotalInodes; +} +#endif + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetClustersCount +// +// Description: +// Returns number of clusters for given cluster chain +// +// Input: +// IN UINT8 FatType - FAT type (FAT12, FAT16 or FAT32) +// IN UINT32 CurrentCluster - first cluster of cluster chain +// UINT32 *NextCluster - first cluster of next cluster chain if there is break +// IN BOOLEAN Continuous - if TRUE, returns only number of subsequent clusters in chain +// if FALSE, returns total number of clusters in cluster chain +// +// Output: +// UINT32 - number of clusters +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +UINT32 GetClustersCount( + IN UINT8 FatType, + IN UINT32 CurrentCluster, + OUT UINT32 *NextCluster, + IN BOOLEAN Continuous ) +{ + UINT32 Count = 0; + UINT32 WorkCluster; + UINT32 Cluster = CurrentCluster; + + if ( FatType == FAT16 ) { + UINT16 *Fat16 = (UINT16*)FatBuffer; + while ( TRUE ) + { + Count++; + WorkCluster = Fat16[Cluster]; + + if ( WorkCluster > 0xfff8 ) { + *NextCluster = 0; + break; + } + + if ( WorkCluster != Cluster + 1 && Continuous ) { + *NextCluster = WorkCluster; + break; + } + Cluster = WorkCluster; + } + } else if ( FatType == FAT32 ) { + UINT32 *Fat32 = (UINT32*)FatBuffer; + while ( TRUE ) + { + Count++; + WorkCluster = Fat32[Cluster] & 0xfffffff; + + if ( WorkCluster > 0xffffff8 ) { + *NextCluster = 0; + break; + } + + if ( WorkCluster != Cluster + 1 && Continuous ) { + *NextCluster = WorkCluster; + break; + } + Cluster = WorkCluster; + } + } else { + while ( TRUE ) { + Count++; + WorkCluster = *(UINT16*)(FatBuffer + Cluster + Cluster / 2); + WorkCluster = (Cluster & 1) ? WorkCluster >> 4 : WorkCluster & 0xfff; + + if ( WorkCluster > 0xff8 ) { + *NextCluster = 0; + break; + } + + if ( WorkCluster != Cluster + 1 && Continuous ) { + *NextCluster = WorkCluster; + break; + } + Cluster = WorkCluster; + } + } + return Count; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetFatData +// +// Description: +// Reads data from FAT device +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN RC_VOL_INFO *Volume - pointer to volume description structure +// IN UINT32 FirstCluster - starting cluster +// IN UINTN Size - size of the data to read +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_SUCCESS - correctly read all FAT data +// EFI_ABORTED - should never get this. +// Other - any errors reported from ReadDevice function +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS GetFatData( + IN EFI_PEI_SERVICES **PeiServices, + IN RC_VOL_INFO *Volume, + IN UINT32 FirstCluster, + IN UINTN Size, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; + UINT32 Count; + UINT32 NextCluster; + UINT32 Cluster = FirstCluster; + UINTN SizeToRead; + + while ( TRUE ) + { + SizeToRead = Size; + Count = GetClustersCount( Volume->FatType, Cluster, &NextCluster, TRUE ); + SizeToRead = (SizeToRead > Count * Volume->BytesPerCluster) ? Count * Volume->BytesPerCluster : SizeToRead; + Status = ReadDevice( PeiServices, + Volume, + Volume->DataOffset + Mul64((UINT64)(Cluster - 2), Volume->BytesPerCluster), + SizeToRead, + Buffer ); + + if ( EFI_ERROR( Status ) || NextCluster == 0 ) { + return Status; + } + + Cluster = NextCluster; + (UINT8*)Buffer += SizeToRead; + Size -= SizeToRead; + } + return EFI_ABORTED; //should never get here +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: GetFatType +// +// Description: +// Prepares given volume for read operations. Reads FAT table, root directory, +// determines FAT type +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN BOOT_SECTOR *Bs - pointer to MBR or diskette FAT data +// +// Output: +// EFI_STATUS - possible return values from ReadDevice, AllocatePages, GetFatData +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS GetFatType( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN BOOT_SECTOR *Bs ) +{ + EFI_STATUS Status; + UINT32 TotalSectors; + UINT32 FatSectors; + UINT32 RootSectors; + UINT32 DataSectors; + UINT32 RootSize; + UINT32 FatSize; + UINT32 DataClusters; + UINT32 RootClusters; + UINT32 DummyCluster; + UINTN FatPages; + UINTN RootPages; + EFI_PHYSICAL_ADDRESS Allocate; + + FatSectors = (Bs->FATSz16 != 0) ? Bs->FATSz16 : Bs->Fat.Fat32.FATSz32; + FatSize = FatSectors * Bs->BytsPerSec; + TotalSectors = (Bs->TotSec16 != 0) ? Bs->TotSec16 : Bs->TotSec32; + RootSectors = ((Bs->RootEntCnt * 32) + (Bs->BytsPerSec - 1)) / Bs->BytsPerSec; + RootSize = RootSectors * Bs->BytsPerSec; + DataSectors = TotalSectors - RootSectors - FatSectors * Bs->NumFATs - Bs->RsvdSecCnt; + DataClusters = DataSectors / Bs->SecPerClus; + + Volume->FatOffset = Bs->RsvdSecCnt * Bs->BytsPerSec; + Volume->RootOffset = Volume->FatOffset + FatSectors * Bs->NumFATs * Bs->BytsPerSec; + Volume->DataOffset = Volume->RootOffset + RootSize; + Volume->BytesPerCluster = Bs->BytsPerSec * Bs->SecPerClus; + Volume->FatType = (DataClusters >= 65525) ? FAT32 : ((DataClusters < 4085) ? FAT12 : FAT16); + + RootEntries = Bs->RootEntCnt; + + // + //Read FAT table + // + FatPages = EFI_SIZE_TO_PAGES( FatSize ); + + if ( FatBufferSize < EFI_PAGES_TO_SIZE( FatPages )) { + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, FatPages, &Allocate ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + FatBuffer = (UINT8*)((UINTN)Allocate); + FatBufferSize = EFI_PAGES_TO_SIZE( FatPages ); + } + MemSet( FatBuffer, FatBufferSize, 0 ); + Status = ReadDevice( PeiServices, Volume, Volume->FatOffset, FatSize, FatBuffer ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + // + //Read Root directory + // + if ( RootSize == 0 ) { + // + //in case of FAT32 it will be so at this time + // + RootClusters = GetClustersCount( FAT32, Bs->Fat.Fat32.RootClus, &DummyCluster, FALSE ); + RootSize = RootClusters * Volume->BytesPerCluster; + RootEntries = RootSize / 32; + } + + RootPages = EFI_SIZE_TO_PAGES( RootSize ); + + if ( RootBufferSize < EFI_PAGES_TO_SIZE( RootPages )) { + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, RootPages, &Allocate ); + if ( EFI_ERROR( Status )) { + return Status; + } + + RootBuffer = (UINT8*)((UINTN)Allocate); + RootBufferSize = EFI_PAGES_TO_SIZE( RootPages ); + } + MemSet( RootBuffer, RootBufferSize, 0 ); + + if ( Volume->FatType == FAT32 ) { + Status = GetFatData( PeiServices, Volume, Bs->Fat.Fat32.RootClus, RootSize, RootBuffer ); + } + else { + Status = ReadDevice( PeiServices, Volume, Volume->RootOffset, RootSize, RootBuffer ); + } + + return Status; + +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessFatVolume +// +// Description: +// Reads recovery capsule from FAT volume +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessFatVolume( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; +// BOOT_SECTOR Bs; + UINT32 i; + UINT32 FirstFileCluster; + UINTN NumberOfFiles; + + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Bs ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + if (!IsFat( &MemBlk->Bs )) { + return EFI_NOT_FOUND; + } + + Status = GetFatType( PeiServices, Volume, &MemBlk->Bs ); +#if SEARCH_FAT_PATH + ThisVolume = Volume; // Save volume info for path search +#endif + + if ( EFI_ERROR( Status )) { + return Status; + } + + GetFileListFromFatVolume((DIR_ENTRY*)RootBuffer, RootEntries, &NumberOfFiles, FatRecoveryFiles); + // + if ( NumberOfFiles == 0 ) + return EFI_NOT_FOUND; + + for(i = 0; i < NumberOfFiles; i++) { + if ( *FileSize < FatRecoveryFiles[i]->FileSize ) + continue; + + FirstFileCluster = (FatRecoveryFiles[i]->FirstClusterHi << 16) + FatRecoveryFiles[i]->FirstClusterLo; + + Status = GetFatData( PeiServices, Volume, FirstFileCluster, FatRecoveryFiles[i]->FileSize, Buffer ); + if(EFI_ERROR(Status)) + continue; + + if(IsValidFile(Buffer, FatRecoveryFiles[i]->FileSize)) { + *FileSize = FatRecoveryFiles[i]->FileSize; + return EFI_SUCCESS; + } + } + return EFI_NOT_FOUND; +} + +#if NTFS_RECOVERY_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: GetRunListElementData +// +// Description: (NTFS) Retrieves the count and cluster of a run from a run list element +// +// Parameters: UINT8 **pRunList - Pointer to the run list, updated if +// UpdateList is TRUE. +// UINT64 *ClusterCount - Length of this run in clusters. +// UINT64 *Cluster - Starting cluster of this run. +// BOOLEAN UpdateList - Update list pointer to next element if TRUE. +// +// Return value: EFI_STATUS Status (EFI_SUCCESS or EFI_END_OF_FILE) +// +// Modified: +// +// Referral(s): +// +// NOTE(S): A run list element has 3 parts -- a size byte, a Cluster +// count, and a Cluster Number. +// The low nibble of the size byte is the size of the Count +// in bytes. The high nibble is the size of the Offset in +// bytes. The element is therefore 1 + (low nibble) + (high +// nibble) bytes long. +// The cluster number is a signed number. The new cluster is +// added to the old one to get the result. So if the new +// cluster lies before the old one on the disk, it will be +// a negative number. +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +GetRunListElementData ( + UINT8 **pRunList, + UINT64 *ClusterCount, + UINT64 *Cluster, + BOOLEAN UpdateList + ) +{ + UINT64 TempCount = 0; + UINT64 TempCluster = 0; + UINT64 LeftFill = 0; + UINT8 LowNibble; + UINT8 HighNibble; + UINT8 i, HighByte; + UINT8 *RunListPtr; + +// +// If the size byte is 0, we have reached the end of the file. +// + RunListPtr = *pRunList; + if (RunListPtr[0] == 0) + { + return EFI_END_OF_FILE; + } + + LowNibble = RunListPtr[0] & 0xF; + HighNibble = RunListPtr[0] >> 4; + RunListPtr++; +// +// Get run length. +// + for (i=LowNibble; i>0; i--) + { + TempCount = Shl64(TempCount, 8); + TempCount += RunListPtr[i-1]; + } + RunListPtr += LowNibble; +// +// Get the run offset. +// + HighByte = RunListPtr[HighNibble-1]; + for (i=HighNibble; i>0; i--) + { + TempCluster = Shl64(TempCluster, 8); + TempCluster += RunListPtr[i-1]; + } + RunListPtr += HighNibble; +// +// If the offset is negative, left-fill the empty bytes with 0xFF. +// + if ((HighByte & 0x80) && (HighNibble < 8)) + { + for (i=8; i>HighNibble; i--) + { + LeftFill = Shr64(LeftFill, 8); + LeftFill |= 0xFF00000000000000; + } + TempCluster |= LeftFill; + } + + *Cluster += TempCluster; + *ClusterCount = TempCount; + if (UpdateList) *pRunList = RunListPtr; + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: GetFrAttribute +// +// Description: (NTFS) Retrieves a File Record Attribute by it's number from a +// File Record. +// +// Parameters: UINT8 *BufferIn - Pointer to a buffer containing a file record +// UINT8 AttributeNumber - Number of the attribute to retrieve +// UINTN **BufferOut - Points to the attribute in the buffer +// +// Return value: EFI_STATUS Status (EFI_SUCCESS or EFI_NOT_FOUND) +// +// Modified: +// +// Referral(s): +// +// Note(s): Attributes are in sequential order, so, for example, +// if we're looking for 30, and we find 10 and then 40, +// we know there is no 30 in the record. +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS +GetFrAttribute ( + UINT8 *BufferIn, + UINT8 AttributeNumber, + UINT8 **BufferOut + ) +{ + UINT8 *TempBuffer; + + TempBuffer = BufferIn; + +// +// Point to 1st attribute. +// + TempBuffer += ((MFT_FILE_RECORD*)TempBuffer)->FR_AttributeOffset; +// +// Search for the attribute. +// + while (TempBuffer[0] != AttributeNumber) + { + if (TempBuffer[0] > AttributeNumber) return EFI_NOT_FOUND; + if (TempBuffer[0] == 0xFF) return EFI_NOT_FOUND; + if ( ((FR_ATTR_HEADER_RES*)TempBuffer)->AHR_Length == 0 ) + return EFI_NOT_FOUND; + TempBuffer += ((FR_ATTR_HEADER_RES*)TempBuffer)->AHR_Length; + } + + *BufferOut = TempBuffer; + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: GetFileRecord +// +// Description: (NTFS) Returns the file record specified by MFTRecordNo in a buffer. +// +// Parameters: VOLUME_INFO *Vi - Volume Info Structure +// BOOT_SECTOR *Bs - Boot sector structure +// UINT64 MFTRecordNo - MFT Record number to get +// UINT8 *Buffer - Buffer to read record into +// UINT64 *MFTSector - Sector where record found +// +// Return value: EFI_STATUS Status (EFI_SUCCESS or EFI_NOT_FOUND) +// +// Modified: +// +// Referral(s): +// +// NOTE(S): The File Records in the Master File Table are numbered +// sequentially. We just have to count our way through the +// MFT's run list until we find it. +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> + +EFI_STATUS +GetFileRecord ( + EFI_PEI_SERVICES **PeiServices, + RC_VOL_INFO *Volume, + BOOT_SECTOR *Bs, + UINT64 MFTRecordNo, + UINT8 *FrBuffer, + UINT64 *MFTSector OPTIONAL + ) +{ + EFI_STATUS Status; + UINT8 *pRunList; + UINT64 Cluster; + UINT64 Sector; + UINT64 Count; + UINT64 ByteCount; + UINT32 SecPerRecord = 1; + UINT64 RecordCount; + UINT32 BytesPerCluster; + UINT64 Offset; + UINT32 RecordSize; + + Cluster = 0; + pRunList = &MemBlk->MFTRunList[0]; + + MFTRecordNo &= MAXIMUM_RECORD_NUMBER; // Isolate number part + + Status = GetRunListElementData(&pRunList, &Count, &Cluster, TRUE); + BytesPerCluster = Bs->BytsPerSec * Bs->SecPerClus; + ByteCount = Mul64(Count, BytesPerCluster); + if ( Bs->BytsPerSec <= FILE_RECORD_SIZE ) { + SecPerRecord = FILE_RECORD_SIZE / Bs->BytsPerSec; + RecordSize = FILE_RECORD_SIZE; + } else { // Special case for 4k sectors + SecPerRecord = 1; + RecordSize = (UINT32)Bs->BytsPerSec; + } +//###DEBUG CHANGE NEEDED LATER //// +// In NTFS, the cluster size can be 512 bytes to 4096 bytes. +// File records are 1024 bytes +// For now, we're going to assume a cluster size of 1024 bytes or more. +//////////////////////////// + + Sector = Mul64(Cluster, Bs->SecPerClus); + RecordCount = 0; + do { + if (ByteCount > 0) + { + Sector += SecPerRecord; + ByteCount -= RecordSize; + } else { // We've used up a run, read from the next one. + Status = GetRunListElementData(&pRunList, &Count, &Cluster, TRUE); + if (EFI_ERROR(Status)) return EFI_NOT_FOUND; + ByteCount = Mul64(Count, BytesPerCluster); + Sector = Mul64(Cluster, Bs->SecPerClus); + continue; + } + RecordCount++; + } while (RecordCount < MFTRecordNo); // Record numbers are 0-based. +// +// We found the sector of the file record wanted. Now read it. +// + Offset = Mul64( Sector, Bs->BytsPerSec ); + Status = ReadDevice( PeiServices, Volume, Offset, RecordSize, FrBuffer ); + if (EFI_ERROR(Status)) return EFI_NOT_FOUND; +// +// A File recored begins with "FILE". Check it. +// + if ( (FrBuffer[0] != 0x46) || \ + (FrBuffer[1] != 0x49) || \ + (FrBuffer[2] != 0x4C) || \ + (FrBuffer[3] != 0x45) ) return EFI_NOT_FOUND; + + *MFTSector = Sector; // Return sector where the record was found + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ReadNTFSFile +// +// Description: +// Reads a file from a device formatted in NTFS. +// +// Input: +// Parameters: VOLUME_INFO *Vi - Volume Info Structure +// BOOT_SECTOR *Bs - Boot sector structure +// UINT8 *RunList - Run List of file to read +// VIOD *Buffer - Buffer to read into +// UINT64 *Size - Size of file to read +// +// Output: +// EFI_STATUS - possible return values +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ReadNTFSFile( + IN EFI_PEI_SERVICES **PeiServices, + RC_VOL_INFO *Volume, + BOOT_SECTOR *Bs, + UINT8 *RunList, + VOID *Buffer, + UINT64 *Size ) +{ + UINT64 TotalContiguousBytes; + UINT64 TotalBytesRead = 0; + UINT64 AbsByte; + UINT64 AccessBytes; + UINT64 ClusterCount; + UINT64 Cluster = 0; + EFI_STATUS Status; + + Status = GetRunListElementData(&RunList, &ClusterCount, + &Cluster, TRUE); + do { + TotalContiguousBytes = Mul64(ClusterCount, + Bs->SecPerClus); + TotalContiguousBytes = Mul64(TotalContiguousBytes, + Bs->BytsPerSec); + if ( TotalContiguousBytes > *Size) AccessBytes = *Size; + + else AccessBytes = TotalContiguousBytes; + + AbsByte = Mul64( Cluster, Bs->SecPerClus ); + AbsByte = Mul64( AbsByte, Bs->BytsPerSec ); + + if (AccessBytes == 0) { + return EFI_VOLUME_CORRUPTED; // Will happen if early EOF. + } + + Status = ReadDevice( PeiServices, + Volume, + AbsByte, + (UINTN)AccessBytes, + Buffer ); + + if (EFI_ERROR(Status)) { + break; + } + + (UINT8 *)Buffer += AccessBytes; + TotalBytesRead +=AccessBytes; + + *Size -= AccessBytes; + + if (AccessBytes == TotalContiguousBytes) + { + Status = GetRunListElementData (&RunList, &ClusterCount, + &Cluster, TRUE); + if (EFI_ERROR(Status)) break; // Error here means EOF. + } + + } while (*Size); + + *Size = (UINT32)TotalBytesRead; + return EFI_SUCCESS; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ReadNTFSRoot +// +// Description: +// Prepares given volume for read operations. Reads NTFS root directory. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN BOOT_SECTOR *Bs - pointer to MBR +// +// Output: +// EFI_STATUS - possible return values +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ReadNTFSRoot( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN BOOT_SECTOR *Bs ) +{ + UINT8 FrBuffer[FILE_RECORD_SIZE]; // This needs to be 4096 for 4k secs. + UINT8 *Buffer2; + UINT8 *Buffer3; + UINT8 *pRunList; + EFI_STATUS Status; + UINT64 TotalSectors; + UINT64 DataSectors; + UINT64 Temp64; + UINT32 Temp32; + UINT16 Temp16; + UINT32 IndexSize; + UINT64 Cluster = 0; + UINT64 ClusterCount; + UINT64 TmpRootSize; + UINTN RootPages; + EFI_PHYSICAL_ADDRESS Allocate; + + TotalSectors = Bs->Fat.Ntfs.TotSec64; + DataSectors = TotalSectors - Bs->RsvdSecCnt; + + Temp64 = Mul64( Bs->Fat.Ntfs.MFTClus, Bs->SecPerClus ); + Volume->FatOffset = Mul64( Temp64, Bs->BytsPerSec ); // For NTFS, FatOffset is MFT Offset + + // + // Read the first file record of the MFT, to get the MFT run list. + // + Status = ReadDevice( PeiServices, Volume, Volume->FatOffset, FILE_RECORD_SIZE, FrBuffer ); + if ( EFI_ERROR( Status )) { + return Status; + } + Buffer2 = &FrBuffer[0]; + Status = GetFrAttribute( Buffer2, FR_ATTRIBUTE_DATA, &Buffer2 ); // Get data attribute + if ( EFI_ERROR( Status )) { + return Status; + } + Buffer2 += ((FR_ATTR_HEADER_NONRES*)Buffer2)->AHNR_RunOffset; // Point to run list + MemCpy( MemBlk->MFTRunList, Buffer2, 256 ); // Copy MFT run list + // + // Get the root directory file record, to get its run list. + // + Buffer2 = &FrBuffer[0]; + Status = GetFileRecord( PeiServices, Volume, Bs, 5, Buffer2, NULL ); // Root is always record no. 5 + if ( EFI_ERROR( Status )) { + return Status; + } + // + // Check for a resident index. It will be in the Index Root Attribute. + // If one if found, it will be saved for searching later. + // + ResidentPresent = FALSE; + Buffer3 = Buffer2; + Status = GetFrAttribute( Buffer2, FR_ATTRIBUTE_INDEX_ROOT, &Buffer3 ); + if ( Status == EFI_SUCCESS) { // Root Attribute found + Temp16 = ((FR_ATTR_HEADER_RES*)Buffer3)->AHR_InfoOffset; + Buffer3 += Temp16; + IndexSize = ((FR_INDEX_ROOT_ATTRIBUTE*)Buffer3)->IRA_TotalSize; + Temp32 = ((FR_INDEX_ROOT_ATTRIBUTE*)Buffer3)->IRA_Offset; + Buffer3 += Temp32 + EFI_FIELD_OFFSET(FR_INDEX_ROOT_ATTRIBUTE, IRA_Offset); + if (IndexSize >= MINIMUM_ENTRY_SIZE) { // Resident index is not empty + MemCpy ( MemBlk->ResidentIndex, Buffer3, IndexSize ); + ResidentPresent = TRUE; + ResidentSize = IndexSize; + } + } + // + // Now, check for a non-resident index. + // + Status = GetFrAttribute( Buffer2, FR_ATTRIBUTE_INDEX_ALLOC, &Buffer2 ); + if ( EFI_ERROR( Status )) { + return Status; + } + Buffer2 += ((FR_ATTR_HEADER_NONRES*)Buffer2)->AHNR_RunOffset; // Point to run list + MemCpy( MemBlk->RootRunList, Buffer2, 128 ); // Copy Root run list + // + // Calculate root directory size by running its run list. + // + pRunList = &MemBlk->RootRunList[0]; + TmpRootSize = 0; + Cluster = 0; + do { + Status = GetRunListElementData( &pRunList, &ClusterCount, &Cluster, TRUE ); + if ( Status == EFI_SUCCESS ) TmpRootSize += ClusterCount; + } while ( Status == EFI_SUCCESS ); + TmpRootSize = Mul64 ( TmpRootSize, Bs->SecPerClus ); + TmpRootSize = Mul64 ( TmpRootSize, Bs->BytsPerSec ); + + Buffer2 = &FrBuffer[0]; + RootPages = EFI_SIZE_TO_PAGES( TmpRootSize ); + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, RootPages, &Allocate ); + if ( EFI_ERROR( Status )) { + return Status; + } + RootBuffer = (UINT8*)((UINTN)Allocate); + RootBufferSize = EFI_PAGES_TO_SIZE( RootPages ); + MemSet( RootBuffer, RootBufferSize, 0 ); + + pRunList = &MemBlk->RootRunList[0]; + Status = ReadNTFSFile( PeiServices, Volume, Bs, pRunList, RootBuffer, &TmpRootSize ); + RootSize = (UINT32)TmpRootSize; + + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessNTFSVolume +// +// Description: +// Reads recovery capsule from NTFS volume +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessNTFSVolume( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; +// BOOT_SECTOR Bs; + UINT32 i; + UINTN NumberOfFiles; + UINT64 MFTRecord; + UINT8 *TmpBuffer; + UINT8 *pRunList; + UINT64 TmpFileSize; + + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Bs ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + if (!IsNtfs( &MemBlk->Bs )) { + return EFI_NOT_FOUND; + } + + Status = ReadNTFSRoot( PeiServices, Volume, &MemBlk->Bs ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + GetFileListFromNtfsVolume((UINT8*)RootBuffer, RootSize, &NumberOfFiles, NtfsRecoveryFiles); + + if ( NumberOfFiles == 0 ) + return EFI_NOT_FOUND; + + for(i = 0; i < NumberOfFiles; i++) { + if ( *FileSize < NtfsRecoveryFiles[i]->INDE_RealSize ) + continue; + + TmpBuffer = (UINT8*)Buffer; + TmpFileSize = NtfsRecoveryFiles[i]->INDE_RealSize; + // + // Get the file's MFT record number, and from that it's run list + // + MFTRecord = NtfsRecoveryFiles[i]->INDE_MFTRecord & MAXIMUM_RECORD_NUMBER; + Status = GetFileRecord( PeiServices, Volume, &MemBlk->Bs, MFTRecord, TmpBuffer, NULL ); + Status = GetFrAttribute( TmpBuffer, FR_ATTRIBUTE_DATA, &TmpBuffer ); + if ( EFI_ERROR( Status )) { + return Status; + } + TmpBuffer += ((FR_ATTR_HEADER_NONRES*)TmpBuffer)->AHNR_RunOffset; // Point to run list + MemCpy( MemBlk->RootRunList, TmpBuffer, 128 ); // Copy the file's run list + // + // Read the file into the provided buffer + // + pRunList = &MemBlk->RootRunList[0]; + Status = ReadNTFSFile( PeiServices, Volume, &MemBlk->Bs, pRunList, Buffer, &TmpFileSize ); + if ( EFI_ERROR( Status )) { + return Status; + } + + if(IsValidFile(Buffer, (UINTN)TmpFileSize)) { + *FileSize = (UINTN)TmpFileSize; + return EFI_SUCCESS; + } + } + return EFI_NOT_FOUND; +} +#endif + +#if EXT_RECOVERY_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: GetNextBlock +// +// Description: (EXT) Retrieves the next block number from an Inode +// block list. +// +// Parameters: VOLUME_INFO *Vi - Volume Info Structure +// VOLUME_SB *Sb - Superblock structure +// VOLUME_IT *Inode - Inode table structure +// UINT32 *BlockNo - Sequential number of the block +// UINT32 *Block - Next block of the file +// BOOLEAN UpdateList - Update block no. to next block if TRUE. +// +// Return value: EFI_STATUS Status (EFI_SUCCESS or EFI_END_OF_FILE) +// +// Modified: +// +// Referral(s): +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS GetNextBlock( + EFI_PEI_SERVICES **PeiServices, + RC_VOL_INFO *Volume, + VOLUME_SB *Sb, + VOLUME_IT *Inode, + UINT32 *BlockNo, + UINT32 *Block, + BOOLEAN UpdateList ) +{ + UINT32 *BlockListPtr; + UINT32 TmpBlock; + UINT32 TmpBlock2; + UINT32 TmpBlkNo; + UINT32 IBlkCnt; + UINT64 Offset; + UINT32 BlockSize; + UINT32 NosPerBlock; + UINTN BlockPages; + EFI_STATUS Status; + EFI_PHYSICAL_ADDRESS Allocate; + + BlockSize = 1024 << Sb->SB_BlockSize; + NosPerBlock = BlockSize / 4; + TmpBlkNo = *BlockNo; + + // Process direct blocks (0-11) + if ((TmpBlkNo < 12) && (Indirect == 0)) + { + BlockListPtr = &Inode->Alloc.Ext2.Blocks[0]; + *Block = BlockListPtr[TmpBlkNo]; + } + + // Process single indirect blocks (12-(256+11)) + if ((TmpBlkNo >= 12) && (TmpBlkNo < NosPerBlock+12) && (Indirect != 1)) + { + Indirect = 1; + TmpBlock = Inode->Alloc.Ext2.Blocks[12]; + Offset = Mul64(TmpBlock, BlockSize); + ReadDevice (PeiServices, Volume, Offset, BlockSize, &BlockList[0]); + } + + if ((TmpBlkNo >= 12) && (TmpBlkNo < NosPerBlock+12) && (Indirect == 1)) + { + BlockPages = EFI_SIZE_TO_PAGES( BlockSize ); + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, BlockPages, &Allocate ); + if ( EFI_ERROR( Status )) { + return EFI_END_OF_FILE; + } + BlockList = (UINT32*)((UINTN)Allocate); + + BlockListPtr = &BlockList[0]; + TmpBlock = TmpBlkNo - 12; + *Block = BlockListPtr[TmpBlock]; + } + + // Process double indirect blocks ((256+12)-(65536+256+11)) + if ((TmpBlkNo >= (NosPerBlock+12)) && (Indirect != 2)) + { + Indirect = 2; + BlockPages = EFI_SIZE_TO_PAGES( BlockSize ); + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, BlockPages, &Allocate ); + if ( EFI_ERROR( Status )) { + return EFI_END_OF_FILE; + } + BlockList2 = (UINT32*)((UINTN)Allocate); + + TmpBlock = Inode->Alloc.Ext2.Blocks[13]; + Offset = Mul64(TmpBlock, BlockSize); + ReadDevice (PeiServices, Volume, Offset, BlockSize, &BlockList[0]); + } + + if ((TmpBlkNo >= (NosPerBlock+12)) && (Indirect == 2)) + { + TmpBlock = TmpBlkNo - 12; + IBlkCnt = TmpBlock / NosPerBlock; + if (TmpBlock % NosPerBlock == 0) + { + // Read another set of nos. into BlockList2 + TmpBlock2 = BlockList[IBlkCnt]; + Offset = Mul64(TmpBlock2, BlockSize); + ReadDevice (PeiServices, Volume, Offset, BlockSize, &BlockList2[0]); + BlockListPtr = &BlockList2[0]; + } + TmpBlock -= (NosPerBlock * IBlkCnt); + *Block = BlockListPtr[TmpBlock]; + } + + if (UpdateList) + { + TmpBlkNo++; + *BlockNo = TmpBlkNo; + } + if (*Block == 0) + { + return EFI_END_OF_FILE; + } else { + return EFI_SUCCESS; + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ReadExtFile +// +// Description: +// Reads a file from a device formatted in Ext(n). +// +// Input: +// Parameters: VOLUME_INFO *Vi - Volume Info Structure +// VOLUME_SB *Sb - Superblock structure +// VOLUME_IT *Inode - Inode table structure +// VIOD *Buffer - Buffer to read into +// UINT64 *Size - Size of file to read +// +// Output: +// EFI_STATUS - possible return values +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ReadExtFile( + IN EFI_PEI_SERVICES **PeiServices, + RC_VOL_INFO *Volume, + VOLUME_SB *Sb, + VOLUME_IT *Inode, + VOID *Buffer, + UINT64 *Size ) +{ + EFI_STATUS Status; + UINT32 BlockSize; + UINT32 Block; + UINT32 BlockNo; + UINT64 Offset; + UINT64 TotalBytesRead = 0; + UINT16 ExtentCount; + UINT64 BigBlock; + UINT32 ReadSize; + UINT16 i; + + BlockSize = 1024 << Sb->SB_BlockSize; + BlockNo = 0; + + // + // Check for which allocation method to use for reading the file + // + if ((Inode->Alloc.Ext4.Header.EH_Magic == 0xF30A) && \ + (Inode->Alloc.Ext4.Header.EH_Max == 4)) + { + // + // Use the EXT4 allocation method + // + ExtentCount = Inode->Alloc.Ext4.Header.EH_Extents; + + for (i=0; i<ExtentCount; i++) + { + BigBlock = Inode->Alloc.Ext4.Extent[i].EE_BlockLo + \ + Shl64(Inode->Alloc.Ext4.Extent[i].EE_BlockHi, 0x20); + Offset = Mul64(BigBlock, BlockSize); + ReadSize = BlockSize * Inode->Alloc.Ext4.Extent[i].EE_Length; + if (*Size <= ReadSize) + { + Status = ReadDevice (PeiServices, Volume, Offset, (UINTN)*Size, Buffer); + if (EFI_ERROR(Status)) { + *Size = TotalBytesRead; + return Status; + } else { + TotalBytesRead += *Size; + *Size = TotalBytesRead; + return EFI_SUCCESS; + } + } + + Status = ReadDevice (PeiServices, Volume, Offset, ReadSize, Buffer); + if (EFI_ERROR(Status)) return Status; + *Size -= ReadSize; + TotalBytesRead += ReadSize; + } // End of read loop + + return EFI_VOLUME_CORRUPTED; // Shouldn't get here + + } else { + // + // Use the EXT2, EXT3 allocation method + // + Status = GetNextBlock ( PeiServices, + Volume, + Sb, + Inode, + &BlockNo, + &Block, + TRUE ); + if (EFI_ERROR(Status)) // Zero-length file + { + *Size = 0; + return Status; + } + + do + { + Offset = Mul64 (BlockSize, Block); + + if (*Size <= BlockSize) + { + Status = ReadDevice (PeiServices, Volume, Offset, (UINTN)*Size, Buffer); + if (EFI_ERROR(Status)) { + *Size = TotalBytesRead; + return Status; + } else { + TotalBytesRead += *Size; + *Size = TotalBytesRead; + return EFI_SUCCESS; + } + } + + Status = ReadDevice (PeiServices, Volume, Offset, BlockSize, Buffer); + if (EFI_ERROR(Status)) return Status; + *Size -= BlockSize; + TotalBytesRead += BlockSize; + + Status = GetNextBlock ( PeiServices, + Volume, + Sb, + Inode, + &BlockNo, + &Block, + TRUE ); + if (EFI_ERROR(Status)) // EOF found + { + *Size = TotalBytesRead; + return EFI_SUCCESS; + } + } + while (*Size); + + return EFI_VOLUME_CORRUPTED; // Shouldn't get here + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ReadExtRoot +// +// Description: +// Prepares given volume for read operations. Reads Ext(n) root directory. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN VOLUME_SB *Sb - pointer to Superblock +// +// Output: +// EFI_STATUS - possible return values +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ReadExtRoot( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN VOLUME_SB *Sb ) +{ + EFI_STATUS Status; + UINT32 BlockSize; + UINT16 InodeSize; + UINT32 BgdtBlock; + VOLUME_BGDT Bgdt; +// VOLUME_IT RootInode; + UINT64 Offset; + UINT64 TmpRootSize; + UINTN RootPages; + EFI_PHYSICAL_ADDRESS Allocate; + + BlockSize = 1024 << Sb->SB_BlockSize; + if (BlockSize == 1024) + { + BgdtBlock = 2; + } else { + BgdtBlock = 1; + } + + // Read in the Block Group Descriptor Table + Offset = Mul64(BlockSize, BgdtBlock); + Status = ReadDevice (PeiServices, + Volume, + Offset, + sizeof(VOLUME_BGDT), + &Bgdt); + if (EFI_ERROR(Status)) + { + return EFI_NOT_FOUND; + } + + InodeBlock = Bgdt.BGDT_InodeTableBlk; + InodeSize = Sb->SB_InodeStrucSize; + + // The root directory's inode is always the 2nd inode in the + // inode table. Read in that inode. + Offset = Mul64(BlockSize, InodeBlock) + InodeSize; + Status = ReadDevice (PeiServices, + Volume, + Offset, + sizeof(VOLUME_IT), + &MemBlk->RootInode); + if (EFI_ERROR(Status)) + { + return EFI_NOT_FOUND; + } + + TmpRootSize = MemBlk->RootInode.IT_SizeLo + Shl64(MemBlk->RootInode.IT_SizeHi, 0x20); + + RootPages = EFI_SIZE_TO_PAGES( TmpRootSize ); + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, RootPages, &Allocate ); + if ( EFI_ERROR( Status )) { + return Status; + } + RootBuffer = (UINT8*)((UINTN)Allocate); + RootBufferSize = EFI_PAGES_TO_SIZE( RootPages ); + MemSet( RootBuffer, RootBufferSize, 0 ); + + Status = ReadExtFile( PeiServices, + Volume, + Sb, + &MemBlk->RootInode, + RootBuffer, + &TmpRootSize ); + RootSize = (UINT32)TmpRootSize; + + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessExtVolume +// +// Description: +// Reads recovery capsule from Ext(n) volume +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessExtVolume( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; +// VOLUME_SB Sb; +// VOLUME_IT FileInode; + UINT32 i; + UINT32 Inode; + UINT64 TmpFileSize; + UINTN NumberOfFiles; + UINT64 Offset; + UINT32 BlockSize; + UINT16 InodeSize; + UINT8 *TmpPtr; + + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Sb ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + // On an EXT(n) volume, the first sector will be all zeros + TmpPtr = (UINT8*)&MemBlk->Sb.SB_TotalInodes; + for (i=0; i<512; i++) + { + if ((UINT8)TmpPtr[i] != 0) + { + return EFI_NOT_FOUND; // Not an EXT(n) volume + } + } + + // The Superblock is always 1024 bytes in on the volume + Status = ReadDevice( PeiServices, Volume, 1024, 512, &MemBlk->Sb ); + + if (!IsExt( &MemBlk->Sb )) { + return EFI_NOT_FOUND; + } + + Status = ReadExtRoot( PeiServices, Volume, &MemBlk->Sb ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + GetFileListFromExtVolume((UINT8*)RootBuffer, RootSize, &NumberOfFiles, ExtRecoveryFiles); + + if ( NumberOfFiles == 0 ) + return EFI_NOT_FOUND; + + BlockSize = 1024 << MemBlk->Sb.SB_BlockSize; + InodeSize = MemBlk->Sb.SB_InodeStrucSize; + for(i = 0; i < NumberOfFiles; i++) { + // An EXT(n) directory entry only contains the name and inode, so we have to + // read the inode to get the size. + Inode = ExtRecoveryFiles[i]->DIR_Inode; + Offset = Mul64(BlockSize, InodeBlock) + \ + Mul64((Inode-1), InodeSize); + Status = ReadDevice (PeiServices, + Volume, + Offset, + sizeof(VOLUME_IT), + &MemBlk->FileInode); + if (EFI_ERROR(Status)) continue; + + TmpFileSize = MemBlk->FileInode.IT_SizeLo + Shl64(MemBlk->FileInode.IT_SizeHi, 0x20); + if ( *FileSize < (UINTN)TmpFileSize ) + continue; + Status = ReadExtFile( PeiServices, + Volume, + &MemBlk->Sb, + &MemBlk->FileInode, + Buffer, + &TmpFileSize ); + if ( EFI_ERROR( Status )) { + return Status; + } + + if(IsValidFile(Buffer, (UINTN)TmpFileSize)) { + *FileSize = (UINTN)TmpFileSize; + return EFI_SUCCESS; + } + } + return EFI_NOT_FOUND; +} +#endif + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FindNextPartition +// +// Description: +// Finds the next partition on the volume, and sets the VolumeOffset in +// the RC_VOL_INFO structure. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// +// Output: +// EFI_STATUS +// +// Note: +// This function uses the following global variables: +// UINTN PartCount - Counter to keep track of search +// BOOLEAN IsMbr - True if looking for MBR partitions +// UINT32 GpeCount - GUID Partition Entry count +// UINT32 PartSector - Starting sector of partition +// PartCount and PartSector must be seeded to 0, and IsMbr must be +// seeded to TRUE before the first call. +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS FindNextPartition( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume ) +{ + EFI_STATUS Status; + UINT64 Offset; + GUID_BOOT_RECORD *Gbr; + GUID_TABLE_HEADER *Gth; + UINT32 GpeSize; + UINT32 i; + UINT32 TempSector; + + // + // Check for MBR partitions + // + if ( IsMbr ) { + while ( PartCount < 4 ) { + if ( MemBlk->Mbr.PartRec[PartCount].OSType == 0xEE ) { + IsMbr = FALSE; // Mark GUID partition found + PartCount = 0; // Reset counter + break; + } + + if ( MemBlk->Mbr.PartRec[PartCount].OSType == 5 + || MemBlk->Mbr.PartRec[PartCount].OSType == 15 ) { // Extended partition + PartSector += MemBlk->Mbr.PartRec[PartCount].StartingLba; + Volume->PartitionOffset = Mul64( 512, PartSector ); + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Mbr ); + if ( EFI_ERROR( Status )) { + return Status; + } + PartCount = 0; + } + + if ( MemBlk->Mbr.PartRec[PartCount].OSType == 0 + || MemBlk->Mbr.PartRec[PartCount].SizeInLba == 0 + || MemBlk->Mbr.PartRec[PartCount].StartingLba == 0 ) { + PartCount++; // Check next partition + continue; + } + + TempSector = MemBlk->Mbr.PartRec[PartCount].StartingLba + PartSector; + Volume->PartitionOffset = Mul64( 512, TempSector ); + PartCount++; + return EFI_SUCCESS; + } + } + if ( IsMbr ) return EFI_NOT_FOUND; // No MBR partitions were found + + // + // Check for GUID partitions + // + if ( PartCount == 0 ) { + Offset = Mul64( 1, Volume->BlockSize ); + Status = ReadDevice( PeiServices, Volume, Offset, 512, &MemBlk->Mbr ); + if ( EFI_ERROR( Status )) { + return Status; + } + Gth = (GUID_TABLE_HEADER*)&MemBlk->Mbr.BootCode[0]; + if ( (Gth->Signature[0] == 0x45) && // Check for "EFI" + (Gth->Signature[1] == 0x46) && + (Gth->Signature[2] == 0x49) ) + { + GpeCount = Gth->EntryCount; + GpeSize = Gth->EntrySize; + // + // We only support entry size of 128 for now. + // + if ( GpeSize != 128 ) return EFI_NOT_FOUND; // + Offset = Mul64( 2, Volume->BlockSize ); + // + // Read in the first entry in the partition table + // + Status = ReadDevice( PeiServices, Volume, Offset, 512, &MemBlk->Mbr ); + if ( EFI_ERROR( Status )) { + return Status; + } + } else return EFI_NOT_FOUND; // Table header not found. + } + + while ( PartCount < GpeCount ) { + i = PartCount % 4; + if ( (i == 0) && (PartCount != 0) ) { + Offset = Mul64( 2+(PartCount/4), Volume->BlockSize ); + Volume->PartitionOffset = 0; // Reset this to zero + Status = ReadDevice( PeiServices, Volume, Offset, 512, &MemBlk->Mbr ); + if ( EFI_ERROR( Status )) { + return Status; + } + } + PartCount++; + Gbr = (GUID_BOOT_RECORD*)&MemBlk->Mbr.BootCode[0]; + Volume->PartitionOffset = Mul64( Gbr->GuidPart[i].FirstLba, Volume->BlockSize ); + // + // The partition count is incremented by 4 for each new Guid Boot Record, + // even if it does not contain 4 partition records. So we may find an empty + // partition. Exit with EFI_NOT_FOUND if there is one. + // + if ( Volume->PartitionOffset == 0 ) { + return EFI_NOT_FOUND; + } + return EFI_SUCCESS; + } + + return EFI_NOT_FOUND; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessFatDevice +// +// Description: +// Reads recovery capsule from FAT device. First treat device as +// non-partitioned device. If failed tries to discover primary partitions and +// search for capsule there. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessFatDevice( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; + EFI_STATUS Status2; + + // + // Assume the volume is floppy-formatted + // + Status = ProcessFatVolume( PeiServices, Volume, FileSize, Buffer ); + + if ( !EFI_ERROR( Status )) { + return Status; + } + + // + // Not floppy formatted, look for partitions. Rread sector 0 (MBR). + // + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Mbr ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + if ( MemBlk->Mbr.Sig != 0xaa55 ) { + return EFI_NOT_FOUND; + } + + PartCount = 0; + PartSector = 0; + IsMbr = TRUE; + + // + // Locate all partitions. Check each one for the recovery file. + // The recovery file will be loaded if it is found, and this + // function will return EFI_SUCCESS. + // + do { + Status = FindNextPartition( PeiServices, Volume ); + if ( !EFI_ERROR(Status) ) { + Status2 = ProcessFatVolume( PeiServices, Volume, FileSize, Buffer ); + if ( !EFI_ERROR(Status2) ) { + return Status2; + } + } + } while (Status == EFI_SUCCESS); + + return EFI_NOT_FOUND; +} + +#if NTFS_RECOVERY_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessNTFSDevice +// +// Description: +// Reads recovery capsule from NTFS device. Tries to discover primary partitions +// and search for capsule there. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessNTFSDevice( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; + EFI_STATUS Status2; + + // + // Assume the volume is floppy-formatted. + // + Status = ProcessNTFSVolume( PeiServices, Volume, FileSize, Buffer ); + + if ( !EFI_ERROR( Status )) { + return Status; + } + + // + // Not floppy formatted, look for partitions. Read sector 0 (MBR). + // + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Mbr ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + if ( MemBlk->Mbr.Sig != 0xaa55 ) { + return EFI_NOT_FOUND; + } + + PartCount = 0; + PartSector = 0; + IsMbr = TRUE; + + // + // Locate all partitions. Check each one for the recovery file. + // The recovery file will be loaded if it is found, and this + // function will return EFI_SUCCESS. + // + do { + Status = FindNextPartition( PeiServices, Volume ); + if ( !EFI_ERROR(Status) ) { + Status2 = ProcessNTFSVolume( PeiServices, Volume, FileSize, Buffer ); + if ( !EFI_ERROR(Status2) ) { + return Status2; + } + } + } while (Status == EFI_SUCCESS); + + return EFI_NOT_FOUND; +} +#endif + +#if EXT_RECOVERY_SUPPORT +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessExtDevice +// +// Description: +// Reads recovery capsule from Ext(n) device. Tries to discover primary partitions +// and search for capsule there. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessExtDevice( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; + EFI_STATUS Status2; + + // + // Assume the volume is floppy-formatted. + // + Status = ProcessExtVolume( PeiServices, Volume, FileSize, Buffer ); + + if ( !EFI_ERROR( Status )) { + return Status; + } + + // + // Not floppy formatted, look for partitions. Read sector 0 (MBR). + // + Status = ReadDevice( PeiServices, Volume, 0, 512, &MemBlk->Mbr ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + if ( MemBlk->Mbr.Sig != 0xaa55 ) { + return EFI_NOT_FOUND; + } + + PartCount = 0; + PartSector = 0; + IsMbr = TRUE; + + // + // Locate all partitions. Check each one for the recovery file. + // The recovery file will be loaded if it is found, and this + // function will return EFI_SUCCESS. + // + do { + Status = FindNextPartition( PeiServices, Volume ); + if ( !EFI_ERROR(Status) ) { + Status2 = ProcessExtVolume( PeiServices, Volume, FileSize, Buffer ); + if ( !EFI_ERROR(Status2) ) { + return Status2; + } + } + } while (Status == EFI_SUCCESS); + + return EFI_NOT_FOUND; +} +#endif + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessPrimaryVolume +// +// Description: +// Reads recovery capsule from ISO9660 device +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessPrimaryVolume( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; + PRIMARY_VOLUME_DESCRIPTOR PriVol; + UINT32 RootSize; + UINTN RootPages; + EFI_PHYSICAL_ADDRESS Allocate; + UINTN NumberOfFiles; + UINT32 i; + + Volume->PartitionOffset = 0; + Status = ReadDevice( PeiServices, Volume, 16 * Volume->BlockSize, Volume->BlockSize, &PriVol ); + + // + //check that we read CD + // + if ( PriVol.Type != 1 || MemCmp( PriVol.StandardId, "CD001", 5 )) { + return EFI_NOT_FOUND; + } + + // + //read root directory + // + RootSize = PriVol.RootDir.DataLength; + RootPages = EFI_SIZE_TO_PAGES( RootSize ); + + if ( RootBufferSize < EFI_PAGES_TO_SIZE( RootPages )) { + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, RootPages, &Allocate ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + RootBuffer = (UINT8*)((UINTN)Allocate); + RootBufferSize = EFI_PAGES_TO_SIZE( RootPages ); + } + MemSet( RootBuffer, RootBufferSize, 0 ); + + Status = ReadDevice( PeiServices, Volume, PriVol.RootDir.ExtentOffset * Volume->BlockSize, RootSize, RootBuffer ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + GetFileListFromPrimaryVolume((DIR_RECORD*)RootBuffer, RootSize, &NumberOfFiles, CdRecoveryFiles); + + if(NumberOfFiles == 0) + return EFI_NOT_FOUND; + + for(i = 0; i < NumberOfFiles; i++) { + if ( *FileSize < CdRecoveryFiles[i]->DataLength ) + continue; + + Status = ReadDevice( PeiServices, Volume, CdRecoveryFiles[i]->ExtentOffset * Volume->BlockSize, CdRecoveryFiles[i]->DataLength, Buffer ); + if(EFI_ERROR(Status)) + continue; + + if(IsValidFile(Buffer, CdRecoveryFiles[i]->DataLength)) { + *FileSize = CdRecoveryFiles[i]->DataLength; + return EFI_SUCCESS; + } + } + return EFI_NOT_FOUND; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: ProcessCd +// +// Description: +// Reads recovery capsule ATAPI device. First search for recovery capsule in +// primary volume. If not found tries to process Eltorito images +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN OUT RC_VOL_INFO *Volume - pointer to volume description structure +// CHAR8 *FileName - recovery capsule file name +// UINTN *FileSize - pointer to size of provided buffer +// OUT VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS ProcessCd( + IN EFI_PEI_SERVICES **PeiServices, + IN OUT RC_VOL_INFO *Volume, + IN OUT UINTN *FileSize, + OUT VOID *Buffer ) +{ + EFI_STATUS Status; + UINT8 Data[2048]; //space for 1 block + BOOT_RECORD_VOLUME_DESCRIPTOR *BootDesc; + INITIAL_DEFAULT_ENTRY *Entry; + + Status = ProcessPrimaryVolume( PeiServices, Volume, FileSize, Buffer ); + + if ( !EFI_ERROR( Status )) { + return Status; + } + + // + //file not found in primary volume, check Eltorito partitions + // + Status = ReadDevice( PeiServices, Volume, 17 * Volume->BlockSize, Volume->BlockSize, Data ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + // + //check if it is Eltorito + // + BootDesc = (BOOT_RECORD_VOLUME_DESCRIPTOR*)Data; + + if ( BootDesc->BootRecordIndicator != 0 + || MemCmp( &(BootDesc->ISO9660Identifier), "CD001", 5 ) + || BootDesc->DescriptorVersion != 1 + || MemCmp( &(BootDesc->BootSystemIdentifier), "EL TORITO SPECIFICATION", 23 )) { + return EFI_NOT_FOUND; + } + + // + //it is Eltorito, read boot catalog + // + Status = ReadDevice( PeiServices, Volume, BootDesc->BootCatalogFirstSector * Volume->BlockSize, Volume->BlockSize, Data ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + Entry = (INITIAL_DEFAULT_ENTRY*) &Data[32]; + Volume->PartitionOffset = Entry->LoadRBA * Volume->BlockSize; + Status = ProcessFatDevice( PeiServices, Volume, FileSize, Buffer ); + return Status; +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------------- +// Procedure: FsRecoveryRead +// +// Description: +// Search for recovery capsule file on all file system devices +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PEI services +// IN CHAR8 *FileName - recovery capsule file name +// IN UINTN DeviceIndex - device index for given BlockIo PPI +// IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *pBlockIo - pointer to BlockIo PPI +// UINTN *FileSize - pointer to size of provided buffer +// VOID *Buffer - pointer to buffer to store data +// +// Output: +// EFI_STATUS +// +//---------------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS FsRecoveryRead( + IN EFI_PEI_SERVICES **PeiServices, + IN UINTN DeviceIndex, + IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *pBlockIo, + IN OUT UINTN *pSize, + OUT VOID *pBuffer ) +{ + EFI_STATUS Status; + RC_VOL_INFO Volume; + EFI_PEI_BLOCK_IO_MEDIA Media; + UINTN BlockPages; + EFI_PHYSICAL_ADDRESS Allocate; + + if ( !pBlockIo || !pSize || *pSize && !pBuffer ) { + return EFI_INVALID_PARAMETER; + } + + MemSet( &Volume, sizeof(RC_VOL_INFO), 0 ); + + Status = pBlockIo->GetBlockDeviceMediaInfo( PeiServices, pBlockIo, DeviceIndex, &Media ); + + if ( EFI_ERROR( Status )) { + return Status; + } + + if ( !Media.MediaPresent ) { + return EFI_NOT_FOUND; + } + + Volume.BlkIo = pBlockIo; + Volume.Device = DeviceIndex; + Volume.BlockSize = Media.BlockSize; + + // + // Allocate memory for MBR, Boot Sector, etc. + // + BlockPages = EFI_SIZE_TO_PAGES( sizeof(MEMORY_BLOCK) ); + Status = (*PeiServices)->AllocatePages( PeiServices, EfiBootServicesData, BlockPages, &Allocate ); + if ( EFI_ERROR( Status )) { + return EFI_NOT_FOUND; + } + MemBlk = (MEMORY_BLOCK*)((UINTN)Allocate); + + if ( Media.BlockSize == 2048 && CdRecoverySupport ) { + Volume.PartitionOffset = 0; + Status = ProcessCd( PeiServices, &Volume, pSize, pBuffer ); + if ( Status == EFI_SUCCESS ) return Status; + } + if ( FatRecoverySupport ) { + Volume.PartitionOffset = 0; + Status = ProcessFatDevice( PeiServices, &Volume, pSize, pBuffer ); + if ( Status == EFI_SUCCESS ) return Status; +#if NTFS_RECOVERY_SUPPORT + } + if ( NtfsRecoverySupport ) { + Volume.PartitionOffset = 0; + Status = ProcessNTFSDevice( PeiServices, &Volume, pSize, pBuffer ); + if ( Status == EFI_SUCCESS ) return Status; +#endif +#if EXT_RECOVERY_SUPPORT + } + if ( ExtRecoverySupport ) { + Volume.PartitionOffset = 0; + Status = ProcessExtDevice( PeiServices, &Volume, pSize, pBuffer ); + if ( Status == EFI_SUCCESS ) return Status; +#endif + + } else { + Status = EFI_NOT_FOUND; + } + return Status; +} + + +/************************************************************************/ +/* Device Recovery Module PPI */ +/************************************************************************/ +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: GetNumberRecoveryCapsules +// +// Description: +// GetNumberRecoveryCapsules function of ppi +// EFI_PEI_DEVICE_RECOVERY_MODULE_PPI. +// +// Input: +// +// Output: +// EFI_SUCCESS - number of recovery capsules returned +// EFI_INVALID_PARAMETER - the pointer NumberRecoveryCapsules is NULL +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +static EFI_STATUS GetNumberRecoveryCapsules( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This, + OUT UINTN *NumberRecoveryCapsules ) +{ + if ( !NumberRecoveryCapsules ) { + return EFI_INVALID_PARAMETER; + } + *NumberRecoveryCapsules = 1; + return EFI_SUCCESS; +} + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: GetRecoveryCapsuleInfo +// +// Description: +// GetRecoveryCapsuleInfo function of ppi EFI_PEI_DEVICE_RECOVERY_MODULE_PPI +// for any block devices including floppies, USB keys, CD-ROMs and HDDs. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PeiServices Structure +// IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This - pointer to the PPI structure +// IN UINTN CapsuleInstance - value indicating the instance of the PPI +// OUT UINTN *Size - Size of the recovery capsule +// OUT EFI_GUID *CapsuleType OPTIONAL - Type of recovery capsule +// +// Output: +// EFI_SUCCESS - Parameters are valid and output parameters are updated +// EFI_INVALID_PARAMETER - Size pointer is NULL +// EFI_NOT_FOUND - asking for a 1 or greater instance of the PPI +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS GetRecoveryCapsuleInfo( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This, + IN UINTN CapsuleInstance, + OUT UINTN *Size, + OUT EFI_GUID *CapsuleType ) +{ + EFI_STATUS Status; + + if ( !Size ) { + return EFI_INVALID_PARAMETER; + } + + if ( CapsuleInstance > 0 ) { + return EFI_NOT_FOUND; + } + + Status = GetRecoveryFileInfo(PeiServices, NULL, Size, NULL); + if(EFI_ERROR(Status)) + return Status; + + if ( CapsuleType ) { + *CapsuleType = guidBlockDeviceCapsule; + } + return EFI_SUCCESS; +} + +#define NUMBER_OF_RETRIES 3 + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: LoadRecoveryCapsule +// +// Description: +// Locates all EFI_PEI_RECOVERY_BLOCK_IO_PPI PPIs. Calls function +// GetNumberOfBlockDevices. For each block device, calls the function +// FsRecoveryRead, to find the recovery image named in var sAmiRomFile. +// +// Input: +// IN EFI_PEI_SERVICES **PeiServices - pointer to PeiServices Structure +// IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This - pointer to the PPI structure +// IN UINTN CapsuleInstance - value indicating the instance of the PPI +// OUT VOID *Buffer - contains information read from the block device +// +// Output: +// EFI_SUCCESS - File read from recovery media +// EFI_INVALID_PARAMETER - Buffer is a NULL pointer +// EFI_NOT_FOUND - asking for a 1 or greater instance of the PPI +// Other - return error values from LocatePpi or FsRecoveryRead +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +static EFI_STATUS LoadRecoveryCapsule( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_PEI_DEVICE_RECOVERY_MODULE_PPI *This, + IN UINTN CapsuleInstance, + OUT VOID *Buffer ) +{ + static EFI_GUID guidBlockIo = EFI_PEI_VIRTUAL_BLOCK_IO_PPI; + EFI_STATUS Status; + EFI_PEI_PPI_DESCRIPTOR *pDummy; + UINTN i; + UINTN RecoveryCapsuleSize; + BOOLEAN ExtendedVerification; + + PEI_TRACE((-1, PeiServices, "..BLOCK DEVICE..")); + + if ( !Buffer ) { + return EFI_INVALID_PARAMETER; + } + + if ( CapsuleInstance > 0 ) { + return EFI_NOT_FOUND; + } + + Status = GetRecoveryFileInfo(PeiServices, NULL, &RecoveryCapsuleSize, &ExtendedVerification); + if ( EFI_ERROR( Status )) + return Status; + + i = 0; + + do + { + EFI_PEI_RECOVERY_BLOCK_IO_PPI *pBlockIo; + UINTN NumberBlockDevices; + UINTN j; + UINTN Size; + Status = (*PeiServices)->LocatePpi( PeiServices, &guidBlockIo, i++, &pDummy, &pBlockIo ); + + if ( EFI_ERROR( Status )) { + break; + } + + if (EFI_ERROR( Status = pBlockIo->GetNumberOfBlockDevices( + PeiServices, pBlockIo, &NumberBlockDevices))) { + continue; + } + + for ( j = 0; j < NumberBlockDevices; j++ ) { + UINTN k; + Size = RecoveryCapsuleSize; + + for ( k = 0; k < NUMBER_OF_RETRIES; k++ ) + { + Status = FsRecoveryRead( + PeiServices, j, pBlockIo, + &Size, Buffer + ); + + if ( !EFI_ERROR(Status) ){ + if(ExtendedVerification || Size == RecoveryCapsuleSize ) + return EFI_SUCCESS; + } + } + } + } while ( TRUE ); + return Status; +} + +/************************************************************************/ +/* Entry Point */ +/************************************************************************/ +EFI_PEI_DEVICE_RECOVERY_MODULE_PPI BlockDeviceRecoveryModule = { + GetNumberRecoveryCapsules, GetRecoveryCapsuleInfo, LoadRecoveryCapsule +}; + +// PPI to be installed +static EFI_PEI_PPI_DESCRIPTOR BlockDeviceRecoveryPpiList[] = { + { + EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST, + &guidRecoveryDevice, &BlockDeviceRecoveryModule + } +}; + + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: BlockDeviceRecoveryEntry +// +// Description: +// Installs EFI_PEI_DEVICE_RECOVERY_MODULE_PPI for loading recovery +// images from block devices such as floppies, USB keys, HDDs or CD-ROMs +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +EFI_STATUS BlockDeviceRecoveryEntry( + IN EFI_FFS_FILE_HEADER *FfsHeader, + IN EFI_PEI_SERVICES **PeiServices ) +{ + ThisPeiServices = PeiServices; + return (*PeiServices)->InstallPpi( PeiServices, BlockDeviceRecoveryPpiList ); +} + +//************************** AMI custom eLink implementation ******************* + +VOID AmiGetFileListFromPrimaryVolume( + IN DIR_RECORD *Root, + IN UINT32 RootSize, + OUT UINTN *NumberOfFiles, + OUT DIR_RECORD **Buffer +) +{ + UINT32 Count = 0; + CHAR8 *DirFileName; + UINT32 FileNameSize; + + VOID *FileName; + UINTN FileSize; + EFI_STATUS Status; + + + *NumberOfFiles = 0; //no files found yet + + Status = GetRecoveryFileInfo(ThisPeiServices, &FileName, &FileSize, NULL); + if(EFI_ERROR(Status)) + return; + + // + //find file in root directory + // + while ( Count < RootSize ) { + DirFileName = (CHAR8*)(Root + 1); + + if(Root->Length == 0) + return; + + // Find the length of the file name. The ISO9660 spec has the following structure + // up to 8 characters then a '.' then up to 3 more characters then a ';' + // then the digits that make up a number between 0 and 32767 + // The filename search uses all characters up to the ';' + FileNameSize = 0; + while(DirFileName[FileNameSize] != ';' && (FileNameSize < Root->LengthOfFileId)) + FileNameSize++; + + if (!EFI_ERROR(FileSearch((CHAR8*)FileName, DirFileName, FALSE, FileNameSize))) { + Buffer[*NumberOfFiles] = Root; + (*NumberOfFiles)++; + break; + } + + Count += Root->Length; + (UINT8 *)Root += Root->Length; + } +} + +#if SEARCH_FAT_PATH +BOOLEAN IsolateName ( + IN CHAR8 **FilePath, + OUT CHAR8 **NextName +) +{ + UINTN len; + BOOLEAN GotName; + UINTN i; + CHAR8 *TempPath; + + TempPath = *FilePath; + len = Strlen(TempPath); + GotName = TRUE; + for ( i = 0; i < len; i++ ) { + if ( TempPath[i] == 0x5C ) { // "\" + GotName = FALSE; + TempPath[i] = 0; + *NextName = TempPath + i + 1; + return GotName; + } + } + return GotName; +} + +#endif + +VOID AmiGetFileListFromFatVolume( + IN DIR_ENTRY *Root, + IN UINT32 RootEntries, + OUT UINTN *NumberOfFiles, + OUT DIR_ENTRY **Buffer +) +{ + UINT32 i; + + VOID *FileName; + UINTN FileSize; + EFI_STATUS Status; + UINT32 DirEntries; + DIR_ENTRY *DirPtr; + CHAR8 *FilePath; +#if SEARCH_FAT_PATH + UINT32 DirSize; + CHAR8 *NextName; + UINTN DirPages; + EFI_PHYSICAL_ADDRESS Allocate; + UINT32 Cluster; +#endif + + *NumberOfFiles = 0; //no files found yet + + Status = GetRecoveryFileInfo(ThisPeiServices, &FileName, &FileSize, NULL); + if(EFI_ERROR(Status)) + return; + + FilePath = FileName; + DirEntries = RootEntries; + DirPtr = Root; +#if SEARCH_FAT_PATH + FilePath = (CHAR8*)FileName; + NextName = FilePath; + + while ( IsolateName (&FilePath, &NextName) == FALSE ) { + // + //Find path name in directory + // + for(i = 0; i < DirEntries; i++) { + if((DirPtr[i].FileName[0] == 0xE5) || (DirPtr[i].FileName[0] == 0)) + continue; + + if(!EFI_ERROR(FileSearch((CHAR8*)FilePath, DirPtr[i].FileName, TRUE, FAT_FILE_NAME_SIZE))) { + // + // A match was found... + // Update FilePath to next name. + // Update DirPtr to this directory, and read it in + // + // *REMOVED* DirSize = DirPtr[i].FileSize; + // + // The size of a directory is not stored in it's directory entry, + // So we will only read in one cluster for now. + // + DirSize = ThisVolume->BytesPerCluster; + DirEntries = DirSize / 32; + Cluster = DirPtr[i].FirstClusterLo + (DirPtr[i].FirstClusterHi << 16); + + DirPages = EFI_SIZE_TO_PAGES( DirSize ); + + if ( DirSize < EFI_PAGES_TO_SIZE( DirPages )) { + Status = (*ThisPeiServices)->AllocatePages( ThisPeiServices, + EfiBootServicesData, DirPages, &Allocate ); + if ( EFI_ERROR( Status )) { + *NumberOfFiles = 0; + return; + } + + DirPtr = (DIR_ENTRY*)((UINTN)Allocate); + DirSize = EFI_PAGES_TO_SIZE( DirPages ); + } + MemSet( DirPtr, DirSize, 0 ); + + Status = GetFatData( ThisPeiServices, ThisVolume, Cluster, DirSize, DirPtr ); + if ( EFI_ERROR( Status )) { + *NumberOfFiles = 0; + return; + } + FilePath = NextName; + break; + } + } + } +#endif + // + // Find file in directory + // + for(i = 0; i < DirEntries; i++) { + if((DirPtr[i].FileName[0] == 0xE5) || (DirPtr[i].FileName[0] == 0)) + continue; + + if(!EFI_ERROR(FileSearch((CHAR8*)FilePath, DirPtr[i].FileName, TRUE, FAT_FILE_NAME_SIZE))) { + Buffer[*NumberOfFiles] = &DirPtr[i]; + *NumberOfFiles = 1; + break; + } + } +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: AmiGetFileListFromNtfsVolume +// +// Description: +// Gets a list of valid recovery files from an NTFS volume. +// As currently written, gets only one file. +// +// Input: +// UINT8 *Root - Pointer to a buffer containing the root directory +// UINT32 RootSize - Size of the root directory +// UINTN *NumberOfFiles - Pointer to number of files found +// INDEX_ENTRY **Buffer - Pointer to buffer containing index entry of +// the file that was found. +// +// Output: +// None - returned in variables. +// +// Notes: +// This is an e-linked function, which can be replaced. +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID AmiGetFileListFromNtfsVolume( + IN UINT8 *Root, + IN UINT32 RootSize, + OUT UINTN *NumberOfFiles, + OUT INDEX_ENTRY **Buffer +) +{ +#if NTFS_RECOVERY_SUPPORT + UINT8 i; + UINT32 IndexSize; + UINT32 IndexSize2; + UINTN Offset; + UINT8 *TmpPtr; + CHAR16 *NamePtr; + CHAR8 TmpFileName[13]; + UINT8 LfnSize; + UINT16 EntrySize; + INDEX_ENTRY *IndxPtr; + VOID *FileName; + UINTN FileSize; + EFI_STATUS Status; + + *NumberOfFiles = 0; //no files found yet + + Status = GetRecoveryFileInfo(ThisPeiServices, &FileName, &FileSize, NULL); + if(EFI_ERROR(Status)) + return; + + if (ResidentPresent) { // If resident index found... + TmpPtr = &MemBlk->ResidentIndex[0]; + IndexSize = ResidentSize; + + do { // loop inside the index + EntrySize = ((INDEX_ENTRY*)TmpPtr)->INDE_EntrySize; + LfnSize = ((INDEX_ENTRY*)TmpPtr)->INDE_NameLength; + if (LfnSize > 12) LfnSize = 12; // Limit name to 12 chars + NamePtr = &((INDEX_ENTRY*)TmpPtr)->INDE_Name[0]; + for ( i=0; i<LfnSize; i++ ) + { + TmpFileName[i] = (CHAR8)(CHAR16)NamePtr[i]; + } + TmpFileName[i] = 0; // Zero-terminate name + + if(!EFI_ERROR(FileSearch((CHAR8*)FileName, TmpFileName, FALSE, LfnSize))) { + IndxPtr = (INDEX_ENTRY*)&TmpPtr[0]; + Buffer[*NumberOfFiles] = IndxPtr; // Save pointer to this entry + *NumberOfFiles = 1; + return; + } + + TmpPtr += EntrySize; + IndexSize -= EntrySize; + if ( IndexSize < MINIMUM_ENTRY_SIZE ) break; + + } while (IndexSize); + } + + do { // do loop handling indexes in the root + Offset = 0; + // Look for "INDX", start of index record + if ( (Root[0] == 0x49) && \ + (Root[1] == 0x4E) && \ + (Root[2] == 0x44) && \ + (Root[3] == 0x58) ) + { + IndexSize = ((INDEX_RECORD*)Root)->INDR_IndxEntrySize; + IndexSize2 = IndexSize; + Offset += ((INDEX_RECORD*)Root)->INDR_IndxEntryOff + \ + EFI_FIELD_OFFSET(INDEX_RECORD, INDR_IndxEntryOff); + TmpPtr = Root; + TmpPtr += Offset; // Point to first entry in index + if (IndexSize < MINIMUM_ENTRY_SIZE) { // Empty index + return; + } + } else return; // no index found + + do { // loop inside the index + EntrySize = ((INDEX_ENTRY*)TmpPtr)->INDE_EntrySize; + LfnSize = ((INDEX_ENTRY*)TmpPtr)->INDE_NameLength; + if (LfnSize > 12) LfnSize = 12; // Limit name to 12 chars + NamePtr = &((INDEX_ENTRY*)TmpPtr)->INDE_Name[0]; + for ( i=0; i<LfnSize; i++ ) + { + TmpFileName[i] = (CHAR8)(CHAR16)NamePtr[i]; + } + TmpFileName[i] = 0; // Zero-terminate name + + if(!EFI_ERROR(FileSearch((CHAR8*)FileName, TmpFileName, FALSE, LfnSize))) { + IndxPtr = (INDEX_ENTRY*)&TmpPtr[0]; + Buffer[*NumberOfFiles] = IndxPtr; // Save pointer to this entry + *NumberOfFiles = 1; + return; + } + + TmpPtr += EntrySize; + IndexSize -= EntrySize; + if ( IndexSize < MINIMUM_ENTRY_SIZE ) break; + + } while (IndexSize); + if ( IndexSize2 < 0x1000 ) { + IndexSize2 = 0x1000; + } else { + IndexSize2 = (IndexSize2 + 0x100) & 0xffffff00 ; // Round off + } + Root += IndexSize2; + RootSize -= IndexSize2; + + } while (RootSize); +#else + *NumberOfFiles = 0; //no files found + return; +#endif +} + +//<AMI_PHDR_START> +//---------------------------------------------------------------------- +// +// Procedure: AmiGetFileListFromExtVolume +// +// Description: +// Gets a list of valid recovery files from an EXT(n) volume. +// As currently written, gets only one file. +// +// Input: +// UINT8 *Root - Pointer to a buffer containing the root directory +// UINT32 RootSize - Size of the root directory +// UINTN *NumberOfFiles - Pointer to number of files found +// DIR_ENTRY_EXT **Buffer - Pointer to buffer containing index entry of +// the file that was found. +// +// Output: +// None - returned in variables. +// +// Notes: +// This is an e-linked function, which can be replaced. +// +//---------------------------------------------------------------------- +//<AMI_PHDR_END> +VOID AmiGetFileListFromExtVolume( + IN UINT8 *Root, + IN UINT32 RootSize, + OUT UINTN *NumberOfFiles, + OUT DIR_ENTRY_EXT **Buffer +) +{ +#if EXT_RECOVERY_SUPPORT + EFI_STATUS Status; + DIR_ENTRY_EXT *TmpPtr; + UINT16 EntryLength; + UINT8 NameLength; + VOID *FileName; + UINTN FileSize; + UINT8 i; + CHAR8 TmpFileName[13]; + + *NumberOfFiles = 0; //no files found yet + + Status = GetRecoveryFileInfo(ThisPeiServices, &FileName, &FileSize, NULL); + if(EFI_ERROR(Status)) + return; + + do { // do loop handling entries in the root + + TmpPtr = (DIR_ENTRY_EXT*)&Root[0]; + EntryLength = TmpPtr->DIR_EntryLength; + if (EntryLength == 0) break; // End of directory, file not found + NameLength = TmpPtr->DIR_NameLength; + if (NameLength > 12) NameLength = 12; + for ( i=0; i<NameLength; i++ ) + { + TmpFileName[i] = TmpPtr->DIR_Name[i]; + } + TmpFileName[i] = 0; // Zero-terminate name + + if(!EFI_ERROR(FileSearch((CHAR8*)FileName, + TmpFileName, + FALSE, + NameLength))) { + Buffer[*NumberOfFiles] = TmpPtr; // Save pointer to this entry + *NumberOfFiles = 1; + return; + } + + Root += EntryLength; + RootSize -= EntryLength; + + } while (RootSize); +#else + *NumberOfFiles = 0; //no files found + return; +#endif +} + +BOOLEAN AmiIsValidFile( + IN VOID *FileData, + IN UINTN FileSize +) +{ + return TRUE; +} + +//********************************************************************** +//********************************************************************** +//** ** +//** (C)Copyright 1985-2009, American Megatrends, Inc. ** +//** ** +//** All Rights Reserved. ** +//** ** +//** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** +//** ** +//** Phone: (770)-246-8600 ** +//** ** +//********************************************************************** +//********************************************************************** |