FwVol.c

Go to the documentation of this file.

 
#include "FwVol.h"
 
EFI_PEI_NOTIFY_DESCRIPTOR  mNotifyOnFvInfoList[] = {
  {
    EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK,
    &gEfiPeiFirmwareVolumeInfoPpiGuid,
    FirmwareVolumeInfoPpiNotifyCallback
  },
  {
    (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
    &gEfiPeiFirmwareVolumeInfo2PpiGuid,
    FirmwareVolumeInfoPpiNotifyCallback
  }
};
 
PEI_FW_VOL_INSTANCE  mPeiFfs2FwVol = {
  PEI_FW_VOL_SIGNATURE,
  FALSE,
  {
    PeiFfsFvPpiProcessVolume,
    PeiFfsFvPpiFindFileByType,
    PeiFfsFvPpiFindFileByName,
    PeiFfsFvPpiGetFileInfo,
    PeiFfsFvPpiGetVolumeInfo,
    PeiFfsFvPpiFindSectionByType,
    PeiFfsFvPpiGetFileInfo2,
    PeiFfsFvPpiFindSectionByType2,
    EFI_PEI_FIRMWARE_VOLUME_PPI_SIGNATURE,
    EFI_PEI_FIRMWARE_VOLUME_PPI_REVISION
  }
};
 
PEI_FW_VOL_INSTANCE  mPeiFfs3FwVol = {
  PEI_FW_VOL_SIGNATURE,
  TRUE,
  {
    PeiFfsFvPpiProcessVolume,
    PeiFfsFvPpiFindFileByType,
    PeiFfsFvPpiFindFileByName,
    PeiFfsFvPpiGetFileInfo,
    PeiFfsFvPpiGetVolumeInfo,
    PeiFfsFvPpiFindSectionByType,
    PeiFfsFvPpiGetFileInfo2,
    PeiFfsFvPpiFindSectionByType2,
    EFI_PEI_FIRMWARE_VOLUME_PPI_SIGNATURE,
    EFI_PEI_FIRMWARE_VOLUME_PPI_REVISION
  }
};
 
EFI_PEI_PPI_DESCRIPTOR  mPeiFfs2FvPpiList = {
  (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  &gEfiFirmwareFileSystem2Guid,
  &mPeiFfs2FwVol.Fv
};
 
EFI_PEI_PPI_DESCRIPTOR  mPeiFfs3FvPpiList = {
  (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  &gEfiFirmwareFileSystem3Guid,
  &mPeiFfs3FwVol.Fv
};
 
UINT8  mFvAttributes[]  = { 0, 4, 7, 9, 10, 12, 15, 16 };
UINT8  mFvAttributes2[] = { 17, 18, 19, 20, 21, 22, 23, 24 };
 
EFI_FV_FILE_ATTRIBUTES
FfsAttributes2FvFileAttributes (
  IN EFI_FFS_FILE_ATTRIBUTES  FfsAttributes
  )
{
  UINT8                   DataAlignment;
  EFI_FV_FILE_ATTRIBUTES  FileAttribute;
 
  DataAlignment = (UINT8)((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT) >> 3);
  ASSERT (DataAlignment < 8);
 
  if ((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT_2) != 0) {
    FileAttribute = (EFI_FV_FILE_ATTRIBUTES)mFvAttributes2[DataAlignment];
  } else {
    FileAttribute = (EFI_FV_FILE_ATTRIBUTES)mFvAttributes[DataAlignment];
  }
 
  if ((FfsAttributes & FFS_ATTRIB_FIXED) == FFS_ATTRIB_FIXED) {
    FileAttribute |= EFI_FV_FILE_ATTRIB_FIXED;
  }
 
  return FileAttribute;
}
 
EFI_FFS_FILE_STATE
GetFileState (
  IN UINT8                ErasePolarity,
  IN EFI_FFS_FILE_HEADER  *FfsHeader
  )
{
  EFI_FFS_FILE_STATE  FileState;
  EFI_FFS_FILE_STATE  HighestBit;
 
  FileState = FfsHeader->State;
 
  if (ErasePolarity != 0) {
    FileState = (EFI_FFS_FILE_STATE) ~FileState;
  }
 
  //
  // Get file state set by its highest none zero bit.
  //
  HighestBit = 0x80;
  while (HighestBit != 0 && (HighestBit & FileState) == 0) {
    HighestBit >>= 1;
  }
 
  return HighestBit;
}
 
UINT8
CalculateHeaderChecksum (
  IN EFI_FFS_FILE_HEADER  *FileHeader
  )
{
  EFI_FFS_FILE_HEADER2  TestFileHeader;
 
  if (IS_FFS_FILE2 (FileHeader)) {
    CopyMem (&TestFileHeader, FileHeader, sizeof (EFI_FFS_FILE_HEADER2));
    //
    // Ignore State and File field in FFS header.
    //
    TestFileHeader.State                        = 0;
    TestFileHeader.IntegrityCheck.Checksum.File = 0;
 
    return CalculateSum8 ((CONST UINT8 *)&TestFileHeader, sizeof (EFI_FFS_FILE_HEADER2));
  } else {
    CopyMem (&TestFileHeader, FileHeader, sizeof (EFI_FFS_FILE_HEADER));
    //
    // Ignore State and File field in FFS header.
    //
    TestFileHeader.State                        = 0;
    TestFileHeader.IntegrityCheck.Checksum.File = 0;
 
    return CalculateSum8 ((CONST UINT8 *)&TestFileHeader, sizeof (EFI_FFS_FILE_HEADER));
  }
}
 
PEI_CORE_FV_HANDLE *
FileHandleToVolume (
  IN   EFI_PEI_FILE_HANDLE  FileHandle
  )
{
  UINTN                       Index;
  PEI_CORE_INSTANCE           *PrivateData;
  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
  UINTN                       BestIndex;
 
  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
  BestIndex   = PrivateData->FvCount;
 
  //
  // Find the best matched FV image that includes this FileHandle.
  // FV may include the child FV, and they are in the same continuous space.
  // If FileHandle is from the child FV, the updated logic can find its matched FV.
  //
  for (Index = 0; Index < PrivateData->FvCount; Index++) {
    FwVolHeader = PrivateData->Fv[Index].FvHeader;
    if (((UINT64)(UINTN)FileHandle > (UINT64)(UINTN)FwVolHeader) &&   \
        ((UINT64)(UINTN)FileHandle <= ((UINT64)(UINTN)FwVolHeader + FwVolHeader->FvLength - 1)))
    {
      if (BestIndex == PrivateData->FvCount) {
        BestIndex = Index;
      } else {
        if ((UINT64)(UINTN)PrivateData->Fv[BestIndex].FvHeader < (UINT64)(UINTN)FwVolHeader) {
          BestIndex = Index;
        }
      }
    }
  }
 
  if (BestIndex < PrivateData->FvCount) {
    return &PrivateData->Fv[BestIndex];
  }
 
  return NULL;
}
 
EFI_STATUS
FindFileEx (
  IN  CONST EFI_PEI_FV_HANDLE    FvHandle,
  IN  CONST EFI_GUID             *FileName    OPTIONAL,
  IN        EFI_FV_FILETYPE      SearchType,
  IN OUT    EFI_PEI_FILE_HANDLE  *FileHandle,
  IN OUT    EFI_PEI_FILE_HANDLE  *AprioriFile  OPTIONAL
  )
{
  EFI_FIRMWARE_VOLUME_HEADER      *FwVolHeader;
  EFI_FIRMWARE_VOLUME_EXT_HEADER  *FwVolExtHeader;
  EFI_FFS_FILE_HEADER             **FileHeader;
  EFI_FFS_FILE_HEADER             *FfsFileHeader;
  UINT32                          FileLength;
  UINT32                          FileOccupiedSize;
  UINT64                          FileOffset;
  UINT64                          FvLength;
  UINT8                           ErasePolarity;
  UINT8                           FileState;
  UINT8                           DataCheckSum;
  BOOLEAN                         IsFfs3Fv;
 
  //
  // Convert the handle of FV to FV header for memory-mapped firmware volume
  //
  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FvHandle;
  FileHeader  = (EFI_FFS_FILE_HEADER **)FileHandle;
 
  IsFfs3Fv = CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiFirmwareFileSystem3Guid);
 
  FvLength = FwVolHeader->FvLength;
  if ((FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) != 0) {
    ErasePolarity = 1;
  } else {
    ErasePolarity = 0;
  }
 
  //
  // If FileHeader is not specified (NULL) or FileName is not NULL,
  // start with the first file in the firmware volume.  Otherwise,
  // start from the FileHeader.
  //
  if ((*FileHeader == NULL) || (FileName != NULL)) {
    if (FwVolHeader->ExtHeaderOffset != 0) {
      //
      // Searching for files starts on an 8 byte aligned boundary after the end of the Extended Header if it exists.
      //
      FwVolExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)((UINT8 *)FwVolHeader + FwVolHeader->ExtHeaderOffset);
      FfsFileHeader  = (EFI_FFS_FILE_HEADER *)((UINT8 *)FwVolExtHeader + FwVolExtHeader->ExtHeaderSize);
    } else {
      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FwVolHeader + FwVolHeader->HeaderLength);
    }
 
    FfsFileHeader = (EFI_FFS_FILE_HEADER *)ALIGN_POINTER (FfsFileHeader, 8);
  } else {
    if (IS_FFS_FILE2 (*FileHeader)) {
      if (!IsFfs3Fv) {
        DEBUG ((DEBUG_ERROR, "It is a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &(*FileHeader)->Name));
      }
 
      FileLength = FFS_FILE2_SIZE (*FileHeader);
      ASSERT (FileLength > 0x00FFFFFF);
    } else {
      FileLength = FFS_FILE_SIZE (*FileHeader);
    }
 
    //
    // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
    //
    FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
    FfsFileHeader    = (EFI_FFS_FILE_HEADER *)((UINT8 *)*FileHeader + FileOccupiedSize);
  }
 
  FileOffset = ((UINT8 *)FfsFileHeader - (UINT8 *)FwVolHeader);
  ASSERT (FileOffset <= MAX_UINT32);
 
  while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {
    //
    // Get FileState which is the highest bit of the State
    //
    FileState = GetFileState (ErasePolarity, FfsFileHeader);
    switch (FileState) {
      case EFI_FILE_HEADER_CONSTRUCTION:
      case EFI_FILE_HEADER_INVALID:
        if (IS_FFS_FILE2 (FfsFileHeader)) {
          if (!IsFfs3Fv) {
            DEBUG ((DEBUG_ERROR, "Found a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &FfsFileHeader->Name));
          }
 
          FileOffset   += sizeof (EFI_FFS_FILE_HEADER2);
          FfsFileHeader =  (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER2));
        } else {
          FileOffset   += sizeof (EFI_FFS_FILE_HEADER);
          FfsFileHeader =  (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));
        }
 
        break;
 
      case EFI_FILE_DATA_VALID:
      case EFI_FILE_MARKED_FOR_UPDATE:
        if (CalculateHeaderChecksum (FfsFileHeader) != 0) {
          ASSERT (FALSE);
          *FileHeader = NULL;
          return EFI_NOT_FOUND;
        }
 
        if (IS_FFS_FILE2 (FfsFileHeader)) {
          FileLength = FFS_FILE2_SIZE (FfsFileHeader);
          ASSERT (FileLength > 0x00FFFFFF);
          FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
          if (!IsFfs3Fv) {
            DEBUG ((DEBUG_ERROR, "Found a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &FfsFileHeader->Name));
            FileOffset   += FileOccupiedSize;
            FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
            break;
          }
        } else {
          FileLength       = FFS_FILE_SIZE (FfsFileHeader);
          FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
        }
 
        DataCheckSum = FFS_FIXED_CHECKSUM;
        if ((FfsFileHeader->Attributes & FFS_ATTRIB_CHECKSUM) == FFS_ATTRIB_CHECKSUM) {
          if (IS_FFS_FILE2 (FfsFileHeader)) {
            DataCheckSum = CalculateCheckSum8 ((CONST UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER2), FileLength - sizeof (EFI_FFS_FILE_HEADER2));
          } else {
            DataCheckSum = CalculateCheckSum8 ((CONST UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER), FileLength - sizeof (EFI_FFS_FILE_HEADER));
          }
        }
 
        if (FfsFileHeader->IntegrityCheck.Checksum.File != DataCheckSum) {
          ASSERT (FALSE);
          *FileHeader = NULL;
          return EFI_NOT_FOUND;
        }
 
        if (FileName != NULL) {
          if (CompareGuid (&FfsFileHeader->Name, (EFI_GUID *)FileName)) {
            *FileHeader = FfsFileHeader;
            return EFI_SUCCESS;
          }
        } else if (SearchType == PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE) {
          if ((FfsFileHeader->Type == EFI_FV_FILETYPE_PEIM) ||
              (FfsFileHeader->Type == EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER) ||
              (FfsFileHeader->Type == EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE))
          {
            *FileHeader = FfsFileHeader;
            return EFI_SUCCESS;
          } else if (AprioriFile != NULL) {
            if (FfsFileHeader->Type == EFI_FV_FILETYPE_FREEFORM) {
              if (CompareGuid (&FfsFileHeader->Name, &gPeiAprioriFileNameGuid)) {
                *AprioriFile = (EFI_PEI_FILE_HANDLE)FfsFileHeader;
              }
            }
          }
        } else if (((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) &&
                   (FfsFileHeader->Type != EFI_FV_FILETYPE_FFS_PAD))
        {
          *FileHeader = FfsFileHeader;
          return EFI_SUCCESS;
        }
 
        FileOffset   += FileOccupiedSize;
        FfsFileHeader =  (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
        break;
 
      case EFI_FILE_DELETED:
        if (IS_FFS_FILE2 (FfsFileHeader)) {
          if (!IsFfs3Fv) {
            DEBUG ((DEBUG_ERROR, "Found a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &FfsFileHeader->Name));
          }
 
          FileLength = FFS_FILE2_SIZE (FfsFileHeader);
          ASSERT (FileLength > 0x00FFFFFF);
        } else {
          FileLength = FFS_FILE_SIZE (FfsFileHeader);
        }
 
        FileOccupiedSize =  GET_OCCUPIED_SIZE (FileLength, 8);
        FileOffset      += FileOccupiedSize;
        FfsFileHeader    =  (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
        break;
 
      default:
        *FileHeader = NULL;
        return EFI_NOT_FOUND;
    }
  }
 
  *FileHeader = NULL;
  return EFI_NOT_FOUND;
}
 
EFI_GUID *
GetFvName (
  IN  CONST EFI_FIRMWARE_VOLUME_HEADER  *FvHeader
  )
{
  EFI_FIRMWARE_VOLUME_EXT_HEADER  *FvExtHeader;
 
  if (FvHeader->ExtHeaderOffset == 0) {
    return NULL;
  }
 
  FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)((UINT8 *)FvHeader + FvHeader->ExtHeaderOffset);
  return &FvExtHeader->FvName;
}
 
VOID
PeiInitializeFv (
  IN  PEI_CORE_INSTANCE          *PrivateData,
  IN CONST EFI_SEC_PEI_HAND_OFF  *SecCoreData
  )
{
  EFI_STATUS                   Status;
  EFI_PEI_FIRMWARE_VOLUME_PPI  *FvPpi;
  EFI_PEI_FV_HANDLE            FvHandle;
  EFI_FIRMWARE_VOLUME_HEADER   *BfvHeader;
 
  //
  // Install FV_PPI for FFS2 file system.
  //
  PeiServicesInstallPpi (&mPeiFfs2FvPpiList);
 
  //
  // Install FV_PPI for FFS3 file system.
  //
  PeiServicesInstallPpi (&mPeiFfs3FvPpiList);
 
  BfvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)SecCoreData->BootFirmwareVolumeBase;
 
  //
  // The FV_PPI in BFV's format should be installed.
  //
  Status = PeiServicesLocatePpi (
             &BfvHeader->FileSystemGuid,
             0,
             NULL,
             (VOID **)&FvPpi
             );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Get handle of BFV
  //
  Status = FvPpi->ProcessVolume (
                    FvPpi,
                    SecCoreData->BootFirmwareVolumeBase,
                    (UINTN)BfvHeader->FvLength,
                    &FvHandle
                    );
  ASSERT_EFI_ERROR (Status);
 
  PrivateData->Fv = AllocateZeroPool (sizeof (PEI_CORE_FV_HANDLE) * FV_GROWTH_STEP);
  ASSERT (PrivateData->Fv != NULL);
  PrivateData->MaxFvCount = FV_GROWTH_STEP;
 
  //
  // Update internal PEI_CORE_FV array.
  //
  PrivateData->Fv[PrivateData->FvCount].FvHeader             = BfvHeader;
  PrivateData->Fv[PrivateData->FvCount].FvPpi                = FvPpi;
  PrivateData->Fv[PrivateData->FvCount].FvHandle             = FvHandle;
  PrivateData->Fv[PrivateData->FvCount].AuthenticationStatus = 0;
  DEBUG ((
    DEBUG_INFO,
    "The %dth FV[%g] start address is 0x%11p, size is 0x%08x, handle is 0x%p\n",
    (UINT32)PrivateData->FvCount,
    GetFvName (BfvHeader),
    (VOID *)BfvHeader,
    (UINT32)BfvHeader->FvLength,
    FvHandle
    ));
  PrivateData->FvCount++;
 
  //
  // Post a call-back for the FvInfoPPI and FvInfo2PPI services to expose
  // additional FVs to PeiCore.
  //
  Status = PeiServicesNotifyPpi (mNotifyOnFvInfoList);
  ASSERT_EFI_ERROR (Status);
}
 
EFI_STATUS
EFIAPI
FirmwareVolumeInfoPpiNotifyCallback (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  )
{
  EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI  FvInfo2Ppi;
  EFI_PEI_FIRMWARE_VOLUME_PPI        *FvPpi;
  PEI_CORE_INSTANCE                  *PrivateData;
  EFI_STATUS                         Status;
  EFI_PEI_FV_HANDLE                  FvHandle;
  UINTN                              FvIndex;
  EFI_PEI_FILE_HANDLE                FileHandle;
  VOID                               *DepexData;
  BOOLEAN                            IsFvInfo2;
  UINTN                              CurFvCount;
  VOID                               *TempPtr;
 
  Status      = EFI_SUCCESS;
  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
 
  if (CompareGuid (NotifyDescriptor->Guid, &gEfiPeiFirmwareVolumeInfo2PpiGuid)) {
    //
    // It is FvInfo2PPI.
    //
    CopyMem (&FvInfo2Ppi, Ppi, sizeof (EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI));
    IsFvInfo2 = TRUE;
  } else {
    //
    // It is FvInfoPPI.
    //
    CopyMem (&FvInfo2Ppi, Ppi, sizeof (EFI_PEI_FIRMWARE_VOLUME_INFO_PPI));
    FvInfo2Ppi.AuthenticationStatus = 0;
    IsFvInfo2                       = FALSE;
  }
 
  if (CompareGuid (&FvInfo2Ppi.FvFormat, &gEfiFirmwareFileSystem2Guid)) {
    //
    // gEfiFirmwareFileSystem2Guid is specified for FvFormat, then here to check the
    // FileSystemGuid pointed by FvInfo against gEfiFirmwareFileSystem2Guid to make sure
    // FvInfo has the firmware file system 2 format.
    //
    // If the ASSERT really appears, FvFormat needs to be specified correctly, for example,
    // gEfiFirmwareFileSystem3Guid can be used for firmware file system 3 format, or
    // ((EFI_FIRMWARE_VOLUME_HEADER *) FvInfo)->FileSystemGuid can be just used for both
    // firmware file system 2 and 3 format.
    //
    ASSERT (CompareGuid (&(((EFI_FIRMWARE_VOLUME_HEADER *)FvInfo2Ppi.FvInfo)->FileSystemGuid), &gEfiFirmwareFileSystem2Guid));
  }
 
  //
  // Locate the corresponding FV_PPI according to the format GUID of the FV found
  //
  Status = PeiServicesLocatePpi (
             &FvInfo2Ppi.FvFormat,
             0,
             NULL,
             (VOID **)&FvPpi
             );
  if (!EFI_ERROR (Status)) {
    //
    // Process new found FV and get FV handle.
    //
    Status = FvPpi->ProcessVolume (FvPpi, FvInfo2Ppi.FvInfo, FvInfo2Ppi.FvInfoSize, &FvHandle);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "Fail to process new found FV, FV may be corrupted!\n"));
      return Status;
    }
 
    //
    // Check whether the FV has already been processed.
    //
    for (FvIndex = 0; FvIndex < PrivateData->FvCount; FvIndex++) {
      if (PrivateData->Fv[FvIndex].FvHandle == FvHandle) {
        if (IsFvInfo2 && (FvInfo2Ppi.AuthenticationStatus != PrivateData->Fv[FvIndex].AuthenticationStatus)) {
          PrivateData->Fv[FvIndex].AuthenticationStatus = FvInfo2Ppi.AuthenticationStatus;
          DEBUG ((DEBUG_INFO, "Update AuthenticationStatus of the %dth FV to 0x%x!\n", FvIndex, FvInfo2Ppi.AuthenticationStatus));
        }
 
        DEBUG ((DEBUG_INFO, "The FV %p has already been processed!\n", FvInfo2Ppi.FvInfo));
        return EFI_SUCCESS;
      }
    }
 
    if (PrivateData->FvCount >= PrivateData->MaxFvCount) {
      //
      // Run out of room, grow the buffer.
      //
      TempPtr = AllocateZeroPool (
                  sizeof (PEI_CORE_FV_HANDLE) * (PrivateData->MaxFvCount + FV_GROWTH_STEP)
                  );
      ASSERT (TempPtr != NULL);
      CopyMem (
        TempPtr,
        PrivateData->Fv,
        sizeof (PEI_CORE_FV_HANDLE) * PrivateData->MaxFvCount
        );
      PrivateData->Fv         = TempPtr;
      PrivateData->MaxFvCount = PrivateData->MaxFvCount + FV_GROWTH_STEP;
    }
 
    //
    // Update internal PEI_CORE_FV array.
    //
    PrivateData->Fv[PrivateData->FvCount].FvHeader             = (EFI_FIRMWARE_VOLUME_HEADER *)FvInfo2Ppi.FvInfo;
    PrivateData->Fv[PrivateData->FvCount].FvPpi                = FvPpi;
    PrivateData->Fv[PrivateData->FvCount].FvHandle             = FvHandle;
    PrivateData->Fv[PrivateData->FvCount].AuthenticationStatus = FvInfo2Ppi.AuthenticationStatus;
    CurFvCount                                                 = PrivateData->FvCount;
    DEBUG ((
      DEBUG_INFO,
      "The %dth FV[%g] start address is 0x%11p, size is 0x%08x, handle is 0x%p\n",
      (UINT32)CurFvCount,
      GetFvName ((EFI_FIRMWARE_VOLUME_HEADER *)FvInfo2Ppi.FvInfo),
      (VOID *)FvInfo2Ppi.FvInfo,
      FvInfo2Ppi.FvInfoSize,
      FvHandle
      ));
    PrivateData->FvCount++;
 
    //
    // Scan and process the new discovered FV for EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
    //
    FileHandle = NULL;
    do {
      Status = FvPpi->FindFileByType (
                        FvPpi,
                        EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
                        FvHandle,
                        &FileHandle
                        );
      if (!EFI_ERROR (Status)) {
        Status = FvPpi->FindSectionByType (
                          FvPpi,
                          EFI_SECTION_PEI_DEPEX,
                          FileHandle,
                          (VOID **)&DepexData
                          );
        if (!EFI_ERROR (Status)) {
          if (!PeimDispatchReadiness (PeiServices, DepexData)) {
            //
            // Dependency is not satisfied.
            //
            continue;
          }
        }
 
        DEBUG ((DEBUG_INFO, "Found firmware volume Image File[%g] %p in FV[%d] %p\n", FileHandle, FileHandle, CurFvCount, FvHandle));
        ProcessFvFile (PrivateData, &PrivateData->Fv[CurFvCount], FileHandle);
      }
    } while (FileHandle != NULL);
  } else {
    DEBUG ((DEBUG_ERROR, "Fail to process FV %p because no corresponding EFI_FIRMWARE_VOLUME_PPI is found!\n", FvInfo2Ppi.FvInfo));
 
    AddUnknownFormatFvInfo (PrivateData, &FvInfo2Ppi);
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
VerifyGuidedSectionGuid (
  IN  EFI_GUID                               *GuidedSectionGuid,
  OUT EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI  **GuidedSectionExtraction
  )
{
  EFI_PEI_HOB_POINTERS  Hob;
  EFI_GUID              *GuidRecorded;
  VOID                  *Interface;
  EFI_STATUS            Status;
 
  //
  // Check if there is the Guided Section GUID HOB recorded the GUID itself.
  //
  Hob.Raw = GetFirstGuidHob (GuidedSectionGuid);
  if (Hob.Raw != NULL) {
    GuidRecorded = (EFI_GUID *)GET_GUID_HOB_DATA (Hob);
    if (CompareGuid (GuidRecorded, GuidedSectionGuid)) {
      //
      // Found the recorded GuidedSectionGuid.
      //
      Status = PeiServicesLocatePpi (GuidedSectionGuid, 0, NULL, (VOID **)&Interface);
      if (!EFI_ERROR (Status) && (Interface != NULL)) {
        //
        // Found the supported Guided Section Extraction Ppi for the Guided Section.
        //
        *GuidedSectionExtraction = (EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI *)Interface;
        return TRUE;
      }
 
      return FALSE;
    }
  }
 
  return FALSE;
}
 
EFI_STATUS
ProcessSection (
  IN CONST EFI_PEI_SERVICES     **PeiServices,
  IN EFI_SECTION_TYPE           SectionType,
  IN OUT UINTN                  *SectionInstance,
  IN EFI_COMMON_SECTION_HEADER  *Section,
  IN UINTN                      SectionSize,
  OUT VOID                      **OutputBuffer,
  OUT UINT32                    *AuthenticationStatus,
  IN BOOLEAN                    IsFfs3Fv
  )
{
  EFI_STATUS                             Status;
  UINT32                                 SectionLength;
  UINTN                                  ParsedLength;
  EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI  *GuidSectionPpi;
  EFI_PEI_DECOMPRESS_PPI                 *DecompressPpi;
  VOID                                   *PpiOutput;
  UINTN                                  PpiOutputSize;
  UINTN                                  Index;
  UINT32                                 Authentication;
  PEI_CORE_INSTANCE                      *PrivateData;
  EFI_GUID                               *SectionDefinitionGuid;
  BOOLEAN                                SectionCached;
  VOID                                   *TempOutputBuffer;
  UINT32                                 TempAuthenticationStatus;
  UINT16                                 GuidedSectionAttributes;
 
  PrivateData   = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
  *OutputBuffer = NULL;
  ParsedLength  = 0;
  Index         = 0;
  Status        = EFI_NOT_FOUND;
  PpiOutput     = NULL;
  PpiOutputSize = 0;
  while (ParsedLength < SectionSize) {
    if (IS_SECTION2 (Section)) {
      ASSERT (SECTION2_SIZE (Section) > 0x00FFFFFF);
      if (!IsFfs3Fv) {
        DEBUG ((DEBUG_ERROR, "Found a FFS3 formatted section in a non-FFS3 formatted FV.\n"));
        SectionLength = SECTION2_SIZE (Section);
        if (SectionLength == 0) {
          break;
        }
 
        //
        // SectionLength is adjusted it is 4 byte aligned.
        // Go to the next section
        //
        SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
        ASSERT (SectionLength != 0);
        ParsedLength += SectionLength;
        Section       = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
        continue;
      }
    }
 
    if (Section->Type == SectionType) {
      //
      // The type matches, so check the instance count to see if it's the one we want.
      //
      (*SectionInstance)--;
      if (*SectionInstance == 0) {
        //
        // Got it!
        //
        if (IS_SECTION2 (Section)) {
          *OutputBuffer = (VOID *)((UINT8 *)Section + sizeof (EFI_COMMON_SECTION_HEADER2));
        } else {
          *OutputBuffer = (VOID *)((UINT8 *)Section + sizeof (EFI_COMMON_SECTION_HEADER));
        }
 
        return EFI_SUCCESS;
      } else {
        if (IS_SECTION2 (Section)) {
          SectionLength = SECTION2_SIZE (Section);
        } else {
          SectionLength = SECTION_SIZE (Section);
        }
 
        if (SectionLength == 0) {
          break;
        }
 
        //
        // SectionLength is adjusted it is 4 byte aligned.
        // Go to the next section
        //
        SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
        ASSERT (SectionLength != 0);
        ParsedLength += SectionLength;
        Section       = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
        continue;
      }
    } else if ((Section->Type == EFI_SECTION_GUID_DEFINED) || (Section->Type == EFI_SECTION_COMPRESSION)) {
      //
      // Check the encapsulated section is extracted into the cache data.
      //
      SectionCached = FALSE;
      for (Index = 0; Index < PrivateData->CacheSection.AllSectionCount; Index++) {
        if (Section == PrivateData->CacheSection.Section[Index]) {
          SectionCached  = TRUE;
          PpiOutput      = PrivateData->CacheSection.SectionData[Index];
          PpiOutputSize  = PrivateData->CacheSection.SectionSize[Index];
          Authentication = PrivateData->CacheSection.AuthenticationStatus[Index];
          //
          // Search section directly from the cache data.
          //
          TempAuthenticationStatus = 0;
          Status                   = ProcessSection (
                                       PeiServices,
                                       SectionType,
                                       SectionInstance,
                                       PpiOutput,
                                       PpiOutputSize,
                                       &TempOutputBuffer,
                                       &TempAuthenticationStatus,
                                       IsFfs3Fv
                                       );
          if (!EFI_ERROR (Status)) {
            *OutputBuffer         = TempOutputBuffer;
            *AuthenticationStatus = TempAuthenticationStatus | Authentication;
            return EFI_SUCCESS;
          }
        }
      }
 
      //
      // If SectionCached is TRUE, the section data has been cached and scanned.
      //
      if (!SectionCached) {
        Status         = EFI_NOT_FOUND;
        Authentication = 0;
        if (Section->Type == EFI_SECTION_GUID_DEFINED) {
          if (IS_SECTION2 (Section)) {
            SectionDefinitionGuid   = &((EFI_GUID_DEFINED_SECTION2 *)Section)->SectionDefinitionGuid;
            GuidedSectionAttributes = ((EFI_GUID_DEFINED_SECTION2 *)Section)->Attributes;
          } else {
            SectionDefinitionGuid   = &((EFI_GUID_DEFINED_SECTION *)Section)->SectionDefinitionGuid;
            GuidedSectionAttributes = ((EFI_GUID_DEFINED_SECTION *)Section)->Attributes;
          }
 
          if (VerifyGuidedSectionGuid (SectionDefinitionGuid, &GuidSectionPpi)) {
            Status = GuidSectionPpi->ExtractSection (
                                       GuidSectionPpi,
                                       Section,
                                       &PpiOutput,
                                       &PpiOutputSize,
                                       &Authentication
                                       );
          } else if ((GuidedSectionAttributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {
            //
            // Figure out the proper authentication status for GUIDED section without processing required
            //
            Status = EFI_SUCCESS;
            if ((GuidedSectionAttributes & EFI_GUIDED_SECTION_AUTH_STATUS_VALID) == EFI_GUIDED_SECTION_AUTH_STATUS_VALID) {
              Authentication |= EFI_AUTH_STATUS_IMAGE_SIGNED | EFI_AUTH_STATUS_NOT_TESTED;
            }
 
            if (IS_SECTION2 (Section)) {
              PpiOutputSize = SECTION2_SIZE (Section) - ((EFI_GUID_DEFINED_SECTION2 *)Section)->DataOffset;
              PpiOutput     = (UINT8 *)Section + ((EFI_GUID_DEFINED_SECTION2 *)Section)->DataOffset;
            } else {
              PpiOutputSize = SECTION_SIZE (Section) - ((EFI_GUID_DEFINED_SECTION *)Section)->DataOffset;
              PpiOutput     = (UINT8 *)Section + ((EFI_GUID_DEFINED_SECTION *)Section)->DataOffset;
            }
          }
        } else if (Section->Type == EFI_SECTION_COMPRESSION) {
          Status = PeiServicesLocatePpi (&gEfiPeiDecompressPpiGuid, 0, NULL, (VOID **)&DecompressPpi);
          if (!EFI_ERROR (Status)) {
            Status = DecompressPpi->Decompress (
                                      DecompressPpi,
                                      (CONST EFI_COMPRESSION_SECTION *)Section,
                                      &PpiOutput,
                                      &PpiOutputSize
                                      );
          }
        }
 
        if (!EFI_ERROR (Status)) {
          if ((Authentication & EFI_AUTH_STATUS_NOT_TESTED) == 0) {
            //
            // Update cache section data.
            //
            if (PrivateData->CacheSection.AllSectionCount < CACHE_SETION_MAX_NUMBER) {
              PrivateData->CacheSection.AllSectionCount++;
            }
 
            PrivateData->CacheSection.Section[PrivateData->CacheSection.SectionIndex]              = Section;
            PrivateData->CacheSection.SectionData[PrivateData->CacheSection.SectionIndex]          = PpiOutput;
            PrivateData->CacheSection.SectionSize[PrivateData->CacheSection.SectionIndex]          = PpiOutputSize;
            PrivateData->CacheSection.AuthenticationStatus[PrivateData->CacheSection.SectionIndex] = Authentication;
            PrivateData->CacheSection.SectionIndex                                                 = (PrivateData->CacheSection.SectionIndex + 1)%CACHE_SETION_MAX_NUMBER;
          }
 
          TempAuthenticationStatus = 0;
          Status                   = ProcessSection (
                                       PeiServices,
                                       SectionType,
                                       SectionInstance,
                                       PpiOutput,
                                       PpiOutputSize,
                                       &TempOutputBuffer,
                                       &TempAuthenticationStatus,
                                       IsFfs3Fv
                                       );
          if (!EFI_ERROR (Status)) {
            *OutputBuffer         = TempOutputBuffer;
            *AuthenticationStatus = TempAuthenticationStatus | Authentication;
            return EFI_SUCCESS;
          }
        }
      }
    }
 
    if (IS_SECTION2 (Section)) {
      SectionLength = SECTION2_SIZE (Section);
    } else {
      SectionLength = SECTION_SIZE (Section);
    }
 
    if (SectionLength == 0) {
      break;
    }
 
    //
    // SectionLength is adjusted it is 4 byte aligned.
    // Go to the next section
    //
    SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
    ASSERT (SectionLength != 0);
    ParsedLength += SectionLength;
    Section       = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
  }
 
  return EFI_NOT_FOUND;
}
 
EFI_STATUS
EFIAPI
PeiFfsFindSectionData (
  IN CONST EFI_PEI_SERVICES   **PeiServices,
  IN     EFI_SECTION_TYPE     SectionType,
  IN     EFI_PEI_FILE_HANDLE  FileHandle,
  OUT VOID                    **SectionData
  )
{
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if ((CoreFvHandle == NULL) || (CoreFvHandle->FvPpi == NULL)) {
    return EFI_NOT_FOUND;
  }
 
  return CoreFvHandle->FvPpi->FindSectionByType (CoreFvHandle->FvPpi, SectionType, FileHandle, SectionData);
}
 
EFI_STATUS
EFIAPI
PeiFfsFindSectionData3 (
  IN CONST EFI_PEI_SERVICES   **PeiServices,
  IN     EFI_SECTION_TYPE     SectionType,
  IN     UINTN                SectionInstance,
  IN     EFI_PEI_FILE_HANDLE  FileHandle,
  OUT VOID                    **SectionData,
  OUT UINT32                  *AuthenticationStatus
  )
{
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if ((CoreFvHandle == NULL) || (CoreFvHandle->FvPpi == NULL)) {
    return EFI_NOT_FOUND;
  }
 
  if ((CoreFvHandle->FvPpi->Signature == EFI_PEI_FIRMWARE_VOLUME_PPI_SIGNATURE) &&
      (CoreFvHandle->FvPpi->Revision == EFI_PEI_FIRMWARE_VOLUME_PPI_REVISION))
  {
    return CoreFvHandle->FvPpi->FindSectionByType2 (CoreFvHandle->FvPpi, SectionType, SectionInstance, FileHandle, SectionData, AuthenticationStatus);
  }
 
  //
  // The old FvPpi doesn't support to find section by section instance
  // and return authentication status, so return EFI_UNSUPPORTED.
  //
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
PeiFfsFindNextFile (
  IN CONST EFI_PEI_SERVICES   **PeiServices,
  IN UINT8                    SearchType,
  IN EFI_PEI_FV_HANDLE        FvHandle,
  IN OUT EFI_PEI_FILE_HANDLE  *FileHandle
  )
{
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  CoreFvHandle = FvHandleToCoreHandle (FvHandle);
 
  if ((CoreFvHandle == NULL) || (CoreFvHandle->FvPpi == NULL)) {
    return EFI_NOT_FOUND;
  }
 
  return CoreFvHandle->FvPpi->FindFileByType (CoreFvHandle->FvPpi, SearchType, FvHandle, FileHandle);
}
 
EFI_STATUS
EFIAPI
PeiFfsFindNextVolume (
  IN CONST EFI_PEI_SERVICES  **PeiServices,
  IN     UINTN               Instance,
  IN OUT EFI_PEI_FV_HANDLE   *VolumeHandle
  )
{
  PEI_CORE_INSTANCE   *Private;
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  if (VolumeHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
 
  CoreFvHandle = FindNextCoreFvHandle (Private, Instance);
  if (CoreFvHandle == NULL) {
    *VolumeHandle = NULL;
    return EFI_NOT_FOUND;
  }
 
  *VolumeHandle = CoreFvHandle->FvHandle;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PeiFfsFindFileByName (
  IN  CONST EFI_GUID       *FileName,
  IN  EFI_PEI_FV_HANDLE    VolumeHandle,
  OUT EFI_PEI_FILE_HANDLE  *FileHandle
  )
{
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  if ((VolumeHandle == NULL) || (FileName == NULL) || (FileHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  CoreFvHandle = FvHandleToCoreHandle (VolumeHandle);
  if ((CoreFvHandle == NULL) || (CoreFvHandle->FvPpi == NULL)) {
    return EFI_NOT_FOUND;
  }
 
  return CoreFvHandle->FvPpi->FindFileByName (CoreFvHandle->FvPpi, FileName, &VolumeHandle, FileHandle);
}
 
EFI_STATUS
EFIAPI
PeiFfsGetFileInfo (
  IN EFI_PEI_FILE_HANDLE  FileHandle,
  OUT EFI_FV_FILE_INFO    *FileInfo
  )
{
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  if ((FileHandle == NULL) || (FileInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Retrieve the FirmwareVolume which the file resides in.
  //
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if ((CoreFvHandle == NULL) || (CoreFvHandle->FvPpi == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  return CoreFvHandle->FvPpi->GetFileInfo (CoreFvHandle->FvPpi, FileHandle, FileInfo);
}
 
EFI_STATUS
EFIAPI
PeiFfsGetFileInfo2 (
  IN EFI_PEI_FILE_HANDLE  FileHandle,
  OUT EFI_FV_FILE_INFO2   *FileInfo
  )
{
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  if ((FileHandle == NULL) || (FileInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Retrieve the FirmwareVolume which the file resides in.
  //
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if ((CoreFvHandle == NULL) || (CoreFvHandle->FvPpi == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((CoreFvHandle->FvPpi->Signature == EFI_PEI_FIRMWARE_VOLUME_PPI_SIGNATURE) &&
      (CoreFvHandle->FvPpi->Revision == EFI_PEI_FIRMWARE_VOLUME_PPI_REVISION))
  {
    return CoreFvHandle->FvPpi->GetFileInfo2 (CoreFvHandle->FvPpi, FileHandle, FileInfo);
  }
 
  //
  // The old FvPpi doesn't support to return file info with authentication status,
  // so return EFI_UNSUPPORTED.
  //
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
PeiFfsGetVolumeInfo (
  IN EFI_PEI_FV_HANDLE  VolumeHandle,
  OUT EFI_FV_INFO       *VolumeInfo
  )
{
  PEI_CORE_FV_HANDLE  *CoreHandle;
 
  if ((VolumeInfo == NULL) || (VolumeHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  CoreHandle = FvHandleToCoreHandle (VolumeHandle);
 
  if ((CoreHandle == NULL) || (CoreHandle->FvPpi == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  return CoreHandle->FvPpi->GetVolumeInfo (CoreHandle->FvPpi, VolumeHandle, VolumeInfo);
}
 
BOOLEAN
GetFvUsedSize (
  IN EFI_FIRMWARE_VOLUME_HEADER  *FvHeader,
  OUT UINT32                     *FvUsedSize,
  OUT UINT8                      *EraseByte
  )
{
  UINT16                                        ExtHeaderOffset;
  EFI_FIRMWARE_VOLUME_EXT_HEADER                *ExtHeader;
  EFI_FIRMWARE_VOLUME_EXT_ENTRY                 *ExtEntryList;
  EFI_FIRMWARE_VOLUME_EXT_ENTRY_USED_SIZE_TYPE  *ExtEntryUsedSize;
 
  ExtHeaderOffset = ReadUnaligned16 (&FvHeader->ExtHeaderOffset);
  if (ExtHeaderOffset != 0) {
    ExtHeader    = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)((UINT8 *)FvHeader + ExtHeaderOffset);
    ExtEntryList = (EFI_FIRMWARE_VOLUME_EXT_ENTRY *)(ExtHeader + 1);
    while ((UINTN)ExtEntryList < ((UINTN)ExtHeader + ReadUnaligned32 (&ExtHeader->ExtHeaderSize))) {
      if (ReadUnaligned16 (&ExtEntryList->ExtEntryType) == EFI_FV_EXT_TYPE_USED_SIZE_TYPE) {
        //
        // USED_SIZE FV_EXT_TYPE entry is found.
        //
        ExtEntryUsedSize = (EFI_FIRMWARE_VOLUME_EXT_ENTRY_USED_SIZE_TYPE *)ExtEntryList;
        *FvUsedSize      = ReadUnaligned32 (&ExtEntryUsedSize->UsedSize);
        if ((ReadUnaligned32 (&FvHeader->Attributes) & EFI_FVB2_ERASE_POLARITY) != 0) {
          *EraseByte = 0xFF;
        } else {
          *EraseByte = 0;
        }
 
        DEBUG ((
          DEBUG_INFO,
          "FV at 0x%x has 0x%x used size, and erase byte is 0x%02x\n",
          FvHeader,
          *FvUsedSize,
          *EraseByte
          ));
        return TRUE;
      }
 
      ExtEntryList = (EFI_FIRMWARE_VOLUME_EXT_ENTRY *)
                     ((UINT8 *)ExtEntryList + ReadUnaligned16 (&ExtEntryList->ExtEntrySize));
    }
  }
 
  //
  // No USED_SIZE FV_EXT_TYPE entry found.
  //
  return FALSE;
}
 
EFI_STATUS
ProcessFvFile (
  IN  PEI_CORE_INSTANCE    *PrivateData,
  IN  PEI_CORE_FV_HANDLE   *ParentFvCoreHandle,
  IN  EFI_PEI_FILE_HANDLE  ParentFvFileHandle
  )
{
  EFI_STATUS                   Status;
  EFI_FV_INFO                  ParentFvImageInfo;
  UINT32                       FvAlignment;
  VOID                         *NewFvBuffer;
  EFI_PEI_HOB_POINTERS         HobPtr;
  EFI_PEI_FIRMWARE_VOLUME_PPI  *ParentFvPpi;
  EFI_PEI_FV_HANDLE            ParentFvHandle;
  EFI_FIRMWARE_VOLUME_HEADER   *FvHeader;
  EFI_FV_FILE_INFO             FileInfo;
  UINT64                       FvLength;
  UINT32                       AuthenticationStatus;
  UINT32                       FvUsedSize;
  UINT8                        EraseByte;
  UINTN                        Index;
 
  //
  // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already
  // been extracted.
  //
  HobPtr.Raw = GetHobList ();
  while ((HobPtr.Raw = GetNextHob (EFI_HOB_TYPE_FV2, HobPtr.Raw)) != NULL) {
    if (CompareGuid (&(((EFI_FFS_FILE_HEADER *)ParentFvFileHandle)->Name), &HobPtr.FirmwareVolume2->FileName)) {
      //
      // this FILE has been dispatched, it will not be dispatched again.
      //
      DEBUG ((DEBUG_INFO, "FV file %p has been dispatched!\r\n", ParentFvFileHandle));
      return EFI_SUCCESS;
    }
 
    HobPtr.Raw = GET_NEXT_HOB (HobPtr);
  }
 
  ParentFvHandle = ParentFvCoreHandle->FvHandle;
  ParentFvPpi    = ParentFvCoreHandle->FvPpi;
 
  Status = EFI_SUCCESS;
 
  //
  // Find FvImage(s) in FvFile
  //
  Index = 0;
  do {
    AuthenticationStatus = 0;
    if ((ParentFvPpi->Signature == EFI_PEI_FIRMWARE_VOLUME_PPI_SIGNATURE) &&
        (ParentFvPpi->Revision == EFI_PEI_FIRMWARE_VOLUME_PPI_REVISION))
    {
      Status = ParentFvPpi->FindSectionByType2 (
                              ParentFvPpi,
                              EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
                              Index,
                              ParentFvFileHandle,
                              (VOID **)&FvHeader,
                              &AuthenticationStatus
                              );
    } else {
      //
      // Old FvPpi has no parameter to input SearchInstance,
      // only one instance is supported.
      //
      if (Index > 0) {
        break;
      }
 
      Status = ParentFvPpi->FindSectionByType (
                              ParentFvPpi,
                              EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
                              ParentFvFileHandle,
                              (VOID **)&FvHeader
                              );
    }
 
    if (EFI_ERROR (Status)) {
      break;
    }
 
    Status = VerifyPeim (PrivateData, ParentFvHandle, ParentFvFileHandle, AuthenticationStatus);
    if (Status == EFI_SECURITY_VIOLATION) {
      break;
    }
 
    //
    // If EFI_FVB2_WEAK_ALIGNMENT is set in the volume header then the first byte of the volume
    // can be aligned on any power-of-two boundary. A weakly aligned volume can not be moved from
    // its initial linked location and maintain its alignment.
    //
    if ((ReadUnaligned32 (&FvHeader->Attributes) & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) {
      //
      // FvAlignment must be greater than or equal to 8 bytes of the minimum FFS alignment value.
      //
      FvAlignment = 1 << ((ReadUnaligned32 (&FvHeader->Attributes) & EFI_FVB2_ALIGNMENT) >> 16);
      if (FvAlignment < 8) {
        FvAlignment = 8;
      }
 
      DEBUG ((
        DEBUG_INFO,
        "%a() FV at 0x%x, FvAlignment required is 0x%x\n",
        __func__,
        FvHeader,
        FvAlignment
        ));
 
      //
      // Check FvImage alignment.
      //
      if ((UINTN)FvHeader % FvAlignment != 0) {
        FvLength    = ReadUnaligned64 (&FvHeader->FvLength);
        NewFvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32)FvLength), FvAlignment);
        if (NewFvBuffer == NULL) {
          Status = EFI_OUT_OF_RESOURCES;
          break;
        }
 
        if (GetFvUsedSize (FvHeader, &FvUsedSize, &EraseByte)) {
          //
          // Copy the used bytes and fill the rest with the erase value.
          //
          CopyMem (NewFvBuffer, FvHeader, (UINTN)FvUsedSize);
          SetMem (
            (UINT8 *)NewFvBuffer + FvUsedSize,
            (UINTN)(FvLength - FvUsedSize),
            EraseByte
            );
        } else {
          CopyMem (NewFvBuffer, FvHeader, (UINTN)FvLength);
        }
 
        FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)NewFvBuffer;
      }
    }
 
    Status = ParentFvPpi->GetVolumeInfo (ParentFvPpi, ParentFvHandle, &ParentFvImageInfo);
    ASSERT_EFI_ERROR (Status);
 
    Status = ParentFvPpi->GetFileInfo (ParentFvPpi, ParentFvFileHandle, &FileInfo);
    ASSERT_EFI_ERROR (Status);
 
    //
    // Install FvInfo(2) Ppi
    // NOTE: FvInfo2 must be installed before FvInfo so that recursive processing of encapsulated
    // FVs inherit the proper AuthenticationStatus.
    //
    PeiServicesInstallFvInfo2Ppi (
      &FvHeader->FileSystemGuid,
      (VOID **)FvHeader,
      (UINT32)FvHeader->FvLength,
      &ParentFvImageInfo.FvName,
      &FileInfo.FileName,
      AuthenticationStatus
      );
 
    PeiServicesInstallFvInfoPpi (
      &FvHeader->FileSystemGuid,
      (VOID **)FvHeader,
      (UINT32)FvHeader->FvLength,
      &ParentFvImageInfo.FvName,
      &FileInfo.FileName
      );
 
    //
    // Expose the extracted FvImage to the FV HOB consumer phase, i.e. DXE phase
    //
    BuildFvHob (
      (EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader,
      FvHeader->FvLength
      );
 
    //
    // Makes the encapsulated volume show up in DXE phase to skip processing of
    // encapsulated file again.
    //
    BuildFv2Hob (
      (EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader,
      FvHeader->FvLength,
      &ParentFvImageInfo.FvName,
      &FileInfo.FileName
      );
 
    //
    // Build FV3 HOB with authentication status to be propagated to DXE.
    //
    BuildFv3Hob (
      (EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader,
      FvHeader->FvLength,
      AuthenticationStatus,
      TRUE,
      &ParentFvImageInfo.FvName,
      &FileInfo.FileName
      );
 
    Index++;
  } while (TRUE);
 
  if (Index > 0) {
    //
    // At least one FvImage has been processed successfully.
    //
    return EFI_SUCCESS;
  } else {
    return Status;
  }
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiProcessVolume (
  IN  CONST  EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN  VOID                                *Buffer,
  IN  UINTN                               BufferSize,
  OUT EFI_PEI_FV_HANDLE                   *FvHandle
  )
{
  EFI_STATUS  Status;
 
  ASSERT (FvHandle != NULL);
 
  if (Buffer == NULL) {
    return EFI_VOLUME_CORRUPTED;
  }
 
  //
  // The build-in EFI_PEI_FIRMWARE_VOLUME_PPI for FFS2/FFS3 support memory-mapped
  // FV image and the handle is pointed to FV image's buffer.
  //
  *FvHandle = (EFI_PEI_FV_HANDLE)Buffer;
 
  //
  // Do verify for given FV buffer.
  //
  Status = VerifyFv ((EFI_FIRMWARE_VOLUME_HEADER *)Buffer);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Fail to verify FV which address is 0x%11p", Buffer));
    return EFI_VOLUME_CORRUPTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiFindFileByType (
  IN CONST  EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN        EFI_FV_FILETYPE              SearchType,
  IN        EFI_PEI_FV_HANDLE            FvHandle,
  IN OUT    EFI_PEI_FILE_HANDLE          *FileHandle
  )
{
  return FindFileEx (FvHandle, NULL, SearchType, FileHandle, NULL);
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiFindFileByName (
  IN  CONST  EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN  CONST  EFI_GUID                     *FileName,
  IN  EFI_PEI_FV_HANDLE                   *FvHandle,
  OUT EFI_PEI_FILE_HANDLE                 *FileHandle
  )
{
  EFI_STATUS         Status;
  PEI_CORE_INSTANCE  *PrivateData;
  UINTN              Index;
 
  if ((FvHandle == NULL) || (FileName == NULL) || (FileHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (*FvHandle != NULL) {
    Status = FindFileEx (*FvHandle, FileName, 0, FileHandle, NULL);
    if (Status == EFI_NOT_FOUND) {
      *FileHandle = NULL;
    }
  } else {
    //
    // If *FvHandle = NULL, so search all FV for given filename
    //
    Status = EFI_NOT_FOUND;
 
    PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
    for (Index = 0; Index < PrivateData->FvCount; Index++) {
      //
      // Only search the FV which is associated with a EFI_PEI_FIRMWARE_VOLUME_PPI instance.
      //
      if (PrivateData->Fv[Index].FvPpi != NULL) {
        Status = FindFileEx (PrivateData->Fv[Index].FvHandle, FileName, 0, FileHandle, NULL);
        if (!EFI_ERROR (Status)) {
          *FvHandle = PrivateData->Fv[Index].FvHandle;
          break;
        }
      }
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiGetFileInfo (
  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN        EFI_PEI_FILE_HANDLE          FileHandle,
  OUT       EFI_FV_FILE_INFO             *FileInfo
  )
{
  UINT8                FileState;
  UINT8                ErasePolarity;
  EFI_FFS_FILE_HEADER  *FileHeader;
  PEI_CORE_FV_HANDLE   *CoreFvHandle;
  PEI_FW_VOL_INSTANCE  *FwVolInstance;
 
  if ((FileHandle == NULL) || (FileInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Retrieve the FirmwareVolume which the file resides in.
  //
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if (CoreFvHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  FwVolInstance = PEI_FW_VOL_INSTANCE_FROM_FV_THIS (This);
 
  if ((CoreFvHandle->FvHeader->Attributes & EFI_FVB2_ERASE_POLARITY) != 0) {
    ErasePolarity = 1;
  } else {
    ErasePolarity = 0;
  }
 
  //
  // Get FileState which is the highest bit of the State
  //
  FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER *)FileHandle);
 
  switch (FileState) {
    case EFI_FILE_DATA_VALID:
    case EFI_FILE_MARKED_FOR_UPDATE:
      break;
    default:
      return EFI_INVALID_PARAMETER;
  }
 
  FileHeader = (EFI_FFS_FILE_HEADER *)FileHandle;
  if (IS_FFS_FILE2 (FileHeader)) {
    ASSERT (FFS_FILE2_SIZE (FileHeader) > 0x00FFFFFF);
    if (!FwVolInstance->IsFfs3Fv) {
      DEBUG ((DEBUG_ERROR, "It is a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &FileHeader->Name));
      return EFI_INVALID_PARAMETER;
    }
 
    FileInfo->BufferSize = FFS_FILE2_SIZE (FileHeader) - sizeof (EFI_FFS_FILE_HEADER2);
    FileInfo->Buffer     = (UINT8 *)FileHeader + sizeof (EFI_FFS_FILE_HEADER2);
  } else {
    FileInfo->BufferSize = FFS_FILE_SIZE (FileHeader) - sizeof (EFI_FFS_FILE_HEADER);
    FileInfo->Buffer     = (UINT8 *)FileHeader + sizeof (EFI_FFS_FILE_HEADER);
  }
 
  CopyMem (&FileInfo->FileName, &FileHeader->Name, sizeof (EFI_GUID));
  FileInfo->FileType       = FileHeader->Type;
  FileInfo->FileAttributes = FfsAttributes2FvFileAttributes (FileHeader->Attributes);
  if ((CoreFvHandle->FvHeader->Attributes & EFI_FVB2_MEMORY_MAPPED) == EFI_FVB2_MEMORY_MAPPED) {
    FileInfo->FileAttributes |= EFI_FV_FILE_ATTRIB_MEMORY_MAPPED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiGetFileInfo2 (
  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN        EFI_PEI_FILE_HANDLE          FileHandle,
  OUT       EFI_FV_FILE_INFO2            *FileInfo
  )
{
  EFI_STATUS          Status;
  PEI_CORE_FV_HANDLE  *CoreFvHandle;
 
  if ((FileHandle == NULL) || (FileInfo == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Retrieve the FirmwareVolume which the file resides in.
  //
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if (CoreFvHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = PeiFfsFvPpiGetFileInfo (This, FileHandle, (EFI_FV_FILE_INFO *)FileInfo);
  if (!EFI_ERROR (Status)) {
    FileInfo->AuthenticationStatus = CoreFvHandle->AuthenticationStatus;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiGetVolumeInfo (
  IN  CONST  EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN  EFI_PEI_FV_HANDLE                   FvHandle,
  OUT EFI_FV_INFO                         *VolumeInfo
  )
{
  EFI_FIRMWARE_VOLUME_HEADER      FwVolHeader;
  EFI_FIRMWARE_VOLUME_EXT_HEADER  *FwVolExHeaderInfo;
 
  if ((VolumeInfo == NULL) || (FvHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // VolumeHandle may not align at 8 byte,
  // but FvLength is UINT64 type, which requires FvHeader align at least 8 byte.
  // So, Copy FvHeader into the local FvHeader structure.
  //
  CopyMem (&FwVolHeader, FvHandle, sizeof (EFI_FIRMWARE_VOLUME_HEADER));
 
  //
  // Check FV Image Signature
  //
  if (FwVolHeader.Signature != EFI_FVH_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }
 
  ZeroMem (VolumeInfo, sizeof (EFI_FV_INFO));
  VolumeInfo->FvAttributes = FwVolHeader.Attributes;
  VolumeInfo->FvStart      = (VOID *)FvHandle;
  VolumeInfo->FvSize       = FwVolHeader.FvLength;
  CopyMem (&VolumeInfo->FvFormat, &FwVolHeader.FileSystemGuid, sizeof (EFI_GUID));
 
  if (FwVolHeader.ExtHeaderOffset != 0) {
    FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)(((UINT8 *)FvHandle) + FwVolHeader.ExtHeaderOffset);
    CopyMem (&VolumeInfo->FvName, &FwVolExHeaderInfo->FvName, sizeof (EFI_GUID));
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiFindSectionByType (
  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN        EFI_SECTION_TYPE             SearchType,
  IN        EFI_PEI_FILE_HANDLE          FileHandle,
  OUT VOID                               **SectionData
  )
{
  UINT32  AuthenticationStatus;
 
  return PeiFfsFvPpiFindSectionByType2 (This, SearchType, 0, FileHandle, SectionData, &AuthenticationStatus);
}
 
EFI_STATUS
EFIAPI
PeiFfsFvPpiFindSectionByType2 (
  IN  CONST EFI_PEI_FIRMWARE_VOLUME_PPI  *This,
  IN        EFI_SECTION_TYPE             SearchType,
  IN        UINTN                        SearchInstance,
  IN        EFI_PEI_FILE_HANDLE          FileHandle,
  OUT VOID                               **SectionData,
  OUT UINT32                             *AuthenticationStatus
  )
{
  EFI_STATUS                 Status;
  EFI_FFS_FILE_HEADER        *FfsFileHeader;
  UINT32                     FileSize;
  EFI_COMMON_SECTION_HEADER  *Section;
  PEI_FW_VOL_INSTANCE        *FwVolInstance;
  PEI_CORE_FV_HANDLE         *CoreFvHandle;
  UINTN                      Instance;
  UINT32                     ExtractedAuthenticationStatus;
 
  if (SectionData == NULL) {
    return EFI_NOT_FOUND;
  }
 
  FwVolInstance = PEI_FW_VOL_INSTANCE_FROM_FV_THIS (This);
 
  //
  // Retrieve the FirmwareVolume which the file resides in.
  //
  CoreFvHandle = FileHandleToVolume (FileHandle);
  if (CoreFvHandle == NULL) {
    return EFI_NOT_FOUND;
  }
 
  FfsFileHeader = (EFI_FFS_FILE_HEADER *)(FileHandle);
 
  if (IS_FFS_FILE2 (FfsFileHeader)) {
    ASSERT (FFS_FILE2_SIZE (FfsFileHeader) > 0x00FFFFFF);
    if (!FwVolInstance->IsFfs3Fv) {
      DEBUG ((DEBUG_ERROR, "It is a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &FfsFileHeader->Name));
      return EFI_NOT_FOUND;
    }
 
    Section  = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER2));
    FileSize = FFS_FILE2_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER2);
  } else {
    Section  = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));
    FileSize = FFS_FILE_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER);
  }
 
  Instance                      = SearchInstance + 1;
  ExtractedAuthenticationStatus = 0;
  Status                        = ProcessSection (
                                    GetPeiServicesTablePointer (),
                                    SearchType,
                                    &Instance,
                                    Section,
                                    FileSize,
                                    SectionData,
                                    &ExtractedAuthenticationStatus,
                                    FwVolInstance->IsFfs3Fv
                                    );
  if (!EFI_ERROR (Status)) {
    //
    // Inherit the authentication status.
    //
    *AuthenticationStatus = ExtractedAuthenticationStatus | CoreFvHandle->AuthenticationStatus;
  }
 
  return Status;
}
 
PEI_CORE_FV_HANDLE *
FvHandleToCoreHandle (
  IN EFI_PEI_FV_HANDLE  FvHandle
  )
{
  UINTN              Index;
  PEI_CORE_INSTANCE  *PrivateData;
 
  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
  for (Index = 0; Index < PrivateData->FvCount; Index++) {
    if (FvHandle == PrivateData->Fv[Index].FvHandle) {
      return &PrivateData->Fv[Index];
    }
  }
 
  return NULL;
}
 
PEI_CORE_FV_HANDLE *
FindNextCoreFvHandle (
  IN PEI_CORE_INSTANCE  *Private,
  IN UINTN              Instance
  )
{
  if (Instance >= Private->FvCount) {
    return NULL;
  }
 
  return &Private->Fv[Instance];
}
 
VOID
PeiReinitializeFv (
  IN  PEI_CORE_INSTANCE  *PrivateData
  )
{
  VOID                    *OldFfsFvPpi;
  EFI_PEI_PPI_DESCRIPTOR  *OldDescriptor;
  UINTN                   Index;
  EFI_STATUS              Status;
 
  //
  // Locate old build-in Ffs2 EFI_PEI_FIRMWARE_VOLUME_PPI which
  // in flash.
  //
  Status = PeiServicesLocatePpi (
             &gEfiFirmwareFileSystem2Guid,
             0,
             &OldDescriptor,
             &OldFfsFvPpi
             );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Re-install the EFI_PEI_FIRMWARE_VOLUME_PPI for build-in Ffs2
  // which is shadowed from flash to permanent memory within PeiCore image.
  //
  Status = PeiServicesReInstallPpi (OldDescriptor, &mPeiFfs2FvPpiList);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Fixup all FvPpi pointers for the implementation in flash to permanent memory.
  //
  for (Index = 0; Index < PrivateData->FvCount; Index++) {
    if (PrivateData->Fv[Index].FvPpi == OldFfsFvPpi) {
      PrivateData->Fv[Index].FvPpi = &mPeiFfs2FwVol.Fv;
    }
  }
 
  //
  // Locate old build-in Ffs3 EFI_PEI_FIRMWARE_VOLUME_PPI which
  // in flash.
  //
  Status = PeiServicesLocatePpi (
             &gEfiFirmwareFileSystem3Guid,
             0,
             &OldDescriptor,
             &OldFfsFvPpi
             );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Re-install the EFI_PEI_FIRMWARE_VOLUME_PPI for build-in Ffs3
  // which is shadowed from flash to permanent memory within PeiCore image.
  //
  Status = PeiServicesReInstallPpi (OldDescriptor, &mPeiFfs3FvPpiList);
  ASSERT_EFI_ERROR (Status);
 
  //
  // Fixup all FvPpi pointers for the implementation in flash to permanent memory.
  //
  for (Index = 0; Index < PrivateData->FvCount; Index++) {
    if (PrivateData->Fv[Index].FvPpi == OldFfsFvPpi) {
      PrivateData->Fv[Index].FvPpi = &mPeiFfs3FwVol.Fv;
    }
  }
}
 
EFI_STATUS
AddUnknownFormatFvInfo (
  IN PEI_CORE_INSTANCE                  *PrivateData,
  IN EFI_PEI_FIRMWARE_VOLUME_INFO2_PPI  *FvInfo2Ppi
  )
{
  PEI_CORE_UNKNOW_FORMAT_FV_INFO  *NewUnknownFv;
  VOID                            *TempPtr;
 
  if (PrivateData->UnknownFvInfoCount >= PrivateData->MaxUnknownFvInfoCount) {
    //
    // Run out of room, grow the buffer.
    //
    TempPtr = AllocateZeroPool (
                sizeof (PEI_CORE_UNKNOW_FORMAT_FV_INFO) * (PrivateData->MaxUnknownFvInfoCount + FV_GROWTH_STEP)
                );
    ASSERT (TempPtr != NULL);
    CopyMem (
      TempPtr,
      PrivateData->UnknownFvInfo,
      sizeof (PEI_CORE_UNKNOW_FORMAT_FV_INFO) * PrivateData->MaxUnknownFvInfoCount
      );
    PrivateData->UnknownFvInfo         = TempPtr;
    PrivateData->MaxUnknownFvInfoCount = PrivateData->MaxUnknownFvInfoCount + FV_GROWTH_STEP;
  }
 
  NewUnknownFv = &PrivateData->UnknownFvInfo[PrivateData->UnknownFvInfoCount];
  PrivateData->UnknownFvInfoCount++;
 
  CopyGuid (&NewUnknownFv->FvFormat, &FvInfo2Ppi->FvFormat);
  NewUnknownFv->FvInfo                  = FvInfo2Ppi->FvInfo;
  NewUnknownFv->FvInfoSize              = FvInfo2Ppi->FvInfoSize;
  NewUnknownFv->AuthenticationStatus    = FvInfo2Ppi->AuthenticationStatus;
  NewUnknownFv->NotifyDescriptor.Flags  = (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);
  NewUnknownFv->NotifyDescriptor.Guid   = &NewUnknownFv->FvFormat;
  NewUnknownFv->NotifyDescriptor.Notify = ThirdPartyFvPpiNotifyCallback;
 
  PeiServicesNotifyPpi (&NewUnknownFv->NotifyDescriptor);
  return EFI_SUCCESS;
}
 
EFI_STATUS
FindUnknownFormatFvInfo (
  IN  PEI_CORE_INSTANCE  *PrivateData,
  IN  EFI_GUID           *Format,
  OUT VOID               **FvInfo,
  OUT UINT32             *FvInfoSize,
  OUT UINT32             *AuthenticationStatus
  )
{
  UINTN  Index;
  UINTN  Index2;
 
  Index = 0;
  for ( ; Index < PrivateData->UnknownFvInfoCount; Index++) {
    if (CompareGuid (Format, &PrivateData->UnknownFvInfo[Index].FvFormat)) {
      break;
    }
  }
 
  if (Index == PrivateData->UnknownFvInfoCount) {
    return EFI_NOT_FOUND;
  }
 
  *FvInfo               = PrivateData->UnknownFvInfo[Index].FvInfo;
  *FvInfoSize           = PrivateData->UnknownFvInfo[Index].FvInfoSize;
  *AuthenticationStatus = PrivateData->UnknownFvInfo[Index].AuthenticationStatus;
 
  //
  // Remove an entry from UnknownFvInfo array.
  //
  Index2 = Index + 1;
  for ( ; Index2 < PrivateData->UnknownFvInfoCount; Index2++, Index++) {
    CopyMem (&PrivateData->UnknownFvInfo[Index], &PrivateData->UnknownFvInfo[Index2], sizeof (PEI_CORE_UNKNOW_FORMAT_FV_INFO));
  }
 
  PrivateData->UnknownFvInfoCount--;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
ThirdPartyFvPpiNotifyCallback (
  IN EFI_PEI_SERVICES           **PeiServices,
  IN EFI_PEI_NOTIFY_DESCRIPTOR  *NotifyDescriptor,
  IN VOID                       *Ppi
  )
{
  PEI_CORE_INSTANCE            *PrivateData;
  EFI_PEI_FIRMWARE_VOLUME_PPI  *FvPpi;
  VOID                         *FvInfo;
  UINT32                       FvInfoSize;
  UINT32                       AuthenticationStatus;
  EFI_STATUS                   Status;
  EFI_PEI_FV_HANDLE            FvHandle;
  BOOLEAN                      IsProcessed;
  UINTN                        FvIndex;
  EFI_PEI_FILE_HANDLE          FileHandle;
  VOID                         *DepexData;
  UINTN                        CurFvCount;
  VOID                         *TempPtr;
 
  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
  FvPpi       = (EFI_PEI_FIRMWARE_VOLUME_PPI *)Ppi;
 
  do {
    Status = FindUnknownFormatFvInfo (PrivateData, NotifyDescriptor->Guid, &FvInfo, &FvInfoSize, &AuthenticationStatus);
    if (EFI_ERROR (Status)) {
      return EFI_SUCCESS;
    }
 
    //
    // Process new found FV and get FV handle.
    //
    Status = FvPpi->ProcessVolume (FvPpi, FvInfo, FvInfoSize, &FvHandle);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "Fail to process the FV 0x%p, FV may be corrupted!\n", FvInfo));
      continue;
    }
 
    //
    // Check whether the FV has already been processed.
    //
    IsProcessed = FALSE;
    for (FvIndex = 0; FvIndex < PrivateData->FvCount; FvIndex++) {
      if (PrivateData->Fv[FvIndex].FvHandle == FvHandle) {
        DEBUG ((DEBUG_INFO, "The FV %p has already been processed!\n", FvInfo));
        IsProcessed = TRUE;
        break;
      }
    }
 
    if (IsProcessed) {
      continue;
    }
 
    if (PrivateData->FvCount >= PrivateData->MaxFvCount) {
      //
      // Run out of room, grow the buffer.
      //
      TempPtr = AllocateZeroPool (
                  sizeof (PEI_CORE_FV_HANDLE) * (PrivateData->MaxFvCount + FV_GROWTH_STEP)
                  );
      ASSERT (TempPtr != NULL);
      CopyMem (
        TempPtr,
        PrivateData->Fv,
        sizeof (PEI_CORE_FV_HANDLE) * PrivateData->MaxFvCount
        );
      PrivateData->Fv         = TempPtr;
      PrivateData->MaxFvCount = PrivateData->MaxFvCount + FV_GROWTH_STEP;
    }
 
    //
    // Update internal PEI_CORE_FV array.
    //
    PrivateData->Fv[PrivateData->FvCount].FvHeader             = (EFI_FIRMWARE_VOLUME_HEADER *)FvInfo;
    PrivateData->Fv[PrivateData->FvCount].FvPpi                = FvPpi;
    PrivateData->Fv[PrivateData->FvCount].FvHandle             = FvHandle;
    PrivateData->Fv[PrivateData->FvCount].AuthenticationStatus = AuthenticationStatus;
    CurFvCount                                                 = PrivateData->FvCount;
    DEBUG ((
      DEBUG_INFO,
      "The %dth FV[%g] start address is 0x%11p, size is 0x%08x, handle is 0x%p\n",
      (UINT32)CurFvCount,
      GetFvName ((EFI_FIRMWARE_VOLUME_HEADER *)FvInfo),
      (VOID *)FvInfo,
      FvInfoSize,
      FvHandle
      ));
    PrivateData->FvCount++;
 
    //
    // Scan and process the new discovered FV for EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
    //
    FileHandle = NULL;
    do {
      Status = FvPpi->FindFileByType (
                        FvPpi,
                        EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
                        FvHandle,
                        &FileHandle
                        );
      if (!EFI_ERROR (Status)) {
        Status = FvPpi->FindSectionByType (
                          FvPpi,
                          EFI_SECTION_PEI_DEPEX,
                          FileHandle,
                          (VOID **)&DepexData
                          );
        if (!EFI_ERROR (Status)) {
          if (!PeimDispatchReadiness (PeiServices, DepexData)) {
            //
            // Dependency is not satisfied.
            //
            continue;
          }
        }
 
        DEBUG ((DEBUG_INFO, "Found firmware volume Image File[%g] %p in FV[%d] %p\n", FileHandle, FileHandle, CurFvCount, FvHandle));
        ProcessFvFile (PrivateData, &PrivateData->Fv[CurFvCount], FileHandle);
      }
    } while (FileHandle != NULL);
  } while (TRUE);
}