3 Responsibility of this module is to load the DXE Core from a Firmware Volume.
5 Copyright (c) 2006 - 2008, Intel Corporation. <BR>
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
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.
17 #include <Ppi/GuidedSectionExtraction.h>
22 The ExtractSection() function processes the input section and
23 returns a pointer to the section contents. If the section being
24 extracted does not require processing (if the section
25 GuidedSectionHeader.Attributes has the
26 EFI_GUIDED_SECTION_PROCESSING_REQUIRED field cleared), then
27 OutputBuffer is just updated to point to the start of the
28 section's contents. Otherwise, *Buffer must be allocated
29 from PEI permanent memory.
31 @param This Indicates the
32 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI instance.
33 Buffer containing the input GUIDed section to be
34 processed. OutputBuffer OutputBuffer is
35 allocated from PEI permanent memory and contains
36 the new section stream.
37 @param InputSection A pointer to the input buffer, which contains
38 the input section to be processed.
39 @param OutputBuffer A pointer to a caller-allocated buffer, whose
40 size is specified by the contents of OutputSize.
41 @param OutputSize A pointer to a caller-allocated
42 UINTN in which the size of *OutputBuffer
43 allocation is stored. If the function
44 returns anything other than EFI_SUCCESS,
45 the value of OutputSize is undefined.
46 @param AuthenticationStatus A pointer to a caller-allocated
47 UINT32 that indicates the
48 authentication status of the
49 output buffer. If the input
50 section's GuidedSectionHeader.
51 Attributes field has the
52 EFI_GUIDED_SECTION_AUTH_STATUS_VALID
54 AuthenticationStatus must return
55 zero. These bits reflect the
56 status of the extraction
57 operation. If the function
58 returns anything other than
59 EFI_SUCCESS, the value of
60 AuthenticationStatus is
63 @retval EFI_SUCCESS The InputSection was
64 successfully processed and the
65 section contents were returned.
67 @retval EFI_OUT_OF_RESOURCES The system has insufficient
68 resources to process the request.
70 @retval EFI_INVALID_PARAMETER The GUID in InputSection does
71 not match this instance of the
72 GUIDed Section Extraction PPI.
76 CustomGuidedSectionExtract (
77 IN CONST EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
*This
,
78 IN CONST VOID
*InputSection
,
79 OUT VOID
**OutputBuffer
,
80 OUT UINTN
*OutputSize
,
81 OUT UINT32
*AuthenticationStatus
86 Decompresses a section to the output buffer.
88 This function lookes up the compression type field in the input section and
89 applies the appropriate compression algorithm to compress the section to a
90 callee allocated buffer.
92 @param This Points to this instance of the
93 EFI_PEI_DECOMPRESS_PEI PPI.
94 @param CompressionSection Points to the compressed section.
95 @param OutputBuffer Holds the returned pointer to the decompressed
97 @param OutputSize Holds the returned size of the decompress
100 @retval EFI_SUCCESS The section was decompressed successfully.
101 OutputBuffer contains the resulting data and
102 OutputSize contains the resulting size.
108 IN CONST EFI_PEI_DECOMPRESS_PPI
*This
,
109 IN CONST EFI_COMPRESSION_SECTION
*CompressionSection
,
110 OUT VOID
**OutputBuffer
,
111 OUT UINTN
*OutputSize
115 BOOLEAN gInMemory
= FALSE
;
118 // Module Globals used in the DXE to PEI handoff
119 // These must be module globals, so the stack can be switched
121 STATIC EFI_DXE_IPL_PPI mDxeIplPpi
= {
125 STATIC EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI mCustomGuidedSectionExtractionPpi
= {
126 CustomGuidedSectionExtract
129 STATIC EFI_PEI_DECOMPRESS_PPI mDecompressPpi
= {
133 STATIC EFI_PEI_PPI_DESCRIPTOR mPpiList
[] = {
135 EFI_PEI_PPI_DESCRIPTOR_PPI
,
140 (EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
141 &gEfiPeiDecompressPpiGuid
,
146 STATIC EFI_PEI_PPI_DESCRIPTOR mPpiSignal
= {
147 (EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
148 &gEfiEndOfPeiSignalPpiGuid
,
153 Initializes the Dxe Ipl PPI
155 @param FfsHandle The handle of FFS file.
156 @param PeiServices General purpose services available to
163 PeimInitializeDxeIpl (
164 IN EFI_PEI_FILE_HANDLE FfsHandle
,
165 IN EFI_PEI_SERVICES
**PeiServices
169 EFI_BOOT_MODE BootMode
;
170 EFI_GUID
*ExtractHandlerGuidTable
;
171 UINTN ExtractHandlerNumber
;
172 EFI_PEI_PPI_DESCRIPTOR
*GuidPpi
;
174 Status
= PeiServicesGetBootMode (&BootMode
);
175 ASSERT_EFI_ERROR (Status
);
177 if (BootMode
!= BOOT_ON_S3_RESUME
) {
178 Status
= PeiServicesRegisterForShadow (FfsHandle
);
179 if (Status
== EFI_SUCCESS
) {
181 // EFI_SUCESS means the first time call register for shadow
184 } else if (Status
== EFI_ALREADY_STARTED
) {
189 // Get custom extract guided section method guid list
191 ExtractHandlerNumber
= ExtractGuidedSectionGetGuidList (&ExtractHandlerGuidTable
);
194 // Install custom extraction guid ppi
196 if (ExtractHandlerNumber
> 0) {
198 GuidPpi
= (EFI_PEI_PPI_DESCRIPTOR
*) AllocatePool (ExtractHandlerNumber
* sizeof (EFI_PEI_PPI_DESCRIPTOR
));
199 ASSERT (GuidPpi
!= NULL
);
200 while (ExtractHandlerNumber
-- > 0) {
201 GuidPpi
->Flags
= EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
;
202 GuidPpi
->Ppi
= &mCustomGuidedSectionExtractionPpi
;
203 GuidPpi
->Guid
= &(ExtractHandlerGuidTable
[ExtractHandlerNumber
]);
204 Status
= PeiServicesInstallPpi (GuidPpi
++);
205 ASSERT_EFI_ERROR(Status
);
214 // Install DxeIpl and Decompress PPIs.
216 Status
= PeiServicesInstallPpi (mPpiList
);
217 ASSERT_EFI_ERROR(Status
);
223 Main entry point to last PEIM
225 @param This Entry point for DXE IPL PPI
226 @param PeiServices General purpose services available to every PEIM.
227 @param HobList Address to the Pei HOB list
229 @return EFI_SUCCESS DXE core was successfully loaded.
230 @return EFI_OUT_OF_RESOURCES There are not enough resources to load DXE core.
236 IN EFI_DXE_IPL_PPI
*This
,
237 IN EFI_PEI_SERVICES
**PeiServices
,
238 IN EFI_PEI_HOB_POINTERS HobList
242 EFI_GUID DxeCoreFileName
;
243 EFI_PHYSICAL_ADDRESS DxeCoreAddress
;
245 EFI_PHYSICAL_ADDRESS DxeCoreEntryPoint
;
246 EFI_BOOT_MODE BootMode
;
247 EFI_PEI_FILE_HANDLE FileHandle
;
248 EFI_PEI_READ_ONLY_VARIABLE2_PPI
*Variable
;
250 EFI_MEMORY_TYPE_INFORMATION MemoryData
[EfiMaxMemoryType
+ 1];
253 // if in S3 Resume, restore configure
255 Status
= PeiServicesGetBootMode (&BootMode
);
256 ASSERT_EFI_ERROR(Status
);
258 if (BootMode
== BOOT_ON_S3_RESUME
) {
259 Status
= AcpiS3ResumeOs();
260 ASSERT_EFI_ERROR (Status
);
261 } else if (BootMode
== BOOT_IN_RECOVERY_MODE
) {
262 Status
= PeiRecoverFirmware ();
263 if (EFI_ERROR (Status
)) {
264 DEBUG ((DEBUG_ERROR
, "Load Recovery Capsule Failed.(Status = %r)\n", Status
));
269 // Now should have a HOB with the DXE core w/ the old HOB destroyed
273 Status
= PeiServicesLocatePpi (
274 &gEfiPeiReadOnlyVariable2PpiGuid
,
279 if (!EFI_ERROR (Status
)) {
280 DataSize
= sizeof (MemoryData
);
281 Status
= Variable
->GetVariable (
283 EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME
,
284 &gEfiMemoryTypeInformationGuid
,
289 if (!EFI_ERROR (Status
)) {
291 // Build the GUID'd HOB for DXE
294 &gEfiMemoryTypeInformationGuid
,
302 // Look in all the FVs present in PEI and find the DXE Core
305 Status
= DxeIplFindDxeCore (&FileHandle
);
306 ASSERT_EFI_ERROR (Status
);
308 CopyMem(&DxeCoreFileName
, &(((EFI_FFS_FILE_HEADER
*)FileHandle
)->Name
), sizeof (EFI_GUID
));
311 // Load the DXE Core from a Firmware Volume, may use LoadFile ppi to do this for save code size.
313 Status
= PeiLoadFile (
320 ASSERT_EFI_ERROR (Status
);
323 // Add HOB for the DXE Core
328 EFI_SIZE_TO_PAGES ((UINT32
) DxeCoreSize
) * EFI_PAGE_SIZE
,
333 // Report Status Code EFI_SW_PEI_PC_HANDOFF_TO_NEXT
337 PcdGet32(PcdStatusCodeValuePeiHandoffToDxe
)
342 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION PtrPeImage
;
343 PtrPeImage
.Pe32
= (EFI_IMAGE_NT_HEADERS32
*) ((UINTN
) DxeCoreAddress
+ ((EFI_IMAGE_DOS_HEADER
*) (UINTN
) DxeCoreAddress
)->e_lfanew
);
345 if (PtrPeImage
.Pe32
->FileHeader
.Machine
!= IMAGE_FILE_MACHINE_IA64
) {
346 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Loading DXE CORE at 0x%10p EntryPoint=0x%10p\n", (VOID
*)(UINTN
)DxeCoreAddress
, (VOID
*)(UINTN
)DxeCoreEntryPoint
));
349 // For IPF Image, the real entry point should be print.
351 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "Loading DXE CORE at 0x%10p EntryPoint=0x%10p\n", (VOID
*)(UINTN
)DxeCoreAddress
, (VOID
*)(UINTN
)(*(UINT64
*)(UINTN
)DxeCoreEntryPoint
)));
356 // Transfer control to the DXE Core
357 // The handoff state is simply a pointer to the HOB list
359 HandOffToDxeCore (DxeCoreEntryPoint
, HobList
, &mPpiSignal
);
361 // If we get here, then the DXE Core returned. This is an error
362 // Dxe Core should not return.
367 return EFI_OUT_OF_RESOURCES
;
374 Find DxeCore driver from all First Volumes.
376 @param FileHandle Pointer to FFS file to search.
378 @return EFI_SUCESS Success to find the FFS in specificed FV
379 @return others Fail to find the FFS in specificed FV
384 OUT EFI_PEI_FILE_HANDLE
*FileHandle
388 EFI_STATUS FileStatus
;
390 EFI_PEI_FV_HANDLE VolumeHandle
;
396 Status
= PeiServicesFfsFindNextVolume (Instance
++, &VolumeHandle
);
397 if (!EFI_ERROR (Status
)) {
398 FileStatus
= PeiServicesFfsFindNextFile (EFI_FV_FILETYPE_DXE_CORE
, VolumeHandle
, FileHandle
);
399 if (!EFI_ERROR (FileStatus
)) {
403 } while (!EFI_ERROR (Status
));
405 return EFI_NOT_FOUND
;
412 Loads and relocates a PE/COFF image into memory.
414 @param FileHandle The image file handle
415 @param ImageAddress The base address of the relocated PE/COFF image
416 @param ImageSize The size of the relocated PE/COFF image
417 @param EntryPoint The entry point of the relocated PE/COFF image
419 @return EFI_SUCCESS The file was loaded and relocated
420 @return EFI_OUT_OF_RESOURCES There was not enough memory to load and relocate the PE/COFF file
425 IN EFI_PEI_FILE_HANDLE FileHandle
,
426 OUT EFI_PHYSICAL_ADDRESS
*ImageAddress
,
427 OUT UINT64
*ImageSize
,
428 OUT EFI_PHYSICAL_ADDRESS
*EntryPoint
433 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext
;
436 // First try to find the PE32 section in this ffs file.
438 Status
= PeiServicesFfsFindSectionData (
444 if (EFI_ERROR (Status
)) {
446 // NO image types we support so exit.
451 ZeroMem (&ImageContext
, sizeof (ImageContext
));
452 ImageContext
.Handle
= Pe32Data
;
453 Status
= GetImageReadFunction (&ImageContext
);
455 ASSERT_EFI_ERROR (Status
);
457 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
458 if (EFI_ERROR (Status
)) {
462 // Allocate Memory for the image
464 ImageContext
.ImageAddress
= (EFI_PHYSICAL_ADDRESS
)(UINTN
) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32
) ImageContext
.ImageSize
));
465 ASSERT (ImageContext
.ImageAddress
!= 0);
468 // Load the image to our new buffer
470 Status
= PeCoffLoaderLoadImage (&ImageContext
);
471 if (EFI_ERROR (Status
)) {
475 // Relocate the image in our new buffer
477 Status
= PeCoffLoaderRelocateImage (&ImageContext
);
478 if (EFI_ERROR (Status
)) {
483 // Flush the instruction cache so the image data is written before we execute it
485 InvalidateInstructionCacheRange ((VOID
*)(UINTN
)ImageContext
.ImageAddress
, (UINTN
)ImageContext
.ImageSize
);
487 *ImageAddress
= ImageContext
.ImageAddress
;
488 *ImageSize
= ImageContext
.ImageSize
;
489 *EntryPoint
= ImageContext
.EntryPoint
;
498 The ExtractSection() function processes the input section and
499 returns a pointer to the section contents. If the section being
500 extracted does not require processing (if the section
501 GuidedSectionHeader.Attributes has the
502 EFI_GUIDED_SECTION_PROCESSING_REQUIRED field cleared), then
503 OutputBuffer is just updated to point to the start of the
504 section's contents. Otherwise, *Buffer must be allocated
505 from PEI permanent memory.
507 @param This Indicates the
508 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI instance.
509 Buffer containing the input GUIDed section to be
510 processed. OutputBuffer OutputBuffer is
511 allocated from PEI permanent memory and contains
512 the new section stream.
513 @param InputSection A pointer to the input buffer, which contains
514 the input section to be processed.
515 @param OutputBuffer A pointer to a caller-allocated buffer, whose
516 size is specified by the contents of OutputSize.
517 @param OutputSize A pointer to a caller-allocated
518 UINTN in which the size of *OutputBuffer
519 allocation is stored. If the function
520 returns anything other than EFI_SUCCESS,
521 the value of OutputSize is undefined.
522 @param AuthenticationStatus A pointer to a caller-allocated
523 UINT32 that indicates the
524 authentication status of the
525 output buffer. If the input
526 section's GuidedSectionHeader.
527 Attributes field has the
528 EFI_GUIDED_SECTION_AUTH_STATUS_VALID
530 AuthenticationStatus must return
531 zero. These bits reflect the
532 status of the extraction
533 operation. If the function
534 returns anything other than
535 EFI_SUCCESS, the value of
536 AuthenticationStatus is
539 @retval EFI_SUCCESS The InputSection was
540 successfully processed and the
541 section contents were returned.
543 @retval EFI_OUT_OF_RESOURCES The system has insufficient
544 resources to process the request.
546 @retval EFI_INVALID_PARAMETER The GUID in InputSection does
547 not match this instance of the
548 GUIDed Section Extraction PPI.
552 CustomGuidedSectionExtract (
553 IN CONST EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
*This
,
554 IN CONST VOID
*InputSection
,
555 OUT VOID
**OutputBuffer
,
556 OUT UINTN
*OutputSize
,
557 OUT UINT32
*AuthenticationStatus
561 UINT8
*ScratchBuffer
;
562 UINT32 ScratchBufferSize
;
563 UINT32 OutputBufferSize
;
564 UINT16 SectionAttribute
;
567 // Init local variable
569 ScratchBuffer
= NULL
;
572 // Call GetInfo to get the size and attribute of input guided section data.
574 Status
= ExtractGuidedSectionGetInfo (
581 if (EFI_ERROR (Status
)) {
582 DEBUG ((DEBUG_ERROR
, "GetInfo from guided section Failed - %r\n", Status
));
586 if (ScratchBufferSize
!= 0) {
588 // Allocate scratch buffer
590 ScratchBuffer
= AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize
));
591 if (ScratchBuffer
== NULL
) {
592 return EFI_OUT_OF_RESOURCES
;
596 if (((SectionAttribute
& EFI_GUIDED_SECTION_PROCESSING_REQUIRED
) != 0) && OutputBufferSize
> 0) {
598 // Allocate output buffer
600 *OutputBuffer
= AllocatePages (EFI_SIZE_TO_PAGES (OutputBufferSize
) + 1);
601 if (*OutputBuffer
== NULL
) {
602 return EFI_OUT_OF_RESOURCES
;
604 DEBUG ((DEBUG_INFO
, "Customed Guided section Memory Size required is 0x%x and address is 0x%p\n", OutputBufferSize
, *OutputBuffer
));
606 // *OutputBuffer still is one section. Adjust *OutputBuffer offset,
607 // skip EFI section header to make section data at page alignment.
609 *OutputBuffer
= (VOID
*)((UINT8
*) *OutputBuffer
+ EFI_PAGE_SIZE
- sizeof (EFI_COMMON_SECTION_HEADER
));
612 Status
= ExtractGuidedSectionDecode (
619 if (EFI_ERROR (Status
)) {
623 DEBUG ((DEBUG_ERROR
, "Extract guided section Failed - %r\n", Status
));
627 *OutputSize
= (UINTN
) OutputBufferSize
;
635 Decompresses a section to the output buffer.
637 This function lookes up the compression type field in the input section and
638 applies the appropriate compression algorithm to compress the section to a
639 callee allocated buffer.
641 @param This Points to this instance of the
642 EFI_PEI_DECOMPRESS_PEI PPI.
643 @param CompressionSection Points to the compressed section.
644 @param OutputBuffer Holds the returned pointer to the decompressed
646 @param OutputSize Holds the returned size of the decompress
649 @retval EFI_SUCCESS The section was decompressed successfully.
650 OutputBuffer contains the resulting data and
651 OutputSize contains the resulting size.
657 IN CONST EFI_PEI_DECOMPRESS_PPI
*This
,
658 IN CONST EFI_COMPRESSION_SECTION
*CompressionSection
,
659 OUT VOID
**OutputBuffer
,
660 OUT UINTN
*OutputSize
665 UINT8
*ScratchBuffer
;
667 UINT32 ScratchBufferSize
;
668 EFI_COMMON_SECTION_HEADER
*Section
;
671 if (CompressionSection
->CommonHeader
.Type
!= EFI_SECTION_COMPRESSION
) {
673 return EFI_INVALID_PARAMETER
;
676 Section
= (EFI_COMMON_SECTION_HEADER
*) CompressionSection
;
677 SectionLength
= *(UINT32
*) (Section
->Size
) & 0x00ffffff;
680 // This is a compression set, expand it
682 switch (CompressionSection
->CompressionType
) {
683 case EFI_STANDARD_COMPRESSION
:
685 // Load EFI standard compression.
686 // For compressed data, decompress them to dstbuffer.
688 Status
= UefiDecompressGetInfo (
689 (UINT8
*) ((EFI_COMPRESSION_SECTION
*) Section
+ 1),
690 (UINT32
) SectionLength
- sizeof (EFI_COMPRESSION_SECTION
),
691 (UINT32
*) &DstBufferSize
,
694 if (EFI_ERROR (Status
)) {
698 DEBUG ((DEBUG_ERROR
, "Decompress GetInfo Failed - %r\n", Status
));
699 return EFI_NOT_FOUND
;
702 // Allocate scratch buffer
704 ScratchBuffer
= AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize
));
705 if (ScratchBuffer
== NULL
) {
706 return EFI_OUT_OF_RESOURCES
;
709 // Allocate destination buffer, extra one page for adjustment
711 DstBuffer
= AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize
) + 1);
712 if (DstBuffer
== NULL
) {
713 return EFI_OUT_OF_RESOURCES
;
716 // DstBuffer still is one section. Adjust DstBuffer offset, skip EFI section header
717 // to make section data at page alignment.
719 DstBuffer
= DstBuffer
+ EFI_PAGE_SIZE
- sizeof (EFI_COMMON_SECTION_HEADER
);
721 // Call decompress function
723 Status
= UefiDecompress (
724 (CHAR8
*) ((EFI_COMPRESSION_SECTION
*) Section
+ 1),
728 if (EFI_ERROR (Status
)) {
732 DEBUG ((DEBUG_ERROR
, "Decompress Failed - %r\n", Status
));
733 return EFI_NOT_FOUND
;
737 case EFI_NOT_COMPRESSED
:
739 // Allocate destination buffer
741 DstBufferSize
= CompressionSection
->UncompressedLength
;
742 DstBuffer
= AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize
) + 1);
743 if (DstBuffer
== NULL
) {
744 return EFI_OUT_OF_RESOURCES
;
747 // Adjust DstBuffer offset, skip EFI section header
748 // to make section data at page alignment.
750 DstBuffer
= DstBuffer
+ EFI_PAGE_SIZE
- sizeof (EFI_COMMON_SECTION_HEADER
);
752 // stream is not actually compressed, just encapsulated. So just copy it.
754 CopyMem (DstBuffer
, CompressionSection
+ 1, DstBufferSize
);
759 // Don't support other unknown compression type.
762 return EFI_NOT_FOUND
;
765 *OutputSize
= DstBufferSize
;
766 *OutputBuffer
= DstBuffer
;
775 Updates the Stack HOB passed to DXE phase.
777 This function traverses the whole HOB list and update the stack HOB to
778 reflect the real stack that is used by DXE core.
780 @param BaseAddress The lower address of stack used by DxeCore.
781 @param Length The length of stack used by DxeCore.
786 IN EFI_PHYSICAL_ADDRESS BaseAddress
,
790 EFI_PEI_HOB_POINTERS Hob
;
792 Hob
.Raw
= GetHobList ();
793 while ((Hob
.Raw
= GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION
, Hob
.Raw
)) != NULL
) {
794 if (CompareGuid (&gEfiHobMemoryAllocStackGuid
, &(Hob
.MemoryAllocationStack
->AllocDescriptor
.Name
))) {
796 // Build a new memory allocation HOB with old stack info with EfiConventionalMemory type
797 // to be reclaimed by DXE core.
799 BuildMemoryAllocationHob (
800 Hob
.MemoryAllocationStack
->AllocDescriptor
.MemoryBaseAddress
,
801 Hob
.MemoryAllocationStack
->AllocDescriptor
.MemoryLength
,
802 EfiConventionalMemory
805 // Update the BSP Stack Hob to reflect the new stack info.
807 Hob
.MemoryAllocationStack
->AllocDescriptor
.MemoryBaseAddress
= BaseAddress
;
808 Hob
.MemoryAllocationStack
->AllocDescriptor
.MemoryLength
= Length
;
811 Hob
.Raw
= GET_NEXT_HOB (Hob
);