]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Core/DxeIplPeim/DxeLoad.c
projects / mirror_edk2.git / blob
? search:


1359fe99bc9ca176b78adeae502b572e568782b7
[mirror_edk2.git] / 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_EFI_ERROR (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
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 DxeCoreSize,
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 //
240 // Transfer control to the DXE Core
241 // The handoff state is simply a pointer to the HOB list
242 //
243 DEBUG ((EFI_D_INFO, "DXE Core Entry Point 0x%08x\n", (UINTN) DxeCoreEntryPoint));
244 HandOffToDxeCore (DxeCoreEntryPoint, HobList, &mPpiSignal);
245 //
246 // If we get here, then the DXE Core returned. This is an error
247 // Dxe Core should not return.
248 //
249 ASSERT (FALSE);
250 CpuDeadLoop ();
251
252 return EFI_OUT_OF_RESOURCES;
253 }
254
255
256 STATIC
257 EFI_STATUS
258 GetFvAlignment (
259 IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader,
260 OUT UINT32 *FvAlignment
261 )
262 {
263 //
264 // Because FvLength in FvHeader is UINT64 type,
265 // so FvHeader must meed at least 8 bytes alignment.
266 // Get the appropriate alignment requirement.
267 //
268 if ((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) < EFI_FVB2_ALIGNMENT_8) {
269 return EFI_UNSUPPORTED;
270 }
271
272 *FvAlignment = 1 << ((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16);
273 return EFI_SUCCESS;
274 }
275
276 /**
277 Search EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE image and expand
278 as memory FV
279
280 @return EFI_OUT_OF_RESOURCES There are no memory space to exstract FV
281 @return EFI_SUCESS Sucess to find the FV
282 **/
283 EFI_STATUS
284 DxeIplAddEncapsulatedFirmwareVolumes (
285 VOID
286 )
287 {
288 EFI_STATUS Status;
289 EFI_STATUS VolumeStatus;
290 UINTN Index;
291 EFI_FV_INFO VolumeInfo;
292 EFI_PEI_FV_HANDLE VolumeHandle;
293 EFI_PEI_FILE_HANDLE FileHandle;
294 UINT32 SectionLength;
295 EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
296 EFI_FIRMWARE_VOLUME_IMAGE_SECTION *SectionHeader;
297 VOID *DstBuffer;
298 UINT32 FvAlignment;
299
300 Status = EFI_NOT_FOUND;
301 Index = 0;
302
303 do {
304 VolumeStatus = DxeIplFindFirmwareVolumeInstance (
305 &Index,
306 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
307 &VolumeHandle,
308 &FileHandle
309 );
310
311 if (!EFI_ERROR (VolumeStatus)) {
312 Status = PeiServicesFfsFindSectionData (
313 EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
314 (EFI_FFS_FILE_HEADER *)FileHandle,
315 (VOID **)&FvHeader
316 );
317
318 if (!EFI_ERROR (Status)) {
319 if (FvHeader->Signature == EFI_FVH_SIGNATURE) {
320 //
321 // Because FvLength in FvHeader is UINT64 type,
322 // so FvHeader must meed at least 8 bytes alignment.
323 // If current FvImage base address doesn't meet its alignment,
324 // we need to reload this FvImage to another correct memory address.
325 //
326 Status = GetFvAlignment(FvHeader, &FvAlignment);
327 if (EFI_ERROR(Status)) {
328 return Status;
329 }
330 if (((UINTN) FvHeader % FvAlignment) != 0) {
331 SectionHeader = (EFI_FIRMWARE_VOLUME_IMAGE_SECTION*)((UINTN)FvHeader - sizeof(EFI_FIRMWARE_VOLUME_IMAGE_SECTION));
332 SectionLength = *(UINT32 *)SectionHeader->Size & 0x00FFFFFF;
333
334 DstBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINTN) SectionLength - sizeof (EFI_COMMON_SECTION_HEADER)), FvAlignment);
335 if (DstBuffer == NULL) {
336 return EFI_OUT_OF_RESOURCES;
337 }
338 CopyMem (DstBuffer, FvHeader, (UINTN) SectionLength - sizeof (EFI_COMMON_SECTION_HEADER));
339 FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) DstBuffer;
340 }
341
342 //
343 // This new Firmware Volume comes from a firmware file within a firmware volume.
344 // Record the original Firmware Volume Name.
345 //
346 PeiServicesFfsGetVolumeInfo (&VolumeHandle, &VolumeInfo);
347
348 PeiPiLibBuildPiFvInfoPpi (
349 (EFI_PHYSICAL_ADDRESS) FvHeader,
350 FvHeader->FvLength,
351 &(VolumeInfo.FvName),
352 &(((EFI_FFS_FILE_HEADER*)FileHandle)->Name)
353 );
354
355 ASSERT_EFI_ERROR (Status);
356
357 //
358 // Makes the encapsulated volume show up in DXE phase to skip processing of
359 // encapsulated file again.
360 //
361 BuildFv2Hob (
362 (EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader,
363 FvHeader->FvLength,
364 &VolumeInfo.FvName,
365 &(((EFI_FFS_FILE_HEADER *)FileHandle)->Name)
366 );
367 return Status;
368 }
369 }
370 }
371 } while (!EFI_ERROR (VolumeStatus));
372
373 return Status;
374 }
375
376 /**
377 Find the First Volume that contains the first FileType.
378
379 @param Instance The Fv instance.
380 @param SeachType The type of file to search.
381 @param VolumeHandle Pointer to Fv which contains the file to search.
382 @param FileHandle Pointer to FFS file to search.
383
384 @return EFI_SUCESS Success to find the FFS in specificed FV
385 @return others Fail to find the FFS in specificed FV
386 */
387 EFI_STATUS
388 DxeIplFindFirmwareVolumeInstance (
389 IN OUT UINTN *Instance,
390 IN EFI_FV_FILETYPE SeachType,
391 OUT EFI_PEI_FV_HANDLE *VolumeHandle,
392 OUT EFI_PEI_FILE_HANDLE *FileHandle
393 )
394 {
395 EFI_STATUS Status;
396 EFI_STATUS VolumeStatus;
397
398 do {
399 VolumeStatus = PeiServicesFfsFindNextVolume (*Instance, VolumeHandle);
400 if (!EFI_ERROR (VolumeStatus)) {
401 *FileHandle = NULL;
402 Status = PeiServicesFfsFindNextFile (SeachType, *VolumeHandle, FileHandle);
403 if (!EFI_ERROR (Status)) {
404 return Status;
405 }
406 }
407 *Instance += 1;
408 } while (!EFI_ERROR (VolumeStatus));
409
410 return VolumeStatus;
411 }
412
413 /**
414 Loads and relocates a PE/COFF image into memory.
415
416 @param FileHandle The image file handle
417 @param ImageAddress The base address of the relocated PE/COFF image
418 @param ImageSize The size of the relocated PE/COFF image
419 @param EntryPoint The entry point of the relocated PE/COFF image
420
421 @return EFI_SUCCESS The file was loaded and relocated
422 @return EFI_OUT_OF_RESOURCES There was not enough memory to load and relocate the PE/COFF file
423 **/
424 EFI_STATUS
425 PeiLoadFile (
426 IN EFI_PEI_FILE_HANDLE FileHandle,
427 OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
428 OUT UINT64 *ImageSize,
429 OUT EFI_PHYSICAL_ADDRESS *EntryPoint
430 )
431 {
432
433 EFI_STATUS Status;
434 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
435 VOID *Pe32Data;
436 //
437 // First try to find the required section in this ffs file.
438 //
439 Status = PeiServicesFfsFindSectionData (
440 EFI_SECTION_PE32,
441 FileHandle,
442 &Pe32Data
443 );
444
445 if (EFI_ERROR (Status)) {
446 Status = PeiServicesFfsFindSectionData (
447 EFI_SECTION_TE,
448 FileHandle,
449 &Pe32Data
450 );
451 }
452
453 if (EFI_ERROR (Status)) {
454 //
455 // NO image types we support so exit.
456 //
457 return Status;
458 }
459
460 ZeroMem (&ImageContext, sizeof (ImageContext));
461 ImageContext.Handle = Pe32Data;
462 Status = GetImageReadFunction (&ImageContext);
463
464 ASSERT_EFI_ERROR (Status);
465
466 Status = PeCoffLoaderGetImageInfo (&ImageContext);
467 if (EFI_ERROR (Status)) {
468 return Status;
469 }
470 //
471 // Allocate Memory for the image
472 //
473 ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) ImageContext.ImageSize));
474 ASSERT (ImageContext.ImageAddress != 0);
475
476 //
477 // Load the image to our new buffer
478 //
479 Status = PeCoffLoaderLoadImage (&ImageContext);
480 if (EFI_ERROR (Status)) {
481 return Status;
482 }
483 //
484 // Relocate the image in our new buffer
485 //
486 Status = PeCoffLoaderRelocateImage (&ImageContext);
487 if (EFI_ERROR (Status)) {
488 return Status;
489 }
490
491 //
492 // Flush the instruction cache so the image data is written before we execute it
493 //
494 InvalidateInstructionCacheRange ((VOID *)(UINTN)ImageContext.ImageAddress, (UINTN)ImageContext.ImageSize);
495
496 *ImageAddress = ImageContext.ImageAddress;
497 *ImageSize = ImageContext.ImageSize;
498 *EntryPoint = ImageContext.EntryPoint;
499
500 return EFI_SUCCESS;
501 }
502
503 /**
504 The ExtractSection() function processes the input section and
505 returns a pointer to the section contents. If the section being
506 extracted does not require processing (if the section
507 GuidedSectionHeader.Attributes has the
508 EFI_GUIDED_SECTION_PROCESSING_REQUIRED field cleared), then
509 OutputBuffer is just updated to point to the start of the
510 section's contents. Otherwise, *Buffer must be allocated
511 from PEI permanent memory.
512
513 @param This Indicates the
514 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI instance.
515 Buffer containing the input GUIDed section to be
516 processed. OutputBuffer OutputBuffer is
517 allocated from PEI permanent memory and contains
518 the new section stream.
519
520 @param OutputSize A pointer to a caller-allocated
521 UINTN in which the size of *OutputBuffer
522 allocation is stored. If the function
523 returns anything other than EFI_SUCCESS,
524 the value of OutputSize is undefined.
525
526 @param AuthenticationStatus A pointer to a caller-allocated
527 UINT32 that indicates the
528 authentication status of the
529 output buffer. If the input
530 section's GuidedSectionHeader.
531 Attributes field has the
532 EFI_GUIDED_SECTION_AUTH_STATUS_VALID
533 bit as clear,
534 AuthenticationStatus must return
535 zero. These bits reflect the
536 status of the extraction
537 operation. If the function
538 returns anything other than
539 EFI_SUCCESS, the value of
540 AuthenticationStatus is
541 undefined.
542
543 @retval EFI_SUCCESS The InputSection was
544 successfully processed and the
545 section contents were returned.
546
547 @retval EFI_OUT_OF_RESOURCES The system has insufficient
548 resources to process the request.
549
550 @reteval EFI_INVALID_PARAMETER The GUID in InputSection does
551 not match this instance of the
552 GUIDed Section Extraction PPI.
553 **/
554 EFI_STATUS
555 CustomGuidedSectionExtract (
556 IN CONST EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI *This,
557 IN CONST VOID *InputSection,
558 OUT VOID **OutputBuffer,
559 OUT UINTN *OutputSize,
560 OUT UINT32 *AuthenticationStatus
561 )
562 {
563 EFI_STATUS Status;
564 UINT8 *ScratchBuffer;
565 UINT32 ScratchBufferSize;
566 UINT32 OutputBufferSize;
567 UINT16 SectionAttribute;
568
569 //
570 // Init local variable
571 //
572 ScratchBuffer = NULL;
573
574 //
575 // Call GetInfo to get the size and attribute of input guided section data.
576 //
577 Status = ExtractGuidedSectionGetInfo (
578 InputSection,
579 &OutputBufferSize,
580 &ScratchBufferSize,
581 &SectionAttribute
582 );
583
584 if (EFI_ERROR (Status)) {
585 DEBUG ((EFI_D_ERROR, "GetInfo from guided section Failed - %r\n", Status));
586 return Status;
587 }
588
589 if (ScratchBufferSize != 0) {
590 //
591 // Allocate scratch buffer
592 //
593 ScratchBuffer = AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));
594 if (ScratchBuffer == NULL) {
595 return EFI_OUT_OF_RESOURCES;
596 }
597 }
598
599 if ((SectionAttribute & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) && OutputBufferSize > 0) {
600 //
601 // Allocate output buffer
602 //
603 *OutputBuffer = AllocatePages (EFI_SIZE_TO_PAGES (OutputBufferSize));
604 if (*OutputBuffer == NULL) {
605 return EFI_OUT_OF_RESOURCES;
606 }
607 }
608
609 Status = ExtractGuidedSectionDecode (
610 InputSection,
611 OutputBuffer,
612 ScratchBuffer,
613 AuthenticationStatus
614 );
615
616 if (EFI_ERROR (Status)) {
617 //
618 // Decode failed
619 //
620 DEBUG ((EFI_D_ERROR, "Extract guided section Failed - %r\n", Status));
621 return Status;
622 }
623
624 *OutputSize = (UINTN) OutputBufferSize;
625
626 return EFI_SUCCESS;
627 }
628
629 STATIC
630 EFI_STATUS
631 EFIAPI
632 Decompress (
633 IN CONST EFI_PEI_DECOMPRESS_PPI *This,
634 IN CONST EFI_COMPRESSION_SECTION *CompressionSection,
635 OUT VOID **OutputBuffer,
636 OUT UINTN *OutputSize
637 )
638 {
639 EFI_STATUS Status;
640 UINT8 *DstBuffer;
641 UINT8 *ScratchBuffer;
642 UINTN DstBufferSize;
643 UINT32 ScratchBufferSize;
644 EFI_COMMON_SECTION_HEADER *Section;
645 UINTN SectionLength;
646
647 if (CompressionSection->CommonHeader.Type != EFI_SECTION_COMPRESSION) {
648 ASSERT (FALSE);
649 return EFI_INVALID_PARAMETER;
650 }
651
652 Section = (EFI_COMMON_SECTION_HEADER *) CompressionSection;
653 SectionLength = *(UINT32 *) (Section->Size) & 0x00ffffff;
654
655 //
656 // This is a compression set, expand it
657 //
658 switch (CompressionSection->CompressionType) {
659 case EFI_STANDARD_COMPRESSION:
660 //
661 // Load EFI standard compression.
662 // For compressed data, decompress them to dstbuffer.
663 //
664 Status = UefiDecompressGetInfo (
665 (UINT8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
666 (UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION),
667 (UINT32 *) &DstBufferSize,
668 &ScratchBufferSize
669 );
670 if (EFI_ERROR (Status)) {
671 //
672 // GetInfo failed
673 //
674 DEBUG ((EFI_D_ERROR, "Decompress GetInfo Failed - %r\n", Status));
675 return EFI_NOT_FOUND;
676 }
677 //
678 // Allocate scratch buffer
679 //
680 ScratchBuffer = AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));
681 if (ScratchBuffer == NULL) {
682 return EFI_OUT_OF_RESOURCES;
683 }
684 //
685 // Allocate destination buffer
686 //
687 DstBuffer = AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize));
688 if (DstBuffer == NULL) {
689 return EFI_OUT_OF_RESOURCES;
690 }
691 //
692 // Call decompress function
693 //
694 Status = UefiDecompress (
695 (CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
696 DstBuffer,
697 ScratchBuffer
698 );
699 if (EFI_ERROR (Status)) {
700 //
701 // Decompress failed
702 //
703 DEBUG ((EFI_D_ERROR, "Decompress Failed - %r\n", Status));
704 return EFI_NOT_FOUND;
705 }
706 break;
707
708 // porting note the original branch for customized compress is removed, it should be change to use GUID compress
709
710 case EFI_NOT_COMPRESSED:
711 //
712 // Allocate destination buffer
713 //
714 DstBufferSize = CompressionSection->UncompressedLength;
715 DstBuffer = AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize));
716 if (DstBuffer == NULL) {
717 return EFI_OUT_OF_RESOURCES;
718 }
719 //
720 // stream is not actually compressed, just encapsulated. So just copy it.
721 //
722 CopyMem (DstBuffer, CompressionSection + 1, DstBufferSize);
723 break;
724
725 default:
726 //
727 // Don't support other unknown compression type.
728 //
729 ASSERT (FALSE);
730 return EFI_NOT_FOUND;
731 }
732
733 *OutputSize = DstBufferSize;
734 *OutputBuffer = DstBuffer;
735
736 return EFI_SUCCESS;
737 }
738
EFI Development Kit II mirror for PVE