MdeModulePkg/Core/DxeIplPeim/DxeLoad.c

   1 /**@file
   2   Last PEIM.
   3   Responsibility of this module is to load the DXE Core from a Firmware Volume.
   4
   5 Copyright (c) 2006 - 2007 Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "DxeIpl.h"
  17 #include <Ppi/GuidedSectionExtraction.h>
  18 #include <FrameworkPei.h>
  19
  20 EFI_STATUS
  21 CustomGuidedSectionExtract (
  22   IN CONST  EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI *This,
  23   IN CONST  VOID                                  *InputSection,
  24   OUT       VOID                                  **OutputBuffer,
  25   OUT       UINTN                                 *OutputSize,
  26   OUT       UINT32                                *AuthenticationStatus
  27 );
  28
  29 STATIC
  30 EFI_STATUS
  31 EFIAPI
  32 Decompress (
  33   IN CONST  EFI_PEI_DECOMPRESS_PPI  *This,
  34   IN CONST  EFI_COMPRESSION_SECTION *InputSection,
  35   OUT       VOID                    **OutputBuffer,
  36   OUT       UINTN                   *OutputSize
  37 );
  38
  39
  40 BOOLEAN gInMemory = FALSE;
  41
  42 //
  43 // Module Globals used in the DXE to PEI handoff
  44 // These must be module globals, so the stack can be switched
  45 //
  46 static EFI_DXE_IPL_PPI mDxeIplPpi = {
  47   DxeLoadCore
  48 };
  49
  50 STATIC EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI mCustomGuidedSectionExtractionPpi = {
  51   CustomGuidedSectionExtract
  52 };
  53
  54 STATIC EFI_PEI_DECOMPRESS_PPI mDecompressPpi = {
  55   Decompress
  56 };
  57
  58 static EFI_PEI_PPI_DESCRIPTOR     mPpiList[] = {
  59   {
  60     EFI_PEI_PPI_DESCRIPTOR_PPI,
  61     &gEfiDxeIplPpiGuid,
  62     &mDxeIplPpi
  63   },
  64   {
  65     (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  66     &gEfiPeiDecompressPpiGuid,
  67     &mDecompressPpi
  68   }
  69 };
  70
  71 static EFI_PEI_PPI_DESCRIPTOR     mPpiSignal = {
  72   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  73   &gEfiEndOfPeiSignalPpiGuid,
  74   NULL
  75 };
  76
  77 /**
  78   Initializes the Dxe Ipl PPI
  79
  80   @param  FfsHandle   The handle of FFS file.
  81   @param  PeiServices General purpose services available to
  82                       every PEIM.
  83   @return EFI_SUCESS
  84 */
  85 EFI_STATUS
  86 EFIAPI
  87 PeimInitializeDxeIpl (
  88   IN EFI_PEI_FILE_HANDLE       FfsHandle,
  89   IN EFI_PEI_SERVICES          **PeiServices
  90   )
  91 {
  92   EFI_STATUS                                Status;
  93   EFI_BOOT_MODE                             BootMode;
  94   EFI_GUID                                  *ExtractHandlerGuidTable;
  95   UINTN                                     ExtractHandlerNumber;
  96   EFI_PEI_PPI_DESCRIPTOR                    *GuidPpi;
  97
  98   Status = PeiServicesGetBootMode (&BootMode);
  99   ASSERT_EFI_ERROR (Status);
 100
 101   if (BootMode != BOOT_ON_S3_RESUME) {
 102     Status = PeiServicesRegisterForShadow (FfsHandle);
 103     if (Status == EFI_SUCCESS) {
 104       //
 105       // EFI_SUCESS means the first time call register for shadow
 106       //
 107       return Status;
 108     } else if (Status == EFI_ALREADY_STARTED) {
 109
 110       gInMemory = TRUE;
 111
 112       //
 113       // Get custom extract guided section method guid list
 114       //
 115       ExtractHandlerNumber = ExtractGuidedSectionGetGuidList (&ExtractHandlerGuidTable);
 116
 117       //
 118       // Install custom extraction guid ppi
 119       //
 120       if (ExtractHandlerNumber > 0) {
 121         GuidPpi = NULL;
 122         GuidPpi = (EFI_PEI_PPI_DESCRIPTOR *) AllocatePool (ExtractHandlerNumber * sizeof (EFI_PEI_PPI_DESCRIPTOR));
 123         ASSERT (GuidPpi != NULL);
 124         while (ExtractHandlerNumber-- > 0) {
 125           GuidPpi->Flags = EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST;
 126           GuidPpi->Ppi   = &mCustomGuidedSectionExtractionPpi;
 127           GuidPpi->Guid  = &(ExtractHandlerGuidTable [ExtractHandlerNumber]);
 128           Status = PeiServicesInstallPpi (GuidPpi++);
 129           ASSERT_EFI_ERROR(Status);
 130         }
 131       }
 132     } else {
 133       ASSERT (FALSE);
 134     }
 135   }
 136
 137   //
 138   // Install FvFileLoader and DxeIpl PPIs.
 139   //
 140   Status = PeiServicesInstallPpi (mPpiList);
 141   ASSERT_EFI_ERROR(Status);
 142
 143   return Status;
 144 }
 145
 146 /**
 147    Main entry point to last PEIM
 148
 149    @param This          Entry point for DXE IPL PPI
 150    @param PeiServices   General purpose services available to every PEIM.
 151    @param HobList       Address to the Pei HOB list
 152
 153    @return EFI_SUCCESS              DXE core was successfully loaded.
 154    @return EFI_OUT_OF_RESOURCES     There are not enough resources to load DXE core.
 155 **/
 156 EFI_STATUS
 157 EFIAPI
 158 DxeLoadCore (
 159   IN EFI_DXE_IPL_PPI       *This,
 160   IN EFI_PEI_SERVICES      **PeiServices,
 161   IN EFI_PEI_HOB_POINTERS  HobList
 162   )
 163 {
 164   EFI_STATUS                                Status;
 165   EFI_GUID                                  DxeCoreFileName;
 166   EFI_PHYSICAL_ADDRESS                      DxeCoreAddress;
 167   UINT64                                    DxeCoreSize;
 168   EFI_PHYSICAL_ADDRESS                      DxeCoreEntryPoint;
 169   EFI_BOOT_MODE                             BootMode;
 170   EFI_PEI_FV_HANDLE                         VolumeHandle;
 171   EFI_PEI_FILE_HANDLE                       FileHandle;
 172   UINTN                                     Instance;
 173
 174   //
 175   // if in S3 Resume, restore configure
 176   //
 177   Status = PeiServicesGetBootMode (&BootMode);
 178   ASSERT_EFI_ERROR(Status);
 179
 180   if (BootMode == BOOT_ON_S3_RESUME) {
 181     Status = AcpiS3ResumeOs();
 182     ASSERT_EFI_ERROR (Status);
 183   } else if (BootMode == BOOT_IN_RECOVERY_MODE) {
 184     Status = PeiRecoverFirmware ();
 185     if (EFI_ERROR (Status)) {
 186       DEBUG ((EFI_D_ERROR, "Load Recovery Capsule Failed.(Status = %r)\n", Status));
 187       CpuDeadLoop ();
 188     }
 189
 190     //
 191     // Now should have a HOB with the DXE core w/ the old HOB destroyed
 192     //
 193   }
 194
 195   //
 196   // If any FV contains an encapsulated FV extract that FV
 197   //
 198   DxeIplAddEncapsulatedFirmwareVolumes ();
 199
 200   //
 201   // Look in all the FVs present in PEI and find the DXE Core
 202   //
 203   Instance = 0;
 204   Status = DxeIplFindFirmwareVolumeInstance (&Instance, EFI_FV_FILETYPE_DXE_CORE, &VolumeHandle, &FileHandle);
 205   ASSERT_EFI_ERROR (Status);
 206
 207   CopyMem(&DxeCoreFileName, &(((EFI_FFS_FILE_HEADER*)FileHandle)->Name), sizeof (EFI_GUID));
 208
 209   //
 210   // Load the DXE Core from a Firmware Volume, may use LoadFile ppi to do this for save code size.
 211   //
 212   Status = PeiLoadFile (
 213             FileHandle,
 214             &DxeCoreAddress,
 215             &DxeCoreSize,
 216             &DxeCoreEntryPoint
 217             );
 218
 219   ASSERT_EFI_ERROR (Status);
 220
 221   //
 222   // Add HOB for the DXE Core
 223   //
 224   BuildModuleHob (
 225     &DxeCoreFileName,
 226     DxeCoreAddress,
 227     EFI_SIZE_TO_PAGES ((UINT32) DxeCoreSize) * EFI_PAGE_SIZE,
 228     DxeCoreEntryPoint
 229     );
 230
 231   //
 232   // Report Status Code EFI_SW_PEI_PC_HANDOFF_TO_NEXT
 233   //
 234   REPORT_STATUS_CODE (
 235     EFI_PROGRESS_CODE,
 236     EFI_SOFTWARE_PEI_MODULE | EFI_SW_PEI_CORE_PC_HANDOFF_TO_NEXT
 237     );
 238
 239   DEBUG_CODE_BEGIN ();
 240
 241     EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION       PtrPeImage;
 242     PtrPeImage.Pe32 = (EFI_IMAGE_NT_HEADERS32 *) ((UINTN) DxeCoreAddress + ((EFI_IMAGE_DOS_HEADER *) (UINTN) DxeCoreAddress)->e_lfanew);
 243
 244     if (PtrPeImage.Pe32->FileHeader.Machine != IMAGE_FILE_MACHINE_IA64) {
 245       DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Loading DXE CORE at 0x%10p EntryPoint=0x%10p\n", (VOID *)(UINTN)DxeCoreAddress, (VOID *)(UINTN)DxeCoreEntryPoint));
 246     } else {
 247       //
 248       // For IPF Image, the real entry point should be print.
 249       //
 250       DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Loading DXE CORE at 0x%10p EntryPoint=0x%10p\n", (VOID *)(UINTN)DxeCoreAddress, (VOID *)(UINTN)(*(UINT64 *)(UINTN)DxeCoreEntryPoint)));
 251     }
 252
 253   DEBUG_CODE_END ();
 254   //
 255   // Transfer control to the DXE Core
 256   // The handoff state is simply a pointer to the HOB list
 257   //
 258   HandOffToDxeCore (DxeCoreEntryPoint, HobList, &mPpiSignal);
 259   //
 260   // If we get here, then the DXE Core returned.  This is an error
 261   // Dxe Core should not return.
 262   //
 263   ASSERT (FALSE);
 264   CpuDeadLoop ();
 265
 266   return EFI_OUT_OF_RESOURCES;
 267 }
 268
 269
 270 STATIC
 271 EFI_STATUS
 272 GetFvAlignment (
 273   IN    EFI_FIRMWARE_VOLUME_HEADER   *FvHeader,
 274   OUT   UINT32                      *FvAlignment
 275   )
 276 {
 277   //
 278   // Because FvLength in FvHeader is UINT64 type,
 279   // so FvHeader must meed at least 8 bytes alignment.
 280   // Get the appropriate alignment requirement.
 281   //
 282   if ((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) < EFI_FVB2_ALIGNMENT_8) {
 283     return EFI_UNSUPPORTED;
 284   }
 285
 286    *FvAlignment = 1 << ((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16);
 287    return EFI_SUCCESS;
 288 }
 289
 290 /**
 291    Search EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE image and expand
 292    as memory FV
 293
 294    @return EFI_OUT_OF_RESOURCES There are no memory space to exstract FV
 295    @return EFI_SUCESS           Sucess to find the FV
 296 **/
 297 EFI_STATUS
 298 DxeIplAddEncapsulatedFirmwareVolumes (
 299   VOID
 300   )
 301 {
 302   EFI_STATUS                  Status;
 303   EFI_STATUS                  VolumeStatus;
 304   UINTN                       Index;
 305   EFI_FV_INFO                 VolumeInfo;
 306   EFI_PEI_FV_HANDLE           VolumeHandle;
 307   EFI_PEI_FILE_HANDLE         FileHandle;
 308   UINT32                      SectionLength;
 309   EFI_FIRMWARE_VOLUME_HEADER  *FvHeader;
 310   EFI_FIRMWARE_VOLUME_IMAGE_SECTION *SectionHeader;
 311   VOID                        *DstBuffer;
 312   UINT32                       FvAlignment;
 313
 314   Status = EFI_NOT_FOUND;
 315   Index  = 0;
 316
 317   do {
 318     VolumeStatus = DxeIplFindFirmwareVolumeInstance (
 319                     &Index,
 320                     EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
 321                     &VolumeHandle,
 322                     &FileHandle
 323                     );
 324
 325     if (!EFI_ERROR (VolumeStatus)) {
 326          Status = PeiServicesFfsFindSectionData (
 327                     EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
 328                     (EFI_FFS_FILE_HEADER *)FileHandle,
 329                     (VOID **)&FvHeader
 330                     );
 331
 332       if (!EFI_ERROR (Status)) {
 333         if (FvHeader->Signature == EFI_FVH_SIGNATURE) {
 334           //
 335           // Because FvLength in FvHeader is UINT64 type,
 336           // so FvHeader must meed at least 8 bytes alignment.
 337           // If current FvImage base address doesn't meet its alignment,
 338           // we need to reload this FvImage to another correct memory address.
 339           //
 340           Status = GetFvAlignment(FvHeader, &FvAlignment);
 341           if (EFI_ERROR(Status)) {
 342             return Status;
 343           }
 344           if (((UINTN) FvHeader % FvAlignment) != 0) {
 345             SectionHeader = (EFI_FIRMWARE_VOLUME_IMAGE_SECTION*)((UINTN)FvHeader - sizeof(EFI_FIRMWARE_VOLUME_IMAGE_SECTION));
 346             SectionLength =  *(UINT32 *)SectionHeader->Size & 0x00FFFFFF;
 347
 348             DstBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINTN) SectionLength - sizeof (EFI_COMMON_SECTION_HEADER)), FvAlignment);
 349             if (DstBuffer == NULL) {
 350               return EFI_OUT_OF_RESOURCES;
 351             }
 352             CopyMem (DstBuffer, FvHeader, (UINTN) SectionLength - sizeof (EFI_COMMON_SECTION_HEADER));
 353             FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) DstBuffer;
 354           }
 355
 356           //
 357           // This new Firmware Volume comes from a firmware file within a firmware volume.
 358           // Record the original Firmware Volume Name.
 359           //
 360           PeiServicesFfsGetVolumeInfo (&VolumeHandle, &VolumeInfo);
 361
 362           PiLibInstallFvInfoPpi (
 363             NULL,
 364             FvHeader,
 365             (UINT32) FvHeader->FvLength,
 366             &(VolumeInfo.FvName),
 367             &(((EFI_FFS_FILE_HEADER*)FileHandle)->Name)
 368             );
 369
 370           //
 371           // Inform HOB consumer phase, i.e. DXE core, the existance of this FV
 372           //
 373           BuildFvHob (
 374             (EFI_PHYSICAL_ADDRESS) (UINTN) FvHeader,
 375             FvHeader->FvLength
 376           );
 377
 378           ASSERT_EFI_ERROR (Status);
 379
 380           //
 381           // Makes the encapsulated volume show up in DXE phase to skip processing of
 382           // encapsulated file again.
 383           //
 384           BuildFv2Hob (
 385             (EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader,
 386             FvHeader->FvLength,
 387             &VolumeInfo.FvName,
 388             &(((EFI_FFS_FILE_HEADER *)FileHandle)->Name)
 389             );
 390           return Status;
 391         }
 392       }
 393     }
 394   } while (!EFI_ERROR (VolumeStatus));
 395
 396   return Status;
 397 }
 398
 399 /**
 400    Find the First Volume that contains the first FileType.
 401
 402    @param Instance      The Fv instance.
 403    @param SeachType     The type of file to search.
 404    @param VolumeHandle  Pointer to Fv which contains the file to search.
 405    @param FileHandle    Pointer to FFS file to search.
 406
 407    @return EFI_SUCESS   Success to find the FFS in specificed FV
 408    @return others       Fail to find the FFS in specificed FV
 409  */
 410 EFI_STATUS
 411 DxeIplFindFirmwareVolumeInstance (
 412   IN OUT UINTN              *Instance,
 413   IN  EFI_FV_FILETYPE       SeachType,
 414   OUT EFI_PEI_FV_HANDLE     *VolumeHandle,
 415   OUT EFI_PEI_FILE_HANDLE   *FileHandle
 416   )
 417 {
 418   EFI_STATUS  Status;
 419   EFI_STATUS  VolumeStatus;
 420
 421   do {
 422     VolumeStatus = PeiServicesFfsFindNextVolume (*Instance, VolumeHandle);
 423     if (!EFI_ERROR (VolumeStatus)) {
 424       *FileHandle = NULL;
 425       Status = PeiServicesFfsFindNextFile (SeachType, *VolumeHandle, FileHandle);
 426       if (!EFI_ERROR (Status)) {
 427         return Status;
 428       }
 429     }
 430     *Instance += 1;
 431   } while (!EFI_ERROR (VolumeStatus));
 432
 433   return VolumeStatus;
 434 }
 435
 436 /**
 437    Loads and relocates a PE/COFF image into memory.
 438
 439    @param FileHandle        The image file handle
 440    @param ImageAddress      The base address of the relocated PE/COFF image
 441    @param ImageSize         The size of the relocated PE/COFF image
 442    @param EntryPoint        The entry point of the relocated PE/COFF image
 443
 444    @return EFI_SUCCESS           The file was loaded and relocated
 445    @return EFI_OUT_OF_RESOURCES  There was not enough memory to load and relocate the PE/COFF file
 446 **/
 447 EFI_STATUS
 448 PeiLoadFile (
 449   IN  EFI_PEI_FILE_HANDLE                       FileHandle,
 450   OUT EFI_PHYSICAL_ADDRESS                      *ImageAddress,
 451   OUT UINT64                                    *ImageSize,
 452   OUT EFI_PHYSICAL_ADDRESS                      *EntryPoint
 453   )
 454 {
 455
 456   EFI_STATUS                        Status;
 457   PE_COFF_LOADER_IMAGE_CONTEXT      ImageContext;
 458   VOID                              *Pe32Data;
 459   //
 460   // First try to find the PE32 section in this ffs file.
 461   //
 462   Status = PeiServicesFfsFindSectionData (
 463              EFI_SECTION_PE32,
 464              FileHandle,
 465              &Pe32Data
 466              );
 467
 468   if (EFI_ERROR (Status)) {
 469     //
 470     // NO image types we support so exit.
 471     //
 472     return Status;
 473   }
 474
 475   ZeroMem (&ImageContext, sizeof (ImageContext));
 476   ImageContext.Handle = Pe32Data;
 477   Status              = GetImageReadFunction (&ImageContext);
 478
 479   ASSERT_EFI_ERROR (Status);
 480
 481   Status = PeCoffLoaderGetImageInfo (&ImageContext);
 482   if (EFI_ERROR (Status)) {
 483     return Status;
 484   }
 485   //
 486   // Allocate Memory for the image
 487   //
 488   ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) ImageContext.ImageSize));
 489   ASSERT (ImageContext.ImageAddress != 0);
 490
 491   //
 492   // Load the image to our new buffer
 493   //
 494   Status = PeCoffLoaderLoadImage (&ImageContext);
 495   if (EFI_ERROR (Status)) {
 496     return Status;
 497   }
 498   //
 499   // Relocate the image in our new buffer
 500   //
 501   Status = PeCoffLoaderRelocateImage (&ImageContext);
 502   if (EFI_ERROR (Status)) {
 503     return Status;
 504   }
 505
 506   //
 507   // Flush the instruction cache so the image data is written before we execute it
 508   //
 509   InvalidateInstructionCacheRange ((VOID *)(UINTN)ImageContext.ImageAddress, (UINTN)ImageContext.ImageSize);
 510
 511   *ImageAddress = ImageContext.ImageAddress;
 512   *ImageSize    = ImageContext.ImageSize;
 513   *EntryPoint   = ImageContext.EntryPoint;
 514
 515   return EFI_SUCCESS;
 516 }
 517
 518 /**
 519   The ExtractSection() function processes the input section and
 520   returns a pointer to the section contents. If the section being
 521   extracted does not require processing (if the section
 522   GuidedSectionHeader.Attributes has the
 523   EFI_GUIDED_SECTION_PROCESSING_REQUIRED field cleared), then
 524   OutputBuffer is just updated to point to the start of the
 525   section's contents. Otherwise, *Buffer must be allocated
 526   from PEI permanent memory.
 527
 528   @param This                   Indicates the
 529                                 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI instance.
 530                                 Buffer containing the input GUIDed section to be
 531                                 processed. OutputBuffer OutputBuffer is
 532                                 allocated from PEI permanent memory and contains
 533                                 the new section stream.
 534
 535   @param OutputSize             A pointer to a caller-allocated
 536                                 UINTN in which the size of *OutputBuffer
 537                                 allocation is stored. If the function
 538                                 returns anything other than EFI_SUCCESS,
 539                                 the value of OutputSize is undefined.
 540
 541   @param AuthenticationStatus   A pointer to a caller-allocated
 542                                 UINT32 that indicates the
 543                                 authentication status of the
 544                                 output buffer. If the input
 545                                 section's GuidedSectionHeader.
 546                                 Attributes field has the
 547                                 EFI_GUIDED_SECTION_AUTH_STATUS_VALID
 548                                 bit as clear,
 549                                 AuthenticationStatus must return
 550                                 zero. These bits reflect the
 551                                 status of the extraction
 552                                 operation. If the function
 553                                 returns anything other than
 554                                 EFI_SUCCESS, the value of
 555                                 AuthenticationStatus is
 556                                 undefined.
 557
 558   @retval EFI_SUCCESS           The InputSection was
 559                                 successfully processed and the
 560                                 section contents were returned.
 561
 562   @retval EFI_OUT_OF_RESOURCES  The system has insufficient
 563                                 resources to process the request.
 564
 565   @reteval EFI_INVALID_PARAMETER The GUID in InputSection does
 566                                 not match this instance of the
 567                                 GUIDed Section Extraction PPI.
 568 **/
 569 EFI_STATUS
 570 CustomGuidedSectionExtract (
 571   IN CONST  EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI *This,
 572   IN CONST  VOID                                  *InputSection,
 573   OUT       VOID                                  **OutputBuffer,
 574   OUT       UINTN                                 *OutputSize,
 575   OUT       UINT32                                *AuthenticationStatus
 576 )
 577 {
 578   EFI_STATUS      Status;
 579   UINT8           *ScratchBuffer;
 580   UINT32          ScratchBufferSize;
 581   UINT32          OutputBufferSize;
 582   UINT16          SectionAttribute;
 583
 584   //
 585   // Init local variable
 586   //
 587   ScratchBuffer = NULL;
 588
 589   //
 590   // Call GetInfo to get the size and attribute of input guided section data.
 591   //
 592   Status = ExtractGuidedSectionGetInfo (
 593             InputSection,
 594             &OutputBufferSize,
 595             &ScratchBufferSize,
 596             &SectionAttribute
 597            );
 598
 599   if (EFI_ERROR (Status)) {
 600     DEBUG ((EFI_D_ERROR, "GetInfo from guided section Failed - %r\n", Status));
 601     return Status;
 602   }
 603
 604   if (ScratchBufferSize != 0) {
 605     //
 606     // Allocate scratch buffer
 607     //
 608     ScratchBuffer = AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));
 609     if (ScratchBuffer == NULL) {
 610       return EFI_OUT_OF_RESOURCES;
 611     }
 612   }
 613
 614   if ((SectionAttribute & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) && OutputBufferSize > 0) {
 615     //
 616     // Allocate output buffer
 617     //
 618     *OutputBuffer = AllocatePages (EFI_SIZE_TO_PAGES (OutputBufferSize));
 619     if (*OutputBuffer == NULL) {
 620       return EFI_OUT_OF_RESOURCES;
 621     }
 622   }
 623
 624   Status = ExtractGuidedSectionDecode (
 625              InputSection,
 626              OutputBuffer,
 627              ScratchBuffer,
 628              AuthenticationStatus
 629            );
 630
 631   if (EFI_ERROR (Status)) {
 632     //
 633     // Decode failed
 634     //
 635     DEBUG ((EFI_D_ERROR, "Extract guided section Failed - %r\n", Status));
 636     return Status;
 637   }
 638
 639   *OutputSize = (UINTN) OutputBufferSize;
 640
 641   return EFI_SUCCESS;
 642 }
 643
 644 STATIC
 645 EFI_STATUS
 646 EFIAPI
 647 Decompress (
 648   IN CONST  EFI_PEI_DECOMPRESS_PPI  *This,
 649   IN CONST  EFI_COMPRESSION_SECTION *CompressionSection,
 650   OUT       VOID                    **OutputBuffer,
 651   OUT       UINTN                   *OutputSize
 652  )
 653 {
 654   EFI_STATUS                      Status;
 655   UINT8                           *DstBuffer;
 656   UINT8                           *ScratchBuffer;
 657   UINTN                           DstBufferSize;
 658   UINT32                          ScratchBufferSize;
 659   EFI_COMMON_SECTION_HEADER       *Section;
 660   UINTN                           SectionLength;
 661
 662   if (CompressionSection->CommonHeader.Type != EFI_SECTION_COMPRESSION) {
 663     ASSERT (FALSE);
 664     return EFI_INVALID_PARAMETER;
 665   }
 666
 667   Section = (EFI_COMMON_SECTION_HEADER *) CompressionSection;
 668   SectionLength         = *(UINT32 *) (Section->Size) & 0x00ffffff;
 669
 670   //
 671   // This is a compression set, expand it
 672   //
 673   switch (CompressionSection->CompressionType) {
 674   case EFI_STANDARD_COMPRESSION:
 675     //
 676     // Load EFI standard compression.
 677     // For compressed data, decompress them to dstbuffer.
 678     //
 679     Status = UefiDecompressGetInfo (
 680                (UINT8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
 681                (UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION),
 682                (UINT32 *) &DstBufferSize,
 683                &ScratchBufferSize
 684                );
 685     if (EFI_ERROR (Status)) {
 686       //
 687       // GetInfo failed
 688       //
 689       DEBUG ((EFI_D_ERROR, "Decompress GetInfo Failed - %r\n", Status));
 690       return EFI_NOT_FOUND;
 691     }
 692     //
 693     // Allocate scratch buffer
 694     //
 695     ScratchBuffer = AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));
 696     if (ScratchBuffer == NULL) {
 697       return EFI_OUT_OF_RESOURCES;
 698     }
 699     //
 700     // Allocate destination buffer
 701     //
 702     DstBuffer = AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize));
 703     if (DstBuffer == NULL) {
 704       return EFI_OUT_OF_RESOURCES;
 705     }
 706     //
 707     // Call decompress function
 708     //
 709     Status = UefiDecompress (
 710                 (CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
 711                 DstBuffer,
 712                 ScratchBuffer
 713                 );
 714     if (EFI_ERROR (Status)) {
 715       //
 716       // Decompress failed
 717       //
 718       DEBUG ((EFI_D_ERROR, "Decompress Failed - %r\n", Status));
 719       return EFI_NOT_FOUND;
 720     }
 721     break;
 722
 723   // porting note the original branch for customized compress is removed, it should be change to use GUID compress
 724
 725   case EFI_NOT_COMPRESSED:
 726     //
 727     // Allocate destination buffer
 728     //
 729     DstBufferSize = CompressionSection->UncompressedLength;
 730     DstBuffer     = AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize));
 731     if (DstBuffer == NULL) {
 732       return EFI_OUT_OF_RESOURCES;
 733     }
 734     //
 735     // stream is not actually compressed, just encapsulated.  So just copy it.
 736     //
 737     CopyMem (DstBuffer, CompressionSection + 1, DstBufferSize);
 738     break;
 739
 740   default:
 741     //
 742     // Don't support other unknown compression type.
 743     //
 744     ASSERT (FALSE);
 745     return EFI_NOT_FOUND;
 746   }
 747
 748   *OutputSize = DstBufferSize;
 749   *OutputBuffer = DstBuffer;
 750
 751   return EFI_SUCCESS;
 752 }
 753