]> git.proxmox.com Git - mirror_edk2.git/blob - OvmfPkg/Sec/SecMain.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
OvmfPkg X64 ResetVector: Move page tables from 512KB to 8MB
[mirror_edk2.git] / OvmfPkg / Sec / SecMain.c
1 /** @file
2 Main SEC phase code. Transitions to PEI.
3
4 Copyright (c) 2008 - 2011, Intel Corporation. All rights reserved.<BR>
5
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
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 <PiPei.h>
17
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
32 #include <Ppi/TemporaryRamSupport.h>
33
34 #define SEC_IDT_ENTRY_COUNT 34
35
36 typedef struct _SEC_IDT_TABLE {
37 EFI_PEI_SERVICES *PeiService;
38 IA32_IDT_GATE_DESCRIPTOR IdtTable[SEC_IDT_ENTRY_COUNT];
39 } SEC_IDT_TABLE;
40
41 VOID
42 EFIAPI
43 SecStartupPhase2 (
44 IN VOID *Context
45 );
46
47 EFI_STATUS
48 EFIAPI
49 TemporaryRamMigration (
50 IN CONST EFI_PEI_SERVICES **PeiServices,
51 IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase,
52 IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase,
53 IN UINTN CopySize
54 );
55
56 //
57 //
58 //
59 EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mTemporaryRamSupportPpi = {
60 TemporaryRamMigration
61 };
62
63 EFI_PEI_PPI_DESCRIPTOR mPrivateDispatchTable[] = {
64 {
65 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
66 &gEfiTemporaryRamSupportPpiGuid,
67 &mTemporaryRamSupportPpi
68 },
69 };
70
71 //
72 // Template of an IDT entry pointing to 10:FFFFFFE4h.
73 //
74 IA32_IDT_GATE_DESCRIPTOR mIdtEntryTemplate = {
75 { // Bits
76 0xffe4, // OffsetLow
77 0x10, // Selector
78 0x0, // Reserved_0
79 IA32_IDT_GATE_TYPE_INTERRUPT_32, // GateType
80 0xffff // OffsetHigh
81 }
82 };
83
84 /**
85 Locates the main boot firmware volume.
86
87 @param[in,out] BootFv On input, the base of the BootFv
88 On output, the decompressed main firmware volume
89
90 @retval EFI_SUCCESS The main firmware volume was located and decompressed
91 @retval EFI_NOT_FOUND The main firmware volume was not found
92
93 **/
94 EFI_STATUS
95 FindMainFv (
96 IN OUT EFI_FIRMWARE_VOLUME_HEADER **BootFv
97 )
98 {
99 EFI_FIRMWARE_VOLUME_HEADER *Fv;
100 UINTN Distance;
101
102 ASSERT (((UINTN) *BootFv & EFI_PAGE_MASK) == 0);
103
104 Fv = *BootFv;
105 Distance = (UINTN) (*BootFv)->FvLength;
106 do {
107 Fv = (EFI_FIRMWARE_VOLUME_HEADER*) ((UINT8*) Fv - EFI_PAGE_SIZE);
108 Distance += EFI_PAGE_SIZE;
109 if (Distance > SIZE_32MB) {
110 return EFI_NOT_FOUND;
111 }
112
113 if (Fv->Signature != EFI_FVH_SIGNATURE) {
114 continue;
115 }
116
117 if ((UINTN) Fv->FvLength > Distance) {
118 continue;
119 }
120
121 *BootFv = Fv;
122 return EFI_SUCCESS;
123
124 } while (TRUE);
125 }
126
127 /**
128 Locates a section within a series of sections
129 with the specified section type.
130
131 @param[in] Sections The sections to search
132 @param[in] SizeOfSections Total size of all sections
133 @param[in] SectionType The section type to locate
134 @param[out] FoundSection The FFS section if found
135
136 @retval EFI_SUCCESS The file and section was found
137 @retval EFI_NOT_FOUND The file and section was not found
138 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
139
140 **/
141 EFI_STATUS
142 FindFfsSectionInSections (
143 IN VOID *Sections,
144 IN UINTN SizeOfSections,
145 IN EFI_SECTION_TYPE SectionType,
146 OUT EFI_COMMON_SECTION_HEADER **FoundSection
147 )
148 {
149 EFI_PHYSICAL_ADDRESS CurrentAddress;
150 UINT32 Size;
151 EFI_PHYSICAL_ADDRESS EndOfSections;
152 EFI_COMMON_SECTION_HEADER *Section;
153 EFI_PHYSICAL_ADDRESS EndOfSection;
154
155 //
156 // Loop through the FFS file sections within the PEI Core FFS file
157 //
158 EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) Sections;
159 EndOfSections = EndOfSection + SizeOfSections;
160 for (;;) {
161 if (EndOfSection == EndOfSections) {
162 break;
163 }
164 CurrentAddress = (EndOfSection + 3) & ~(3ULL);
165 if (CurrentAddress >= EndOfSections) {
166 return EFI_VOLUME_CORRUPTED;
167 }
168
169 Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;
170 DEBUG ((EFI_D_INFO, "Section->Type: 0x%x\n", Section->Type));
171
172 Size = SECTION_SIZE (Section);
173 if (Size < sizeof (*Section)) {
174 return EFI_VOLUME_CORRUPTED;
175 }
176
177 EndOfSection = CurrentAddress + Size;
178 if (EndOfSection > EndOfSections) {
179 return EFI_VOLUME_CORRUPTED;
180 }
181
182 //
183 // Look for the requested section type
184 //
185 if (Section->Type == SectionType) {
186 *FoundSection = Section;
187 return EFI_SUCCESS;
188 }
189 DEBUG ((EFI_D_INFO, "Section->Type (0x%x) != SectionType (0x%x)\n", Section->Type, SectionType));
190 }
191
192 return EFI_NOT_FOUND;
193 }
194
195 /**
196 Locates a FFS file with the specified file type and a section
197 within that file with the specified section type.
198
199 @param[in] Fv The firmware volume to search
200 @param[in] FileType The file type to locate
201 @param[in] SectionType The section type to locate
202 @param[out] FoundSection The FFS section if found
203
204 @retval EFI_SUCCESS The file and section was found
205 @retval EFI_NOT_FOUND The file and section was not found
206 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
207
208 **/
209 EFI_STATUS
210 EFIAPI
211 FindFfsFileAndSection (
212 IN EFI_FIRMWARE_VOLUME_HEADER *Fv,
213 IN EFI_FV_FILETYPE FileType,
214 IN EFI_SECTION_TYPE SectionType,
215 OUT EFI_COMMON_SECTION_HEADER **FoundSection
216 )
217 {
218 EFI_STATUS Status;
219 EFI_PHYSICAL_ADDRESS CurrentAddress;
220 EFI_PHYSICAL_ADDRESS EndOfFirmwareVolume;
221 EFI_FFS_FILE_HEADER *File;
222 UINT32 Size;
223 EFI_PHYSICAL_ADDRESS EndOfFile;
224
225 if (Fv->Signature != EFI_FVH_SIGNATURE) {
226 DEBUG ((EFI_D_INFO, "FV at %p does not have FV header signature\n", Fv));
227 return EFI_VOLUME_CORRUPTED;
228 }
229
230 CurrentAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Fv;
231 EndOfFirmwareVolume = CurrentAddress + Fv->FvLength;
232
233 //
234 // Loop through the FFS files in the Boot Firmware Volume
235 //
236 for (EndOfFile = CurrentAddress + Fv->HeaderLength; ; ) {
237
238 CurrentAddress = (EndOfFile + 7) & ~(7ULL);
239 if (CurrentAddress > EndOfFirmwareVolume) {
240 return EFI_VOLUME_CORRUPTED;
241 }
242
243 File = (EFI_FFS_FILE_HEADER*)(UINTN) CurrentAddress;
244 Size = *(UINT32*) File->Size & 0xffffff;
245 if (Size < (sizeof (*File) + sizeof (EFI_COMMON_SECTION_HEADER))) {
246 return EFI_VOLUME_CORRUPTED;
247 }
248 DEBUG ((EFI_D_INFO, "File->Type: 0x%x\n", File->Type));
249
250 EndOfFile = CurrentAddress + Size;
251 if (EndOfFile > EndOfFirmwareVolume) {
252 return EFI_VOLUME_CORRUPTED;
253 }
254
255 //
256 // Look for the request file type
257 //
258 if (File->Type != FileType) {
259 DEBUG ((EFI_D_INFO, "File->Type (0x%x) != FileType (0x%x)\n", File->Type, FileType));
260 continue;
261 }
262
263 Status = FindFfsSectionInSections (
264 (VOID*) (File + 1),
265 (UINTN) EndOfFile - (UINTN) (File + 1),
266 SectionType,
267 FoundSection
268 );
269 if (!EFI_ERROR (Status) || (Status == EFI_VOLUME_CORRUPTED)) {
270 return Status;
271 }
272 }
273 }
274
275 /**
276 Locates the compressed main firmware volume and decompresses it.
277
278 @param[in,out] Fv On input, the firmware volume to search
279 On output, the decompressed main FV
280
281 @retval EFI_SUCCESS The file and section was found
282 @retval EFI_NOT_FOUND The file and section was not found
283 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
284
285 **/
286 EFI_STATUS
287 EFIAPI
288 DecompressGuidedFv (
289 IN OUT EFI_FIRMWARE_VOLUME_HEADER **Fv
290 )
291 {
292 EFI_STATUS Status;
293 EFI_GUID_DEFINED_SECTION *Section;
294 UINT32 OutputBufferSize;
295 UINT32 ScratchBufferSize;
296 UINT16 SectionAttribute;
297 UINT32 AuthenticationStatus;
298 VOID *OutputBuffer;
299 VOID *ScratchBuffer;
300 EFI_FIRMWARE_VOLUME_IMAGE_SECTION *NewFvSection;
301 EFI_FIRMWARE_VOLUME_HEADER *NewFv;
302
303 NewFvSection = (EFI_FIRMWARE_VOLUME_IMAGE_SECTION*) NULL;
304
305 Status = FindFfsFileAndSection (
306 *Fv,
307 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
308 EFI_SECTION_GUID_DEFINED,
309 (EFI_COMMON_SECTION_HEADER**) &Section
310 );
311 if (EFI_ERROR (Status)) {
312 DEBUG ((EFI_D_ERROR, "Unable to find GUID defined section\n"));
313 return Status;
314 }
315
316 Status = ExtractGuidedSectionGetInfo (
317 Section,
318 &OutputBufferSize,
319 &ScratchBufferSize,
320 &SectionAttribute
321 );
322 if (EFI_ERROR (Status)) {
323 DEBUG ((EFI_D_ERROR, "Unable to GetInfo for GUIDed section\n"));
324 return Status;
325 }
326
327 //PcdGet32 (PcdOvmfMemFvBase), PcdGet32 (PcdOvmfMemFvSize)
328 OutputBuffer = (VOID*) ((UINT8*)(UINTN) PcdGet32 (PcdOvmfMemFvBase) + SIZE_1MB);
329 ScratchBuffer = ALIGN_POINTER ((UINT8*) OutputBuffer + OutputBufferSize, SIZE_1MB);
330 Status = ExtractGuidedSectionDecode (
331 Section,
332 &OutputBuffer,
333 ScratchBuffer,
334 &AuthenticationStatus
335 );
336 if (EFI_ERROR (Status)) {
337 DEBUG ((EFI_D_ERROR, "Error during GUID section decode\n"));
338 return Status;
339 }
340
341 Status = FindFfsSectionInSections (
342 OutputBuffer,
343 OutputBufferSize,
344 EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
345 (EFI_COMMON_SECTION_HEADER**) &NewFvSection
346 );
347 if (EFI_ERROR (Status)) {
348 DEBUG ((EFI_D_ERROR, "Unable to find FV image in extracted data\n"));
349 return Status;
350 }
351
352 NewFv = (EFI_FIRMWARE_VOLUME_HEADER*)(UINTN) PcdGet32 (PcdOvmfMemFvBase);
353 CopyMem (NewFv, (VOID*) (NewFvSection + 1), PcdGet32 (PcdOvmfMemFvSize));
354
355 if (NewFv->Signature != EFI_FVH_SIGNATURE) {
356 DEBUG ((EFI_D_ERROR, "Extracted FV at %p does not have FV header signature\n", NewFv));
357 CpuDeadLoop ();
358 return EFI_VOLUME_CORRUPTED;
359 }
360
361 *Fv = NewFv;
362 return EFI_SUCCESS;
363 }
364
365 /**
366 Locates the PEI Core entry point address
367
368 @param[in] Fv The firmware volume to search
369 @param[out] PeiCoreEntryPoint The entry point of the PEI Core image
370
371 @retval EFI_SUCCESS The file and section was found
372 @retval EFI_NOT_FOUND The file and section was not found
373 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
374
375 **/
376 EFI_STATUS
377 EFIAPI
378 FindPeiCoreImageBaseInFv (
379 IN EFI_FIRMWARE_VOLUME_HEADER *Fv,
380 OUT EFI_PHYSICAL_ADDRESS *PeiCoreImageBase
381 )
382 {
383 EFI_STATUS Status;
384 EFI_COMMON_SECTION_HEADER *Section;
385
386 Status = FindFfsFileAndSection (
387 Fv,
388 EFI_FV_FILETYPE_PEI_CORE,
389 EFI_SECTION_PE32,
390 &Section
391 );
392 if (EFI_ERROR (Status)) {
393 Status = FindFfsFileAndSection (
394 Fv,
395 EFI_FV_FILETYPE_PEI_CORE,
396 EFI_SECTION_TE,
397 &Section
398 );
399 if (EFI_ERROR (Status)) {
400 DEBUG ((EFI_D_ERROR, "Unable to find PEI Core image\n"));
401 return Status;
402 }
403 }
404
405 *PeiCoreImageBase = (EFI_PHYSICAL_ADDRESS)(UINTN)(Section + 1);
406 return EFI_SUCCESS;
407 }
408
409 /**
410 Locates the PEI Core entry point address
411
412 @param[in,out] Fv The firmware volume to search
413 @param[out] PeiCoreEntryPoint The entry point of the PEI Core image
414
415 @retval EFI_SUCCESS The file and section was found
416 @retval EFI_NOT_FOUND The file and section was not found
417 @retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
418
419 **/
420 VOID
421 EFIAPI
422 FindPeiCoreImageBase (
423 IN OUT EFI_FIRMWARE_VOLUME_HEADER **BootFv,
424 OUT EFI_PHYSICAL_ADDRESS *PeiCoreImageBase
425 )
426 {
427 *PeiCoreImageBase = 0;
428
429 FindMainFv (BootFv);
430
431 DecompressGuidedFv (BootFv);
432
433 FindPeiCoreImageBaseInFv (*BootFv, PeiCoreImageBase);
434 }
435
436 /**
437 Find core image base.
438
439 **/
440 EFI_STATUS
441 EFIAPI
442 FindImageBase (
443 IN EFI_FIRMWARE_VOLUME_HEADER *BootFirmwareVolumePtr,
444 OUT EFI_PHYSICAL_ADDRESS *SecCoreImageBase
445 )
446 {
447 EFI_PHYSICAL_ADDRESS CurrentAddress;
448 EFI_PHYSICAL_ADDRESS EndOfFirmwareVolume;
449 EFI_FFS_FILE_HEADER *File;
450 UINT32 Size;
451 EFI_PHYSICAL_ADDRESS EndOfFile;
452 EFI_COMMON_SECTION_HEADER *Section;
453 EFI_PHYSICAL_ADDRESS EndOfSection;
454
455 *SecCoreImageBase = 0;
456
457 CurrentAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) BootFirmwareVolumePtr;
458 EndOfFirmwareVolume = CurrentAddress + BootFirmwareVolumePtr->FvLength;
459
460 //
461 // Loop through the FFS files in the Boot Firmware Volume
462 //
463 for (EndOfFile = CurrentAddress + BootFirmwareVolumePtr->HeaderLength; ; ) {
464
465 CurrentAddress = (EndOfFile + 7) & 0xfffffffffffffff8ULL;
466 if (CurrentAddress > EndOfFirmwareVolume) {
467 return EFI_NOT_FOUND;
468 }
469
470 File = (EFI_FFS_FILE_HEADER*)(UINTN) CurrentAddress;
471 Size = *(UINT32*) File->Size & 0xffffff;
472 if (Size < sizeof (*File)) {
473 return EFI_NOT_FOUND;
474 }
475
476 EndOfFile = CurrentAddress + Size;
477 if (EndOfFile > EndOfFirmwareVolume) {
478 return EFI_NOT_FOUND;
479 }
480
481 //
482 // Look for SEC Core
483 //
484 if (File->Type != EFI_FV_FILETYPE_SECURITY_CORE) {
485 continue;
486 }
487
488 //
489 // Loop through the FFS file sections within the FFS file
490 //
491 EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) (File + 1);
492 for (;;) {
493 CurrentAddress = (EndOfSection + 3) & 0xfffffffffffffffcULL;
494 Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;
495
496 Size = *(UINT32*) Section->Size & 0xffffff;
497 if (Size < sizeof (*Section)) {
498 return EFI_NOT_FOUND;
499 }
500
501 EndOfSection = CurrentAddress + Size;
502 if (EndOfSection > EndOfFile) {
503 return EFI_NOT_FOUND;
504 }
505
506 //
507 // Look for executable sections
508 //
509 if (Section->Type == EFI_SECTION_PE32 || Section->Type == EFI_SECTION_TE) {
510 if (File->Type == EFI_FV_FILETYPE_SECURITY_CORE) {
511 *SecCoreImageBase = (PHYSICAL_ADDRESS) (UINTN) (Section + 1);
512 }
513 break;
514 }
515 }
516
517 //
518 // SEC Core image found
519 //
520 if (*SecCoreImageBase != 0) {
521 return EFI_SUCCESS;
522 }
523 }
524 }
525
526 /*
527 Find and return Pei Core entry point.
528
529 It also find SEC and PEI Core file debug inforamtion. It will report them if
530 remote debug is enabled.
531
532 **/
533 VOID
534 EFIAPI
535 FindAndReportEntryPoints (
536 IN EFI_FIRMWARE_VOLUME_HEADER **BootFirmwareVolumePtr,
537 OUT EFI_PEI_CORE_ENTRY_POINT *PeiCoreEntryPoint
538 )
539 {
540 EFI_STATUS Status;
541 EFI_PHYSICAL_ADDRESS SecCoreImageBase;
542 EFI_PHYSICAL_ADDRESS PeiCoreImageBase;
543 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
544
545 //
546 // Find SEC Core and PEI Core image base
547 //
548 Status = FindImageBase (*BootFirmwareVolumePtr, &SecCoreImageBase);
549 ASSERT_EFI_ERROR (Status);
550
551 FindPeiCoreImageBase (BootFirmwareVolumePtr, &PeiCoreImageBase);
552
553 ZeroMem ((VOID *) &ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));
554 //
555 // Report SEC Core debug information when remote debug is enabled
556 //
557 ImageContext.ImageAddress = SecCoreImageBase;
558 ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);
559 PeCoffLoaderRelocateImageExtraAction (&ImageContext);
560
561 //
562 // Report PEI Core debug information when remote debug is enabled
563 //
564 ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)PeiCoreImageBase;
565 ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);
566 PeCoffLoaderRelocateImageExtraAction (&ImageContext);
567
568 //
569 // Find PEI Core entry point
570 //
571 Status = PeCoffLoaderGetEntryPoint ((VOID *) (UINTN) PeiCoreImageBase, (VOID**) PeiCoreEntryPoint);
572 if (EFI_ERROR (Status)) {
573 *PeiCoreEntryPoint = 0;
574 }
575
576 return;
577 }
578
579 VOID
580 EFIAPI
581 SecCoreStartupWithStack (
582 IN EFI_FIRMWARE_VOLUME_HEADER *BootFv,
583 IN VOID *TopOfCurrentStack
584 )
585 {
586 EFI_SEC_PEI_HAND_OFF SecCoreData;
587 SEC_IDT_TABLE IdtTableInStack;
588 IA32_DESCRIPTOR IdtDescriptor;
589 UINT32 Index;
590
591 ProcessLibraryConstructorList (NULL, NULL);
592
593 DEBUG ((EFI_D_ERROR,
594 "SecCoreStartupWithStack(0x%x, 0x%x)\n",
595 (UINT32)(UINTN)BootFv,
596 (UINT32)(UINTN)TopOfCurrentStack
597 ));
598
599 //
600 // Initialize floating point operating environment
601 // to be compliant with UEFI spec.
602 //
603 InitializeFloatingPointUnits ();
604
605 //
606 // Initialize IDT
607 //
608 IdtTableInStack.PeiService = NULL;
609 for (Index = 0; Index < SEC_IDT_ENTRY_COUNT; Index ++) {
610 CopyMem (&IdtTableInStack.IdtTable[Index], &mIdtEntryTemplate, sizeof (mIdtEntryTemplate));
611 }
612
613 IdtDescriptor.Base = (UINTN)&IdtTableInStack.IdtTable;
614 IdtDescriptor.Limit = (UINT16)(sizeof (IdtTableInStack.IdtTable) - 1);
615
616 AsmWriteIdtr (&IdtDescriptor);
617
618 #if defined (MDE_CPU_X64)
619 //
620 // ASSERT that the Page Tables were set by the reset vector code to
621 // the address we expect.
622 //
623 ASSERT (AsmReadCr3 () == (UINTN) PcdGet32 (PcdOvmfSecPageTablesBase));
624 #endif
625
626 //
627 // |-------------| <-- TopOfCurrentStack
628 // | Stack | 32k
629 // |-------------|
630 // | Heap | 32k
631 // |-------------| <-- SecCoreData.TemporaryRamBase
632 //
633
634 //
635 // Initialize SEC hand-off state
636 //
637 SecCoreData.DataSize = sizeof(EFI_SEC_PEI_HAND_OFF);
638
639 SecCoreData.TemporaryRamSize = SIZE_64KB;
640 SecCoreData.TemporaryRamBase = (VOID*)((UINT8 *)TopOfCurrentStack - SecCoreData.TemporaryRamSize);
641
642 SecCoreData.PeiTemporaryRamBase = SecCoreData.TemporaryRamBase;
643 SecCoreData.PeiTemporaryRamSize = SecCoreData.TemporaryRamSize >> 1;
644
645 SecCoreData.StackBase = (UINT8 *)SecCoreData.TemporaryRamBase + SecCoreData.PeiTemporaryRamSize;
646 SecCoreData.StackSize = SecCoreData.TemporaryRamSize >> 1;
647
648 SecCoreData.BootFirmwareVolumeBase = BootFv;
649 SecCoreData.BootFirmwareVolumeSize = (UINTN) BootFv->FvLength;
650
651 //
652 // Make sure the 8259 is masked before initializing the Debug Agent and the debug timer is enabled
653 //
654 IoWrite8 (0x21, 0xff);
655 IoWrite8 (0xA1, 0xff);
656
657 //
658 // Initialize Debug Agent to support source level debug in SEC/PEI phases before memory ready.
659 //
660 InitializeDebugAgent (DEBUG_AGENT_INIT_PREMEM_SEC, &SecCoreData, SecStartupPhase2);
661 }
662
663 /**
664 Caller provided function to be invoked at the end of InitializeDebugAgent().
665
666 Entry point to the C language phase of SEC. After the SEC assembly
667 code has initialized some temporary memory and set up the stack,
668 the control is transferred to this function.
669
670 @param[in] Context The first input parameter of InitializeDebugAgent().
671
672 **/
673 VOID
674 EFIAPI
675 SecStartupPhase2(
676 IN VOID *Context
677 )
678 {
679 EFI_SEC_PEI_HAND_OFF *SecCoreData;
680 EFI_FIRMWARE_VOLUME_HEADER *BootFv;
681 EFI_PEI_CORE_ENTRY_POINT PeiCoreEntryPoint;
682
683 SecCoreData = (EFI_SEC_PEI_HAND_OFF *) Context;
684
685 //
686 // Find PEI Core entry point. It will report SEC and Pei Core debug information if remote debug
687 // is enabled.
688 //
689 BootFv = (EFI_FIRMWARE_VOLUME_HEADER *)SecCoreData->BootFirmwareVolumeBase;
690 FindAndReportEntryPoints (&BootFv, &PeiCoreEntryPoint);
691 SecCoreData->BootFirmwareVolumeBase = BootFv;
692 SecCoreData->BootFirmwareVolumeSize = (UINTN) BootFv->FvLength;
693
694 //
695 // Transfer the control to the PEI core
696 //
697 (*PeiCoreEntryPoint) (SecCoreData, (EFI_PEI_PPI_DESCRIPTOR *)&mPrivateDispatchTable);
698
699 //
700 // If we get here then the PEI Core returned, which is not recoverable.
701 //
702 ASSERT (FALSE);
703 CpuDeadLoop ();
704 }
705
706 EFI_STATUS
707 EFIAPI
708 TemporaryRamMigration (
709 IN CONST EFI_PEI_SERVICES **PeiServices,
710 IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase,
711 IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase,
712 IN UINTN CopySize
713 )
714 {
715 IA32_DESCRIPTOR IdtDescriptor;
716 VOID *OldHeap;
717 VOID *NewHeap;
718 VOID *OldStack;
719 VOID *NewStack;
720 DEBUG_AGENT_CONTEXT_POSTMEM_SEC DebugAgentContext;
721 BOOLEAN OldStatus;
722 BASE_LIBRARY_JUMP_BUFFER JumpBuffer;
723
724 DEBUG ((EFI_D_ERROR, "TemporaryRamMigration(0x%x, 0x%x, 0x%x)\n", (UINTN)TemporaryMemoryBase, (UINTN)PermanentMemoryBase, CopySize));
725
726 OldHeap = (VOID*)(UINTN)TemporaryMemoryBase;
727 NewHeap = (VOID*)((UINTN)PermanentMemoryBase + (CopySize >> 1));
728
729 OldStack = (VOID*)((UINTN)TemporaryMemoryBase + (CopySize >> 1));
730 NewStack = (VOID*)(UINTN)PermanentMemoryBase;
731
732 DebugAgentContext.HeapMigrateOffset = (UINTN)NewHeap - (UINTN)OldHeap;
733 DebugAgentContext.StackMigrateOffset = (UINTN)NewStack - (UINTN)OldStack;
734
735 OldStatus = SaveAndSetDebugTimerInterrupt (FALSE);
736 InitializeDebugAgent (DEBUG_AGENT_INIT_POSTMEM_SEC, (VOID *) &DebugAgentContext, NULL);
737
738 //
739 // Migrate Heap
740 //
741 CopyMem (NewHeap, OldHeap, CopySize >> 1);
742
743 //
744 // Migrate Stack
745 //
746 CopyMem (NewStack, OldStack, CopySize >> 1);
747
748 //
749 // Rebase IDT table in permanent memory
750 //
751 AsmReadIdtr (&IdtDescriptor);
752 IdtDescriptor.Base = IdtDescriptor.Base - (UINTN)OldStack + (UINTN)NewStack;
753
754 AsmWriteIdtr (&IdtDescriptor);
755
756 //
757 // Use SetJump()/LongJump() to switch to a new stack.
758 //
759 if (SetJump (&JumpBuffer) == 0) {
760 #if defined (MDE_CPU_IA32)
761 JumpBuffer.Esp = JumpBuffer.Esp + DebugAgentContext.StackMigrateOffset;
762 #endif
763 #if defined (MDE_CPU_X64)
764 JumpBuffer.Rsp = JumpBuffer.Rsp + DebugAgentContext.StackMigrateOffset;
765 #endif
766 LongJump (&JumpBuffer, (UINTN)-1);
767 }
768
769 SaveAndSetDebugTimerInterrupt (OldStatus);
770
771 return EFI_SUCCESS;
772 }
773
EFI Development Kit II mirror for PVE