SecMain.c@ 78403

Last change on this file since 78403 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 24.7 KB

Line
1	/** @file
2	Main SEC phase code. Transitions to PEI.
3
4	Copyright (c) 2008 - 2013, 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	The Instance parameter indicates which instance of the section
132	type to return. (0 is first instance, 1 is second...)
133
134	@param[in] Sections The sections to search
135	@param[in] SizeOfSections Total size of all sections
136	@param[in] SectionType The section type to locate
137	@param[in] Instance The section instance number
138	@param[out] FoundSection The FFS section if found
139
140	@retval EFI_SUCCESS The file and section was found
141	@retval EFI_NOT_FOUND The file and section was not found
142	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
143
144	**/
145	EFI_STATUS
146	FindFfsSectionInstance (
147	IN VOID *Sections,
148	IN UINTN SizeOfSections,
149	IN EFI_SECTION_TYPE SectionType,
150	IN UINTN Instance,
151	OUT EFI_COMMON_SECTION_HEADER **FoundSection
152	)
153	{
154	EFI_PHYSICAL_ADDRESS CurrentAddress;
155	UINT32 Size;
156	EFI_PHYSICAL_ADDRESS EndOfSections;
157	EFI_COMMON_SECTION_HEADER *Section;
158	EFI_PHYSICAL_ADDRESS EndOfSection;
159
160	//
161	// Loop through the FFS file sections within the PEI Core FFS file
162	//
163	EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) Sections;
164	EndOfSections = EndOfSection + SizeOfSections;
165	for (;;) {
166	if (EndOfSection == EndOfSections) {
167	break;
168	}
169	CurrentAddress = (EndOfSection + 3) & ~(3ULL);
170	if (CurrentAddress >= EndOfSections) {
171	return EFI_VOLUME_CORRUPTED;
172	}
173
174	Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;
175
176	Size = SECTION_SIZE (Section);
177	if (Size < sizeof (*Section)) {
178	return EFI_VOLUME_CORRUPTED;
179	}
180
181	EndOfSection = CurrentAddress + Size;
182	if (EndOfSection > EndOfSections) {
183	return EFI_VOLUME_CORRUPTED;
184	}
185
186	//
187	// Look for the requested section type
188	//
189	if (Section->Type == SectionType) {
190	if (Instance == 0) {
191	*FoundSection = Section;
192	return EFI_SUCCESS;
193	} else {
194	Instance--;
195	}
196	}
197	}
198
199	return EFI_NOT_FOUND;
200	}
201
202	/**
203	Locates a section within a series of sections
204	with the specified section type.
205
206	@param[in] Sections The sections to search
207	@param[in] SizeOfSections Total size of all sections
208	@param[in] SectionType The section type to locate
209	@param[out] FoundSection The FFS section if found
210
211	@retval EFI_SUCCESS The file and section was found
212	@retval EFI_NOT_FOUND The file and section was not found
213	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
214
215	**/
216	EFI_STATUS
217	FindFfsSectionInSections (
218	IN VOID *Sections,
219	IN UINTN SizeOfSections,
220	IN EFI_SECTION_TYPE SectionType,
221	OUT EFI_COMMON_SECTION_HEADER **FoundSection
222	)
223	{
224	return FindFfsSectionInstance (
225	Sections,
226	SizeOfSections,
227	SectionType,
228	0,
229	FoundSection
230	);
231	}
232
233	/**
234	Locates a FFS file with the specified file type and a section
235	within that file with the specified section type.
236
237	@param[in] Fv The firmware volume to search
238	@param[in] FileType The file type to locate
239	@param[in] SectionType The section type to locate
240	@param[out] FoundSection The FFS section if found
241
242	@retval EFI_SUCCESS The file and section was found
243	@retval EFI_NOT_FOUND The file and section was not found
244	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
245
246	**/
247	EFI_STATUS
248	FindFfsFileAndSection (
249	IN EFI_FIRMWARE_VOLUME_HEADER *Fv,
250	IN EFI_FV_FILETYPE FileType,
251	IN EFI_SECTION_TYPE SectionType,
252	OUT EFI_COMMON_SECTION_HEADER **FoundSection
253	)
254	{
255	EFI_STATUS Status;
256	EFI_PHYSICAL_ADDRESS CurrentAddress;
257	EFI_PHYSICAL_ADDRESS EndOfFirmwareVolume;
258	EFI_FFS_FILE_HEADER *File;
259	UINT32 Size;
260	EFI_PHYSICAL_ADDRESS EndOfFile;
261
262	if (Fv->Signature != EFI_FVH_SIGNATURE) {
263	DEBUG ((EFI_D_ERROR, "FV at %p does not have FV header signature\n", Fv));
264	return EFI_VOLUME_CORRUPTED;
265	}
266
267	CurrentAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Fv;
268	EndOfFirmwareVolume = CurrentAddress + Fv->FvLength;
269
270	//
271	// Loop through the FFS files in the Boot Firmware Volume
272	//
273	for (EndOfFile = CurrentAddress + Fv->HeaderLength; ; ) {
274
275	CurrentAddress = (EndOfFile + 7) & ~(7ULL);
276	if (CurrentAddress > EndOfFirmwareVolume) {
277	return EFI_VOLUME_CORRUPTED;
278	}
279
280	File = (EFI_FFS_FILE_HEADER*)(UINTN) CurrentAddress;
281	Size = (UINT32) File->Size & 0xffffff;
282	if (Size < (sizeof (*File) + sizeof (EFI_COMMON_SECTION_HEADER))) {
283	return EFI_VOLUME_CORRUPTED;
284	}
285
286	EndOfFile = CurrentAddress + Size;
287	if (EndOfFile > EndOfFirmwareVolume) {
288	return EFI_VOLUME_CORRUPTED;
289	}
290
291	//
292	// Look for the request file type
293	//
294	if (File->Type != FileType) {
295	continue;
296	}
297
298	Status = FindFfsSectionInSections (
299	(VOID*) (File + 1),
300	(UINTN) EndOfFile - (UINTN) (File + 1),
301	SectionType,
302	FoundSection
303	);
304	if (!EFI_ERROR (Status) \|\| (Status == EFI_VOLUME_CORRUPTED)) {
305	return Status;
306	}
307	}
308	}
309
310	/**
311	Locates the compressed main firmware volume and decompresses it.
312
313	@param[in,out] Fv On input, the firmware volume to search
314	On output, the decompressed BOOT/PEI FV
315
316	@retval EFI_SUCCESS The file and section was found
317	@retval EFI_NOT_FOUND The file and section was not found
318	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
319
320	**/
321	EFI_STATUS
322	DecompressMemFvs (
323	IN OUT EFI_FIRMWARE_VOLUME_HEADER **Fv
324	)
325	{
326	EFI_STATUS Status;
327	EFI_GUID_DEFINED_SECTION *Section;
328	UINT32 OutputBufferSize;
329	UINT32 ScratchBufferSize;
330	UINT16 SectionAttribute;
331	UINT32 AuthenticationStatus;
332	VOID *OutputBuffer;
333	VOID *ScratchBuffer;
334	EFI_FIRMWARE_VOLUME_IMAGE_SECTION *FvSection;
335	EFI_FIRMWARE_VOLUME_HEADER *PeiMemFv;
336	EFI_FIRMWARE_VOLUME_HEADER *DxeMemFv;
337
338	FvSection = (EFI_FIRMWARE_VOLUME_IMAGE_SECTION*) NULL;
339
340	Status = FindFfsFileAndSection (
341	*Fv,
342	EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
343	EFI_SECTION_GUID_DEFINED,
344	(EFI_COMMON_SECTION_HEADER**) &Section
345	);
346	if (EFI_ERROR (Status)) {
347	DEBUG ((EFI_D_ERROR, "Unable to find GUID defined section\n"));
348	return Status;
349	}
350
351	Status = ExtractGuidedSectionGetInfo (
352	Section,
353	&OutputBufferSize,
354	&ScratchBufferSize,
355	&SectionAttribute
356	);
357	if (EFI_ERROR (Status)) {
358	DEBUG ((EFI_D_ERROR, "Unable to GetInfo for GUIDed section\n"));
359	return Status;
360	}
361
362	OutputBuffer = (VOID) ((UINT8)(UINTN) PcdGet32 (PcdOvmfDxeMemFvBase) + SIZE_1MB);
363	ScratchBuffer = ALIGN_POINTER ((UINT8*) OutputBuffer + OutputBufferSize, SIZE_1MB);
364	Status = ExtractGuidedSectionDecode (
365	Section,
366	&OutputBuffer,
367	ScratchBuffer,
368	&AuthenticationStatus
369	);
370	if (EFI_ERROR (Status)) {
371	DEBUG ((EFI_D_ERROR, "Error during GUID section decode\n"));
372	return Status;
373	}
374
375	Status = FindFfsSectionInstance (
376	OutputBuffer,
377	OutputBufferSize,
378	EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
379	0,
380	(EFI_COMMON_SECTION_HEADER**) &FvSection
381	);
382	if (EFI_ERROR (Status)) {
383	DEBUG ((EFI_D_ERROR, "Unable to find PEI FV section\n"));
384	return Status;
385	}
386
387	ASSERT (SECTION_SIZE (FvSection) ==
388	(PcdGet32 (PcdOvmfPeiMemFvSize) + sizeof (*FvSection)));
389	ASSERT (FvSection->Type == EFI_SECTION_FIRMWARE_VOLUME_IMAGE);
390
391	PeiMemFv = (EFI_FIRMWARE_VOLUME_HEADER*)(UINTN) PcdGet32 (PcdOvmfPeiMemFvBase);
392	CopyMem (PeiMemFv, (VOID*) (FvSection + 1), PcdGet32 (PcdOvmfPeiMemFvSize));
393
394	if (PeiMemFv->Signature != EFI_FVH_SIGNATURE) {
395	DEBUG ((EFI_D_ERROR, "Extracted FV at %p does not have FV header signature\n", PeiMemFv));
396	CpuDeadLoop ();
397	return EFI_VOLUME_CORRUPTED;
398	}
399
400	Status = FindFfsSectionInstance (
401	OutputBuffer,
402	OutputBufferSize,
403	EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
404	1,
405	(EFI_COMMON_SECTION_HEADER**) &FvSection
406	);
407	if (EFI_ERROR (Status)) {
408	DEBUG ((EFI_D_ERROR, "Unable to find DXE FV section\n"));
409	return Status;
410	}
411
412	ASSERT (FvSection->Type == EFI_SECTION_FIRMWARE_VOLUME_IMAGE);
413	ASSERT (SECTION_SIZE (FvSection) ==
414	(PcdGet32 (PcdOvmfDxeMemFvSize) + sizeof (*FvSection)));
415
416	DxeMemFv = (EFI_FIRMWARE_VOLUME_HEADER*)(UINTN) PcdGet32 (PcdOvmfDxeMemFvBase);
417	CopyMem (DxeMemFv, (VOID*) (FvSection + 1), PcdGet32 (PcdOvmfDxeMemFvSize));
418
419	if (DxeMemFv->Signature != EFI_FVH_SIGNATURE) {
420	DEBUG ((EFI_D_ERROR, "Extracted FV at %p does not have FV header signature\n", DxeMemFv));
421	CpuDeadLoop ();
422	return EFI_VOLUME_CORRUPTED;
423	}
424
425	*Fv = PeiMemFv;
426	return EFI_SUCCESS;
427	}
428
429	/**
430	Locates the PEI Core entry point address
431
432	@param[in] Fv The firmware volume to search
433	@param[out] PeiCoreEntryPoint The entry point of the PEI Core image
434
435	@retval EFI_SUCCESS The file and section was found
436	@retval EFI_NOT_FOUND The file and section was not found
437	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
438
439	**/
440	EFI_STATUS
441	FindPeiCoreImageBaseInFv (
442	IN EFI_FIRMWARE_VOLUME_HEADER *Fv,
443	OUT EFI_PHYSICAL_ADDRESS *PeiCoreImageBase
444	)
445	{
446	EFI_STATUS Status;
447	EFI_COMMON_SECTION_HEADER *Section;
448
449	Status = FindFfsFileAndSection (
450	Fv,
451	EFI_FV_FILETYPE_PEI_CORE,
452	EFI_SECTION_PE32,
453	&Section
454	);
455	if (EFI_ERROR (Status)) {
456	Status = FindFfsFileAndSection (
457	Fv,
458	EFI_FV_FILETYPE_PEI_CORE,
459	EFI_SECTION_TE,
460	&Section
461	);
462	if (EFI_ERROR (Status)) {
463	DEBUG ((EFI_D_ERROR, "Unable to find PEI Core image\n"));
464	return Status;
465	}
466	}
467
468	*PeiCoreImageBase = (EFI_PHYSICAL_ADDRESS)(UINTN)(Section + 1);
469	return EFI_SUCCESS;
470	}
471
472
473	/**
474	Reads 8-bits of CMOS data.
475
476	Reads the 8-bits of CMOS data at the location specified by Index.
477	The 8-bit read value is returned.
478
479	@param Index The CMOS location to read.
480
481	@return The value read.
482
483	**/
484	STATIC
485	UINT8
486	CmosRead8 (
487	IN UINTN Index
488	)
489	{
490	IoWrite8 (0x70, (UINT8) Index);
491	return IoRead8 (0x71);
492	}
493
494
495	STATIC
496	BOOLEAN
497	IsS3Resume (
498	VOID
499	)
500	{
501	return (CmosRead8 (0xF) == 0xFE);
502	}
503
504
505	STATIC
506	EFI_STATUS
507	GetS3ResumePeiFv (
508	IN OUT EFI_FIRMWARE_VOLUME_HEADER **PeiFv
509	)
510	{
511	PeiFv = (EFI_FIRMWARE_VOLUME_HEADER)(UINTN) PcdGet32 (PcdOvmfPeiMemFvBase);
512	return EFI_SUCCESS;
513	}
514
515
516	/**
517	Locates the PEI Core entry point address
518
519	@param[in,out] Fv The firmware volume to search
520	@param[out] PeiCoreEntryPoint The entry point of the PEI Core image
521
522	@retval EFI_SUCCESS The file and section was found
523	@retval EFI_NOT_FOUND The file and section was not found
524	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted
525
526	**/
527	VOID
528	FindPeiCoreImageBase (
529	IN OUT EFI_FIRMWARE_VOLUME_HEADER **BootFv,
530	OUT EFI_PHYSICAL_ADDRESS *PeiCoreImageBase
531	)
532	{
533	*PeiCoreImageBase = 0;
534
535	if (IsS3Resume ()) {
536	DEBUG ((EFI_D_VERBOSE, "SEC: S3 resume\n"));
537	GetS3ResumePeiFv (BootFv);
538	} else {
539	DEBUG ((EFI_D_VERBOSE, "SEC: Normal boot\n"));
540	FindMainFv (BootFv);
541
542	DecompressMemFvs (BootFv);
543	}
544
545	FindPeiCoreImageBaseInFv (*BootFv, PeiCoreImageBase);
546	}
547
548	/**
549	Find core image base.
550
551	**/
552	EFI_STATUS
553	FindImageBase (
554	IN EFI_FIRMWARE_VOLUME_HEADER *BootFirmwareVolumePtr,
555	OUT EFI_PHYSICAL_ADDRESS *SecCoreImageBase
556	)
557	{
558	EFI_PHYSICAL_ADDRESS CurrentAddress;
559	EFI_PHYSICAL_ADDRESS EndOfFirmwareVolume;
560	EFI_FFS_FILE_HEADER *File;
561	UINT32 Size;
562	EFI_PHYSICAL_ADDRESS EndOfFile;
563	EFI_COMMON_SECTION_HEADER *Section;
564	EFI_PHYSICAL_ADDRESS EndOfSection;
565
566	*SecCoreImageBase = 0;
567
568	CurrentAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) BootFirmwareVolumePtr;
569	EndOfFirmwareVolume = CurrentAddress + BootFirmwareVolumePtr->FvLength;
570
571	//
572	// Loop through the FFS files in the Boot Firmware Volume
573	//
574	for (EndOfFile = CurrentAddress + BootFirmwareVolumePtr->HeaderLength; ; ) {
575
576	CurrentAddress = (EndOfFile + 7) & 0xfffffffffffffff8ULL;
577	if (CurrentAddress > EndOfFirmwareVolume) {
578	return EFI_NOT_FOUND;
579	}
580
581	File = (EFI_FFS_FILE_HEADER*)(UINTN) CurrentAddress;
582	Size = (UINT32) File->Size & 0xffffff;
583	if (Size < sizeof (*File)) {
584	return EFI_NOT_FOUND;
585	}
586
587	EndOfFile = CurrentAddress + Size;
588	if (EndOfFile > EndOfFirmwareVolume) {
589	return EFI_NOT_FOUND;
590	}
591
592	//
593	// Look for SEC Core
594	//
595	if (File->Type != EFI_FV_FILETYPE_SECURITY_CORE) {
596	continue;
597	}
598
599	//
600	// Loop through the FFS file sections within the FFS file
601	//
602	EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) (File + 1);
603	for (;;) {
604	CurrentAddress = (EndOfSection + 3) & 0xfffffffffffffffcULL;
605	Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;
606
607	Size = (UINT32) Section->Size & 0xffffff;
608	if (Size < sizeof (*Section)) {
609	return EFI_NOT_FOUND;
610	}
611
612	EndOfSection = CurrentAddress + Size;
613	if (EndOfSection > EndOfFile) {
614	return EFI_NOT_FOUND;
615	}
616
617	//
618	// Look for executable sections
619	//
620	if (Section->Type == EFI_SECTION_PE32 \|\| Section->Type == EFI_SECTION_TE) {
621	if (File->Type == EFI_FV_FILETYPE_SECURITY_CORE) {
622	*SecCoreImageBase = (PHYSICAL_ADDRESS) (UINTN) (Section + 1);
623	}
624	break;
625	}
626	}
627
628	//
629	// SEC Core image found
630	//
631	if (*SecCoreImageBase != 0) {
632	return EFI_SUCCESS;
633	}
634	}
635	}
636
637	/*
638	Find and return Pei Core entry point.
639
640	It also find SEC and PEI Core file debug inforamtion. It will report them if
641	remote debug is enabled.
642
643	**/
644	VOID
645	FindAndReportEntryPoints (
646	IN EFI_FIRMWARE_VOLUME_HEADER **BootFirmwareVolumePtr,
647	OUT EFI_PEI_CORE_ENTRY_POINT *PeiCoreEntryPoint
648	)
649	{
650	EFI_STATUS Status;
651	EFI_PHYSICAL_ADDRESS SecCoreImageBase;
652	EFI_PHYSICAL_ADDRESS PeiCoreImageBase;
653	PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
654
655	//
656	// Find SEC Core and PEI Core image base
657	//
658	Status = FindImageBase (*BootFirmwareVolumePtr, &SecCoreImageBase);
659	ASSERT_EFI_ERROR (Status);
660
661	FindPeiCoreImageBase (BootFirmwareVolumePtr, &PeiCoreImageBase);
662
663	ZeroMem ((VOID *) &ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));
664	//
665	// Report SEC Core debug information when remote debug is enabled
666	//
667	ImageContext.ImageAddress = SecCoreImageBase;
668	ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);
669	PeCoffLoaderRelocateImageExtraAction (&ImageContext);
670
671	//
672	// Report PEI Core debug information when remote debug is enabled
673	//
674	ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)PeiCoreImageBase;
675	ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);
676	PeCoffLoaderRelocateImageExtraAction (&ImageContext);
677
678	//
679	// Find PEI Core entry point
680	//
681	Status = PeCoffLoaderGetEntryPoint ((VOID ) (UINTN) PeiCoreImageBase, (VOID*) PeiCoreEntryPoint);
682	if (EFI_ERROR (Status)) {
683	*PeiCoreEntryPoint = 0;
684	}
685
686	return;
687	}
688
689	VOID
690	EFIAPI
691	SecCoreStartupWithStack (
692	IN EFI_FIRMWARE_VOLUME_HEADER *BootFv,
693	IN VOID *TopOfCurrentStack
694	)
695	{
696	EFI_SEC_PEI_HAND_OFF SecCoreData;
697	SEC_IDT_TABLE IdtTableInStack;
698	IA32_DESCRIPTOR IdtDescriptor;
699	UINT32 Index;
700
701	ProcessLibraryConstructorList (NULL, NULL);
702
703	DEBUG ((EFI_D_INFO,
704	"SecCoreStartupWithStack(0x%x, 0x%x)\n",
705	(UINT32)(UINTN)BootFv,
706	(UINT32)(UINTN)TopOfCurrentStack
707	));
708
709	//
710	// Initialize floating point operating environment
711	// to be compliant with UEFI spec.
712	//
713	InitializeFloatingPointUnits ();
714
715	//
716	// Initialize IDT
717	//
718	IdtTableInStack.PeiService = NULL;
719	for (Index = 0; Index < SEC_IDT_ENTRY_COUNT; Index ++) {
720	CopyMem (&IdtTableInStack.IdtTable[Index], &mIdtEntryTemplate, sizeof (mIdtEntryTemplate));
721	}
722
723	IdtDescriptor.Base = (UINTN)&IdtTableInStack.IdtTable;
724	IdtDescriptor.Limit = (UINT16)(sizeof (IdtTableInStack.IdtTable) - 1);
725
726	AsmWriteIdtr (&IdtDescriptor);
727
728	#if defined (MDE_CPU_X64)
729	//
730	// ASSERT that the Page Tables were set by the reset vector code to
731	// the address we expect.
732	//
733	ASSERT (AsmReadCr3 () == (UINTN) PcdGet32 (PcdOvmfSecPageTablesBase));
734	#endif
735
736	//
737	// \|-------------\| <-- TopOfCurrentStack
738	// \| Stack \| 32k
739	// \|-------------\|
740	// \| Heap \| 32k
741	// \|-------------\| <-- SecCoreData.TemporaryRamBase
742	//
743
744	ASSERT ((UINTN) (PcdGet32 (PcdOvmfSecPeiTempRamBase) +
745	PcdGet32 (PcdOvmfSecPeiTempRamSize)) ==
746	(UINTN) TopOfCurrentStack);
747
748	//
749	// Initialize SEC hand-off state
750	//
751	SecCoreData.DataSize = sizeof(EFI_SEC_PEI_HAND_OFF);
752
753	SecCoreData.TemporaryRamSize = (UINTN) PcdGet32 (PcdOvmfSecPeiTempRamSize);
754	SecCoreData.TemporaryRamBase = (VOID)((UINT8 )TopOfCurrentStack - SecCoreData.TemporaryRamSize);
755
756	SecCoreData.PeiTemporaryRamBase = SecCoreData.TemporaryRamBase;
757	SecCoreData.PeiTemporaryRamSize = SecCoreData.TemporaryRamSize >> 1;
758
759	SecCoreData.StackBase = (UINT8 *)SecCoreData.TemporaryRamBase + SecCoreData.PeiTemporaryRamSize;
760	SecCoreData.StackSize = SecCoreData.TemporaryRamSize >> 1;
761
762	SecCoreData.BootFirmwareVolumeBase = BootFv;
763	SecCoreData.BootFirmwareVolumeSize = (UINTN) BootFv->FvLength;
764
765	//
766	// Make sure the 8259 is masked before initializing the Debug Agent and the debug timer is enabled
767	//
768	IoWrite8 (0x21, 0xff);
769	IoWrite8 (0xA1, 0xff);
770
771	//
772	// Initialize Debug Agent to support source level debug in SEC/PEI phases before memory ready.
773	//
774	InitializeDebugAgent (DEBUG_AGENT_INIT_PREMEM_SEC, &SecCoreData, SecStartupPhase2);
775	}
776
777	/**
778	Caller provided function to be invoked at the end of InitializeDebugAgent().
779
780	Entry point to the C language phase of SEC. After the SEC assembly
781	code has initialized some temporary memory and set up the stack,
782	the control is transferred to this function.
783
784	@param[in] Context The first input parameter of InitializeDebugAgent().
785
786	**/
787	VOID
788	EFIAPI
789	SecStartupPhase2(
790	IN VOID *Context
791	)
792	{
793	EFI_SEC_PEI_HAND_OFF *SecCoreData;
794	EFI_FIRMWARE_VOLUME_HEADER *BootFv;
795	EFI_PEI_CORE_ENTRY_POINT PeiCoreEntryPoint;
796
797	SecCoreData = (EFI_SEC_PEI_HAND_OFF *) Context;
798
799	//
800	// Find PEI Core entry point. It will report SEC and Pei Core debug information if remote debug
801	// is enabled.
802	//
803	BootFv = (EFI_FIRMWARE_VOLUME_HEADER *)SecCoreData->BootFirmwareVolumeBase;
804	FindAndReportEntryPoints (&BootFv, &PeiCoreEntryPoint);
805	SecCoreData->BootFirmwareVolumeBase = BootFv;
806	SecCoreData->BootFirmwareVolumeSize = (UINTN) BootFv->FvLength;
807
808	//
809	// Transfer the control to the PEI core
810	//
811	(PeiCoreEntryPoint) (SecCoreData, (EFI_PEI_PPI_DESCRIPTOR )&mPrivateDispatchTable);
812
813	//
814	// If we get here then the PEI Core returned, which is not recoverable.
815	//
816	ASSERT (FALSE);
817	CpuDeadLoop ();
818	}
819
820	EFI_STATUS
821	EFIAPI
822	TemporaryRamMigration (
823	IN CONST EFI_PEI_SERVICES **PeiServices,
824	IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase,
825	IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase,
826	IN UINTN CopySize
827	)
828	{
829	IA32_DESCRIPTOR IdtDescriptor;
830	VOID *OldHeap;
831	VOID *NewHeap;
832	VOID *OldStack;
833	VOID *NewStack;
834	DEBUG_AGENT_CONTEXT_POSTMEM_SEC DebugAgentContext;
835	BOOLEAN OldStatus;
836	BASE_LIBRARY_JUMP_BUFFER JumpBuffer;
837
838	DEBUG ((EFI_D_INFO,
839	"TemporaryRamMigration(0x%x, 0x%x, 0x%x)\n",
840	(UINTN) TemporaryMemoryBase,
841	(UINTN) PermanentMemoryBase,
842	CopySize
843	));
844
845	OldHeap = (VOID*)(UINTN)TemporaryMemoryBase;
846	NewHeap = (VOID*)((UINTN)PermanentMemoryBase + (CopySize >> 1));
847
848	OldStack = (VOID*)((UINTN)TemporaryMemoryBase + (CopySize >> 1));
849	NewStack = (VOID*)(UINTN)PermanentMemoryBase;
850
851	DebugAgentContext.HeapMigrateOffset = (UINTN)NewHeap - (UINTN)OldHeap;
852	DebugAgentContext.StackMigrateOffset = (UINTN)NewStack - (UINTN)OldStack;
853
854	OldStatus = SaveAndSetDebugTimerInterrupt (FALSE);
855	InitializeDebugAgent (DEBUG_AGENT_INIT_POSTMEM_SEC, (VOID *) &DebugAgentContext, NULL);
856
857	//
858	// Migrate Heap
859	//
860	CopyMem (NewHeap, OldHeap, CopySize >> 1);
861
862	//
863	// Migrate Stack
864	//
865	CopyMem (NewStack, OldStack, CopySize >> 1);
866
867	//
868	// Rebase IDT table in permanent memory
869	//
870	AsmReadIdtr (&IdtDescriptor);
871	IdtDescriptor.Base = IdtDescriptor.Base - (UINTN)OldStack + (UINTN)NewStack;
872
873	AsmWriteIdtr (&IdtDescriptor);
874
875	//
876	// Use SetJump()/LongJump() to switch to a new stack.
877	//
878	if (SetJump (&JumpBuffer) == 0) {
879	#if defined (MDE_CPU_IA32)
880	JumpBuffer.Esp = JumpBuffer.Esp + DebugAgentContext.StackMigrateOffset;
881	#endif
882	#if defined (MDE_CPU_X64)
883	JumpBuffer.Rsp = JumpBuffer.Rsp + DebugAgentContext.StackMigrateOffset;
884	#endif
885	LongJump (&JumpBuffer, (UINTN)-1);
886	}
887
888	SaveAndSetDebugTimerInterrupt (OldStatus);
889
890	return EFI_SUCCESS;
891	}
892

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/OvmfPkg/Sec/SecMain.c@ 78403

Download in other formats: