//************************************************************************* //************************************************************************* //** ** //** (C)Copyright 1985-2008, American Megatrends, Inc. ** //** ** //** All Rights Reserved. ** //** ** //** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** //** ** //** Phone: (770)-246-8600 ** //** ** //************************************************************************* //************************************************************************* //************************************************************************* // $Header: /Alaska/BIN/Core/Modules/Recovery/RecoveryCsp.h 5 8/09/12 11:12a Pats $ // // $Revision: 5 $ // // $Date: 8/09/12 11:12a $ //************************************************************************* // Revision History // ---------------- // $Log: /Alaska/BIN/Core/Modules/Recovery/RecoveryCsp.h $ // // 5 8/09/12 11:12a 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) // // 4 1/25/12 2:47p 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) // // 3 5/13/11 4:44p Artems // Replaced GetFileName infrastructure with GetRecoveryFileInfo for // clarification // // 2 2/05/11 2:46p Artems // EIP 39463: Added support for secure update - GetFileName eLink // // 1 6/11/10 11:45a Artems // Definitions of layout for FAT and ISO9660 structures // //************************************************************************* // // // Name: RecoveryCsp.h // // Description: // File system recovery data types definition // // //************************************************************************* #ifndef __RECOVERY_CSP__H__ #define __RECOVERY_CSP__H__ #ifdef __cplusplus extern "C" { #endif #include #define FAT12 0 #define FAT16 1 #define FAT32 2 #define NTFS 3 #define EXTx 4 // // Some NTFS definitions // #define FILE_RECORD_SIZE 1024 // Size of an NTFS file record #define MAXIMUM_RECORD_NUMBER 0x0000FFFFFFFFFFFF // NTFS max record no. #define FR_ATTRIBUTE_NAME 0x00000030 #define FR_ATTRIBUTE_VOLUME_NAME 0x00000060 #define FR_ATTRIBUTE_DATA 0x00000080 #define FR_ATTRIBUTE_INDEX_ROOT 0x00000090 #define FR_ATTRIBUTE_INDEX_ALLOC 0x000000A0 #define MINIMUM_ENTRY_SIZE 0x58 #pragma pack(push, 1) typedef struct { CHAR8 FileName[11]; UINT8 Unused[3]; //Attr, NTRes, CrtTimeTenth; UINT16 Unused1[3]; //CrtTime, CrtDate, LstAccDate; UINT16 FirstClusterHi; UINT16 Unused2[2]; //WrtTime, WrtDate; UINT16 FirstClusterLo; UINT32 FileSize; } DIR_ENTRY; typedef struct { UINT8 jmp[3]; //0 CHAR8 OEMName[8]; //3 UINT16 BytsPerSec; //11 UINT8 SecPerClus; //13 UINT16 RsvdSecCnt; //14 UINT8 NumFATs; //16 UINT16 RootEntCnt; //17 UINT16 TotSec16; //19 UINT8 Media; //21 UINT16 FATSz16; //22 UINT16 SecPerTrk; //24 UINT16 NumHeads; //26 UINT32 HiddSec; //28 UINT32 TotSec32; //32 union { struct { UINT8 Padding[510 - 36]; } Fat16; struct { UINT32 FATSz32; //36 UINT8 Padding1[4]; //40 UINT32 RootClus; //44 UINT8 Padding2[510 - 48]; } Fat32; struct { UINT32 FATSz32u; //36 UINT64 TotSec64; //40 UINT64 MFTClus; //48 UINT8 Padding3[510 - 56]; } Ntfs; } Fat; UINT16 Signature; } BOOT_SECTOR; typedef struct _RC_VOL_INFO { UINT32 BlockSize; EFI_PEI_RECOVERY_BLOCK_IO_PPI *BlkIo; UINTN Device; UINT8 FatType; UINT8 *FatPointer; DIR_ENTRY *RootPointer; UINT64 PartitionOffset; UINT64 FatOffset; UINT64 RootOffset; UINT64 DataOffset; UINT32 BytesPerCluster; } RC_VOL_INFO; typedef struct { UINT8 Length, ExtAttrLength; //1,2 UINT32 ExtentOffset, Unused1; //3..10 UINT32 DataLength, Unused2; //11..18 UINT8 DataTime[7]; //19..25 UINT8 Flags; //26 UINT8 Unused3[32 - 26]; //27..32 UINT8 LengthOfFileId; //33 } DIR_RECORD; typedef struct { UINT8 Type; //1 CHAR8 StandardId[5]; //2..6 UINT8 Version; //7 UINT8 Unused1[156 - 7]; //8..156 DIR_RECORD RootDir; //157..190 UINT8 Padding; CHAR8 Unused2[2048 - 190]; //191..2048 } PRIMARY_VOLUME_DESCRIPTOR; typedef struct { UINT8 BootRecordIndicator; CHAR8 ISO9660Identifier[0x5]; UINT8 DescriptorVersion; CHAR8 BootSystemIdentifier[0x20]; CHAR8 Unused0[0x20]; UINT32 BootCatalogFirstSector; UINT8 Unused1[0x7B6]; } BOOT_RECORD_VOLUME_DESCRIPTOR; typedef struct { UINT8 HeaderID; UINT8 PlatformID; UINT8 Reserved0[0x2]; CHAR8 ManufacturerID[0x18]; UINT16 Checksum; UINT16 Key; } VALIDATION_ENTRY; typedef struct { UINT8 BootIndicator; UINT8 BootMediaType; UINT16 LoadSegment; UINT8 SystemType; UINT8 Unused0; UINT16 SectorCount; UINT32 LoadRBA; UINT8 Unused1[0x14]; } INITIAL_DEFAULT_ENTRY; typedef struct _MBR_PARTITION { UINT8 BootIndicator; UINT8 StartHead; UINT8 StartSector; UINT8 StartTrack; UINT8 OSType; UINT8 EndHead; UINT8 EndSector; UINT8 EndTrack; UINT32 StartingLba; UINT32 SizeInLba; } MBR_PARTITION; typedef struct _MASTER_BOOT_RECORD { UINT8 BootCode[440]; UINT32 UniqueMbrSig; UINT16 Unknown; MBR_PARTITION PartRec[4]; UINT16 Sig; } MASTER_BOOT_RECORD; // // GUID Partition structures // typedef struct _GUID_PARTITION { UINT8 TypeGuid[16]; UINT8 UniqueGuid[16]; UINT64 FirstLba; UINT64 LastLba; UINT64 Flags; CHAR16 Name[36]; } GUID_PARTITION; typedef struct _GUID_BOOT_RECORD { GUID_PARTITION GuidPart[4]; } GUID_BOOT_RECORD; typedef struct _GUID_TABLE_HEADER { UINT8 Signature[8]; UINT32 Revision; UINT32 HeaderSize; UINT32 HeaderCRC; UINT32 Reserved; UINT64 CurrentLBA; UINT64 BackupLBA; UINT64 FirstLBA; UINT64 LastLBA; UINT8 DiskGuid[16]; UINT64 StartLBA; UINT32 EntryCount; UINT32 EntrySize; UINT32 ArraySize; } GUID_TABLE_HEADER; // // NTFS Structures // // //---------------------------------------------------------------------------- // Name: MFT_FILE_RECORD // // Description: Structure of a Master File Table file record. // // Referrals: // //---------------------------------------------------------------------------- // typedef struct _MFT_FILE_RECORD { CHAR8 FR_Name[4]; // 0x00 - Always "FILE" UINT16 FR_UpdateSeqOffset; // 0x04 UINT16 FR_UpdateSeqSize; // 0x06 UINT64 FR_LogSeqNumber; // 0x08 UINT16 FR_SequenceNumber; // 0x10 UINT16 FR_HardLinkCount; // 0x12 UINT16 FR_AttributeOffset; // 0x14 - Offset to Attributes UINT16 FR_Flags; // 0x16 - File Record Flags // 0x01 - Record is in use // 0x02 - Record is a directory UINT32 FR_RealSize; // 0x18 - Real size of record UINT32 FR_AllocatedSize; // 0x1C - Allocated size of record UINT64 FR_BaseRecordNumber; // 0x20 - Zero if this is a base record } MFT_FILE_RECORD; // //---------------------------------------------------------------------------- // Name: FR_ATTR_HEADER_RES // // Description: Structure of a File Record resident attribute header. // // Referrals: // // Note(s): The "Name" in this structure is not a file name, but the // name of the attribute. Not used in this driver. // //---------------------------------------------------------------------------- // typedef struct _FR_ATTR_HEADER_RES { UINT32 AHR_Type; // 0x00 - Attribute Type // 0x30 - File Name // 0x80 - Data UINT32 AHR_Length; // 0x04 - Attribute Length UINT8 AHR_NonResFlag; // 0x08 - Non-Resident Flag UINT8 AHR_NameLength; // 0x09 - Name Length (if named) UINT16 AHR_NameOffset; // 0x0A - Offset to Name (if named) UINT16 AHR_Flags; // 0x0C - Attribute Hdr. Flags // 0x0001 - Compressed // 0x4000 - Encrypted // 0x8000 - Sparse UINT16 AHR_AttributeId; // 0x0E UINT32 AHR_InfoLength; // 0x10 - Attribute Information Length UINT16 AHR_InfoOffset; // 0x14 - Offset to this Attribute's // Information UINT16 AHR_IndexFlag; // 0x16 } FR_ATTR_HEADER_RES; // //---------------------------------------------------------------------------- // Name: FR_ATTR_HEADER_NONRES // // Description: Structure of a File Record non-resident attribute header. // // Referrals: // //---------------------------------------------------------------------------- // typedef struct _FR_ATTR_HEADER_NONRES { UINT32 AHNR_Type; // 0x00 - Attribute Type // 0x30 - File Name // 0x80 - Data UINT32 AHNR_Length; // 0x04 - Attribute Length UINT8 AHNR_NonResFlag; // 0x08 - Non-Resident Flag UINT8 AHNR_NameLength; // 0x09 - Name Length (if named) UINT16 AHNR_NameOffset; // 0x0A - Offset to Name (if named) UINT16 AHNR_Flags; // 0x0C - Flags // 0x0001 - Compressed // 0x4000 - Encrypted // 0x8000 - Sparse UINT16 AHNR_AttributeId; // 0x0E UINT64 AHNR_StartingVCN; // 0x10 - Staeting Virtual Cluster Number UINT64 AHNR_LastVCN; // 0x18 - Last Virtual Cluster Number UINT16 AHNR_RunOffset; // 0x20 - Offset to data runs // (Usually 0x40 for a // Data attribute) } FR_ATTR_HEADER_NONRES; // //---------------------------------------------------------------------------- // Name: FR_NAME_ATTRIBUTE (0x30) // // Description: Structure of a Master File Table Name Attribute. // // Referrals: // // Notes: Time stamps in NTFS are the number of 100ns units since // January 1, 1601. // This attribute is preceeded by a resident attribute header. //---------------------------------------------------------------------------- // typedef struct _FR_NAME_ATTRIBUTE { UINT64 NA_PDReference; // 0x00 - Parent Directory Reference UINT64 NA_CreationTime; // 0x08 - File Creation Time UINT64 NA_AlteredTime; // 0x10 - File Altered Time UINT64 NA_MFTChangedTime; // 0x18 - MFT Record Changed Time UINT64 NA_ReadTime; // 0x20 - File Read Time UINT64 NA_AllocatedSize; // 0x28 - Allocated Size of File UINT64 NA_RealSize; // 0x30 - Real size of File UINT32 NA_Flags; // 0x38 - File Flags // Note: These flags correspond to // DOS flags up to 0x20 (Archive). // If other flags are set, reject // the file. UINT32 NA_Reparse; // 0x3C UINT8 NA_NameLength; // 0x40 - Length of file name in Words UINT8 NA_NameType; // 0x41 - File Name type // 0x00 - POSIX // 0x01 - Unicode // 0x02 - DOS // 0x03 - Both CHAR16 NA_Name[1]; // 0x42 - File Name (unicode) } FR_NAME_ATTRIBUTE; // //---------------------------------------------------------------------------- // Name: FR_DATA_ATTRIBUTE (0x80) // // Description: Structure of a Master File Table Data Attribute. // // Referrals: // // Notes: This attribute can be preceeded by a resident or non-resident // attribute header. If resident, the data will be the actual // file data. If non-resident, the data will be a run list // //---------------------------------------------------------------------------- // typedef struct _FR_DATA_ATTRIBUTE { UINT8 DA_Data[1]; // 0x00 - Run List or data } FR_DATA_ATTRIBUTE; // //---------------------------------------------------------------------------- // Name: FR_INDEX_ROOT_ATTRIBUTE (0x90) // // Description: Structure of a Master File Table Index Root Attribute. // // Referrals: // // Notes: A small index will have it's entries inside this attribute. // This attribute is preceeded by a resident attribute header. // //---------------------------------------------------------------------------- // typedef struct _FR_INDEX_ROOT_ATTRIBUTE { UINT32 IRA_Type; UINT32 IRA_Collation; UINT32 IRA_Size; UINT8 IRA_ClustersPerIndexRec; UINT8 Padding1[3]; UINT32 IRA_Offset; // 0x10 - Offset to Index entries (if small index) // The above offset is from here, // not from beginning. UINT32 IRA_TotalSize; UINT32 IRA_AllocSize; UINT8 IRA_Flags; // 0x1C - 0 = small index, 1 = large index UINT8 Padding2[3]; } FR_INDEX_ROOT_ATTRIBUTE; // //---------------------------------------------------------------------------- // Name: FR_INDEX_ALLOC_ATTRIBUTE (0xA0) // // Description: Structure of a Master File Table Index Allocation Attribute. // // Referrals: // // Notes: A large index will be in a separate index file, and the // run list in this attribute will indicate where it is. // This attribute is preceeded by a non-resident attribute header // //---------------------------------------------------------------------------- // typedef struct _FR_INDEX_ALLOC_ATTRIBUTE { UINT8 IAA_RunList[1]; // 0x00 - Run list of index record } FR_INDEX_ALLOC_ATTRIBUTE; // //---------------------------------------------------------------------------- // Name: INDEX_RECORD // // Description: Structure of an Index record. // // Referrals: // // Notes: In NTFS, the Index is equivalent to a directory in FAT. A large // index will be contained in an Index Record, while a small index // will be contained within the Master File Table File Record for // the index, in the Index Root Attribute. Index Records are // files, the way FAT directories are files, but not every // "directory" will have a file. See the structure INDEX_ENTRY // for the actual "directory entry" format. // //---------------------------------------------------------------------------- // typedef struct _INDEX_RECORD { CHAR8 INDR_Name[4]; // 0x00 - Always "INDX" UINT16 INDR_UpSeqOff; // 0x04 - Offset to update sequence UINT16 INDR_UpSeqSize; // 0x06 - Size of update sequence UINT64 INDR_LogSeqNo; // 0x08 - Log sequence number UINT64 INDR_VCN; // 0x10 - Virtual Cluster Number UINT32 INDR_IndxEntryOff; // 0x18 - Offset to Index Entries // (from here, not from start) UINT32 INDR_IndxEntrySize; // 0x1C - Size of Index Entries UINT32 INDR_IndxEntryAlloc; // 0x20 - Allocated size of Entries UINT8 INDR_LeafNode; // 0x24 - 1 if not leaf node UINT8 INDR_Padding[3]; // 0x25 - Padding UINT16 INDR_UpdateSequence; // 0x28 - Update Sequence UINT16 INDR_SeqenceArray[1]; // 0x2A - Sequence Array } INDEX_RECORD; // //---------------------------------------------------------------------------- // Name: INDEX_ENTRY // // Description: Structure of an Index record entry. // // Referrals: // // Notes: In NTFS, the index is the equivalent of a directory in FAT, // so the index entry is the equivalent of a directory entry. // The lower 4 bytes of the MFT reference is the number of the // file's File Record in the MFT. The lower 4 bytes of the MFT // parent reference is the number of the File Record for the // Index that this entry is in. //---------------------------------------------------------------------------- // typedef struct _INDEX_ENTRY { UINT64 INDE_MFTRecord; // 0x00 - MFT reference of this entry's file UINT16 INDE_EntrySize; // 0x08 - Size of this entry UINT16 INDE_NameOffset; // 0x0a - Offset to file name UINT16 INDE_IndexFlags; // 0x0C - Index Flags UINT16 INDE_Padding; UINT64 INDE_MFTParentRec; // 0x10 - MFT refernece of this entry's parent UINT64 INDE_CreationTime; // 0x18 - File Creation Time UINT64 INDE_AlteredTime; // 0x20 - File Altered Time UINT64 INDE_MFTChangedTime; // 0x28 - MFT Record Changed Time UINT64 INDE_ReadTime; // 0x30 - File Read Time UINT64 INDE_AllocSize; // 0x38 - Allocated File Size UINT64 INDE_RealSize; // 0x40 - Real File Size UINT64 INDE_FileFlags; // 0x48 - File Flags (like DOS flags + more) UINT8 INDE_NameLength; // 0x50 - Length of File name UINT8 INDE_NameType; // 0x51 - File Name type // 0x00 - POSIX // 0x01 - Unicode // 0x02 - DOS // 0x03 - Both CHAR16 INDE_Name[1]; // 0x52 - File Name (Unicode, not terminated) } INDEX_ENTRY; // // EXTx STRUCTURES // // //---------------------------------------------------------------------------- // Name: DIR_ENTRY_EXT // // Description: Structure of a EXT directory entry // // Referrals: // // Notes: The directory entry length must be a multiple of 4 bytes // Padding will be added after the name if necessary. // Note that the directory does not contain any file info // other than the name. That info is in the inode for the file. // //---------------------------------------------------------------------------- // typedef struct _DIR_ENTRY_EXT { UINT32 DIR_Inode; // 0x00 - Inode no. of file UINT16 DIR_EntryLength; // 0x04 - Length of dir. entry UINT8 DIR_NameLength; // 0x06 - Length of name UINT8 DIR_FileType; // 0x07 - Type of file // 1 = regular file, 2 = directory CHAR8 DIR_Name[1]; // 0x08 - File name starts here } DIR_ENTRY_EXT; // //---------------------------------------------------------------------------- // Name: VOLUME_SB // // Description: Structure of the Volume SuperBlock for EXT volumes. // // Referrals: // // Notes: The Superblock is equivalent to the BPB of a FAT or NTFS // volume, containing information about the volume. However, // it does not contain any boot code. // //---------------------------------------------------------------------------- // typedef struct _VOLUME_SB { UINT32 SB_TotalInodes; // 0x00 - Total Inodes UINT32 SB_TotalBlocks; // 0x04 - Total size in blocks UINT32 SB_ReservedBlocks; // 0x08 - Reserved blocks UINT32 SB_FreeBlocks; // 0x0C - Free blocks UINT32 SB_FreeInodes; // 0x10 - Free inodes UINT32 SB_FirstBlock; // 0x14 - First data block (always 1 or 0) UINT32 SB_BlockSize; // 0x18 - Block size shift value // The actual block size is calculated // as 1024 << SB_BlockSize UINT32 SB_FragSize; // 0x0C - Fragment size UINT32 SB_BlocksPerGroup; // 0x20 - Blocks per group UINT32 SB_FragsPerGroup; // 0x24 - Fragments per group UINT32 SB_InodesPerGroup; // 0x28 - Inodes per group UINT32 SB_LastMountTime; // 0x2C - Time of last mount UINT32 SB_LastWriteTime; // 0x30 - Time of last write UINT16 SB_MountCount; // 0x34 - Count of mounts since verification UINT16 SB_MaxMountCount; // 0x36 - Max mounts allowed before check UINT16 SB_Magic; // 0x38 - Magic number (0xEF53) UINT16 SB_StatusFlag; // 0x3A - 1 = clean, 2 = error UINT16 SB_ErrorDo; // 0x3C - What to do if error UINT16 SB_MinorRev; // 0x3E - Minor revision level UINT32 SB_LastCheckTime; // 0x40 UINT32 SB_CheckInterval; // 0x44 UINT32 SB_CreatorOS; // 0x48 - OS that created the volume (0=Linux) UINT32 SB_Revision; // 0x4C UINT16 SB_DefaultUID; // 0x50 - Default User ID UINT16 SB_DefaultGID; // 0x52 - Default Group ID UINT32 SB_FirstInode; // 0x54 - First non-reserved inode UINT16 SB_InodeStrucSize; // 0x58 - Inode structure size UINT16 SB_BlockGroupNo; // 0x5A - Block Group Number UINT32 SB_CompFeatMap; // 0x5C - Compatible feature bitmap UINT32 SB_IncompFeatMap; // 0x60 - Incompatible feature bitmap UINT32 SB_ROCompFeatMap; // 0x64 - Read-only comp. feature bitmap EFI_GUID SB_UUID; // 0x68 - Volume Unique ID CHAR8 SB_VolumeName[16]; // 0x78 - Volume name CHAR8 SB_LastPath[64]; // 0x88 - Last mount path (normally not used) UINT32 SB_AlgoBitmap; // 0xC8 - Compression algorithm bitmap UINT8 SB_PreAllocBlocks; // 0xCC - Blocks to pre-allocate for new file UINT8 SB_PreAllocBlocksDir;// 0xCD - Blocks to pre-allocate for new directory UINT8 SB_Padding[512-0xCE];// 0xCE - Padding to 1024 starts here // We're loading this into an MBR buffer, // so we only pad to 512. } VOLUME_SB; // //---------------------------------------------------------------------------- // Name: VOLUME_BGDT // // Description: Structure of the Volume Block Group Descriptor Table. // // Referrals: // // Notes: In EXT, volumes are arranged as groups of blocks. The size // of each group is defined in SB_BlocksPerGroup in the // Superblock. The descriptor table gives info about the group. // //---------------------------------------------------------------------------- // typedef struct _VOLUME_BGDT { UINT32 BGDT_BlockBitmapBlk; // 0x00 - Block bitmap block number UINT32 BGDT_InodeBitmapBlk; // 0x04 - Inode bitmap block number UINT32 BGDT_InodeTableBlk; // 0x08 - Inode table block number UINT16 BGDT_FreeBlocks; // 0x0C - Free blocks in the group UINT16 BGDT_FreeInodes; // 0x0E - Free inodes in the group UINT16 BGDT_UsedDirs; // 0x10 - Inodes used for directories in the group UINT16 BGDT_Padding; // 0x12 - Padding UINT8 BGDT_Reserved[12]; // 0x14 - Reserved } VOLUME_BGDT; // //---------------------------------------------------------------------------- // Name: VOLUME_IT // // Description: Structure of an Inode table // // Referrals: // // Notes: The inode table table contains all the information about each // file EXCEPT the file's name, which is in the directory. // The directory contains the file's name and inode number. // The inodes are numbered sequentially in the table, and the // table occupies consecutive blocks. // // EXT2, EXT3 File allocation method: // The block map of the file in IT_Blocks works as follows: // The first 12 entries are direct block numbers of the file. // The 13th entry is the number of a block containing block // numbers of the file (single-indirect blocks). // The 14th entry is the number of a block containing block // numbers of blocks containing file block numbers (double- // indirect blocks). // Similarly, the 15th entry is triple-indirect blocks. // Therefore, the maximum file size with 1024-byte blocks // would be 12+256+65536+16777216 1024-byte blocks. // // EXT4 File allocation method: // Instead of a block map, EXT4 has a header followed by up // to 4 extents of contiguous blocks. If the entire file is // contiguous, there will be only one extent. Each extent // consists of a 32-bit logical block no. (relative to the // start of the file), a 16-bit block count, and a 48-bit // physical block number, expressed as a 16-bit high value // and a 32-bit low value. If a file requires more than 4 // extents, the value of EH_Depth in the header will be // non-zero, and the first extent will point to a block of // extents indtead of the file. // // The file dates in VOLUME_IT are the number of seconds since // January 1, 1970. // //---------------------------------------------------------------------------- // typedef struct _EXT_HDR { UINT16 EH_Magic; // 0x00 - Magic number (0xF30A) UINT16 EH_Extents; // 0x02 - Number of extents UINT16 EH_Max; // 0x04 - Maximum no. of extents UINT16 EH_Depth; // 0x06 - Depth of tree (0 normally) UINT32 EH_Generation; // 0x08 - Generation ID (currently 0) } EXT_HDR; typedef struct _EXT_EXT { UINT32 EE_LogBlk; // 0x00 - Logical block no. UINT16 EE_Length; // 0x04 - Length of extent in blocks UINT16 EE_BlockHi; // 0x06 - Uppper 16 bits of block no. UINT32 EE_BlockLo; // 0x08 - Lower 32 bits of block no. } EXT_EXT; typedef struct _VOLUME_IT { UINT16 IT_Type; // 0x00 - File type and access rights // 0x8??? = regular file // 0x4??? = directory UINT16 IT_UID; // 0x02 - User ID UINT32 IT_SizeLo; // 0x04 - File size (low 32 bits) UINT32 IT_ATime; // 0x08 - Last access time UINT32 IT_CTime; // 0x0C - File creation time UINT32 IT_MTime; // 0x10 - File modified time UINT32 IT_DTime; // 0x14 - File deleted time UINT16 IT_GID; // 0x18 - Group ID UINT16 IT_Links; // 0x1A - Links to this file (usually 1) UINT32 IT_ListSize; // 0x1C - Block list size in 512-byte units. UINT32 IT_Flags; // 0x20 - File flags UINT32 IT_OSD1; // 0x24 - OS Dependant value no. 1 union { struct { UINT32 Blocks[15]; // 0x28 - Blocks occupied by file (see notes) } Ext2; struct { EXT_HDR Header; // 0x28 - Extent header EXT_EXT Extent[4]; // 0x34 - Extents of file (see notes) } Ext4; } Alloc; UINT32 IT_Version; // 0x64 - File version UINT32 IT_FileACL; // 0x68 - File Access Control List UINT32 IT_SizeHi; // 0x6C - File size (high 32 bits) UINT32 IT_Fragment; // 0x70 - Not used in Linux UINT32 IT_OSD2[3]; // 0x74 - OS Dependant value no. 2 } VOLUME_IT; // //---------------------------------------------------------------------------- // Name: MEMORY_BLOCK // // Description: Structure of a memory boock used to hold various basic // structures. // // Referrals: // // Notes: In order to make a smaller compiled binary, this memory block // is allocated, and used to hold structures that were formerly // reserved statically. // //---------------------------------------------------------------------------- // typedef struct _MEMORY_BLOCK { MASTER_BOOT_RECORD Mbr; // Master boot record (all file systems) BOOT_SECTOR Bs; // Boot sector (FAT and NTFS) UINT8 MFTRunList[256];// Master File Table run list (NTFS) UINT8 RootRunList[128];// Root dir run list (NTFS) UINT8 ResidentIndex[256];// Stores resident index (NTFS) VOLUME_SB Sb; // Superblock (EXT(n)) VOLUME_IT RootInode; // Root directory inode (EXT(n)) VOLUME_IT FileInode; // File inode (EXT(n)) } MEMORY_BLOCK; #pragma pack(pop) //**************** eLink override definitions ******************************* //This functions may be overriden by eLinks VOID GetFileListFromPrimaryVolume( IN DIR_RECORD *Root, IN UINT32 RootSize, OUT UINTN *NumberOfFiles, OUT DIR_RECORD **Buffer ); VOID GetFileListFromFatVolume( IN DIR_ENTRY *Root, IN UINT32 RootEntries, OUT UINTN *NumberOfFiles, OUT DIR_ENTRY **Buffer ); VOID GetFileListFromNtfsVolume( IN UINT8 *Root, IN UINT32 RootSize, OUT UINTN *NumberOfFiles, OUT INDEX_ENTRY **Buffer ); VOID GetFileListFromExtVolume( IN UINT8 *Root, IN UINT32 RootSize, OUT UINTN *NumberOfFiles, OUT DIR_ENTRY_EXT **Buffer ); BOOLEAN IsValidFile( IN VOID *FileData, IN UINTN FileSize ); EFI_STATUS GetRecoveryFileInfo( IN EFI_PEI_SERVICES **PeiServices, IN OUT VOID **pCapsuleName, IN OUT UINTN *pCapsuleSize, OUT BOOLEAN *ExtendedVerification ); /****** DO NOT WRITE BELOW THIS LINE *******/ #ifdef __cplusplus } #endif #endif //************************************************************************* //************************************************************************* //** ** //** (C)Copyright 1985-2008, American Megatrends, Inc. ** //** ** //** All Rights Reserved. ** //** ** //** 5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093 ** //** ** //** Phone: (770)-246-8600 ** //** ** //************************************************************************* //*************************************************************************