path: root/Core/EM/Recovery/RecoveryCsp.h

//*************************************************************************
//*************************************************************************
//**                                                                     **
//**        (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
// 
//*************************************************************************
//<AMI_FHDR_START>
//
// Name:  RecoveryCsp.h
//
//  Description:
//  File system recovery data types definition
//
//<AMI_FHDR_END>
//*************************************************************************
#ifndef __RECOVERY_CSP__H__
#define __RECOVERY_CSP__H__
#ifdef __cplusplus
extern "C" {
#endif

#include <PPI/DeviceRecoveryBlockIo.h>

#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
//
//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// Name:        MFT_FILE_RECORD
//
// Description: Structure of a Master File Table file record.
//
// Referrals:
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;


//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;


//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// Name:        FR_ATTR_HEADER_NONRES
//
// Description: Structure of a File Record non-resident attribute header.
//
// Referrals:
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;


//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;

//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

typedef struct _FR_DATA_ATTRIBUTE
{
    UINT8 DA_Data[1];   // 0x00 - Run List or data
} FR_DATA_ATTRIBUTE;

//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>
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;

//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>
typedef struct _FR_INDEX_ALLOC_ATTRIBUTE
{
    UINT8 IAA_RunList[1];   // 0x00 - Run list of index record
} FR_INDEX_ALLOC_ATTRIBUTE;

//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>
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;

//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//----------------------------------------------------------------------------
//<AMI_SHDR_END>
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
//
//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>
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;


//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;


//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;


//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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;

//<AMI_SHDR_START>
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
//<AMI_SHDR_END>

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                         **
//**                                                                     **
//*************************************************************************
//*************************************************************************