2 Main SEC phase code. Transitions to PEI.
4 Copyright (c) 2008 - 2015, Intel Corporation. All rights reserved.<BR>
6 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.
18 #include <Library/PeimEntryPoint.h>
19 #include <Library/BaseLib.h>
20 #include <Library/DebugLib.h>
21 #include <Library/BaseMemoryLib.h>
22 #include <Library/PeiServicesLib.h>
23 #include <Library/PcdLib.h>
24 #include <Library/UefiCpuLib.h>
25 #include <Library/DebugAgentLib.h>
26 #include <Library/IoLib.h>
27 #include <Library/PeCoffLib.h>
28 #include <Library/PeCoffGetEntryPointLib.h>
29 #include <Library/PeCoffExtraActionLib.h>
30 #include <Library/ExtractGuidedSectionLib.h>
31 #include <Library/LocalApicLib.h>
33 #include <Ppi/TemporaryRamSupport.h>
35 #define SEC_IDT_ENTRY_COUNT 34
37 typedef struct _SEC_IDT_TABLE
{
38 EFI_PEI_SERVICES
*PeiService
;
39 IA32_IDT_GATE_DESCRIPTOR IdtTable
[SEC_IDT_ENTRY_COUNT
];
50 TemporaryRamMigration (
51 IN CONST EFI_PEI_SERVICES
**PeiServices
,
52 IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase
,
53 IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase
,
60 EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mTemporaryRamSupportPpi
= {
64 EFI_PEI_PPI_DESCRIPTOR mPrivateDispatchTable
[] = {
66 (EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
67 &gEfiTemporaryRamSupportPpiGuid
,
68 &mTemporaryRamSupportPpi
73 // Template of an IDT entry pointing to 10:FFFFFFE4h.
75 IA32_IDT_GATE_DESCRIPTOR mIdtEntryTemplate
= {
80 IA32_IDT_GATE_TYPE_INTERRUPT_32
, // GateType
86 Locates the main boot firmware volume.
88 @param[in,out] BootFv On input, the base of the BootFv
89 On output, the decompressed main firmware volume
91 @retval EFI_SUCCESS The main firmware volume was located and decompressed
92 @retval EFI_NOT_FOUND The main firmware volume was not found
97 IN OUT EFI_FIRMWARE_VOLUME_HEADER
**BootFv
100 EFI_FIRMWARE_VOLUME_HEADER
*Fv
;
103 ASSERT (((UINTN
) *BootFv
& EFI_PAGE_MASK
) == 0);
106 Distance
= (UINTN
) (*BootFv
)->FvLength
;
108 Fv
= (EFI_FIRMWARE_VOLUME_HEADER
*) ((UINT8
*) Fv
- EFI_PAGE_SIZE
);
109 Distance
+= EFI_PAGE_SIZE
;
110 if (Distance
> SIZE_32MB
) {
111 return EFI_NOT_FOUND
;
114 if (Fv
->Signature
!= EFI_FVH_SIGNATURE
) {
118 if ((UINTN
) Fv
->FvLength
> Distance
) {
129 Locates a section within a series of sections
130 with the specified section type.
132 The Instance parameter indicates which instance of the section
133 type to return. (0 is first instance, 1 is second...)
135 @param[in] Sections The sections to search
136 @param[in] SizeOfSections Total size of all sections
137 @param[in] SectionType The section type to locate
138 @param[in] Instance The section instance number
139 @param[out] FoundSection The FFS section if found
141 @retval EFI_SUCCESS The file and section was found
142 @retval EFI_NOT_FOUND The file and section was not found
143 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
147 FindFfsSectionInstance (
149 IN UINTN SizeOfSections
,
150 IN EFI_SECTION_TYPE SectionType
,
152 OUT EFI_COMMON_SECTION_HEADER
**FoundSection
155 EFI_PHYSICAL_ADDRESS CurrentAddress
;
157 EFI_PHYSICAL_ADDRESS EndOfSections
;
158 EFI_COMMON_SECTION_HEADER
*Section
;
159 EFI_PHYSICAL_ADDRESS EndOfSection
;
162 // Loop through the FFS file sections within the PEI Core FFS file
164 EndOfSection
= (EFI_PHYSICAL_ADDRESS
)(UINTN
) Sections
;
165 EndOfSections
= EndOfSection
+ SizeOfSections
;
167 if (EndOfSection
== EndOfSections
) {
170 CurrentAddress
= (EndOfSection
+ 3) & ~(3ULL);
171 if (CurrentAddress
>= EndOfSections
) {
172 return EFI_VOLUME_CORRUPTED
;
175 Section
= (EFI_COMMON_SECTION_HEADER
*)(UINTN
) CurrentAddress
;
177 Size
= SECTION_SIZE (Section
);
178 if (Size
< sizeof (*Section
)) {
179 return EFI_VOLUME_CORRUPTED
;
182 EndOfSection
= CurrentAddress
+ Size
;
183 if (EndOfSection
> EndOfSections
) {
184 return EFI_VOLUME_CORRUPTED
;
188 // Look for the requested section type
190 if (Section
->Type
== SectionType
) {
192 *FoundSection
= Section
;
200 return EFI_NOT_FOUND
;
204 Locates a section within a series of sections
205 with the specified section type.
207 @param[in] Sections The sections to search
208 @param[in] SizeOfSections Total size of all sections
209 @param[in] SectionType The section type to locate
210 @param[out] FoundSection The FFS section if found
212 @retval EFI_SUCCESS The file and section was found
213 @retval EFI_NOT_FOUND The file and section was not found
214 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
218 FindFfsSectionInSections (
220 IN UINTN SizeOfSections
,
221 IN EFI_SECTION_TYPE SectionType
,
222 OUT EFI_COMMON_SECTION_HEADER
**FoundSection
225 return FindFfsSectionInstance (
235 Locates a FFS file with the specified file type and a section
236 within that file with the specified section type.
238 @param[in] Fv The firmware volume to search
239 @param[in] FileType The file type to locate
240 @param[in] SectionType The section type to locate
241 @param[out] FoundSection The FFS section if found
243 @retval EFI_SUCCESS The file and section was found
244 @retval EFI_NOT_FOUND The file and section was not found
245 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
249 FindFfsFileAndSection (
250 IN EFI_FIRMWARE_VOLUME_HEADER
*Fv
,
251 IN EFI_FV_FILETYPE FileType
,
252 IN EFI_SECTION_TYPE SectionType
,
253 OUT EFI_COMMON_SECTION_HEADER
**FoundSection
257 EFI_PHYSICAL_ADDRESS CurrentAddress
;
258 EFI_PHYSICAL_ADDRESS EndOfFirmwareVolume
;
259 EFI_FFS_FILE_HEADER
*File
;
261 EFI_PHYSICAL_ADDRESS EndOfFile
;
263 if (Fv
->Signature
!= EFI_FVH_SIGNATURE
) {
264 DEBUG ((EFI_D_ERROR
, "FV at %p does not have FV header signature\n", Fv
));
265 return EFI_VOLUME_CORRUPTED
;
268 CurrentAddress
= (EFI_PHYSICAL_ADDRESS
)(UINTN
) Fv
;
269 EndOfFirmwareVolume
= CurrentAddress
+ Fv
->FvLength
;
272 // Loop through the FFS files in the Boot Firmware Volume
274 for (EndOfFile
= CurrentAddress
+ Fv
->HeaderLength
; ; ) {
276 CurrentAddress
= (EndOfFile
+ 7) & ~(7ULL);
277 if (CurrentAddress
> EndOfFirmwareVolume
) {
278 return EFI_VOLUME_CORRUPTED
;
281 File
= (EFI_FFS_FILE_HEADER
*)(UINTN
) CurrentAddress
;
282 Size
= *(UINT32
*) File
->Size
& 0xffffff;
283 if (Size
< (sizeof (*File
) + sizeof (EFI_COMMON_SECTION_HEADER
))) {
284 return EFI_VOLUME_CORRUPTED
;
287 EndOfFile
= CurrentAddress
+ Size
;
288 if (EndOfFile
> EndOfFirmwareVolume
) {
289 return EFI_VOLUME_CORRUPTED
;
293 // Look for the request file type
295 if (File
->Type
!= FileType
) {
299 Status
= FindFfsSectionInSections (
301 (UINTN
) EndOfFile
- (UINTN
) (File
+ 1),
305 if (!EFI_ERROR (Status
) || (Status
== EFI_VOLUME_CORRUPTED
)) {
312 Locates the compressed main firmware volume and decompresses it.
314 @param[in,out] Fv On input, the firmware volume to search
315 On output, the decompressed BOOT/PEI FV
317 @retval EFI_SUCCESS The file and section was found
318 @retval EFI_NOT_FOUND The file and section was not found
319 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
324 IN OUT EFI_FIRMWARE_VOLUME_HEADER
**Fv
328 EFI_GUID_DEFINED_SECTION
*Section
;
329 UINT32 OutputBufferSize
;
330 UINT32 ScratchBufferSize
;
331 UINT16 SectionAttribute
;
332 UINT32 AuthenticationStatus
;
335 EFI_FIRMWARE_VOLUME_IMAGE_SECTION
*FvSection
;
336 EFI_FIRMWARE_VOLUME_HEADER
*PeiMemFv
;
337 EFI_FIRMWARE_VOLUME_HEADER
*DxeMemFv
;
339 FvSection
= (EFI_FIRMWARE_VOLUME_IMAGE_SECTION
*) NULL
;
341 Status
= FindFfsFileAndSection (
343 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
,
344 EFI_SECTION_GUID_DEFINED
,
345 (EFI_COMMON_SECTION_HEADER
**) &Section
347 if (EFI_ERROR (Status
)) {
348 DEBUG ((EFI_D_ERROR
, "Unable to find GUID defined section\n"));
352 Status
= ExtractGuidedSectionGetInfo (
358 if (EFI_ERROR (Status
)) {
359 DEBUG ((EFI_D_ERROR
, "Unable to GetInfo for GUIDed section\n"));
363 OutputBuffer
= (VOID
*) ((UINT8
*)(UINTN
) PcdGet32 (PcdOvmfDxeMemFvBase
) + SIZE_1MB
);
364 ScratchBuffer
= ALIGN_POINTER ((UINT8
*) OutputBuffer
+ OutputBufferSize
, SIZE_1MB
);
366 DEBUG ((EFI_D_VERBOSE
, "%a: OutputBuffer@%p+0x%x ScratchBuffer@%p+0x%x "
367 "PcdOvmfDecompressionScratchEnd=0x%x\n", __FUNCTION__
, OutputBuffer
,
368 OutputBufferSize
, ScratchBuffer
, ScratchBufferSize
,
369 PcdGet32 (PcdOvmfDecompressionScratchEnd
)));
370 ASSERT ((UINTN
)ScratchBuffer
+ ScratchBufferSize
==
371 PcdGet32 (PcdOvmfDecompressionScratchEnd
));
373 Status
= ExtractGuidedSectionDecode (
377 &AuthenticationStatus
379 if (EFI_ERROR (Status
)) {
380 DEBUG ((EFI_D_ERROR
, "Error during GUID section decode\n"));
384 Status
= FindFfsSectionInstance (
387 EFI_SECTION_FIRMWARE_VOLUME_IMAGE
,
389 (EFI_COMMON_SECTION_HEADER
**) &FvSection
391 if (EFI_ERROR (Status
)) {
392 DEBUG ((EFI_D_ERROR
, "Unable to find PEI FV section\n"));
396 ASSERT (SECTION_SIZE (FvSection
) ==
397 (PcdGet32 (PcdOvmfPeiMemFvSize
) + sizeof (*FvSection
)));
398 ASSERT (FvSection
->Type
== EFI_SECTION_FIRMWARE_VOLUME_IMAGE
);
400 PeiMemFv
= (EFI_FIRMWARE_VOLUME_HEADER
*)(UINTN
) PcdGet32 (PcdOvmfPeiMemFvBase
);
401 CopyMem (PeiMemFv
, (VOID
*) (FvSection
+ 1), PcdGet32 (PcdOvmfPeiMemFvSize
));
403 if (PeiMemFv
->Signature
!= EFI_FVH_SIGNATURE
) {
404 DEBUG ((EFI_D_ERROR
, "Extracted FV at %p does not have FV header signature\n", PeiMemFv
));
406 return EFI_VOLUME_CORRUPTED
;
409 Status
= FindFfsSectionInstance (
412 EFI_SECTION_FIRMWARE_VOLUME_IMAGE
,
414 (EFI_COMMON_SECTION_HEADER
**) &FvSection
416 if (EFI_ERROR (Status
)) {
417 DEBUG ((EFI_D_ERROR
, "Unable to find DXE FV section\n"));
421 ASSERT (FvSection
->Type
== EFI_SECTION_FIRMWARE_VOLUME_IMAGE
);
422 ASSERT (SECTION_SIZE (FvSection
) ==
423 (PcdGet32 (PcdOvmfDxeMemFvSize
) + sizeof (*FvSection
)));
425 DxeMemFv
= (EFI_FIRMWARE_VOLUME_HEADER
*)(UINTN
) PcdGet32 (PcdOvmfDxeMemFvBase
);
426 CopyMem (DxeMemFv
, (VOID
*) (FvSection
+ 1), PcdGet32 (PcdOvmfDxeMemFvSize
));
428 if (DxeMemFv
->Signature
!= EFI_FVH_SIGNATURE
) {
429 DEBUG ((EFI_D_ERROR
, "Extracted FV at %p does not have FV header signature\n", DxeMemFv
));
431 return EFI_VOLUME_CORRUPTED
;
439 Locates the PEI Core entry point address
441 @param[in] Fv The firmware volume to search
442 @param[out] PeiCoreEntryPoint The entry point of the PEI Core image
444 @retval EFI_SUCCESS The file and section was found
445 @retval EFI_NOT_FOUND The file and section was not found
446 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
450 FindPeiCoreImageBaseInFv (
451 IN EFI_FIRMWARE_VOLUME_HEADER
*Fv
,
452 OUT EFI_PHYSICAL_ADDRESS
*PeiCoreImageBase
456 EFI_COMMON_SECTION_HEADER
*Section
;
458 Status
= FindFfsFileAndSection (
460 EFI_FV_FILETYPE_PEI_CORE
,
464 if (EFI_ERROR (Status
)) {
465 Status
= FindFfsFileAndSection (
467 EFI_FV_FILETYPE_PEI_CORE
,
471 if (EFI_ERROR (Status
)) {
472 DEBUG ((EFI_D_ERROR
, "Unable to find PEI Core image\n"));
477 *PeiCoreImageBase
= (EFI_PHYSICAL_ADDRESS
)(UINTN
)(Section
+ 1);
483 Reads 8-bits of CMOS data.
485 Reads the 8-bits of CMOS data at the location specified by Index.
486 The 8-bit read value is returned.
488 @param Index The CMOS location to read.
490 @return The value read.
499 IoWrite8 (0x70, (UINT8
) Index
);
500 return IoRead8 (0x71);
510 return (CmosRead8 (0xF) == 0xFE);
517 IN OUT EFI_FIRMWARE_VOLUME_HEADER
**PeiFv
520 *PeiFv
= (EFI_FIRMWARE_VOLUME_HEADER
*)(UINTN
) PcdGet32 (PcdOvmfPeiMemFvBase
);
526 Locates the PEI Core entry point address
528 @param[in,out] Fv The firmware volume to search
529 @param[out] PeiCoreEntryPoint The entry point of the PEI Core image
531 @retval EFI_SUCCESS The file and section was found
532 @retval EFI_NOT_FOUND The file and section was not found
533 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
537 FindPeiCoreImageBase (
538 IN OUT EFI_FIRMWARE_VOLUME_HEADER
**BootFv
,
539 OUT EFI_PHYSICAL_ADDRESS
*PeiCoreImageBase
544 *PeiCoreImageBase
= 0;
546 S3Resume
= IsS3Resume ();
547 if (S3Resume
&& !FeaturePcdGet (PcdSmmSmramRequire
)) {
549 // A malicious runtime OS may have injected something into our previously
550 // decoded PEI FV, but we don't care about that unless SMM/SMRAM is required.
552 DEBUG ((EFI_D_VERBOSE
, "SEC: S3 resume\n"));
553 GetS3ResumePeiFv (BootFv
);
556 // We're either not resuming, or resuming "securely" -- we'll decompress
557 // both PEI FV and DXE FV from pristine flash.
559 DEBUG ((EFI_D_VERBOSE
, "SEC: %a\n",
560 S3Resume
? "S3 resume (with PEI decompression)" : "Normal boot"));
563 DecompressMemFvs (BootFv
);
566 FindPeiCoreImageBaseInFv (*BootFv
, PeiCoreImageBase
);
570 Find core image base.
575 IN EFI_FIRMWARE_VOLUME_HEADER
*BootFirmwareVolumePtr
,
576 OUT EFI_PHYSICAL_ADDRESS
*SecCoreImageBase
579 EFI_PHYSICAL_ADDRESS CurrentAddress
;
580 EFI_PHYSICAL_ADDRESS EndOfFirmwareVolume
;
581 EFI_FFS_FILE_HEADER
*File
;
583 EFI_PHYSICAL_ADDRESS EndOfFile
;
584 EFI_COMMON_SECTION_HEADER
*Section
;
585 EFI_PHYSICAL_ADDRESS EndOfSection
;
587 *SecCoreImageBase
= 0;
589 CurrentAddress
= (EFI_PHYSICAL_ADDRESS
)(UINTN
) BootFirmwareVolumePtr
;
590 EndOfFirmwareVolume
= CurrentAddress
+ BootFirmwareVolumePtr
->FvLength
;
593 // Loop through the FFS files in the Boot Firmware Volume
595 for (EndOfFile
= CurrentAddress
+ BootFirmwareVolumePtr
->HeaderLength
; ; ) {
597 CurrentAddress
= (EndOfFile
+ 7) & 0xfffffffffffffff8ULL
;
598 if (CurrentAddress
> EndOfFirmwareVolume
) {
599 return EFI_NOT_FOUND
;
602 File
= (EFI_FFS_FILE_HEADER
*)(UINTN
) CurrentAddress
;
603 Size
= *(UINT32
*) File
->Size
& 0xffffff;
604 if (Size
< sizeof (*File
)) {
605 return EFI_NOT_FOUND
;
608 EndOfFile
= CurrentAddress
+ Size
;
609 if (EndOfFile
> EndOfFirmwareVolume
) {
610 return EFI_NOT_FOUND
;
616 if (File
->Type
!= EFI_FV_FILETYPE_SECURITY_CORE
) {
621 // Loop through the FFS file sections within the FFS file
623 EndOfSection
= (EFI_PHYSICAL_ADDRESS
)(UINTN
) (File
+ 1);
625 CurrentAddress
= (EndOfSection
+ 3) & 0xfffffffffffffffcULL
;
626 Section
= (EFI_COMMON_SECTION_HEADER
*)(UINTN
) CurrentAddress
;
628 Size
= *(UINT32
*) Section
->Size
& 0xffffff;
629 if (Size
< sizeof (*Section
)) {
630 return EFI_NOT_FOUND
;
633 EndOfSection
= CurrentAddress
+ Size
;
634 if (EndOfSection
> EndOfFile
) {
635 return EFI_NOT_FOUND
;
639 // Look for executable sections
641 if (Section
->Type
== EFI_SECTION_PE32
|| Section
->Type
== EFI_SECTION_TE
) {
642 if (File
->Type
== EFI_FV_FILETYPE_SECURITY_CORE
) {
643 *SecCoreImageBase
= (PHYSICAL_ADDRESS
) (UINTN
) (Section
+ 1);
650 // SEC Core image found
652 if (*SecCoreImageBase
!= 0) {
659 Find and return Pei Core entry point.
661 It also find SEC and PEI Core file debug inforamtion. It will report them if
662 remote debug is enabled.
666 FindAndReportEntryPoints (
667 IN EFI_FIRMWARE_VOLUME_HEADER
**BootFirmwareVolumePtr
,
668 OUT EFI_PEI_CORE_ENTRY_POINT
*PeiCoreEntryPoint
672 EFI_PHYSICAL_ADDRESS SecCoreImageBase
;
673 EFI_PHYSICAL_ADDRESS PeiCoreImageBase
;
674 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext
;
677 // Find SEC Core and PEI Core image base
679 Status
= FindImageBase (*BootFirmwareVolumePtr
, &SecCoreImageBase
);
680 ASSERT_EFI_ERROR (Status
);
682 FindPeiCoreImageBase (BootFirmwareVolumePtr
, &PeiCoreImageBase
);
684 ZeroMem ((VOID
*) &ImageContext
, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT
));
686 // Report SEC Core debug information when remote debug is enabled
688 ImageContext
.ImageAddress
= SecCoreImageBase
;
689 ImageContext
.PdbPointer
= PeCoffLoaderGetPdbPointer ((VOID
*) (UINTN
) ImageContext
.ImageAddress
);
690 PeCoffLoaderRelocateImageExtraAction (&ImageContext
);
693 // Report PEI Core debug information when remote debug is enabled
695 ImageContext
.ImageAddress
= (EFI_PHYSICAL_ADDRESS
)(UINTN
)PeiCoreImageBase
;
696 ImageContext
.PdbPointer
= PeCoffLoaderGetPdbPointer ((VOID
*) (UINTN
) ImageContext
.ImageAddress
);
697 PeCoffLoaderRelocateImageExtraAction (&ImageContext
);
700 // Find PEI Core entry point
702 Status
= PeCoffLoaderGetEntryPoint ((VOID
*) (UINTN
) PeiCoreImageBase
, (VOID
**) PeiCoreEntryPoint
);
703 if (EFI_ERROR (Status
)) {
704 *PeiCoreEntryPoint
= 0;
712 SecCoreStartupWithStack (
713 IN EFI_FIRMWARE_VOLUME_HEADER
*BootFv
,
714 IN VOID
*TopOfCurrentStack
717 EFI_SEC_PEI_HAND_OFF SecCoreData
;
718 SEC_IDT_TABLE IdtTableInStack
;
719 IA32_DESCRIPTOR IdtDescriptor
;
721 volatile UINT8
*Table
;
724 // To ensure SMM can't be compromised on S3 resume, we must force re-init of
725 // the BaseExtractGuidedSectionLib. Since this is before library contructors
726 // are called, we must use a loop rather than SetMem.
728 Table
= (UINT8
*)(UINTN
)FixedPcdGet64 (PcdGuidedExtractHandlerTableAddress
);
730 Index
< FixedPcdGet32 (PcdGuidedExtractHandlerTableSize
);
735 ProcessLibraryConstructorList (NULL
, NULL
);
738 "SecCoreStartupWithStack(0x%x, 0x%x)\n",
739 (UINT32
)(UINTN
)BootFv
,
740 (UINT32
)(UINTN
)TopOfCurrentStack
744 // Initialize floating point operating environment
745 // to be compliant with UEFI spec.
747 InitializeFloatingPointUnits ();
752 IdtTableInStack
.PeiService
= NULL
;
753 for (Index
= 0; Index
< SEC_IDT_ENTRY_COUNT
; Index
++) {
754 CopyMem (&IdtTableInStack
.IdtTable
[Index
], &mIdtEntryTemplate
, sizeof (mIdtEntryTemplate
));
757 IdtDescriptor
.Base
= (UINTN
)&IdtTableInStack
.IdtTable
;
758 IdtDescriptor
.Limit
= (UINT16
)(sizeof (IdtTableInStack
.IdtTable
) - 1);
760 AsmWriteIdtr (&IdtDescriptor
);
762 #if defined (MDE_CPU_X64)
764 // ASSERT that the Page Tables were set by the reset vector code to
765 // the address we expect.
767 ASSERT (AsmReadCr3 () == (UINTN
) PcdGet32 (PcdOvmfSecPageTablesBase
));
771 // |-------------| <-- TopOfCurrentStack
775 // |-------------| <-- SecCoreData.TemporaryRamBase
778 ASSERT ((UINTN
) (PcdGet32 (PcdOvmfSecPeiTempRamBase
) +
779 PcdGet32 (PcdOvmfSecPeiTempRamSize
)) ==
780 (UINTN
) TopOfCurrentStack
);
783 // Initialize SEC hand-off state
785 SecCoreData
.DataSize
= sizeof(EFI_SEC_PEI_HAND_OFF
);
787 SecCoreData
.TemporaryRamSize
= (UINTN
) PcdGet32 (PcdOvmfSecPeiTempRamSize
);
788 SecCoreData
.TemporaryRamBase
= (VOID
*)((UINT8
*)TopOfCurrentStack
- SecCoreData
.TemporaryRamSize
);
790 SecCoreData
.PeiTemporaryRamBase
= SecCoreData
.TemporaryRamBase
;
791 SecCoreData
.PeiTemporaryRamSize
= SecCoreData
.TemporaryRamSize
>> 1;
793 SecCoreData
.StackBase
= (UINT8
*)SecCoreData
.TemporaryRamBase
+ SecCoreData
.PeiTemporaryRamSize
;
794 SecCoreData
.StackSize
= SecCoreData
.TemporaryRamSize
>> 1;
796 SecCoreData
.BootFirmwareVolumeBase
= BootFv
;
797 SecCoreData
.BootFirmwareVolumeSize
= (UINTN
) BootFv
->FvLength
;
800 // Make sure the 8259 is masked before initializing the Debug Agent and the debug timer is enabled
802 IoWrite8 (0x21, 0xff);
803 IoWrite8 (0xA1, 0xff);
806 // Initialize Local APIC Timer hardware and disable Local APIC Timer
807 // interrupts before initializing the Debug Agent and the debug timer is
810 InitializeApicTimer (0, MAX_UINT32
, TRUE
, 5);
811 DisableApicTimerInterrupt ();
814 // Initialize Debug Agent to support source level debug in SEC/PEI phases before memory ready.
816 InitializeDebugAgent (DEBUG_AGENT_INIT_PREMEM_SEC
, &SecCoreData
, SecStartupPhase2
);
820 Caller provided function to be invoked at the end of InitializeDebugAgent().
822 Entry point to the C language phase of SEC. After the SEC assembly
823 code has initialized some temporary memory and set up the stack,
824 the control is transferred to this function.
826 @param[in] Context The first input parameter of InitializeDebugAgent().
835 EFI_SEC_PEI_HAND_OFF
*SecCoreData
;
836 EFI_FIRMWARE_VOLUME_HEADER
*BootFv
;
837 EFI_PEI_CORE_ENTRY_POINT PeiCoreEntryPoint
;
839 SecCoreData
= (EFI_SEC_PEI_HAND_OFF
*) Context
;
842 // Find PEI Core entry point. It will report SEC and Pei Core debug information if remote debug
845 BootFv
= (EFI_FIRMWARE_VOLUME_HEADER
*)SecCoreData
->BootFirmwareVolumeBase
;
846 FindAndReportEntryPoints (&BootFv
, &PeiCoreEntryPoint
);
847 SecCoreData
->BootFirmwareVolumeBase
= BootFv
;
848 SecCoreData
->BootFirmwareVolumeSize
= (UINTN
) BootFv
->FvLength
;
851 // Transfer the control to the PEI core
853 (*PeiCoreEntryPoint
) (SecCoreData
, (EFI_PEI_PPI_DESCRIPTOR
*)&mPrivateDispatchTable
);
856 // If we get here then the PEI Core returned, which is not recoverable.
864 TemporaryRamMigration (
865 IN CONST EFI_PEI_SERVICES
**PeiServices
,
866 IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase
,
867 IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase
,
871 IA32_DESCRIPTOR IdtDescriptor
;
876 DEBUG_AGENT_CONTEXT_POSTMEM_SEC DebugAgentContext
;
878 BASE_LIBRARY_JUMP_BUFFER JumpBuffer
;
881 "TemporaryRamMigration(0x%Lx, 0x%Lx, 0x%Lx)\n",
887 OldHeap
= (VOID
*)(UINTN
)TemporaryMemoryBase
;
888 NewHeap
= (VOID
*)((UINTN
)PermanentMemoryBase
+ (CopySize
>> 1));
890 OldStack
= (VOID
*)((UINTN
)TemporaryMemoryBase
+ (CopySize
>> 1));
891 NewStack
= (VOID
*)(UINTN
)PermanentMemoryBase
;
893 DebugAgentContext
.HeapMigrateOffset
= (UINTN
)NewHeap
- (UINTN
)OldHeap
;
894 DebugAgentContext
.StackMigrateOffset
= (UINTN
)NewStack
- (UINTN
)OldStack
;
896 OldStatus
= SaveAndSetDebugTimerInterrupt (FALSE
);
897 InitializeDebugAgent (DEBUG_AGENT_INIT_POSTMEM_SEC
, (VOID
*) &DebugAgentContext
, NULL
);
902 CopyMem (NewHeap
, OldHeap
, CopySize
>> 1);
907 CopyMem (NewStack
, OldStack
, CopySize
>> 1);
910 // Rebase IDT table in permanent memory
912 AsmReadIdtr (&IdtDescriptor
);
913 IdtDescriptor
.Base
= IdtDescriptor
.Base
- (UINTN
)OldStack
+ (UINTN
)NewStack
;
915 AsmWriteIdtr (&IdtDescriptor
);
918 // Use SetJump()/LongJump() to switch to a new stack.
920 if (SetJump (&JumpBuffer
) == 0) {
921 #if defined (MDE_CPU_IA32)
922 JumpBuffer
.Esp
= JumpBuffer
.Esp
+ DebugAgentContext
.StackMigrateOffset
;
924 #if defined (MDE_CPU_X64)
925 JumpBuffer
.Rsp
= JumpBuffer
.Rsp
+ DebugAgentContext
.StackMigrateOffset
;
927 LongJump (&JumpBuffer
, (UINTN
)-1);
930 SaveAndSetDebugTimerInterrupt (OldStatus
);