3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. 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
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.
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.
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.
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.
26 This code produces 128 K of temporary memory for the PEI stack by directly
27 allocate memory space with ReadWrite and Execute attribute.
35 NT_PEI_LOAD_FILE_PPI mSecNtLoadFilePpi
= { SecWinNtPeiLoadFile
};
37 PEI_NT_AUTOSCAN_PPI mSecNtAutoScanPpi
= { SecWinNtPeiAutoScan
};
39 PEI_NT_THUNK_PPI mSecWinNtThunkPpi
= { SecWinNtWinNtThunkAddress
};
41 EFI_PEI_PROGRESS_CODE_PPI mSecStatusCodePpi
= { SecPeiReportStatusCode
};
43 NT_FWH_PPI mSecFwhInformationPpi
= { SecWinNtFdAddress
};
45 TEMPORARY_RAM_SUPPORT_PPI mSecTemporaryRamSupportPpi
= {SecTemporaryRamSupport
};
47 EFI_PEI_PPI_DESCRIPTOR gPrivateDispatchTable
[] = {
49 EFI_PEI_PPI_DESCRIPTOR_PPI
,
50 &gNtPeiLoadFilePpiGuid
,
54 EFI_PEI_PPI_DESCRIPTOR_PPI
,
55 &gPeiNtAutoScanPpiGuid
,
59 EFI_PEI_PPI_DESCRIPTOR_PPI
,
64 EFI_PEI_PPI_DESCRIPTOR_PPI
,
65 &gEfiPeiStatusCodePpiGuid
,
69 EFI_PEI_PPI_DESCRIPTOR_PPI
,
70 &gEfiTemporaryRamSupportPpiGuid
,
71 &mSecTemporaryRamSupportPpi
74 EFI_PEI_PPI_DESCRIPTOR_PPI
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
,
76 &mSecFwhInformationPpi
82 // Default information about where the FD is located.
83 // This array gets filled in with information from PcdWinNtFirmwareVolume
84 // The number of array elements is allocated base on parsing
85 // PcdWinNtFirmwareVolume and the memory is never freed.
87 UINTN gFdInfoCount
= 0;
91 // Array that supports seperate memory rantes.
92 // The memory ranges are set by PcdWinNtMemorySizeForSecMain.
93 // The number of array elements is allocated base on parsing
94 // PcdWinNtMemorySizeForSecMain value and the memory is never freed.
96 UINTN gSystemMemoryCount
= 0;
97 NT_SYSTEM_MEMORY
*gSystemMemory
;
102 UINT32 TemporaryMemoryBase
,
103 UINT32 PermenentMemoryBase
106 SecNt32PeCoffRelocateImage (
107 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
119 Main entry point to SEC for WinNt. This is a Windows program
122 Argc - Number of command line arguments
123 Argv - Array of command line argument strings
124 Envp - Array of environmemt variable strings
133 EFI_PHYSICAL_ADDRESS InitialStackMemory
;
134 UINT64 InitialStackMemorySize
;
142 CHAR16
*MemorySizeStr
;
143 CHAR16
*FirmwareVolumesStr
;
146 MemorySizeStr
= (CHAR16
*) FixedPcdGetPtr (PcdWinNtMemorySizeForSecMain
);
147 FirmwareVolumesStr
= (CHAR16
*) FixedPcdGetPtr (PcdWinNtFirmwareVolume
);
149 printf ("\nEDK SEC Main NT Emulation Environment from www.TianoCore.org\n");
152 // Make some Windows calls to Set the process to the highest priority in the
153 // idle class. We need this to have good performance.
155 SetPriorityClass (GetCurrentProcess (), IDLE_PRIORITY_CLASS
);
156 SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_HIGHEST
);
159 // Allocate space for gSystemMemory Array
161 gSystemMemoryCount
= CountSeperatorsInString (MemorySizeStr
, '!') + 1;
162 gSystemMemory
= calloc (gSystemMemoryCount
, sizeof (NT_SYSTEM_MEMORY
));
163 if (gSystemMemory
== NULL
) {
164 wprintf (L
"ERROR : Can not allocate memory for %s. Exiting.\n", MemorySizeStr
);
168 // Allocate space for gSystemMemory Array
170 gFdInfoCount
= CountSeperatorsInString (FirmwareVolumesStr
, '!') + 1;
171 gFdInfo
= calloc (gFdInfoCount
, sizeof (NT_FD_INFO
));
172 if (gFdInfo
== NULL
) {
173 wprintf (L
"ERROR : Can not allocate memory for %s. Exiting.\n", FirmwareVolumesStr
);
177 // Setup Boot Mode. If BootModeStr == "" then BootMode = 0 (BOOT_WITH_FULL_CONFIGURATION)
179 printf (" BootMode 0x%02x\n", FixedPcdGet32 (PcdWinNtBootMode
));
182 // Allocate 128K memory to emulate temp memory for PEI.
183 // on a real platform this would be SRAM, or using the cache as RAM.
184 // Set InitialStackMemory to zero so WinNtOpenFile will allocate a new mapping
186 InitialStackMemorySize
= STACK_SIZE
;
187 InitialStackMemory
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) VirtualAlloc (NULL
, (SIZE_T
) (InitialStackMemorySize
), MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
188 if (InitialStackMemory
== 0) {
189 printf ("ERROR : Can not allocate enough space for SecStack\n");
193 for (StackPointer
= (UINTN
*) (UINTN
) InitialStackMemory
;
194 StackPointer
< (UINTN
*) ((UINTN
)InitialStackMemory
+ (SIZE_T
) InitialStackMemorySize
);
196 *StackPointer
= 0x5AA55AA5;
199 wprintf (L
" SEC passing in %d bytes of temp RAM to PEI\n", InitialStackMemorySize
);
202 // Open All the firmware volumes and remember the info in the gFdInfo global
204 FileNamePtr
= (CHAR16
*)malloc (StrLen ((CHAR16
*)FirmwareVolumesStr
) * sizeof(CHAR16
));
205 if (FileNamePtr
== NULL
) {
206 printf ("ERROR : Can not allocate memory for firmware volume string\n");
210 StrCpy (FileNamePtr
, (CHAR16
*)FirmwareVolumesStr
);
212 for (Done
= FALSE
, Index
= 0, PeiCoreFile
= NULL
; !Done
; Index
++) {
213 FileName
= FileNamePtr
;
214 for (Index1
= 0; (FileNamePtr
[Index1
] != '!') && (FileNamePtr
[Index1
] != 0); Index1
++)
216 if (FileNamePtr
[Index1
] == 0) {
219 FileNamePtr
[Index1
] = '\0';
220 FileNamePtr
= FileNamePtr
+ Index1
+ 1;
224 // Open the FD and remmeber where it got mapped into our processes address space
226 Status
= WinNtOpenFile (
230 &gFdInfo
[Index
].Address
,
233 if (EFI_ERROR (Status
)) {
234 printf ("ERROR : Can not open Firmware Device File %S (0x%X). Exiting.\n", FileName
, Status
);
238 printf (" FD loaded from");
240 // printf can't print filenames directly as the \ gets interperted as an
243 for (Index2
= 0; FileName
[Index2
] != '\0'; Index2
++) {
244 printf ("%c", FileName
[Index2
]);
247 if (PeiCoreFile
== NULL
) {
249 // Assume the beginning of the FD is an FV and look for the PEI Core.
250 // Load the first one we find.
252 Status
= SecFfsFindPeiCore ((EFI_FIRMWARE_VOLUME_HEADER
*) (UINTN
) gFdInfo
[Index
].Address
, &PeiCoreFile
);
253 if (!EFI_ERROR (Status
)) {
254 printf (" contains SEC Core");
261 // Calculate memory regions and store the information in the gSystemMemory
262 // global for later use. The autosizing code will use this data to
263 // map this memory into the SEC process memory space.
265 for (Index
= 0, Done
= FALSE
; !Done
; Index
++) {
267 // Save the size of the memory and make a Unicode filename SystemMemory00, ...
269 gSystemMemory
[Index
].Size
= _wtoi (MemorySizeStr
) * 0x100000;
272 // Find the next region
274 for (Index1
= 0; MemorySizeStr
[Index1
] != '!' && MemorySizeStr
[Index1
] != 0; Index1
++)
276 if (MemorySizeStr
[Index1
] == 0) {
280 MemorySizeStr
= MemorySizeStr
+ Index1
+ 1;
286 // Hand off to PEI Core
288 SecLoadFromCore ((UINTN
) InitialStackMemory
, (UINTN
) InitialStackMemorySize
, (UINTN
) gFdInfo
[0].Address
, PeiCoreFile
);
291 // If we get here, then the PEI Core returned. This is an error as PEI should
292 // always hand off to DXE.
294 printf ("ERROR : PEI Core returned\n");
302 IN DWORD CreationDisposition
,
303 IN OUT EFI_PHYSICAL_ADDRESS
*BaseAddress
,
309 Opens and memory maps a file using WinNt services. If BaseAddress is non zero
310 the process will try and allocate the memory starting at BaseAddress.
313 FileName - The name of the file to open and map
314 MapSize - The amount of the file to map in bytes
315 CreationDisposition - The flags to pass to CreateFile(). Use to create new files for
316 memory emulation, and exiting files for firmware volume emulation
317 BaseAddress - The base address of the mapped file in the user address space.
318 If passed in as NULL the a new memory region is used.
319 If passed in as non NULL the request memory region is used for
320 the mapping of the file into the process space.
321 Length - The size of the mapped region in bytes
324 EFI_SUCCESS - The file was opened and mapped.
325 EFI_NOT_FOUND - FileName was not found in the current directory
326 EFI_DEVICE_ERROR - An error occured attempting to map the opened file
332 VOID
*VirtualAddress
;
336 // Use Win API to open/create a file
338 NtFileHandle
= CreateFile (
340 GENERIC_READ
| GENERIC_WRITE
,
344 FILE_ATTRIBUTE_NORMAL
,
347 if (NtFileHandle
== INVALID_HANDLE_VALUE
) {
348 return EFI_NOT_FOUND
;
351 // Map the open file into a memory range
353 NtMapHandle
= CreateFileMapping (
361 if (NtMapHandle
== NULL
) {
362 return EFI_DEVICE_ERROR
;
365 // Get the virtual address (address in the emulator) of the mapped file
367 VirtualAddress
= MapViewOfFileEx (
373 (LPVOID
) (UINTN
) *BaseAddress
375 if (VirtualAddress
== NULL
) {
376 return EFI_DEVICE_ERROR
;
381 // Seek to the end of the file to figure out the true file size.
383 FileSize
= SetFilePointer (
389 if (FileSize
== -1) {
390 return EFI_DEVICE_ERROR
;
393 *Length
= (UINT64
) FileSize
;
395 *Length
= (UINT64
) MapSize
;
398 *BaseAddress
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) VirtualAddress
;
404 #define BYTES_PER_RECORD 512
408 SecPeiReportStatusCode (
409 IN CONST EFI_PEI_SERVICES
**PeiServices
,
410 IN EFI_STATUS_CODE_TYPE CodeType
,
411 IN EFI_STATUS_CODE_VALUE Value
,
413 IN CONST EFI_GUID
*CallerId
,
414 IN CONST EFI_STATUS_CODE_DATA
*Data OPTIONAL
420 This routine produces the ReportStatusCode PEI service. It's passed
421 up to the PEI Core via a PPI. T
423 This code currently uses the NT clib printf. This does not work the same way
424 as the EFI Print (), as %t, %g, %s as Unicode are not supported.
427 (see EFI_PEI_REPORT_STATUS_CODE)
430 EFI_SUCCESS - Always return success
433 // TODO: PeiServices - add argument and description to function comment
434 // TODO: CodeType - add argument and description to function comment
435 // TODO: Value - add argument and description to function comment
436 // TODO: Instance - add argument and description to function comment
437 // TODO: CallerId - add argument and description to function comment
438 // TODO: Data - add argument and description to function comment
442 CHAR8 PrintBuffer
[BYTES_PER_RECORD
* 2];
450 } else if (ReportStatusCodeExtractAssertInfo (CodeType
, Value
, Data
, &Filename
, &Description
, &LineNumber
)) {
452 // Processes ASSERT ()
454 printf ("ASSERT %s(%d): %s\n", Filename
, (int)LineNumber
, Description
);
456 } else if (ReportStatusCodeExtractDebugInfo (Data
, &ErrorLevel
, &Marker
, &Format
)) {
458 // Process DEBUG () macro
460 AsciiVSPrint (PrintBuffer
, BYTES_PER_RECORD
, Format
, Marker
);
461 printf (PrintBuffer
);
468 Transfers control to a function starting with a new stack.
470 Transfers control to the function specified by EntryPoint using the new stack
471 specified by NewStack and passing in the parameters specified by Context1 and
472 Context2. Context1 and Context2 are optional and may be NULL. The function
473 EntryPoint must never return.
475 If EntryPoint is NULL, then ASSERT().
476 If NewStack is NULL, then ASSERT().
478 @param EntryPoint A pointer to function to call with the new stack.
479 @param Context1 A pointer to the context to pass into the EntryPoint
481 @param Context2 A pointer to the context to pass into the EntryPoint
483 @param NewStack A pointer to the new stack to use for the EntryPoint
485 @param NewBsp A pointer to the new BSP for the EntryPoint on IPF. It's
486 Reserved on other architectures.
492 IN SWITCH_STACK_ENTRY_POINT EntryPoint
,
493 IN VOID
*Context1
, OPTIONAL
494 IN VOID
*Context2
, OPTIONAL
495 IN VOID
*Context3
, OPTIONAL
499 BASE_LIBRARY_JUMP_BUFFER JumpBuffer
;
501 ASSERT (EntryPoint
!= NULL
);
502 ASSERT (NewStack
!= NULL
);
505 // Stack should be aligned with CPU_STACK_ALIGNMENT
507 ASSERT (((UINTN
)NewStack
& (CPU_STACK_ALIGNMENT
- 1)) == 0);
509 JumpBuffer
.Eip
= (UINTN
)EntryPoint
;
510 JumpBuffer
.Esp
= (UINTN
)NewStack
- sizeof (VOID
*);
511 JumpBuffer
.Esp
-= sizeof (Context1
) + sizeof (Context2
) + sizeof(Context3
);
512 ((VOID
**)JumpBuffer
.Esp
)[1] = Context1
;
513 ((VOID
**)JumpBuffer
.Esp
)[2] = Context2
;
514 ((VOID
**)JumpBuffer
.Esp
)[3] = Context3
;
516 LongJump (&JumpBuffer
, (UINTN
)-1);
520 // InternalSwitchStack () will never return
527 IN UINTN LargestRegion
,
528 IN UINTN LargestRegionSize
,
529 IN UINTN BootFirmwareVolumeBase
,
530 IN VOID
*PeiCorePe32File
535 This is the service to load the PEI Core from the Firmware Volume
538 LargestRegion - Memory to use for PEI.
539 LargestRegionSize - Size of Memory to use for PEI
540 BootFirmwareVolumeBase - Start of the Boot FV
541 PeiCorePe32File - PEI Core PE32
544 Success means control is transfered and thus we should never return
551 EFI_PHYSICAL_ADDRESS PeiCoreEntryPoint
;
552 EFI_PHYSICAL_ADDRESS PeiImageAddress
;
553 EFI_SEC_PEI_HAND_OFF
*SecCoreData
;
557 // Compute Top Of Memory for Stack and PEI Core Allocations
559 PeiStackSize
= (UINTN
)RShiftU64((UINT64
)STACK_SIZE
,1);
562 // |-----------| <---- TemporaryRamBase + TemporaryRamSize
565 // |-----------| <---- StackBase / PeiTemporaryMemoryBase
568 // |-----------| <---- TemporaryRamBase
570 TopOfStack
= (VOID
*)(LargestRegion
+ PeiStackSize
);
573 // Reservet space for storing PeiCore's parament in stack.
575 TopOfStack
= (VOID
*)((UINTN
)TopOfStack
- sizeof (EFI_SEC_PEI_HAND_OFF
) - CPU_STACK_ALIGNMENT
);
576 TopOfStack
= ALIGN_POINTER (TopOfStack
, CPU_STACK_ALIGNMENT
);
579 // Bind this information into the SEC hand-off state
581 SecCoreData
= (EFI_SEC_PEI_HAND_OFF
*)(UINTN
) TopOfStack
;
582 SecCoreData
->DataSize
= sizeof(EFI_SEC_PEI_HAND_OFF
);
583 SecCoreData
->BootFirmwareVolumeBase
= (VOID
*)BootFirmwareVolumeBase
;
584 SecCoreData
->BootFirmwareVolumeSize
= FixedPcdGet32(PcdWinNtFirmwareFdSize
);
585 SecCoreData
->TemporaryRamBase
= (VOID
*)(UINTN
)LargestRegion
;
586 SecCoreData
->TemporaryRamSize
= STACK_SIZE
;
587 SecCoreData
->StackBase
= SecCoreData
->TemporaryRamBase
;
588 SecCoreData
->StackSize
= PeiStackSize
;
589 SecCoreData
->PeiTemporaryRamBase
= (VOID
*) ((UINTN
) SecCoreData
->TemporaryRamBase
+ PeiStackSize
);
590 SecCoreData
->PeiTemporaryRamSize
= STACK_SIZE
- PeiStackSize
;
593 // Load the PEI Core from a Firmware Volume
595 Status
= SecWinNtPeiLoadFile (
601 if (EFI_ERROR (Status
)) {
606 // Transfer control to the PEI Core
609 (SWITCH_STACK_ENTRY_POINT
) (UINTN
) PeiCoreEntryPoint
,
611 (VOID
*) (UINTN
) ((EFI_PEI_PPI_DESCRIPTOR
*) &gPrivateDispatchTable
),
616 // If we get here, then the PEI Core returned. This is an error
623 SecWinNtPeiAutoScan (
625 OUT EFI_PHYSICAL_ADDRESS
*MemoryBase
,
626 OUT UINT64
*MemorySize
631 This service is called from Index == 0 until it returns EFI_UNSUPPORTED.
632 It allows discontiguous memory regions to be supported by the emulator.
633 It uses gSystemMemory[] and gSystemMemoryCount that were created by
634 parsing PcdWinNtMemorySizeForSecMain value.
635 The size comes from the Pcd value and the address comes from the memory space
636 with ReadWrite and Execute attributes allocated by VirtualAlloc() API.
639 Index - Which memory region to use
640 MemoryBase - Return Base address of memory region
641 MemorySize - Return size in bytes of the memory region
644 EFI_SUCCESS - If memory region was mapped
645 EFI_UNSUPPORTED - If Index is not supported
649 if (Index
>= gSystemMemoryCount
) {
650 return EFI_UNSUPPORTED
;
654 // Allocate enough memory space for emulator
656 gSystemMemory
[Index
].Memory
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) VirtualAlloc (NULL
, (SIZE_T
) (gSystemMemory
[Index
].Size
), MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
657 if (gSystemMemory
[Index
].Memory
== 0) {
658 return EFI_OUT_OF_RESOURCES
;
661 *MemoryBase
= gSystemMemory
[Index
].Memory
;
662 *MemorySize
= gSystemMemory
[Index
].Size
;
669 SecWinNtWinNtThunkAddress (
675 Since the SEC is the only Windows program in stack it must export
676 an interface to do Win API calls. That's what the WinNtThunk address
677 is for. gWinNt is initailized in WinNtThunk.c.
680 InterfaceSize - sizeof (EFI_WIN_NT_THUNK_PROTOCOL);
681 InterfaceBase - Address of the gWinNt global
684 EFI_SUCCESS - Data returned
694 SecWinNtPeiLoadFile (
696 IN EFI_PHYSICAL_ADDRESS
*ImageAddress
,
697 IN UINT64
*ImageSize
,
698 IN EFI_PHYSICAL_ADDRESS
*EntryPoint
703 Loads and relocates a PE/COFF image into memory.
706 Pe32Data - The base address of the PE/COFF file that is to be loaded and relocated
707 ImageAddress - The base address of the relocated PE/COFF image
708 ImageSize - The size of the relocated PE/COFF image
709 EntryPoint - The entry point of the relocated PE/COFF image
712 EFI_SUCCESS - The file was loaded and relocated
713 EFI_OUT_OF_RESOURCES - There was not enough memory to load and relocate the PE/COFF file
718 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext
;
720 ZeroMem (&ImageContext
, sizeof (ImageContext
));
721 ImageContext
.Handle
= Pe32Data
;
723 ImageContext
.ImageRead
= (PE_COFF_LOADER_READ_FILE
) SecImageRead
;
725 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
726 if (EFI_ERROR (Status
)) {
730 // Allocate space in NT (not emulator) memory with ReadWrite and Execute attribue.
731 // Extra space is for alignment
733 ImageContext
.ImageAddress
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) VirtualAlloc (NULL
, (SIZE_T
) (ImageContext
.ImageSize
+ (ImageContext
.SectionAlignment
* 2)), MEM_COMMIT
, PAGE_EXECUTE_READWRITE
);
734 if (ImageContext
.ImageAddress
== 0) {
735 return EFI_OUT_OF_RESOURCES
;
738 // Align buffer on section boundry
740 ImageContext
.ImageAddress
+= ImageContext
.SectionAlignment
- 1;
741 ImageContext
.ImageAddress
&= ~(ImageContext
.SectionAlignment
- 1);
743 Status
= PeCoffLoaderLoadImage (&ImageContext
);
744 if (EFI_ERROR (Status
)) {
748 Status
= SecNt32PeCoffRelocateImage (&ImageContext
);
749 if (EFI_ERROR (Status
)) {
754 // BugBug: Flush Instruction Cache Here when CPU Lib is ready
757 *ImageAddress
= ImageContext
.ImageAddress
;
758 *ImageSize
= ImageContext
.ImageSize
;
759 *EntryPoint
= ImageContext
.EntryPoint
;
768 IN OUT EFI_PHYSICAL_ADDRESS
*FdBase
,
769 IN OUT UINT64
*FdSize
774 Return the FD Size and base address. Since the FD is loaded from a
775 file into Windows memory only the SEC will know it's address.
778 Index - Which FD, starts at zero.
779 FdSize - Size of the FD in bytes
780 FdBase - Start address of the FD. Assume it points to an FV Header
783 EFI_SUCCESS - Return the Base address and size of the FV
784 EFI_UNSUPPORTED - Index does nto map to an FD in the system
788 if (Index
>= gFdInfoCount
) {
789 return EFI_UNSUPPORTED
;
792 *FdBase
= gFdInfo
[Index
].Address
;
793 *FdSize
= gFdInfo
[Index
].Size
;
795 if (*FdBase
== 0 && *FdSize
== 0) {
796 return EFI_UNSUPPORTED
;
807 IN OUT UINTN
*ReadSize
,
813 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
816 FileHandle - The handle to the PE/COFF file
817 FileOffset - The offset, in bytes, into the file to read
818 ReadSize - The number of bytes to read from the file starting at FileOffset
819 Buffer - A pointer to the buffer to read the data into.
822 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
830 Destination8
= Buffer
;
831 Source8
= (CHAR8
*) ((UINTN
) FileHandle
+ FileOffset
);
834 *(Destination8
++) = *(Source8
++);
843 IN UINTN
*StrLen OPTIONAL
848 Convert the passed in Ascii string to Unicode.
849 Optionally return the length of the strings.
852 Ascii - Ascii string to convert
853 StrLen - Length of string
856 Pointer to malloc'ed Unicode version of Ascii
864 // Allocate a buffer for unicode string
866 for (Index
= 0; Ascii
[Index
] != '\0'; Index
++)
868 Unicode
= malloc ((Index
+ 1) * sizeof (CHAR16
));
869 if (Unicode
== NULL
) {
873 for (Index
= 0; Ascii
[Index
] != '\0'; Index
++) {
874 Unicode
[Index
] = (CHAR16
) Ascii
[Index
];
877 Unicode
[Index
] = '\0';
879 if (StrLen
!= NULL
) {
887 CountSeperatorsInString (
888 IN CONST CHAR16
*String
,
894 Count the number of seperators in String
897 String - String to process
898 Seperator - Item to count
901 Number of Seperator in String
907 for (Count
= 0; *String
!= '\0'; String
++) {
908 if (*String
== Seperator
) {
918 SecNt32PeCoffRelocateImage (
919 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
929 Status
= PeCoffLoaderRelocateImage (ImageContext
);
930 if (EFI_ERROR (Status
)) {
932 // We could not relocated the image in memory properly
938 // If we load our own PE COFF images the Windows debugger can not source
939 // level debug our code. If a valid PDB pointer exists usw it to load
940 // the *.dll file as a library using Windows* APIs. This allows
941 // source level debug. The image is still loaded and reloaced
942 // in the Framework memory space like on a real system (by the code above),
943 // but the entry point points into the DLL loaded by the code bellow.
946 DllEntryPoint
= NULL
;
949 // Load the DLL if it's not an EBC image.
951 if ((ImageContext
->PdbPointer
!= NULL
) &&
952 (ImageContext
->Machine
!= EFI_IMAGE_MACHINE_EBC
)) {
954 // Convert filename from ASCII to Unicode
956 DllFileName
= AsciiToUnicode (ImageContext
->PdbPointer
, &Index
);
959 // Check that we have a valid filename
961 if (Index
< 5 || DllFileName
[Index
- 4] != '.') {
965 // Never return an error if PeCoffLoaderRelocateImage() succeeded.
966 // The image will run, but we just can't source level debug. If we
967 // return an error the image will not run.
972 // Replace .PDB with .DLL on the filename
974 DllFileName
[Index
- 3] = 'D';
975 DllFileName
[Index
- 2] = 'L';
976 DllFileName
[Index
- 1] = 'L';
979 // Load the .DLL file into the user process's address space for source
982 Library
= LoadLibraryEx (DllFileName
, NULL
, DONT_RESOLVE_DLL_REFERENCES
);
983 if (Library
!= NULL
) {
985 // InitializeDriver is the entry point we put in all our EFI DLL's. The
986 // DONT_RESOLVE_DLL_REFERENCES argument to LoadLIbraryEx() supresses the
987 // normal DLL entry point of DllMain, and prevents other modules that are
988 // referenced in side the DllFileName from being loaded. There is no error
989 // checking as the we can point to the PE32 image loaded by Tiano. This
990 // step is only needed for source level debuging
992 DllEntryPoint
= (VOID
*) (UINTN
) GetProcAddress (Library
, "InitializeDriver");
996 if ((Library
!= NULL
) && (DllEntryPoint
!= NULL
)) {
997 ImageContext
->EntryPoint
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) DllEntryPoint
;
998 wprintf (L
"LoadLibraryEx (%s,\n NULL, DONT_RESOLVE_DLL_REFERENCES)\n", DllFileName
);
1000 wprintf (L
"WARNING: No source level debug %s. \n", DllFileName
);
1007 // Never return an error if PeCoffLoaderRelocateImage() succeeded.
1008 // The image will run, but we just can't source level debug. If we
1009 // return an error the image will not run.
1026 SecTemporaryRamSupport (
1027 IN CONST EFI_PEI_SERVICES
**PeiServices
,
1028 IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase
,
1029 IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase
,
1034 // Migrate the whole temporary memory to permenent memory.
1037 (VOID
*)(UINTN
)PermanentMemoryBase
,
1038 (VOID
*)(UINTN
)TemporaryMemoryBase
,
1043 // SecSwitchStack function must be invoked after the memory migration
1044 // immediatly, also we need fixup the stack change caused by new call into
1045 // permenent memory.
1048 (UINT32
) TemporaryMemoryBase
,
1049 (UINT32
) PermanentMemoryBase
1053 // We need *not* fix the return address because currently,
1054 // The PeiCore is excuted in flash.
1058 // Simulate to invalid temporary memory, terminate temporary memory
1060 //ZeroMem ((VOID*)(UINTN)TemporaryMemoryBase, CopySize);