/**
Command entry point.
@param[in] RomBar The Rom Base address.
@param[in] RomSize The Rom size.
@param[in] FileName The file name.
@retval EFI_SUCCESS The command completed successfully.
@retval EFI_INVALID_PARAMETER Command usage error.
@retval EFI_UNSUPPORTED Protocols unsupported.
@retval EFI_OUT_OF_RESOURCES Out of memory.
@retval Other value Unknown error.
**/
EFI_STATUS
EFIAPI
LoadEfiDriversFromRomImage (
VOID *RomBar,
UINTN RomSize,
CONST CHAR16 *FileName
)
{
EFI_PCI_EXPANSION_ROM_HEADER *EfiRomHeader;
PCI_DATA_STRUCTURE *Pcir;
UINTN ImageIndex;
UINTN RomBarOffset;
UINT32 ImageSize;
UINT16 ImageOffset;
EFI_HANDLE ImageHandle;
EFI_STATUS Status;
EFI_STATUS ReturnStatus;
CHAR16 RomFileName[280];
EFI_DEVICE_PATH_PROTOCOL *FilePath;
BOOLEAN SkipImage;
UINT32 DestinationSize;
UINT32 ScratchSize;
UINT8 *Scratch;
VOID *ImageBuffer;
VOID *DecompressedImageBuffer;
UINT32 ImageLength;
EFI_DECOMPRESS_PROTOCOL *Decompress;
UINT32 InitializationSize;
ImageIndex = 0;
ReturnStatus = EFI_NOT_FOUND;
RomBarOffset = (UINTN) RomBar;
do {
EfiRomHeader = (EFI_PCI_EXPANSION_ROM_HEADER *) (UINTN) RomBarOffset;
if (EfiRomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOADPCIROM_CORRUPT), gShellDebug1HiiHandle, FileName, ImageIndex);
// PrintToken (STRING_TOKEN (STR_LOADPCIROM_IMAGE_CORRUPT), HiiHandle, ImageIndex);
return ReturnStatus;
}
//
// If the pointer to the PCI Data Structure is invalid, no further images can be located.
// The PCI Data Structure must be DWORD aligned.
//
if (EfiRomHeader->PcirOffset == 0 ||
(EfiRomHeader->PcirOffset & 3) != 0 ||
RomBarOffset - (UINTN)RomBar + EfiRomHeader->PcirOffset + sizeof (PCI_DATA_STRUCTURE) > RomSize) {
break;
}
Pcir = (PCI_DATA_STRUCTURE *) (UINTN) (RomBarOffset + EfiRomHeader->PcirOffset);
//
// If a valid signature is not present in the PCI Data Structure, no further images can be located.
//
if (Pcir->Signature != PCI_DATA_STRUCTURE_SIGNATURE) {
break;
}
ImageSize = Pcir->ImageLength * 512;
if (RomBarOffset - (UINTN)RomBar + ImageSize > RomSize) {
break;
}
if ((Pcir->CodeType == PCI_CODE_TYPE_EFI_IMAGE) &&
(EfiRomHeader->EfiSignature == EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE) &&
((EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) ||
(EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER))) {
ImageOffset = EfiRomHeader->EfiImageHeaderOffset;
InitializationSize = EfiRomHeader->InitializationSize * 512;
if (InitializationSize <= ImageSize && ImageOffset < InitializationSize) {
ImageBuffer = (VOID *) (UINTN) (RomBarOffset + ImageOffset);
ImageLength = InitializationSize - ImageOffset;
DecompressedImageBuffer = NULL;
//
// decompress here if needed
//
SkipImage = FALSE;
if (EfiRomHeader->CompressionType > EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
SkipImage = TRUE;
}
if (EfiRomHeader->CompressionType == EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
Status = gBS->LocateProtocol (&gEfiDecompressProtocolGuid, NULL, (VOID**)&Decompress);
ASSERT_EFI_ERROR(Status);
if (EFI_ERROR (Status)) {
SkipImage = TRUE;
} else {
SkipImage = TRUE;
Status = Decompress->GetInfo (
Decompress,
ImageBuffer,
ImageLength,
&DestinationSize,
&ScratchSize
);
if (!EFI_ERROR (Status)) {
DecompressedImageBuffer = AllocateZeroPool (DestinationSize);
if (ImageBuffer != NULL) {
Scratch = AllocateZeroPool (ScratchSize);
if (Scratch != NULL) {
Status = Decompress->Decompress (
Decompress,
ImageBuffer,
ImageLength,
DecompressedImageBuffer,
DestinationSize,
Scratch,
ScratchSize
);
if (!EFI_ERROR (Status)) {
ImageBuffer = DecompressedImageBuffer;
ImageLength = DestinationSize;
SkipImage = FALSE;
}
FreePool (Scratch);
}
}
}
}
}
if (!SkipImage) {
//
// load image and start image
//
UnicodeSPrint (RomFileName, sizeof (RomFileName), L"%s[%d]", FileName, ImageIndex);
FilePath = FileDevicePath (NULL, RomFileName);
Status = gBS->LoadImage (
TRUE,
gImageHandle,
FilePath,
ImageBuffer,
ImageLength,
&ImageHandle
);
if (EFI_ERROR (Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOADPCIROM_LOAD_FAIL), gShellDebug1HiiHandle, FileName, ImageIndex, Status);
// PrintToken (STRING_TOKEN (STR_LOADPCIROM_LOAD_IMAGE_ERROR), HiiHandle, ImageIndex, Status);
} else {
Status = gBS->StartImage (ImageHandle, NULL, NULL);
if (EFI_ERROR (Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOADPCIROM_START_FAIL), gShellDebug1HiiHandle, FileName, ImageIndex, Status);
// PrintToken (STRING_TOKEN (STR_LOADPCIROM_START_IMAGE), HiiHandle, ImageIndex, Status);
} else {
ReturnStatus = Status;
}
}
}
if (DecompressedImageBuffer != NULL) {
FreePool (DecompressedImageBuffer);
}
}
}
RomBarOffset = RomBarOffset + ImageSize;
ImageIndex++;
} while (((Pcir->Indicator & 0x80) == 0x00) && ((RomBarOffset - (UINTN) RomBar) < RomSize));
return ReturnStatus;
}
EFI_STATUS
ProcessOpRomImage (
PCI_IO_DEVICE *PciDevice
)
/*++
Routine Description:
Process the oprom image.
Arguments:
PciDevice A pointer to a pci device.
Returns:
EFI Status.
--*/
{
UINT8 Indicator;
UINT32 ImageSize;
UINT16 ImageOffset;
VOID *RomBar;
UINT8 *RomBarOffset;
EFI_HANDLE ImageHandle;
EFI_STATUS Status;
EFI_STATUS retStatus;
BOOLEAN SkipImage;
UINT32 DestinationSize;
UINT32 ScratchSize;
UINT8 *Scratch;
VOID *ImageBuffer;
VOID *DecompressedImageBuffer;
UINT32 ImageLength;
EFI_DECOMPRESS_PROTOCOL *Decompress;
EFI_PCI_EXPANSION_ROM_HEADER *EfiRomHeader;
PCI_DATA_STRUCTURE *Pcir;
UINT32 InitializationSize;
Indicator = 0;
//
// Get the Address of the Rom image
//
RomBar = PciDevice->PciIo.RomImage;
RomBarOffset = (UINT8 *) RomBar;
retStatus = EFI_NOT_FOUND;
if (RomBarOffset == NULL) {
return retStatus;
}
ASSERT (((EFI_PCI_EXPANSION_ROM_HEADER *) RomBarOffset)->Signature == PCI_EXPANSION_ROM_HEADER_SIGNATURE);
do {
EfiRomHeader = (EFI_PCI_EXPANSION_ROM_HEADER *) RomBarOffset;
if (EfiRomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {
RomBarOffset = RomBarOffset + 512;
continue;
}
Pcir = (PCI_DATA_STRUCTURE *) (RomBarOffset + EfiRomHeader->PcirOffset);
ASSERT (Pcir->Signature == PCI_DATA_STRUCTURE_SIGNATURE);
ImageSize = (UINT32) (Pcir->ImageLength * 512);
Indicator = Pcir->Indicator;
if ((Pcir->CodeType == PCI_CODE_TYPE_EFI_IMAGE) &&
(EfiRomHeader->EfiSignature == EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE) &&
((EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) ||
(EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER))) {
ImageOffset = EfiRomHeader->EfiImageHeaderOffset;
InitializationSize = EfiRomHeader->InitializationSize * 512;
if (InitializationSize <= ImageSize && ImageOffset < InitializationSize) {
ImageBuffer = (VOID *) (RomBarOffset + ImageOffset);
ImageLength = InitializationSize - (UINT32)ImageOffset;
DecompressedImageBuffer = NULL;
//
// decompress here if needed
//
SkipImage = FALSE;
if (EfiRomHeader->CompressionType > EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
SkipImage = TRUE;
}
if (EfiRomHeader->CompressionType == EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
Status = gBS->LocateProtocol (&gEfiDecompressProtocolGuid, NULL, (VOID **) &Decompress);
if (EFI_ERROR (Status)) {
SkipImage = TRUE;
} else {
SkipImage = TRUE;
Status = Decompress->GetInfo (
Decompress,
ImageBuffer,
ImageLength,
&DestinationSize,
&ScratchSize
);
if (!EFI_ERROR (Status)) {
DecompressedImageBuffer = NULL;
DecompressedImageBuffer = AllocatePool (DestinationSize);
if (DecompressedImageBuffer != NULL) {
Scratch = AllocatePool (ScratchSize);
if (Scratch != NULL) {
Status = Decompress->Decompress (
Decompress,
ImageBuffer,
ImageLength,
DecompressedImageBuffer,
DestinationSize,
Scratch,
ScratchSize
);
if (!EFI_ERROR (Status)) {
ImageBuffer = DecompressedImageBuffer;
ImageLength = DestinationSize;
SkipImage = FALSE;
}
gBS->FreePool (Scratch);
}
}
}
}
}
if (!SkipImage) {
//
// load image and start image
//
Status = gBS->LoadImage (
FALSE,
gPciBusDriverBinding.DriverBindingHandle,
NULL,
ImageBuffer,
ImageLength,
&ImageHandle
);
if (!EFI_ERROR (Status)) {
Status = gBS->StartImage (ImageHandle, NULL, NULL);
if (!EFI_ERROR (Status)) {
AddDriver (PciDevice, ImageHandle);
retStatus = EFI_SUCCESS;
}
}
}
RomBarOffset = RomBarOffset + ImageSize;
} else {
RomBarOffset = RomBarOffset + ImageSize;
}
} else {
RomBarOffset = RomBarOffset + ImageSize;
}
} while (((Indicator & 0x80) == 0x00) && ((UINTN) (RomBarOffset - (UINT8 *) RomBar) < PciDevice->RomSize));
return retStatus;
}
/**
Function for 'decompress' command.
@param[in] ImageHandle Handle to the Image (NULL if Internal).
@param[in] SystemTable Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunEfiDecompress (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
SHELL_FILE_HANDLE InFileHandle;
SHELL_FILE_HANDLE OutFileHandle;
UINT32 OutSize;
UINTN OutSizeTemp;
VOID *OutBuffer;
UINTN InSize;
VOID *InBuffer;
CHAR16 *InFileName;
CONST CHAR16 *OutFileName;
UINT64 Temp64Bit;
UINT32 ScratchSize;
VOID *ScratchBuffer;
EFI_DECOMPRESS_PROTOCOL *Decompress;
CONST CHAR16 *TempParam;
InFileName = NULL;
OutFileName = NULL;
OutSize = 0;
ShellStatus = SHELL_SUCCESS;
Status = EFI_SUCCESS;
OutBuffer = NULL;
InBuffer = NULL;
ScratchBuffer = NULL;
InFileHandle = NULL;
OutFileHandle = NULL;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
Status = CommandInit();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (EmptyParamList, &Package, &ProblemParam, TRUE);
if (EFI_ERROR(Status)) {
if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
if (ShellCommandLineGetCount(Package) > 3) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
} else if (ShellCommandLineGetCount(Package) < 3) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellDebug1HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
TempParam = ShellCommandLineGetRawValue(Package, 1);
ASSERT(TempParam != NULL);
InFileName = ShellFindFilePath(TempParam);
OutFileName = ShellCommandLineGetRawValue(Package, 2);
if (InFileName == NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_FIND_FAIL), gShellDebug1HiiHandle, TempParam);
ShellStatus = SHELL_NOT_FOUND;
} else {
if (ShellIsDirectory(InFileName) == EFI_SUCCESS){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_NOT_DIR), gShellDebug1HiiHandle, InFileName);
ShellStatus = SHELL_INVALID_PARAMETER;
}
if (ShellIsDirectory(OutFileName) == EFI_SUCCESS){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_NOT_DIR), gShellDebug1HiiHandle, OutFileName);
ShellStatus = SHELL_INVALID_PARAMETER;
}
if (ShellStatus == SHELL_SUCCESS) {
Status = ShellOpenFileByName(InFileName, &InFileHandle, EFI_FILE_MODE_READ, 0);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_OPEN_FAIL), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, 1), Status);
ShellStatus = SHELL_NOT_FOUND;
}
Status = ShellOpenFileByName(OutFileName, &OutFileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_OPEN_FAIL), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, 2), Status);
ShellStatus = SHELL_NOT_FOUND;
}
}
if (ShellStatus == SHELL_SUCCESS) {
Status = FileHandleGetSize(InFileHandle, &Temp64Bit);
ASSERT(Temp64Bit <= (UINT32)(-1));
InSize = (UINTN)Temp64Bit;
ASSERT_EFI_ERROR(Status);
InBuffer = AllocateZeroPool(InSize);
ASSERT(InBuffer != NULL);
Status = gEfiShellProtocol->ReadFile(InFileHandle, &InSize, InBuffer);
ASSERT_EFI_ERROR(Status);
Status = gBS->LocateProtocol(&gEfiDecompressProtocolGuid, NULL, (VOID**)&Decompress);
ASSERT_EFI_ERROR(Status);
Status = Decompress->GetInfo(Decompress, InBuffer, (UINT32)InSize, &OutSize, &ScratchSize);
ASSERT_EFI_ERROR(Status);
OutBuffer = AllocateZeroPool(OutSize);
ScratchBuffer = AllocateZeroPool(ScratchSize);
ASSERT(OutBuffer != NULL);
ASSERT(ScratchBuffer != NULL);
Status = Decompress->Decompress(Decompress, InBuffer, (UINT32)InSize, OutBuffer, OutSize, ScratchBuffer, ScratchSize);
ASSERT_EFI_ERROR(Status);
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_EFI_DECOMPRESS_FAIL), gShellDebug1HiiHandle, Status);
ShellStatus = SHELL_DEVICE_ERROR;
} else {
OutSizeTemp = OutSize;
Status = gEfiShellProtocol->WriteFile(OutFileHandle, &OutSizeTemp, OutBuffer);
OutSize = (UINT32)OutSizeTemp;
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_WRITE_FAIL), gShellDebug1HiiHandle, OutFileName, Status);
ShellStatus = SHELL_DEVICE_ERROR;
}
}
}
}
}
ShellCommandLineFreeVarList (Package);
}
if (InFileHandle != NULL) {
gEfiShellProtocol->CloseFile(InFileHandle);
}
if (OutFileHandle != NULL) {
gEfiShellProtocol->CloseFile(OutFileHandle);
}
SHELL_FREE_NON_NULL(InFileName);
SHELL_FREE_NON_NULL(InBuffer);
SHELL_FREE_NON_NULL(OutBuffer);
SHELL_FREE_NON_NULL(ScratchBuffer);
return (ShellStatus);
}
EFI_STATUS
PciRomLoadEfiDriversFromRomImage (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_PCI_OPTION_ROM_DESCRIPTOR *PciOptionRomDescriptor
)
/*++
Routine Description:
Command entry point.
Arguments:
ImageHandle The image handle.
SystemTable The system table.
Returns:
EFI_SUCCESS - The command completed successfully
EFI_INVALID_PARAMETER - Command usage error
EFI_UNSUPPORTED - Protocols unsupported
EFI_OUT_OF_RESOURCES - Out of memory
Other value - Unknown error
--*/
{
VOID *RomBar;
UINTN RomSize;
CHAR16 *FileName;
EFI_PCI_EXPANSION_ROM_HEADER *EfiRomHeader;
PCI_DATA_STRUCTURE *Pcir;
UINTN ImageIndex;
UINTN RomBarOffset;
UINT32 ImageSize;
UINT16 ImageOffset;
EFI_HANDLE ImageHandle;
EFI_STATUS Status;
EFI_STATUS retStatus;
EFI_DEVICE_PATH_PROTOCOL *FilePath;
BOOLEAN SkipImage;
UINT32 DestinationSize;
UINT32 ScratchSize;
UINT8 *Scratch;
VOID *ImageBuffer;
VOID *DecompressedImageBuffer;
UINT32 ImageLength;
EFI_DECOMPRESS_PROTOCOL *Decompress;
RomBar = (VOID *) (UINTN) PciOptionRomDescriptor->RomAddress;
RomSize = (UINTN) PciOptionRomDescriptor->RomLength;
FileName = L"PciRom Seg=00000000 Bus=00 Dev=00 Func=00 Image=0000";
HexToString (&FileName[11], PciOptionRomDescriptor->Seg, 8);
HexToString (&FileName[24], PciOptionRomDescriptor->Bus, 2);
HexToString (&FileName[31], PciOptionRomDescriptor->Dev, 2);
HexToString (&FileName[39], PciOptionRomDescriptor->Func, 2);
ImageIndex = 0;
retStatus = EFI_NOT_FOUND;
RomBarOffset = (UINTN) RomBar;
do {
EfiRomHeader = (EFI_PCI_EXPANSION_ROM_HEADER *) (UINTN) RomBarOffset;
if (EfiRomHeader->Signature != 0xaa55) {
return retStatus;
}
Pcir = (PCI_DATA_STRUCTURE *) (UINTN) (RomBarOffset + EfiRomHeader->PcirOffset);
ImageSize = Pcir->ImageLength * 512;
if ((Pcir->CodeType == PCI_CODE_TYPE_EFI_IMAGE) &&
(EfiRomHeader->EfiSignature == EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE) ) {
if ((EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) ||
(EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) ) {
ImageOffset = EfiRomHeader->EfiImageHeaderOffset;
ImageSize = EfiRomHeader->InitializationSize * 512;
ImageBuffer = (VOID *) (UINTN) (RomBarOffset + ImageOffset);
ImageLength = ImageSize - ImageOffset;
DecompressedImageBuffer = NULL;
//
// decompress here if needed
//
SkipImage = FALSE;
if (EfiRomHeader->CompressionType > EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
SkipImage = TRUE;
}
if (EfiRomHeader->CompressionType == EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
Status = gBS->LocateProtocol (&gEfiDecompressProtocolGuid, NULL, (VOID **) &Decompress);
if (EFI_ERROR (Status)) {
SkipImage = TRUE;
} else {
SkipImage = TRUE;
Status = Decompress->GetInfo (
Decompress,
ImageBuffer,
ImageLength,
&DestinationSize,
&ScratchSize
);
if (!EFI_ERROR (Status)) {
DecompressedImageBuffer = NULL;
DecompressedImageBuffer = AllocatePool (DestinationSize);
if (DecompressedImageBuffer != NULL) {
Scratch = AllocatePool (ScratchSize);
if (Scratch != NULL) {
Status = Decompress->Decompress (
Decompress,
ImageBuffer,
ImageLength,
DecompressedImageBuffer,
DestinationSize,
Scratch,
ScratchSize
);
if (!EFI_ERROR (Status)) {
ImageBuffer = DecompressedImageBuffer;
ImageLength = DestinationSize;
SkipImage = FALSE;
}
gBS->FreePool (Scratch);
}
}
}
}
}
if (!SkipImage) {
//
// load image and start image
//
HexToString (&FileName[48], ImageIndex, 4);
FilePath = FileDevicePath (NULL, FileName);
Status = gBS->LoadImage (
FALSE,
This->ImageHandle,
FilePath,
ImageBuffer,
ImageLength,
&ImageHandle
);
if (!EFI_ERROR (Status)) {
Status = gBS->StartImage (ImageHandle, NULL, NULL);
if (!EFI_ERROR (Status)) {
PciRomAddImageMapping (
ImageHandle,
PciOptionRomDescriptor->Seg,
PciOptionRomDescriptor->Bus,
PciOptionRomDescriptor->Dev,
PciOptionRomDescriptor->Func
);
retStatus = Status;
}
}
if (FilePath != NULL) {
gBS->FreePool (FilePath);
}
}
if (DecompressedImageBuffer != NULL) {
gBS->FreePool (DecompressedImageBuffer);
}
}
}
RomBarOffset = RomBarOffset + ImageSize;
ImageIndex++;
} while (((Pcir->Indicator & 0x80) == 0x00) && ((RomBarOffset - (UINTN) RomBar) < RomSize));
return retStatus;
}
STATIC
EFI_STATUS
PciRomLoadEfiDriversFromRomImage (
IN EFI_PHYSICAL_ADDRESS Rom,
IN UINTN RomSize
)
{
CHAR16 *FileName;
EFI_PCI_EXPANSION_ROM_HEADER *EfiRomHeader;
PCI_DATA_STRUCTURE *Pcir;
UINTN ImageIndex;
UINTN RomOffset;
UINT32 ImageSize;
UINT16 ImageOffset;
EFI_HANDLE ImageHandle;
EFI_STATUS Status;
EFI_STATUS retStatus;
EFI_DEVICE_PATH_PROTOCOL *FilePath;
BOOLEAN SkipImage;
UINT32 DestinationSize;
UINT32 ScratchSize;
UINT8 *Scratch;
VOID *ImageBuffer;
VOID *DecompressedImageBuffer;
UINT32 ImageLength;
EFI_DECOMPRESS_PROTOCOL *Decompress;
UINT32 InitializationSize;
VBoxLogFlowFuncEnter();
FileName = L"PciRomInMemory";
//FileName = L"PciRom Addr=0000000000000000";
//HexToString (&FileName[12], Rom, 16);
ImageIndex = 0;
retStatus = EFI_NOT_FOUND;
RomOffset = (UINTN) Rom;
do {
EfiRomHeader = (EFI_PCI_EXPANSION_ROM_HEADER *) (UINTN) RomOffset;
if (EfiRomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {
return retStatus;
}
//
// If the pointer to the PCI Data Structure is invalid, no further images can be located.
// The PCI Data Structure must be DWORD aligned.
//
if (EfiRomHeader->PcirOffset == 0 ||
(EfiRomHeader->PcirOffset & 3) != 0 ||
RomOffset - (UINTN)Rom + EfiRomHeader->PcirOffset + sizeof (PCI_DATA_STRUCTURE) > RomSize) {
break;
}
Pcir = (PCI_DATA_STRUCTURE *) (UINTN) (RomOffset + EfiRomHeader->PcirOffset);
//
// If a valid signature is not present in the PCI Data Structure, no further images can be located.
//
if (Pcir->Signature != PCI_DATA_STRUCTURE_SIGNATURE) {
break;
}
ImageSize = Pcir->ImageLength * 512;
if (RomOffset - (UINTN)Rom + ImageSize > RomSize) {
break;
}
if ((Pcir->CodeType == PCI_CODE_TYPE_EFI_IMAGE) &&
(EfiRomHeader->EfiSignature == EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE) &&
((EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) ||
(EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER))) {
ImageOffset = EfiRomHeader->EfiImageHeaderOffset;
InitializationSize = EfiRomHeader->InitializationSize * 512;
if (InitializationSize <= ImageSize && ImageOffset < InitializationSize) {
ImageBuffer = (VOID *) (UINTN) (RomOffset + ImageOffset);
ImageLength = InitializationSize - ImageOffset;
DecompressedImageBuffer = NULL;
//
// decompress here if needed
//
SkipImage = FALSE;
if (EfiRomHeader->CompressionType > EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
SkipImage = TRUE;
}
if (EfiRomHeader->CompressionType == EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {
Status = gBS->LocateProtocol (&gEfiDecompressProtocolGuid, NULL, (VOID **) &Decompress);
if (EFI_ERROR (Status)) {
SkipImage = TRUE;
} else {
SkipImage = TRUE;
Status = Decompress->GetInfo (
Decompress,
ImageBuffer,
ImageLength,
&DestinationSize,
&ScratchSize
);
if (!EFI_ERROR (Status)) {
DecompressedImageBuffer = NULL;
DecompressedImageBuffer = AllocatePool (DestinationSize);
if (DecompressedImageBuffer != NULL) {
Scratch = AllocatePool (ScratchSize);
if (Scratch != NULL) {
Status = Decompress->Decompress (
Decompress,
ImageBuffer,
ImageLength,
DecompressedImageBuffer,
DestinationSize,
Scratch,
ScratchSize
);
if (!EFI_ERROR (Status)) {
ImageBuffer = DecompressedImageBuffer;
ImageLength = DestinationSize;
SkipImage = FALSE;
}
gBS->FreePool (Scratch);
}
}
}
}
}
if (!SkipImage) {
//
// load image and start image
//
FilePath = FileDevicePath (NULL, FileName);
Status = gBS->LoadImage (
FALSE,
gImageHandle,
FilePath,
ImageBuffer,
ImageLength,
&ImageHandle
);
if (!EFI_ERROR (Status)) {
Status = gBS->StartImage (ImageHandle, NULL, NULL);
if (!EFI_ERROR (Status)) {
retStatus = Status;
}
}
if (FilePath != NULL) {
gBS->FreePool (FilePath);
}
}
if (DecompressedImageBuffer != NULL) {
gBS->FreePool (DecompressedImageBuffer);
}
}
}
RomOffset = RomOffset + ImageSize;
ImageIndex++;
} while (((Pcir->Indicator & 0x80) == 0x00) && ((RomOffset - (UINTN) Rom) < RomSize));
VBoxLogFlowFuncLeaveRC(retStatus);
return retStatus;
}
//
//TDS 4.1.1
//
EFI_STATUS
GetInfo_Func (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_DECOMPRESS_PROTOCOL *Decompress;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
UINT32 UncompressedFileSize;
UINT32 CompressedFileSize;
UINT32 DestinationSize;
UINT32 SecondTimeSize;
UINT32 ScratchSize;
UINT32 ScratchSizeOrg;
UINTN Index;
VOID *Buffer;
UINTN BufferSize;
EFI_TEST_ASSERTION AssertionType;
EFI_INI_FILE_HANDLE FileHandle;
EFI_FILE_HANDLE CompressedFHandle;
UINTN MaxOrder;
CHAR16 *FileName;
//
//get tested interface.
//
Decompress = (EFI_DECOMPRESS_PROTOCOL *)ClientInterface;
//
// Get the test Supported Library Interface
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&ProfileLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = GetSystemData (ProfileLib);
if (EFI_ERROR(Status)) {
return Status;
}
//
//open the ini file.
//
Status = OpenTestIniFile (ProfileLib, &FileHandle);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() -no item found for this test case.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
//we initialize this variable because it was taken as UINT32 type, in fact it
//is UINT64 value in ipf platform.
//
MaxOrder = 0;
Status = FileHandle->GetOrderNum (
FileHandle,
SECTION_NAME_GETINFO_BASIC_TEST,
(UINT32 *)&MaxOrder
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() -no item found for this test case",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
CloseTestIniFile (ProfileLib, FileHandle);
return Status;
}
for (Index = 0; Index < MaxOrder; Index++) {
//
//get compressed FileName and Uncompressed File Size.
//
Status = GetUncompressedFileSize (
FileHandle,
SECTION_NAME_GETINFO_BASIC_TEST,
Index,
&UncompressedFileSize
);
if (EFI_ERROR(Status)) {
continue;
}
Status = GetCompressedFileName (
FileHandle,
SECTION_NAME_GETINFO_BASIC_TEST,
Index,
&FileName
);
if (EFI_ERROR(Status)) {
continue;
}
//
//read the Compressed file into memory.
//
Status = OpenFileAndGetSize (
FileName,
&CompressedFHandle,
&CompressedFileSize
);
if (EFI_ERROR(Status)) {
Print (L"Can not open the File :%s\r\n", FileName);
gtBS->FreePool (FileName);
continue;
}
gtBS->FreePool (FileName);
Buffer = AllocatePool (CompressedFileSize);
if (Buffer == NULL) {
CompressedFHandle->Close (CompressedFHandle);
Print (L"Can not allocate %xh buffer.\r\n", CompressedFileSize);
continue;
}
BufferSize = CompressedFileSize;
Status = CompressedFHandle->Read (
CompressedFHandle,
&BufferSize,
Buffer
);
if (EFI_ERROR(Status)) {
CompressedFHandle->Close (CompressedFHandle);
Print (L"File Read Error Status %r\r\n", Status);
gtBS->FreePool (Buffer);
continue;
}
//
//now verify the check points.
//
Status = Decompress->GetInfo (
Decompress,
Buffer,
CompressedFileSize,
&DestinationSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid001,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (DestinationSize == UncompressedFileSize) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid002,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - the Destination Size should be equal with the Uncompressed File Size",
L"%a:%d:Destination Size - %d, Uncompressed File Size - %d",
__FILE__,
__LINE__,
(UINT32)DestinationSize,
(UINT32)UncompressedFileSize
);
//
//call GetInfo again see if the returned value is the same.
//
ScratchSizeOrg = ScratchSize;
Status = Decompress->GetInfo (
Decompress,
Buffer,
CompressedFileSize,
&SecondTimeSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid003,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - call the second time, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (SecondTimeSize == DestinationSize) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid004,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - two time returned Destination size must be equal",
L"%a:%d:First Time - %08x, Second Time- %08x",
__FILE__,
__LINE__,
DestinationSize,
SecondTimeSize
);
if (ScratchSize == ScratchSizeOrg) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid005,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - two time returned Scratch size must be equal",
L"%a:%d:First Time - %08x, Second Time- %08x",
__FILE__,
__LINE__,
ScratchSizeOrg,
ScratchSize
);
//
//free the resources
//
gtBS->FreePool (Buffer);
CompressedFHandle->Close (CompressedFHandle);
}
CloseTestIniFile (ProfileLib, FileHandle);
//
//done successfully
//
return EFI_SUCCESS;
}
//
//TDS 4.1.2
//
EFI_STATUS
Decompress_Func (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STATUS Status;
EFI_DECOMPRESS_PROTOCOL *Decompress;
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
UINT32 UncompressedFileSize;
UINT32 CompressedFileSize;
UINT32 DestinationSize;
UINT32 ScratchSize;
UINTN Index;
UINTN SubIndex;
VOID *CompressedFileBuffer;
VOID *UncompressedFileBuffer;
UINT8 *DecompressBuffer;
VOID *ScratchBuffer;
UINTN BufferSize;
EFI_TEST_ASSERTION AssertionType;
EFI_INI_FILE_HANDLE FileHandle;
EFI_FILE_HANDLE CompressedFHandle;
EFI_FILE_HANDLE UncompressedFHandle;
UINTN MaxOrder;
CHAR16 *CompressedFileName;
CHAR16 *UncompressedFileName;
//
//get tested interface.
//
Decompress = (EFI_DECOMPRESS_PROTOCOL *)ClientInterface;
//
// Get the test Supported Library Interface
//
Status = GetTestSupportLibrary (
SupportHandle,
&StandardLib,
&ProfileLib
);
if (EFI_ERROR(Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = GetSystemData (ProfileLib);
if (EFI_ERROR(Status)) {
return Status;
}
//
//open the ini file.
//
Status = OpenTestIniFile (ProfileLib, &FileHandle);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.Decompress() -not found the profile.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
//
//we initialize this variable because it was taken as UINT32 type, in fact it
//is UINT64 value in ipf platform.
//
MaxOrder = 0;
Status = FileHandle->GetOrderNum (
FileHandle,
SECTION_NAME_DECOMPRESS_BASIC_TEST,
(UINT32 *)&MaxOrder
);
if (EFI_ERROR(Status)) {
CloseTestIniFile (ProfileLib, FileHandle);
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_WARNING,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.Decompress() -no item found for this test case.",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
for (Index = 0; Index < MaxOrder; Index++) {
CompressedFileBuffer = NULL;
UncompressedFileBuffer = NULL;
DecompressBuffer = NULL;
ScratchBuffer = NULL;
//
//get compressed FileName and file size.
//
Status = GetCompressedFileName (
FileHandle,
SECTION_NAME_DECOMPRESS_BASIC_TEST,
Index,
&CompressedFileName
);
if (EFI_ERROR(Status)) {
Print (L"Get CompressedFileName Error\r\n");
continue;
}
Status = GetUncompressedFileName (
FileHandle,
SECTION_NAME_DECOMPRESS_BASIC_TEST,
Index,
&UncompressedFileName
);
if (EFI_ERROR(Status)) {
gtBS->FreePool (CompressedFileName);
Print (L"Get UncompressedFileName Error\r\n");
continue;
}
//
//Open the Compressed file and get file size.
//
Status = OpenFileAndGetSize (
CompressedFileName,
&CompressedFHandle,
&CompressedFileSize
);
if (EFI_ERROR(Status)) {
Print (L"Can not open the File :%s\r\n", CompressedFileName);
gtBS->FreePool (CompressedFileName);
gtBS->FreePool (UncompressedFileName);
continue;
}
gtBS->FreePool (CompressedFileName);
//
//Open the Uncompressed file and get file size.
//
Status = OpenFileAndGetSize (
UncompressedFileName,
&UncompressedFHandle,
&UncompressedFileSize
);
if (EFI_ERROR(Status)) {
Print (L"Can not open the File :%s\r\n", UncompressedFileName);
CompressedFHandle->Close (CompressedFHandle);
gtBS->FreePool (UncompressedFileName);
continue;
}
gtBS->FreePool (UncompressedFileName);
//
//then read the Compressed File into memory.
//
CompressedFileBuffer = AllocatePool (CompressedFileSize);
if (CompressedFileBuffer == NULL) {
CompressedFHandle->Close (CompressedFHandle);
UncompressedFHandle->Close (UncompressedFHandle);
Print (L"Can not allocate %xh buffer.\r\n", CompressedFileSize);
continue;
}
BufferSize = CompressedFileSize;
Status = CompressedFHandle->Read (
CompressedFHandle,
&BufferSize,
CompressedFileBuffer
);
CompressedFHandle->Close (CompressedFHandle);
if (EFI_ERROR(Status)) {
UncompressedFHandle->Close (UncompressedFHandle);
Print (L"File Read Error Status %r\r\n", Status);
gtBS->FreePool (CompressedFileBuffer);
continue;
}
if (UncompressedFileSize == 0) {
UncompressedFHandle->Close (UncompressedFHandle);
Status = Decompress->GetInfo (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
&DestinationSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - return Status Should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (DestinationSize == 0) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - the Destination Size should be equal with the Uncompressed File Size",
L"%a:%d:destination Size - %d, Uncompressed File Size - %d",
__FILE__,
__LINE__,
(UINT32)DestinationSize,
(UINT32)UncompressedFileSize
);
//
// Fill the buffer with 0x00, and check whether the buffer is changed later
//
DecompressBuffer = AllocateZeroPool (128);
if (DecompressBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
Print (L"Can not allocate %xh buffer.\r\n", 128);
continue;
}
ScratchBuffer = AllocatePool (ScratchSize);
if (ScratchBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
Print (L"Can not allocate %xh buffer.\r\n", ScratchSize);
continue;
}
Status = Decompress->Decompress (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
DecompressBuffer,
DestinationSize,
ScratchBuffer,
ScratchSize
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid007,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - decompress zero file, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
AssertionType = EFI_TEST_ASSERTION_PASSED;
//
// Check whether the buffer is changed
//
for (SubIndex = 0; SubIndex < 128; SubIndex++) {
if (DecompressBuffer[SubIndex] != (UINT8)0x00) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
break;
}
}
SubIndex = (SubIndex < 127) ? SubIndex : 127;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid008,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - Decompressed zero length file, the buffer should not be modified",
L"%a:%d:buffer - 0x%02x, expected - 0x00",
__FILE__,
__LINE__,
DecompressBuffer[SubIndex]
);
//
// Fill the buffer with 0xff, and check whether the buffer is changed later
//
for (SubIndex = 0; SubIndex < 128; SubIndex++) {
DecompressBuffer[SubIndex] = (UINT8)0xff;
}
Status = Decompress->Decompress (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
DecompressBuffer,
DestinationSize,
ScratchBuffer,
ScratchSize
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid007,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - decompress zero file, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
AssertionType = EFI_TEST_ASSERTION_PASSED;
//
// Check whether the buffer is changed
//
for (SubIndex = 0; SubIndex < 128; SubIndex++) {
if (DecompressBuffer[SubIndex] != (UINT8)0xff) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
break;
}
}
SubIndex = (SubIndex < 127) ? SubIndex : 127;
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid008,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - Decompressed zero length file, the buffer should not be modified",
L"%a:%d:buffer - 0x%02x, expected - 0xff",
__FILE__,
__LINE__,
DecompressBuffer[SubIndex]
);
//
//free the resources.
//
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
gtBS->FreePool (ScratchBuffer);
continue;
}
//
//the Uncompressed file is not null so read it into memory.
//
UncompressedFileBuffer = AllocatePool (UncompressedFileSize);
if (UncompressedFileBuffer == NULL) {
UncompressedFHandle->Close (UncompressedFHandle);
gtBS->FreePool (CompressedFileBuffer);
Print (L"Can not alloate %xh buffer.\r\n", UncompressedFileSize);
continue;
}
BufferSize = UncompressedFileSize;
Status = UncompressedFHandle->Read (
UncompressedFHandle,
&BufferSize,
UncompressedFileBuffer
);
UncompressedFHandle->Close (UncompressedFHandle);
if (EFI_ERROR(Status)) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
Print (L"File Read Error Status %r\r\n", Status);
continue;
}
//
//now verify the check points.
//
Status = Decompress->GetInfo (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
&DestinationSize,
&ScratchSize
);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (DestinationSize == UncompressedFileSize) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_DECOMPRESS_PROTOCOL.GetInfo() - the Destination Size should be equal with the Uncompressed File Size",
L"%a:%d:destination Size - %d, Uncompressed File Size - %d",
__FILE__,
__LINE__,
(UINT32)DestinationSize,
(UINT32)UncompressedFileSize
);
//
//allocate Decompess buffer and Decompress the compessed data.
//
DecompressBuffer = AllocatePool (DestinationSize);
if (DecompressBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
Print (L"Can not allocate %xh buffer.\r\n", DestinationSize);
continue;
}
ScratchBuffer = AllocatePool (ScratchSize);
if (ScratchBuffer == NULL) {
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
Print (L"Can not allocate %xh buffer.\r\n", ScratchSize);
continue;
}
Status = Decompress->Decompress (
Decompress,
CompressedFileBuffer,
CompressedFileSize,
DecompressBuffer,
DestinationSize,
ScratchBuffer,
ScratchSize
);
if (!EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid009,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - decompress unzero file, return Status should be EFI_SUCCESS",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
if (CompareMem (DecompressBuffer,
UncompressedFileBuffer, UncompressedFileSize) == 0) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
//
//record assertion
//
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDecompressBBTestFunctionAssertionGuid010,
L"EFI_DECOMPRESS_PROTOCOL.Decompess() - Decompressed data should be equal with Uncompressed data",
L"%a:%d",
__FILE__,
__LINE__
);
//
//free the resources
//
gtBS->FreePool (CompressedFileBuffer);
gtBS->FreePool (UncompressedFileBuffer);
gtBS->FreePool (DecompressBuffer);
gtBS->FreePool (ScratchBuffer);
}
CloseTestIniFile (ProfileLib, FileHandle);
//
//done successfully
//
return EFI_SUCCESS;
}
