]> git.proxmox.com Git - mirror_edk2.git/blob - Nt32Pkg/Sec/SecMain.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Move SmmDebug feature from ASM to C.
[mirror_edk2.git] / Nt32Pkg / Sec / SecMain.c
1 /**@file
2
3 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
4 This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 SecMain.c
15
16 Abstract:
17 WinNt emulator of SEC phase. It's really a Win32 application, but this is
18 Ok since all the other modules for NT32 are NOT Win32 applications.
19
20 This program gets NT32 PCD setting and figures out what the memory layout
21 will be, how may FD's will be loaded and also what the boot mode is.
22
23 The SEC registers a set of services with the SEC core. gPrivateDispatchTable
24 is a list of PPI's produced by the SEC that are availble for usage in PEI.
25
26 This code produces 128 K of temporary memory for the PEI stack by directly
27 allocate memory space with ReadWrite and Execute attribute.
28
29 **/
30
31 #include "SecMain.h"
32
33 #ifndef SE_TIME_ZONE_NAME
34 #define SE_TIME_ZONE_NAME TEXT("SeTimeZonePrivilege")
35 #endif
36
37 NT_PEI_LOAD_FILE_PPI mSecNtLoadFilePpi = { SecWinNtPeiLoadFile };
38
39 PEI_NT_AUTOSCAN_PPI mSecNtAutoScanPpi = { SecWinNtPeiAutoScan };
40
41 PEI_NT_THUNK_PPI mSecWinNtThunkPpi = { SecWinNtWinNtThunkAddress };
42
43 EFI_PEI_PROGRESS_CODE_PPI mSecStatusCodePpi = { SecPeiReportStatusCode };
44
45 NT_FWH_PPI mSecFwhInformationPpi = { SecWinNtFdAddress };
46
47 EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mSecTemporaryRamSupportPpi = {SecTemporaryRamSupport};
48
49 EFI_PEI_PPI_DESCRIPTOR gPrivateDispatchTable[] = {
50 {
51 EFI_PEI_PPI_DESCRIPTOR_PPI,
52 &gNtPeiLoadFilePpiGuid,
53 &mSecNtLoadFilePpi
54 },
55 {
56 EFI_PEI_PPI_DESCRIPTOR_PPI,
57 &gPeiNtAutoScanPpiGuid,
58 &mSecNtAutoScanPpi
59 },
60 {
61 EFI_PEI_PPI_DESCRIPTOR_PPI,
62 &gPeiNtThunkPpiGuid,
63 &mSecWinNtThunkPpi
64 },
65 {
66 EFI_PEI_PPI_DESCRIPTOR_PPI,
67 &gEfiPeiStatusCodePpiGuid,
68 &mSecStatusCodePpi
69 },
70 {
71 EFI_PEI_PPI_DESCRIPTOR_PPI,
72 &gEfiTemporaryRamSupportPpiGuid,
73 &mSecTemporaryRamSupportPpi
74 },
75 {
76 EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
77 &gNtFwhPpiGuid,
78 &mSecFwhInformationPpi
79 }
80 };
81
82
83 //
84 // Default information about where the FD is located.
85 // This array gets filled in with information from PcdWinNtFirmwareVolume
86 // The number of array elements is allocated base on parsing
87 // PcdWinNtFirmwareVolume and the memory is never freed.
88 //
89 UINTN gFdInfoCount = 0;
90 NT_FD_INFO *gFdInfo;
91
92 //
93 // Array that supports seperate memory rantes.
94 // The memory ranges are set by PcdWinNtMemorySizeForSecMain.
95 // The number of array elements is allocated base on parsing
96 // PcdWinNtMemorySizeForSecMain value and the memory is never freed.
97 //
98 UINTN gSystemMemoryCount = 0;
99 NT_SYSTEM_MEMORY *gSystemMemory;
100
101 VOID
102 EFIAPI
103 SecSwitchStack (
104 UINT32 TemporaryMemoryBase,
105 UINT32 PermenentMemoryBase
106 );
107 EFI_STATUS
108 SecNt32PeCoffRelocateImage (
109 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
110 );
111
112 VOID
113 EFIAPI
114 PeiSwitchStacks (
115 IN SWITCH_STACK_ENTRY_POINT EntryPoint,
116 IN VOID *Context1, OPTIONAL
117 IN VOID *Context2, OPTIONAL
118 IN VOID *Context3, OPTIONAL
119 IN VOID *NewStack
120 );
121
122 VOID
123 SecPrint (
124 CHAR8 *Format,
125 ...
126 )
127 {
128 va_list Marker;
129 UINTN CharCount;
130 CHAR8 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE];
131
132 va_start (Marker, Format);
133
134 _vsnprintf (Buffer, sizeof (Buffer), Format, Marker);
135
136 va_end (Marker);
137
138 CharCount = strlen (Buffer);
139 WriteFile (
140 GetStdHandle (STD_OUTPUT_HANDLE),
141 Buffer,
142 (DWORD)CharCount,
143 (LPDWORD)&CharCount,
144 NULL
145 );
146 }
147
148 INTN
149 EFIAPI
150 main (
151 IN INTN Argc,
152 IN CHAR8 **Argv,
153 IN CHAR8 **Envp
154 )
155 /*++
156
157 Routine Description:
158 Main entry point to SEC for WinNt. This is a Windows program
159
160 Arguments:
161 Argc - Number of command line arguments
162 Argv - Array of command line argument strings
163 Envp - Array of environmemt variable strings
164
165 Returns:
166 0 - Normal exit
167 1 - Abnormal exit
168
169 --*/
170 {
171 EFI_STATUS Status;
172 HANDLE Token;
173 TOKEN_PRIVILEGES TokenPrivileges;
174 EFI_PHYSICAL_ADDRESS InitialStackMemory;
175 UINT64 InitialStackMemorySize;
176 UINTN Index;
177 UINTN Index1;
178 UINTN Index2;
179 CHAR16 *FileName;
180 CHAR16 *FileNamePtr;
181 BOOLEAN Done;
182 VOID *PeiCoreFile;
183 CHAR16 *MemorySizeStr;
184 CHAR16 *FirmwareVolumesStr;
185 UINTN *StackPointer;
186 UINT32 ProcessAffinityMask;
187 UINT32 SystemAffinityMask;
188 INT32 LowBit;
189
190
191 //
192 // Enable the privilege so that RTC driver can successfully run SetTime()
193 //
194 OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &Token);
195 if (LookupPrivilegeValue(NULL, SE_TIME_ZONE_NAME, &TokenPrivileges.Privileges[0].Luid)) {
196 TokenPrivileges.PrivilegeCount = 1;
197 TokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
198 AdjustTokenPrivileges(Token, FALSE, &TokenPrivileges, 0, (PTOKEN_PRIVILEGES) NULL, 0);
199 }
200
201 MemorySizeStr = (CHAR16 *) PcdGetPtr (PcdWinNtMemorySizeForSecMain);
202 FirmwareVolumesStr = (CHAR16 *) PcdGetPtr (PcdWinNtFirmwareVolume);
203
204 SecPrint ("\nEDK II SEC Main NT Emulation Environment from www.TianoCore.org\n");
205
206 //
207 // Determine the first thread available to this process.
208 //
209 if (GetProcessAffinityMask (GetCurrentProcess (), &ProcessAffinityMask, &SystemAffinityMask)) {
210 LowBit = (INT32)LowBitSet32 (ProcessAffinityMask);
211 if (LowBit != -1) {
212 //
213 // Force the system to bind the process to a single thread to work
214 // around odd semaphore type crashes.
215 //
216 SetProcessAffinityMask (GetCurrentProcess (), (INTN)(BIT0 << LowBit));
217 }
218 }
219
220 //
221 // Make some Windows calls to Set the process to the highest priority in the
222 // idle class. We need this to have good performance.
223 //
224 SetPriorityClass (GetCurrentProcess (), IDLE_PRIORITY_CLASS);
225 SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_HIGHEST);
226
227 //
228 // Allocate space for gSystemMemory Array
229 //
230 gSystemMemoryCount = CountSeperatorsInString (MemorySizeStr, '!') + 1;
231 gSystemMemory = calloc (gSystemMemoryCount, sizeof (NT_SYSTEM_MEMORY));
232 if (gSystemMemory == NULL) {
233 SecPrint ("ERROR : Can not allocate memory for %S. Exiting.\n", MemorySizeStr);
234 exit (1);
235 }
236 //
237 // Allocate space for gSystemMemory Array
238 //
239 gFdInfoCount = CountSeperatorsInString (FirmwareVolumesStr, '!') + 1;
240 gFdInfo = calloc (gFdInfoCount, sizeof (NT_FD_INFO));
241 if (gFdInfo == NULL) {
242 SecPrint ("ERROR : Can not allocate memory for %S. Exiting.\n", FirmwareVolumesStr);
243 exit (1);
244 }
245 //
246 // Setup Boot Mode. If BootModeStr == "" then BootMode = 0 (BOOT_WITH_FULL_CONFIGURATION)
247 //
248 SecPrint (" BootMode 0x%02x\n", PcdGet32 (PcdWinNtBootMode));
249
250 //
251 // Allocate 128K memory to emulate temp memory for PEI.
252 // on a real platform this would be SRAM, or using the cache as RAM.
253 // Set InitialStackMemory to zero so WinNtOpenFile will allocate a new mapping
254 //
255 InitialStackMemorySize = STACK_SIZE;
256 InitialStackMemory = (EFI_PHYSICAL_ADDRESS) (UINTN) VirtualAlloc (NULL, (SIZE_T) (InitialStackMemorySize), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
257 if (InitialStackMemory == 0) {
258 SecPrint ("ERROR : Can not allocate enough space for SecStack\n");
259 exit (1);
260 }
261
262 for (StackPointer = (UINTN*) (UINTN) InitialStackMemory;
263 StackPointer < (UINTN*) ((UINTN)InitialStackMemory + (SIZE_T) InitialStackMemorySize);
264 StackPointer ++) {
265 *StackPointer = 0x5AA55AA5;
266 }
267
268 SecPrint (" SEC passing in %d bytes of temp RAM to PEI\n", InitialStackMemorySize);
269
270 //
271 // Open All the firmware volumes and remember the info in the gFdInfo global
272 //
273 FileNamePtr = (CHAR16 *)malloc (StrLen ((CHAR16 *)FirmwareVolumesStr) * sizeof(CHAR16));
274 if (FileNamePtr == NULL) {
275 SecPrint ("ERROR : Can not allocate memory for firmware volume string\n");
276 exit (1);
277 }
278
279 StrCpy (FileNamePtr, (CHAR16*)FirmwareVolumesStr);
280
281 for (Done = FALSE, Index = 0, PeiCoreFile = NULL; !Done; Index++) {
282 FileName = FileNamePtr;
283 for (Index1 = 0; (FileNamePtr[Index1] != '!') && (FileNamePtr[Index1] != 0); Index1++)
284 ;
285 if (FileNamePtr[Index1] == 0) {
286 Done = TRUE;
287 } else {
288 FileNamePtr[Index1] = '\0';
289 FileNamePtr = FileNamePtr + Index1 + 1;
290 }
291
292 //
293 // Open the FD and remmeber where it got mapped into our processes address space
294 //
295 Status = WinNtOpenFile (
296 FileName,
297 0,
298 OPEN_EXISTING,
299 &gFdInfo[Index].Address,
300 &gFdInfo[Index].Size
301 );
302 if (EFI_ERROR (Status)) {
303 SecPrint ("ERROR : Can not open Firmware Device File %S (0x%X). Exiting.\n", FileName, Status);
304 exit (1);
305 }
306
307 SecPrint (" FD loaded from");
308 //
309 // printf can't print filenames directly as the \ gets interperted as an
310 // escape character.
311 //
312 for (Index2 = 0; FileName[Index2] != '\0'; Index2++) {
313 SecPrint ("%c", FileName[Index2]);
314 }
315
316 if (PeiCoreFile == NULL) {
317 //
318 // Assume the beginning of the FD is an FV and look for the PEI Core.
319 // Load the first one we find.
320 //
321 Status = SecFfsFindPeiCore ((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) gFdInfo[Index].Address, &PeiCoreFile);
322 if (!EFI_ERROR (Status)) {
323 SecPrint (" contains SEC Core");
324 }
325 }
326
327 SecPrint ("\n");
328 }
329 //
330 // Calculate memory regions and store the information in the gSystemMemory
331 // global for later use. The autosizing code will use this data to
332 // map this memory into the SEC process memory space.
333 //
334 for (Index = 0, Done = FALSE; !Done; Index++) {
335 //
336 // Save the size of the memory and make a Unicode filename SystemMemory00, ...
337 //
338 gSystemMemory[Index].Size = _wtoi (MemorySizeStr) * 0x100000;
339
340 //
341 // Find the next region
342 //
343 for (Index1 = 0; MemorySizeStr[Index1] != '!' && MemorySizeStr[Index1] != 0; Index1++)
344 ;
345 if (MemorySizeStr[Index1] == 0) {
346 Done = TRUE;
347 }
348
349 MemorySizeStr = MemorySizeStr + Index1 + 1;
350 }
351
352 SecPrint ("\n");
353
354 //
355 // Hand off to PEI Core
356 //
357 SecLoadFromCore ((UINTN) InitialStackMemory, (UINTN) InitialStackMemorySize, (UINTN) gFdInfo[0].Address, PeiCoreFile);
358
359 //
360 // If we get here, then the PEI Core returned. This is an error as PEI should
361 // always hand off to DXE.
362 //
363 SecPrint ("ERROR : PEI Core returned\n");
364 exit (1);
365 }
366
367 EFI_STATUS
368 WinNtOpenFile (
369 IN CHAR16 *FileName,
370 IN UINT32 MapSize,
371 IN DWORD CreationDisposition,
372 IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress,
373 OUT UINT64 *Length
374 )
375 /*++
376
377 Routine Description:
378 Opens and memory maps a file using WinNt services. If BaseAddress is non zero
379 the process will try and allocate the memory starting at BaseAddress.
380
381 Arguments:
382 FileName - The name of the file to open and map
383 MapSize - The amount of the file to map in bytes
384 CreationDisposition - The flags to pass to CreateFile(). Use to create new files for
385 memory emulation, and exiting files for firmware volume emulation
386 BaseAddress - The base address of the mapped file in the user address space.
387 If passed in as NULL the a new memory region is used.
388 If passed in as non NULL the request memory region is used for
389 the mapping of the file into the process space.
390 Length - The size of the mapped region in bytes
391
392 Returns:
393 EFI_SUCCESS - The file was opened and mapped.
394 EFI_NOT_FOUND - FileName was not found in the current directory
395 EFI_DEVICE_ERROR - An error occured attempting to map the opened file
396
397 --*/
398 {
399 HANDLE NtFileHandle;
400 HANDLE NtMapHandle;
401 VOID *VirtualAddress;
402 UINTN FileSize;
403
404 //
405 // Use Win API to open/create a file
406 //
407 NtFileHandle = CreateFile (
408 FileName,
409 GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE,
410 FILE_SHARE_READ,
411 NULL,
412 CreationDisposition,
413 FILE_ATTRIBUTE_NORMAL,
414 NULL
415 );
416 if (NtFileHandle == INVALID_HANDLE_VALUE) {
417 return EFI_NOT_FOUND;
418 }
419 //
420 // Map the open file into a memory range
421 //
422 NtMapHandle = CreateFileMapping (
423 NtFileHandle,
424 NULL,
425 PAGE_EXECUTE_READWRITE,
426 0,
427 MapSize,
428 NULL
429 );
430 if (NtMapHandle == NULL) {
431 return EFI_DEVICE_ERROR;
432 }
433 //
434 // Get the virtual address (address in the emulator) of the mapped file
435 //
436 VirtualAddress = MapViewOfFileEx (
437 NtMapHandle,
438 FILE_MAP_EXECUTE | FILE_MAP_ALL_ACCESS,
439 0,
440 0,
441 MapSize,
442 (LPVOID) (UINTN) *BaseAddress
443 );
444 if (VirtualAddress == NULL) {
445 return EFI_DEVICE_ERROR;
446 }
447
448 if (MapSize == 0) {
449 //
450 // Seek to the end of the file to figure out the true file size.
451 //
452 FileSize = SetFilePointer (
453 NtFileHandle,
454 0,
455 NULL,
456 FILE_END
457 );
458 if (FileSize == -1) {
459 return EFI_DEVICE_ERROR;
460 }
461
462 *Length = (UINT64) FileSize;
463 } else {
464 *Length = (UINT64) MapSize;
465 }
466
467 *BaseAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) VirtualAddress;
468
469 return EFI_SUCCESS;
470 }
471
472
473 #define BYTES_PER_RECORD 512
474
475 EFI_STATUS
476 EFIAPI
477 SecPeiReportStatusCode (
478 IN CONST EFI_PEI_SERVICES **PeiServices,
479 IN EFI_STATUS_CODE_TYPE CodeType,
480 IN EFI_STATUS_CODE_VALUE Value,
481 IN UINT32 Instance,
482 IN CONST EFI_GUID *CallerId,
483 IN CONST EFI_STATUS_CODE_DATA *Data OPTIONAL
484 )
485 /*++
486
487 Routine Description:
488
489 This routine produces the ReportStatusCode PEI service. It's passed
490 up to the PEI Core via a PPI. T
491
492 This code currently uses the NT clib printf. This does not work the same way
493 as the EFI Print (), as %t, %g, %s as Unicode are not supported.
494
495 Arguments:
496 (see EFI_PEI_REPORT_STATUS_CODE)
497
498 Returns:
499 EFI_SUCCESS - Always return success
500
501 --*/
502 // TODO: PeiServices - add argument and description to function comment
503 // TODO: CodeType - add argument and description to function comment
504 // TODO: Value - add argument and description to function comment
505 // TODO: Instance - add argument and description to function comment
506 // TODO: CallerId - add argument and description to function comment
507 // TODO: Data - add argument and description to function comment
508 {
509 CHAR8 *Format;
510 BASE_LIST Marker;
511 CHAR8 PrintBuffer[BYTES_PER_RECORD * 2];
512 CHAR8 *Filename;
513 CHAR8 *Description;
514 UINT32 LineNumber;
515 UINT32 ErrorLevel;
516
517
518 if (Data == NULL) {
519 } else if (ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) {
520 //
521 // Processes ASSERT ()
522 //
523 SecPrint ("ASSERT %s(%d): %s\n", Filename, (int)LineNumber, Description);
524
525 } else if (ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) {
526 //
527 // Process DEBUG () macro
528 //
529 AsciiBSPrint (PrintBuffer, BYTES_PER_RECORD, Format, Marker);
530 SecPrint (PrintBuffer);
531 }
532
533 return EFI_SUCCESS;
534 }
535
536 #if defined (MDE_CPU_IA32)
537 /**
538 Transfers control to a function starting with a new stack.
539
540 Transfers control to the function specified by EntryPoint using the new stack
541 specified by NewStack and passing in the parameters specified by Context1 and
542 Context2. Context1 and Context2 are optional and may be NULL. The function
543 EntryPoint must never return.
544
545 If EntryPoint is NULL, then ASSERT().
546 If NewStack is NULL, then ASSERT().
547
548 @param EntryPoint A pointer to function to call with the new stack.
549 @param Context1 A pointer to the context to pass into the EntryPoint
550 function.
551 @param Context2 A pointer to the context to pass into the EntryPoint
552 function.
553 @param NewStack A pointer to the new stack to use for the EntryPoint
554 function.
555 @param NewBsp A pointer to the new BSP for the EntryPoint on IPF. It's
556 Reserved on other architectures.
557
558 **/
559 VOID
560 EFIAPI
561 PeiSwitchStacks (
562 IN SWITCH_STACK_ENTRY_POINT EntryPoint,
563 IN VOID *Context1, OPTIONAL
564 IN VOID *Context2, OPTIONAL
565 IN VOID *Context3, OPTIONAL
566 IN VOID *NewStack
567 )
568 {
569 BASE_LIBRARY_JUMP_BUFFER JumpBuffer;
570
571 ASSERT (EntryPoint != NULL);
572 ASSERT (NewStack != NULL);
573
574 //
575 // Stack should be aligned with CPU_STACK_ALIGNMENT
576 //
577 ASSERT (((UINTN)NewStack & (CPU_STACK_ALIGNMENT - 1)) == 0);
578
579 JumpBuffer.Eip = (UINTN)EntryPoint;
580 JumpBuffer.Esp = (UINTN)NewStack - sizeof (VOID*);
581 JumpBuffer.Esp -= sizeof (Context1) + sizeof (Context2) + sizeof(Context3);
582 ((VOID**)JumpBuffer.Esp)[1] = Context1;
583 ((VOID**)JumpBuffer.Esp)[2] = Context2;
584 ((VOID**)JumpBuffer.Esp)[3] = Context3;
585
586 LongJump (&JumpBuffer, (UINTN)-1);
587
588
589 //
590 // InternalSwitchStack () will never return
591 //
592 ASSERT (FALSE);
593 }
594 #endif
595
596 VOID
597 SecLoadFromCore (
598 IN UINTN LargestRegion,
599 IN UINTN LargestRegionSize,
600 IN UINTN BootFirmwareVolumeBase,
601 IN VOID *PeiCorePe32File
602 )
603 /*++
604
605 Routine Description:
606 This is the service to load the PEI Core from the Firmware Volume
607
608 Arguments:
609 LargestRegion - Memory to use for PEI.
610 LargestRegionSize - Size of Memory to use for PEI
611 BootFirmwareVolumeBase - Start of the Boot FV
612 PeiCorePe32File - PEI Core PE32
613
614 Returns:
615 Success means control is transfered and thus we should never return
616
617 --*/
618 {
619 EFI_STATUS Status;
620 VOID *TopOfStack;
621 UINT64 PeiCoreSize;
622 EFI_PHYSICAL_ADDRESS PeiCoreEntryPoint;
623 EFI_PHYSICAL_ADDRESS PeiImageAddress;
624 EFI_SEC_PEI_HAND_OFF *SecCoreData;
625 UINTN PeiStackSize;
626
627 //
628 // Compute Top Of Memory for Stack and PEI Core Allocations
629 //
630 PeiStackSize = (UINTN)RShiftU64((UINT64)STACK_SIZE,1);
631
632 //
633 // |-----------| <---- TemporaryRamBase + TemporaryRamSize
634 // | Heap |
635 // | |
636 // |-----------| <---- StackBase / PeiTemporaryMemoryBase
637 // | |
638 // | Stack |
639 // |-----------| <---- TemporaryRamBase
640 //
641 TopOfStack = (VOID *)(LargestRegion + PeiStackSize);
642
643 //
644 // Reservet space for storing PeiCore's parament in stack.
645 //
646 TopOfStack = (VOID *)((UINTN)TopOfStack - sizeof (EFI_SEC_PEI_HAND_OFF) - CPU_STACK_ALIGNMENT);
647 TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
648
649 //
650 // Bind this information into the SEC hand-off state
651 //
652 SecCoreData = (EFI_SEC_PEI_HAND_OFF*)(UINTN) TopOfStack;
653 SecCoreData->DataSize = sizeof(EFI_SEC_PEI_HAND_OFF);
654 SecCoreData->BootFirmwareVolumeBase = (VOID*)BootFirmwareVolumeBase;
655 SecCoreData->BootFirmwareVolumeSize = PcdGet32(PcdWinNtFirmwareFdSize);
656 SecCoreData->TemporaryRamBase = (VOID*)(UINTN)LargestRegion;
657 SecCoreData->TemporaryRamSize = STACK_SIZE;
658 SecCoreData->StackBase = SecCoreData->TemporaryRamBase;
659 SecCoreData->StackSize = PeiStackSize;
660 SecCoreData->PeiTemporaryRamBase = (VOID*) ((UINTN) SecCoreData->TemporaryRamBase + PeiStackSize);
661 SecCoreData->PeiTemporaryRamSize = STACK_SIZE - PeiStackSize;
662
663 //
664 // Load the PEI Core from a Firmware Volume
665 //
666 Status = SecWinNtPeiLoadFile (
667 PeiCorePe32File,
668 &PeiImageAddress,
669 &PeiCoreSize,
670 &PeiCoreEntryPoint
671 );
672 if (EFI_ERROR (Status)) {
673 return ;
674 }
675
676 //
677 // Transfer control to the PEI Core
678 //
679 PeiSwitchStacks (
680 (SWITCH_STACK_ENTRY_POINT) (UINTN) PeiCoreEntryPoint,
681 SecCoreData,
682 (VOID *) (UINTN) ((EFI_PEI_PPI_DESCRIPTOR *) &gPrivateDispatchTable),
683 NULL,
684 TopOfStack
685 );
686 //
687 // If we get here, then the PEI Core returned. This is an error
688 //
689 return ;
690 }
691
692 EFI_STATUS
693 EFIAPI
694 SecWinNtPeiAutoScan (
695 IN UINTN Index,
696 OUT EFI_PHYSICAL_ADDRESS *MemoryBase,
697 OUT UINT64 *MemorySize
698 )
699 /*++
700
701 Routine Description:
702 This service is called from Index == 0 until it returns EFI_UNSUPPORTED.
703 It allows discontiguous memory regions to be supported by the emulator.
704 It uses gSystemMemory[] and gSystemMemoryCount that were created by
705 parsing PcdWinNtMemorySizeForSecMain value.
706 The size comes from the Pcd value and the address comes from the memory space
707 with ReadWrite and Execute attributes allocated by VirtualAlloc() API.
708
709 Arguments:
710 Index - Which memory region to use
711 MemoryBase - Return Base address of memory region
712 MemorySize - Return size in bytes of the memory region
713
714 Returns:
715 EFI_SUCCESS - If memory region was mapped
716 EFI_UNSUPPORTED - If Index is not supported
717
718 --*/
719 {
720 if (Index >= gSystemMemoryCount) {
721 return EFI_UNSUPPORTED;
722 }
723
724 //
725 // Allocate enough memory space for emulator
726 //
727 gSystemMemory[Index].Memory = (EFI_PHYSICAL_ADDRESS) (UINTN) VirtualAlloc (NULL, (SIZE_T) (gSystemMemory[Index].Size), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
728 if (gSystemMemory[Index].Memory == 0) {
729 return EFI_OUT_OF_RESOURCES;
730 }
731
732 *MemoryBase = gSystemMemory[Index].Memory;
733 *MemorySize = gSystemMemory[Index].Size;
734
735 return EFI_SUCCESS;
736 }
737
738 VOID *
739 EFIAPI
740 SecWinNtWinNtThunkAddress (
741 VOID
742 )
743 /*++
744
745 Routine Description:
746 Since the SEC is the only Windows program in stack it must export
747 an interface to do Win API calls. That's what the WinNtThunk address
748 is for. gWinNt is initailized in WinNtThunk.c.
749
750 Arguments:
751 InterfaceSize - sizeof (EFI_WIN_NT_THUNK_PROTOCOL);
752 InterfaceBase - Address of the gWinNt global
753
754 Returns:
755 EFI_SUCCESS - Data returned
756
757 --*/
758 {
759 return gWinNt;
760 }
761
762
763 EFI_STATUS
764 EFIAPI
765 SecWinNtPeiLoadFile (
766 IN VOID *Pe32Data,
767 IN EFI_PHYSICAL_ADDRESS *ImageAddress,
768 IN UINT64 *ImageSize,
769 IN EFI_PHYSICAL_ADDRESS *EntryPoint
770 )
771 /*++
772
773 Routine Description:
774 Loads and relocates a PE/COFF image into memory.
775
776 Arguments:
777 Pe32Data - The base address of the PE/COFF file that is to be loaded and relocated
778 ImageAddress - The base address of the relocated PE/COFF image
779 ImageSize - The size of the relocated PE/COFF image
780 EntryPoint - The entry point of the relocated PE/COFF image
781
782 Returns:
783 EFI_SUCCESS - The file was loaded and relocated
784 EFI_OUT_OF_RESOURCES - There was not enough memory to load and relocate the PE/COFF file
785
786 --*/
787 {
788 EFI_STATUS Status;
789 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
790
791 ZeroMem (&ImageContext, sizeof (ImageContext));
792 ImageContext.Handle = Pe32Data;
793
794 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) SecImageRead;
795
796 Status = PeCoffLoaderGetImageInfo (&ImageContext);
797 if (EFI_ERROR (Status)) {
798 return Status;
799 }
800 //
801 // Allocate space in NT (not emulator) memory with ReadWrite and Execute attribue.
802 // Extra space is for alignment
803 //
804 ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) VirtualAlloc (NULL, (SIZE_T) (ImageContext.ImageSize + (ImageContext.SectionAlignment * 2)), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
805 if (ImageContext.ImageAddress == 0) {
806 return EFI_OUT_OF_RESOURCES;
807 }
808 //
809 // Align buffer on section boundry
810 //
811 ImageContext.ImageAddress += ImageContext.SectionAlignment - 1;
812 ImageContext.ImageAddress &= ~(ImageContext.SectionAlignment - 1);
813
814 Status = PeCoffLoaderLoadImage (&ImageContext);
815 if (EFI_ERROR (Status)) {
816 return Status;
817 }
818
819 Status = SecNt32PeCoffRelocateImage (&ImageContext);
820 if (EFI_ERROR (Status)) {
821 return Status;
822 }
823
824 //
825 // BugBug: Flush Instruction Cache Here when CPU Lib is ready
826 //
827
828 *ImageAddress = ImageContext.ImageAddress;
829 *ImageSize = ImageContext.ImageSize;
830 *EntryPoint = ImageContext.EntryPoint;
831
832 return EFI_SUCCESS;
833 }
834
835 EFI_STATUS
836 EFIAPI
837 SecWinNtFdAddress (
838 IN UINTN Index,
839 IN OUT EFI_PHYSICAL_ADDRESS *FdBase,
840 IN OUT UINT64 *FdSize
841 )
842 /*++
843
844 Routine Description:
845 Return the FD Size and base address. Since the FD is loaded from a
846 file into Windows memory only the SEC will know it's address.
847
848 Arguments:
849 Index - Which FD, starts at zero.
850 FdSize - Size of the FD in bytes
851 FdBase - Start address of the FD. Assume it points to an FV Header
852
853 Returns:
854 EFI_SUCCESS - Return the Base address and size of the FV
855 EFI_UNSUPPORTED - Index does nto map to an FD in the system
856
857 --*/
858 {
859 if (Index >= gFdInfoCount) {
860 return EFI_UNSUPPORTED;
861 }
862
863 *FdBase = gFdInfo[Index].Address;
864 *FdSize = gFdInfo[Index].Size;
865
866 if (*FdBase == 0 && *FdSize == 0) {
867 return EFI_UNSUPPORTED;
868 }
869
870 return EFI_SUCCESS;
871 }
872
873 EFI_STATUS
874 EFIAPI
875 SecImageRead (
876 IN VOID *FileHandle,
877 IN UINTN FileOffset,
878 IN OUT UINTN *ReadSize,
879 OUT VOID *Buffer
880 )
881 /*++
882
883 Routine Description:
884 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
885
886 Arguments:
887 FileHandle - The handle to the PE/COFF file
888 FileOffset - The offset, in bytes, into the file to read
889 ReadSize - The number of bytes to read from the file starting at FileOffset
890 Buffer - A pointer to the buffer to read the data into.
891
892 Returns:
893 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
894
895 --*/
896 {
897 CHAR8 *Destination8;
898 CHAR8 *Source8;
899 UINTN Length;
900
901 Destination8 = Buffer;
902 Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
903 Length = *ReadSize;
904 while (Length--) {
905 *(Destination8++) = *(Source8++);
906 }
907
908 return EFI_SUCCESS;
909 }
910
911 CHAR16 *
912 AsciiToUnicode (
913 IN CHAR8 *Ascii,
914 IN UINTN *StrLen OPTIONAL
915 )
916 /*++
917
918 Routine Description:
919 Convert the passed in Ascii string to Unicode.
920 Optionally return the length of the strings.
921
922 Arguments:
923 Ascii - Ascii string to convert
924 StrLen - Length of string
925
926 Returns:
927 Pointer to malloc'ed Unicode version of Ascii
928
929 --*/
930 {
931 UINTN Index;
932 CHAR16 *Unicode;
933
934 //
935 // Allocate a buffer for unicode string
936 //
937 for (Index = 0; Ascii[Index] != '\0'; Index++)
938 ;
939 Unicode = malloc ((Index + 1) * sizeof (CHAR16));
940 if (Unicode == NULL) {
941 return NULL;
942 }
943
944 for (Index = 0; Ascii[Index] != '\0'; Index++) {
945 Unicode[Index] = (CHAR16) Ascii[Index];
946 }
947
948 Unicode[Index] = '\0';
949
950 if (StrLen != NULL) {
951 *StrLen = Index;
952 }
953
954 return Unicode;
955 }
956
957 UINTN
958 CountSeperatorsInString (
959 IN CONST CHAR16 *String,
960 IN CHAR16 Seperator
961 )
962 /*++
963
964 Routine Description:
965 Count the number of seperators in String
966
967 Arguments:
968 String - String to process
969 Seperator - Item to count
970
971 Returns:
972 Number of Seperator in String
973
974 --*/
975 {
976 UINTN Count;
977
978 for (Count = 0; *String != '\0'; String++) {
979 if (*String == Seperator) {
980 Count++;
981 }
982 }
983
984 return Count;
985 }
986
987
988 EFI_STATUS
989 SecNt32PeCoffRelocateImage (
990 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
991 )
992 {
993 EFI_STATUS Status;
994 VOID *DllEntryPoint;
995 CHAR16 *DllFileName;
996 HMODULE Library;
997 UINTN Index;
998
999
1000 Status = PeCoffLoaderRelocateImage (ImageContext);
1001 if (EFI_ERROR (Status)) {
1002 //
1003 // We could not relocated the image in memory properly
1004 //
1005 return Status;
1006 }
1007
1008 //
1009 // If we load our own PE COFF images the Windows debugger can not source
1010 // level debug our code. If a valid PDB pointer exists usw it to load
1011 // the *.dll file as a library using Windows* APIs. This allows
1012 // source level debug. The image is still loaded and reloaced
1013 // in the Framework memory space like on a real system (by the code above),
1014 // but the entry point points into the DLL loaded by the code bellow.
1015 //
1016
1017 DllEntryPoint = NULL;
1018
1019 //
1020 // Load the DLL if it's not an EBC image.
1021 //
1022 if ((ImageContext->PdbPointer != NULL) &&
1023 (ImageContext->Machine != EFI_IMAGE_MACHINE_EBC)) {
1024 //
1025 // Convert filename from ASCII to Unicode
1026 //
1027 DllFileName = AsciiToUnicode (ImageContext->PdbPointer, &Index);
1028
1029 //
1030 // Check that we have a valid filename
1031 //
1032 if (Index < 5 || DllFileName[Index - 4] != '.') {
1033 free (DllFileName);
1034
1035 //
1036 // Never return an error if PeCoffLoaderRelocateImage() succeeded.
1037 // The image will run, but we just can't source level debug. If we
1038 // return an error the image will not run.
1039 //
1040 return EFI_SUCCESS;
1041 }
1042 //
1043 // Replace .PDB with .DLL on the filename
1044 //
1045 DllFileName[Index - 3] = 'D';
1046 DllFileName[Index - 2] = 'L';
1047 DllFileName[Index - 1] = 'L';
1048
1049 //
1050 // Load the .DLL file into the user process's address space for source
1051 // level debug
1052 //
1053 Library = LoadLibraryEx (DllFileName, NULL, DONT_RESOLVE_DLL_REFERENCES);
1054 if (Library != NULL) {
1055 //
1056 // InitializeDriver is the entry point we put in all our EFI DLL's. The
1057 // DONT_RESOLVE_DLL_REFERENCES argument to LoadLIbraryEx() supresses the
1058 // normal DLL entry point of DllMain, and prevents other modules that are
1059 // referenced in side the DllFileName from being loaded. There is no error
1060 // checking as the we can point to the PE32 image loaded by Tiano. This
1061 // step is only needed for source level debuging
1062 //
1063 DllEntryPoint = (VOID *) (UINTN) GetProcAddress (Library, "InitializeDriver");
1064
1065 }
1066
1067 if ((Library != NULL) && (DllEntryPoint != NULL)) {
1068 ImageContext->EntryPoint = (EFI_PHYSICAL_ADDRESS) (UINTN) DllEntryPoint;
1069 SecPrint ("LoadLibraryEx (%S,\n NULL, DONT_RESOLVE_DLL_REFERENCES)\n", DllFileName);
1070 } else {
1071 SecPrint ("WARNING: No source level debug %S. \n", DllFileName);
1072 }
1073
1074 free (DllFileName);
1075 }
1076
1077 //
1078 // Never return an error if PeCoffLoaderRelocateImage() succeeded.
1079 // The image will run, but we just can't source level debug. If we
1080 // return an error the image will not run.
1081 //
1082 return EFI_SUCCESS;
1083 }
1084
1085
1086
1087
1088 VOID
1089 _ModuleEntryPoint (
1090 VOID
1091 )
1092 {
1093 }
1094
1095 EFI_STATUS
1096 EFIAPI
1097 SecTemporaryRamSupport (
1098 IN CONST EFI_PEI_SERVICES **PeiServices,
1099 IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase,
1100 IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase,
1101 IN UINTN CopySize
1102 )
1103 {
1104 //
1105 // Migrate the whole temporary memory to permenent memory.
1106 //
1107 CopyMem (
1108 (VOID*)(UINTN)PermanentMemoryBase,
1109 (VOID*)(UINTN)TemporaryMemoryBase,
1110 CopySize
1111 );
1112
1113 //
1114 // SecSwitchStack function must be invoked after the memory migration
1115 // immediatly, also we need fixup the stack change caused by new call into
1116 // permenent memory.
1117 //
1118 SecSwitchStack (
1119 (UINT32) TemporaryMemoryBase,
1120 (UINT32) PermanentMemoryBase
1121 );
1122
1123 //
1124 // We need *not* fix the return address because currently,
1125 // The PeiCore is excuted in flash.
1126 //
1127
1128 //
1129 // Simulate to invalid temporary memory, terminate temporary memory
1130 //
1131 //ZeroMem ((VOID*)(UINTN)TemporaryMemoryBase, CopySize);
1132
1133 return EFI_SUCCESS;
1134 }
1135
EFI Development Kit II mirror for PVE