3 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
4 Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 #define MAP_ANONYMOUS MAP_ANON
19 char *gGdbWorkingFileName
= NULL
;
27 EMU_THUNK_PPI mSecEmuThunkPpi
= {
28 GasketSecUnixPeiAutoScan
,
29 GasketSecUnixFdAddress
,
30 GasketSecEmuThunkAddress
37 // Default information about where the FD is located.
38 // This array gets filled in with information from EFI_FIRMWARE_VOLUMES
39 // EFI_FIRMWARE_VOLUMES is a host environment variable set by system.cmd.
40 // The number of array elements is allocated base on parsing
41 // EFI_FIRMWARE_VOLUMES and the memory is never freed.
43 UINTN gFdInfoCount
= 0;
47 // Array that supports seperate memory rantes.
48 // The memory ranges are set in system.cmd via the EFI_MEMORY_SIZE variable.
49 // The number of array elements is allocated base on parsing
50 // EFI_MEMORY_SIZE and the memory is never freed.
52 UINTN gSystemMemoryCount
= 0;
53 EMU_SYSTEM_MEMORY
*gSystemMemory
;
57 UINTN mImageContextModHandleArraySize
= 0;
58 IMAGE_CONTEXT_TO_MOD_HANDLE
*mImageContextModHandleArray
= NULL
;
60 EFI_PEI_PPI_DESCRIPTOR
*gPpiList
;
65 Main entry point to SEC for Unix. This is a unix program
68 Argc - Number of command line arguments
69 Argv - Array of command line argument strings
70 Envp - Array of environmemt variable strings
85 EFI_PHYSICAL_ADDRESS InitialStackMemory
;
86 UINT64 InitialStackMemorySize
;
93 EFI_PEI_FILE_HANDLE FileHandle
;
95 CHAR16
*MemorySizeStr
;
96 CHAR16
*FirmwareVolumesStr
;
102 MemorySizeStr
= (CHAR16
*) PcdGetPtr (PcdEmuMemorySize
);
103 FirmwareVolumesStr
= (CHAR16
*) PcdGetPtr (PcdEmuFirmwareVolume
);
105 printf ("\nEDK II UNIX Emulation Environment from edk2.sourceforge.net\n");
108 // PPIs pased into PEI_CORE
110 AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI
, &gEmuThunkPpiGuid
, &mSecEmuThunkPpi
);
112 SecInitThunkProtocol ();
115 // Emulator Bus Driver Thunks
117 AddThunkProtocol (&gX11ThunkIo
, (CHAR16
*)PcdGetPtr (PcdEmuGop
), TRUE
);
118 AddThunkProtocol (&gPosixFileSystemThunkIo
, (CHAR16
*)PcdGetPtr (PcdEmuFileSystem
), TRUE
);
119 AddThunkProtocol (&gBlockIoThunkIo
, (CHAR16
*)PcdGetPtr (PcdEmuVirtualDisk
), TRUE
);
120 AddThunkProtocol (&gSnpThunkIo
, (CHAR16
*)PcdGetPtr (PcdEmuNetworkInterface
), TRUE
);
123 // Emulator other Thunks
125 AddThunkProtocol (&gPthreadThunkIo
, (CHAR16
*)PcdGetPtr (PcdEmuApCount
), FALSE
);
127 // EmuSecLibConstructor ();
129 gPpiList
= GetThunkPpiList ();
134 // We can't use dlopen on OS X, so we need a scheme to get symboles into gdb
135 // We need to create a temp file that contains gdb commands so we can load
136 // symbols when we load every PE/COFF image.
138 Index
= strlen (*Argv
);
139 gGdbWorkingFileName
= malloc (Index
+ strlen(".gdb") + 1);
140 strcpy (gGdbWorkingFileName
, *Argv
);
141 strcat (gGdbWorkingFileName
, ".gdb");
146 // Allocate space for gSystemMemory Array
148 gSystemMemoryCount
= CountSeperatorsInString (MemorySizeStr
, '!') + 1;
149 gSystemMemory
= calloc (gSystemMemoryCount
, sizeof (EMU_SYSTEM_MEMORY
));
150 if (gSystemMemory
== NULL
) {
151 printf ("ERROR : Can not allocate memory for system. Exiting.\n");
155 // Allocate space for gSystemMemory Array
157 gFdInfoCount
= CountSeperatorsInString (FirmwareVolumesStr
, '!') + 1;
158 gFdInfo
= calloc (gFdInfoCount
, sizeof (EMU_FD_INFO
));
159 if (gFdInfo
== NULL
) {
160 printf ("ERROR : Can not allocate memory for fd info. Exiting.\n");
164 printf (" BootMode 0x%02x\n", (unsigned int)PcdGet32 (PcdEmuBootMode
));
167 // Open up a 128K file to emulate temp memory for SEC.
168 // on a real platform this would be SRAM, or using the cache as RAM.
169 // Set InitialStackMemory to zero so UnixOpenFile will allocate a new mapping
171 InitialStackMemorySize
= STACK_SIZE
;
172 InitialStackMemory
= (UINTN
)MapMemory (
173 0, (UINT32
) InitialStackMemorySize
,
174 PROT_READ
| PROT_WRITE
| PROT_EXEC
, MAP_ANONYMOUS
| MAP_PRIVATE
176 if (InitialStackMemory
== 0) {
177 printf ("ERROR : Can not open SecStack Exiting\n");
181 printf (" OS Emulator passing in %u KB of temp RAM at 0x%08lx to SEC\n",
182 (unsigned int)(InitialStackMemorySize
/ 1024),
183 (unsigned long)InitialStackMemory
186 for (StackPointer
= (UINTN
*) (UINTN
) InitialStackMemory
;
187 StackPointer
< (UINTN
*)(UINTN
)((UINTN
) InitialStackMemory
+ (UINT64
) InitialStackMemorySize
);
189 *StackPointer
= 0x5AA55AA5;
193 // Open All the firmware volumes and remember the info in the gFdInfo global
195 FileName
= (CHAR8
*)malloc (StrLen (FirmwareVolumesStr
) + 1);
196 if (FileName
== NULL
) {
197 printf ("ERROR : Can not allocate memory for firmware volume string\n");
202 for (Done
= FALSE
, Index
= 0, PeiIndex
= 0, SecFile
= NULL
;
203 FirmwareVolumesStr
[Index2
] != 0;
205 for (Index1
= 0; (FirmwareVolumesStr
[Index2
] != '!') && (FirmwareVolumesStr
[Index2
] != 0); Index2
++) {
206 FileName
[Index1
++] = FirmwareVolumesStr
[Index2
];
208 if (FirmwareVolumesStr
[Index2
] == '!') {
211 FileName
[Index1
] = '\0';
214 // Map FV Recovery Read Only and other areas Read/Write
222 // Open the FD and remmeber where it got mapped into our processes address space
227 &gFdInfo
[Index
].Address
,
231 if (EFI_ERROR (Status
)) {
232 printf ("ERROR : Can not open Firmware Device File %s (%x). Exiting.\n", FileName
, (unsigned int)Status
);
236 printf (" FD loaded from %s at 0x%08lx",FileName
, (unsigned long)gFdInfo
[Index
].Address
);
238 if (SecFile
== NULL
) {
240 // Assume the beginning of the FD is an FV and look for the SEC Core.
241 // Load the first one we find.
244 Status
= PeiServicesFfsFindNextFile (
245 EFI_FV_FILETYPE_SECURITY_CORE
,
246 (EFI_PEI_FV_HANDLE
)(UINTN
)gFdInfo
[Index
].Address
,
249 if (!EFI_ERROR (Status
)) {
250 Status
= PeiServicesFfsFindSectionData (EFI_SECTION_PE32
, FileHandle
, &SecFile
);
251 if (!EFI_ERROR (Status
)) {
253 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.
270 // Save the size of the memory.
272 while (MemorySizeStr
[Index1
] >= '0' && MemorySizeStr
[Index1
] <= '9') {
273 val
= val
* 10 + MemorySizeStr
[Index1
] - '0';
276 gSystemMemory
[Index
++].Size
= val
* 0x100000;
277 if (MemorySizeStr
[Index1
] == 0) {
288 SecLoadFromCore ((UINTN
) InitialStackMemory
, (UINTN
) InitialStackMemorySize
, (UINTN
) gFdInfo
[0].Address
, SecFile
);
291 // If we get here, then the SEC Core returned. This is an error as SEC should
292 // always hand off to PEI Core and then on to DXE Core.
294 printf ("ERROR : SEC returned\n");
299 EFI_PHYSICAL_ADDRESS
*
307 STATIC UINTN base
= 0x40000000;
308 CONST UINTN align
= (1 << 24);
310 BOOLEAN isAligned
= 0;
313 // Try to get an aligned block somewhere in the address space of this
316 while((!isAligned
) && (base
!= 0)) {
317 res
= mmap ((void *)base
, length
, prot
, flags
, fd
, 0);
318 if (res
== MAP_FAILED
) {
321 if ((((UINTN
)res
) & ~(align
-1)) == (UINTN
)res
) {
335 Opens and memory maps a file using Unix services. If BaseAddress is non zero
336 the process will try and allocate the memory starting at BaseAddress.
339 FileName - The name of the file to open and map
340 MapSize - The amount of the file to map in bytes
341 CreationDisposition - The flags to pass to CreateFile(). Use to create new files for
342 memory emulation, and exiting files for firmware volume emulation
343 BaseAddress - The base address of the mapped file in the user address space.
344 If passed in as NULL the a new memory region is used.
345 If passed in as non NULL the request memory region is used for
346 the mapping of the file into the process space.
347 Length - The size of the mapped region in bytes
350 EFI_SUCCESS - The file was opened and mapped.
351 EFI_NOT_FOUND - FileName was not found in the current directory
352 EFI_DEVICE_ERROR - An error occured attempting to map the opened file
358 IN OUT EFI_PHYSICAL_ADDRESS
*BaseAddress
,
366 fd
= open (FileName
, O_RDWR
);
368 return EFI_NOT_FOUND
;
370 FileSize
= lseek (fd
, 0, SEEK_END
);
373 res
= MapMemory (fd
, FileSize
, PROT_READ
| PROT_EXEC
, MAP_PRIVATE
);
378 perror ("MapFile() Failed");
379 return EFI_DEVICE_ERROR
;
382 *Length
= (UINT64
) FileSize
;
383 *BaseAddress
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) res
;
391 IN OUT EFI_PHYSICAL_ADDRESS
*BaseAddress
,
396 void *res
, *res2
, *res3
;
401 fd
= open (FileName
, O_RDWR
);
403 return EFI_NOT_FOUND
;
405 FileSize
= lseek (fd
, 0, SEEK_END
);
407 FvSize
= FixedPcdGet64 (PcdEmuFlashFvRecoverySize
);
409 // Assume start of FD is Recovery FV, and make it write protected
411 (void *)(UINTN
)FixedPcdGet64 (PcdEmuFlashFvRecoveryBase
),
413 PROT_READ
| PROT_EXEC
,
418 if (res
== MAP_FAILED
) {
419 perror ("MapFd0() Failed res =");
421 return EFI_DEVICE_ERROR
;
422 } else if (res
!= (void *)(UINTN
)FixedPcdGet64 (PcdEmuFlashFvRecoveryBase
)) {
423 // We could not load at the build address, so we need to allow writes
424 munmap (res
, FvSize
);
426 (void *)(UINTN
)FixedPcdGet64 (PcdEmuFlashFvRecoveryBase
),
428 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
433 if (res
== MAP_FAILED
) {
434 perror ("MapFd0() Failed res =");
436 return EFI_DEVICE_ERROR
;
440 // Map the rest of the FD as read/write
442 (void *)(FixedPcdGet64 (PcdEmuFlashFvRecoveryBase
) + FvSize
),
444 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
450 if (res2
== MAP_FAILED
) {
451 perror ("MapFd0() Failed res2 =");
452 return EFI_DEVICE_ERROR
;
456 // If enabled use the magic page to communicate between modules
457 // This replaces the PI PeiServicesTable pointer mechanism that
458 // deos not work in the emulator. It also allows the removal of
459 // writable globals from SEC, PEI_CORE (libraries), PEIMs
461 EmuMagicPage
= (void *)(UINTN
)FixedPcdGet64 (PcdPeiServicesTablePage
);
462 if (EmuMagicPage
!= NULL
) {
464 (void *)EmuMagicPage
,
466 PROT_READ
| PROT_WRITE
,
467 MAP_PRIVATE
| MAP_ANONYMOUS
,
471 if (res3
!= EmuMagicPage
) {
472 printf ("MapFd0(): Could not allocate PeiServicesTablePage @ %lx\n", (long unsigned int)EmuMagicPage
);
473 return EFI_DEVICE_ERROR
;
477 *Length
= (UINT64
) FileSize
;
478 *BaseAddress
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) res
;
487 This is the service to load the SEC Core from the Firmware Volume
490 LargestRegion - Memory to use for SEC.
491 LargestRegionSize - Size of Memory to use for PEI
492 BootFirmwareVolumeBase - Start of the Boot FV
493 PeiCorePe32File - SEC PE32
496 Success means control is transfered and thus we should never return
501 IN UINTN LargestRegion
,
502 IN UINTN LargestRegionSize
,
503 IN UINTN BootFirmwareVolumeBase
,
504 IN VOID
*PeiCorePe32File
508 EFI_PHYSICAL_ADDRESS TopOfMemory
;
510 EFI_PHYSICAL_ADDRESS PeiCoreEntryPoint
;
511 EFI_SEC_PEI_HAND_OFF
*SecCoreData
;
515 // Compute Top Of Memory for Stack and PEI Core Allocations
517 TopOfMemory
= LargestRegion
+ LargestRegionSize
;
518 PeiStackSize
= (UINTN
)RShiftU64((UINT64
)STACK_SIZE
,1);
521 // |-----------| <---- TemporaryRamBase + TemporaryRamSize
524 // |-----------| <---- StackBase / PeiTemporaryMemoryBase
527 // |-----------| <---- TemporaryRamBase
529 TopOfStack
= (VOID
*)(LargestRegion
+ PeiStackSize
);
530 TopOfMemory
= LargestRegion
+ PeiStackSize
;
533 // Reservet space for storing PeiCore's parament in stack.
535 TopOfStack
= (VOID
*)((UINTN
)TopOfStack
- sizeof (EFI_SEC_PEI_HAND_OFF
) - CPU_STACK_ALIGNMENT
);
536 TopOfStack
= ALIGN_POINTER (TopOfStack
, CPU_STACK_ALIGNMENT
);
540 // Bind this information into the SEC hand-off state
542 SecCoreData
= (EFI_SEC_PEI_HAND_OFF
*)(UINTN
) TopOfStack
;
543 SecCoreData
->DataSize
= sizeof(EFI_SEC_PEI_HAND_OFF
);
544 SecCoreData
->BootFirmwareVolumeBase
= (VOID
*)BootFirmwareVolumeBase
;
545 SecCoreData
->BootFirmwareVolumeSize
= PcdGet32 (PcdEmuFirmwareFdSize
);
546 SecCoreData
->TemporaryRamBase
= (VOID
*)(UINTN
)LargestRegion
;
547 SecCoreData
->TemporaryRamSize
= STACK_SIZE
;
548 SecCoreData
->StackBase
= SecCoreData
->TemporaryRamBase
;
549 SecCoreData
->StackSize
= PeiStackSize
;
550 SecCoreData
->PeiTemporaryRamBase
= (VOID
*) ((UINTN
) SecCoreData
->TemporaryRamBase
+ PeiStackSize
);
551 SecCoreData
->PeiTemporaryRamSize
= STACK_SIZE
- PeiStackSize
;
554 // Find the SEC Core Entry Point
556 Status
= SecPeCoffGetEntryPoint (PeiCorePe32File
, (VOID
**)&PeiCoreEntryPoint
);
557 if (EFI_ERROR (Status
)) {
562 // Transfer control to the SEC Core
565 (SWITCH_STACK_ENTRY_POINT
) (UINTN
) PeiCoreEntryPoint
,
571 // If we get here, then the SEC Core returned. This is an error
580 This service is called from Index == 0 until it returns EFI_UNSUPPORTED.
581 It allows discontiguous memory regions to be supported by the emulator.
582 It uses gSystemMemory[] and gSystemMemoryCount that were created by
583 parsing the host environment variable EFI_MEMORY_SIZE.
584 The size comes from the varaible and the address comes from the call to
588 Index - Which memory region to use
589 MemoryBase - Return Base address of memory region
590 MemorySize - Return size in bytes of the memory region
593 EFI_SUCCESS - If memory region was mapped
594 EFI_UNSUPPORTED - If Index is not supported
601 OUT EFI_PHYSICAL_ADDRESS
*MemoryBase
,
602 OUT UINT64
*MemorySize
607 if (Index
>= gSystemMemoryCount
) {
608 return EFI_UNSUPPORTED
;
613 0, gSystemMemory
[Index
].Size
,
614 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
615 MAP_PRIVATE
| MAP_ANONYMOUS
617 if (res
== MAP_FAILED
) {
618 return EFI_DEVICE_ERROR
;
620 *MemorySize
= gSystemMemory
[Index
].Size
;
621 *MemoryBase
= (UINTN
)res
;
622 gSystemMemory
[Index
].Memory
= *MemoryBase
;
631 Since the SEC is the only Unix program in stack it must export
632 an interface to do POSIX calls. gUnix is initailized in UnixThunk.c.
635 InterfaceSize - sizeof (EFI_WIN_NT_THUNK_PROTOCOL);
636 InterfaceBase - Address of the gUnix global
639 EFI_SUCCESS - Data returned
648 return &gEmuThunkProtocol
;
655 SecPeCoffGetEntryPoint (
657 IN OUT VOID
**EntryPoint
661 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext
;
663 ZeroMem (&ImageContext
, sizeof (ImageContext
));
664 ImageContext
.Handle
= Pe32Data
;
665 ImageContext
.ImageRead
= (PE_COFF_LOADER_READ_FILE
) SecImageRead
;
667 Status
= PeCoffLoaderGetImageInfo (&ImageContext
);
668 if (EFI_ERROR (Status
)) {
672 if (ImageContext
.ImageAddress
!= (UINTN
)Pe32Data
) {
674 // Relocate image to match the address where it resides
676 ImageContext
.ImageAddress
= (UINTN
)Pe32Data
;
677 Status
= PeCoffLoaderLoadImage (&ImageContext
);
678 if (EFI_ERROR (Status
)) {
682 Status
= PeCoffLoaderRelocateImage (&ImageContext
);
683 if (EFI_ERROR (Status
)) {
688 // Or just return image entry point
690 ImageContext
.PdbPointer
= PeCoffLoaderGetPdbPointer (Pe32Data
);
691 Status
= PeCoffLoaderGetEntryPoint (Pe32Data
, EntryPoint
);
692 if (EFI_ERROR (Status
)) {
695 ImageContext
.EntryPoint
= (UINTN
)*EntryPoint
;
698 // On Unix a dlopen is done that will change the entry point
699 SecPeCoffRelocateImageExtraAction (&ImageContext
);
700 *EntryPoint
= (VOID
*)(UINTN
)ImageContext
.EntryPoint
;
710 Return the FD Size and base address. Since the FD is loaded from a
711 file into host memory only the SEC will know it's address.
714 Index - Which FD, starts at zero.
715 FdSize - Size of the FD in bytes
716 FdBase - Start address of the FD. Assume it points to an FV Header
717 FixUp - Difference between actual FD address and build address
720 EFI_SUCCESS - Return the Base address and size of the FV
721 EFI_UNSUPPORTED - Index does nto map to an FD in the system
728 IN OUT EFI_PHYSICAL_ADDRESS
*FdBase
,
729 IN OUT UINT64
*FdSize
,
730 IN OUT EFI_PHYSICAL_ADDRESS
*FixUp
733 if (Index
>= gFdInfoCount
) {
734 return EFI_UNSUPPORTED
;
737 *FdBase
= gFdInfo
[Index
].Address
;
738 *FdSize
= gFdInfo
[Index
].Size
;
741 if (*FdBase
== 0 && *FdSize
== 0) {
742 return EFI_UNSUPPORTED
;
747 // FD 0 has XIP code and well known PCD values
748 // If the memory buffer could not be allocated at the FD build address
749 // the Fixup is the difference.
751 *FixUp
= *FdBase
- PcdGet64 (PcdEmuFdBaseAddress
);
761 Count the number of seperators in String
764 String - String to process
765 Seperator - Item to count
768 Number of Seperator in String
772 CountSeperatorsInString (
773 IN
const CHAR16
*String
,
779 for (Count
= 0; *String
!= '\0'; String
++) {
780 if (*String
== Seperator
) {
793 IN OUT UINTN
*ReadSize
,
799 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
802 FileHandle - The handle to the PE/COFF file
803 FileOffset - The offset, in bytes, into the file to read
804 ReadSize - The number of bytes to read from the file starting at FileOffset
805 Buffer - A pointer to the buffer to read the data into.
808 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
816 Destination8
= Buffer
;
817 Source8
= (CHAR8
*) ((UINTN
) FileHandle
+ FileOffset
);
820 *(Destination8
++) = *(Source8
++);
830 Store the ModHandle in an array indexed by the Pdb File name.
831 The ModHandle is needed to unload the image.
834 ImageContext - Input data returned from PE Laoder Library. Used to find the
835 .PDB file name of the PE Image.
836 ModHandle - Returned from LoadLibraryEx() and stored for call to
840 EFI_SUCCESS - ModHandle was stored.
845 IN PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
,
850 IMAGE_CONTEXT_TO_MOD_HANDLE
*Array
;
854 Array
= mImageContextModHandleArray
;
855 for (Index
= 0; Index
< mImageContextModHandleArraySize
; Index
++, Array
++) {
856 if (Array
->ImageContext
== NULL
) {
858 // Make a copy of the stirng and store the ModHandle
860 Array
->ImageContext
= ImageContext
;
861 Array
->ModHandle
= ModHandle
;
867 // No free space in mImageContextModHandleArray so grow it by
868 // IMAGE_CONTEXT_TO_MOD_HANDLE entires. realloc will
869 // copy the old values to the new locaiton. But it does
870 // not zero the new memory area.
872 PreviousSize
= mImageContextModHandleArraySize
* sizeof (IMAGE_CONTEXT_TO_MOD_HANDLE
);
873 mImageContextModHandleArraySize
+= MAX_IMAGE_CONTEXT_TO_MOD_HANDLE_ARRAY_SIZE
;
875 mImageContextModHandleArray
= realloc (mImageContextModHandleArray
, mImageContextModHandleArraySize
* sizeof (IMAGE_CONTEXT_TO_MOD_HANDLE
));
876 if (mImageContextModHandleArray
== NULL
) {
878 return EFI_OUT_OF_RESOURCES
;
881 memset (mImageContextModHandleArray
+ PreviousSize
, 0, MAX_IMAGE_CONTEXT_TO_MOD_HANDLE_ARRAY_SIZE
* sizeof (IMAGE_CONTEXT_TO_MOD_HANDLE
));
883 return AddHandle (ImageContext
, ModHandle
);
890 Return the ModHandle and delete the entry in the array.
893 ImageContext - Input data returned from PE Laoder Library. Used to find the
894 .PDB file name of the PE Image.
897 ModHandle - ModHandle assoicated with ImageContext is returned
898 NULL - No ModHandle associated with ImageContext
903 IN PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
907 IMAGE_CONTEXT_TO_MOD_HANDLE
*Array
;
909 if (ImageContext
->PdbPointer
== NULL
) {
911 // If no PDB pointer there is no ModHandle so return NULL
916 Array
= mImageContextModHandleArray
;
917 for (Index
= 0; Index
< mImageContextModHandleArraySize
; Index
++, Array
++) {
918 if (Array
->ImageContext
== ImageContext
) {
920 // If you find a match return it and delete the entry
922 Array
->ImageContext
= NULL
;
923 return Array
->ModHandle
;
933 // Target for gdb breakpoint in a script that uses gGdbWorkingFileName to source a
934 // add-symbol-file command. Hey what can you say scripting in gdb is not that great....
936 // Put .gdbinit in the CWD where you do gdb SecMain.dll for source level debug
939 // b SecGdbScriptBreak
942 // source SecMain.gdb
962 IN CHAR8
*PdbFileName
967 if (PdbFileName
== NULL
) {
971 Len
= strlen (PdbFileName
);
972 if ((Len
< 5)|| (PdbFileName
[Len
- 4] != '.')) {
976 if ((PdbFileName
[Len
- 3] == 'P' || PdbFileName
[Len
- 3] == 'p') &&
977 (PdbFileName
[Len
- 2] == 'D' || PdbFileName
[Len
- 2] == 'd') &&
978 (PdbFileName
[Len
- 1] == 'B' || PdbFileName
[Len
- 1] == 'b')) {
986 #define MAX_SPRINT_BUFFER_SIZE 0x200
990 IN PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
993 if (ImageContext
->PdbPointer
== NULL
) {
995 "0x%08lx Loading NO DEBUG with entry point 0x%08lx\n",
996 (unsigned long)(ImageContext
->ImageAddress
),
997 (unsigned long)ImageContext
->EntryPoint
1001 "0x%08lx Loading %s with entry point 0x%08lx\n",
1002 (unsigned long)(ImageContext
->ImageAddress
+ ImageContext
->SizeOfHeaders
),
1003 ImageContext
->PdbPointer
,
1004 (unsigned long)ImageContext
->EntryPoint
1007 // Keep output synced up
1014 SecPeCoffRelocateImageExtraAction (
1015 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
1020 BOOLEAN EnabledOnEntry
;
1023 // Make sure writting of the file is an atomic operation
1025 if (SecInterruptEanbled ()) {
1026 SecDisableInterrupt ();
1027 EnabledOnEntry
= TRUE
;
1029 EnabledOnEntry
= FALSE
;
1032 PrintLoadAddress (ImageContext
);
1035 // In mach-o (OS X executable) dlopen() can only load files in the MH_DYLIB of MH_BUNDLE format.
1036 // To convert to PE/COFF we need to construct a mach-o with the MH_PRELOAD format. We create
1037 // .dSYM files for the PE/COFF images that can be used by gdb for source level debugging.
1042 // In the Mach-O to PE/COFF conversion the size of the PE/COFF headers is not accounted for.
1043 // Thus we need to skip over the PE/COFF header when giving load addresses for our symbol table.
1045 if (ImageContext
->PdbPointer
!= NULL
&& !IsPdbFile (ImageContext
->PdbPointer
)) {
1047 // Now we have a database of the images that are currently loaded
1051 // 'symbol-file' will clear out currnet symbol mappings in gdb.
1052 // you can do a 'add-symbol-file filename address' for every image we loaded to get source
1053 // level debug in gdb. Note Sec, being a true application will work differently.
1055 // We add the PE/COFF header size into the image as the mach-O does not have a header in
1056 // loaded into system memory.
1058 // This gives us a data base of gdb commands and after something is unloaded that entry will be
1059 // removed. We don't yet have the scheme of how to comunicate with gdb, but we have the
1060 // data base of info ready to roll.
1062 // We could use qXfer:libraries:read, but OS X GDB does not currently support it.
1064 // <library name="/lib/libc.so.6"> // ImageContext->PdbPointer
1065 // <segment address="0x10000000"/> // ImageContext->ImageAddress + ImageContext->SizeOfHeaders
1071 // Write the file we need for the gdb script
1073 GdbTempFile
= fopen (gGdbWorkingFileName
, "w");
1074 if (GdbTempFile
!= NULL
) {
1075 fprintf (GdbTempFile
, "add-symbol-file %s 0x%08lx\n", ImageContext
->PdbPointer
, (long unsigned int)(ImageContext
->ImageAddress
+ ImageContext
->SizeOfHeaders
));
1076 fclose (GdbTempFile
);
1079 // Target for gdb breakpoint in a script that uses gGdbWorkingFileName to set a breakpoint.
1080 // Hey what can you say scripting in gdb is not that great....
1082 SecGdbScriptBreak ();
1087 AddHandle (ImageContext
, ImageContext
->PdbPointer
);
1089 if (EnabledOnEntry
) {
1090 SecEnableInterrupt ();
1098 void *Handle
= NULL
;
1101 if (ImageContext
->PdbPointer
== NULL
) {
1105 if (!IsPdbFile (ImageContext
->PdbPointer
)) {
1111 "Loading %s 0x%08lx - entry point 0x%08lx\n",
1112 ImageContext
->PdbPointer
,
1113 (unsigned long)ImageContext
->ImageAddress
,
1114 (unsigned long)ImageContext
->EntryPoint
1117 Handle
= dlopen (ImageContext
->PdbPointer
, RTLD_NOW
);
1120 Entry
= dlsym (Handle
, "_ModuleEntryPoint");
1122 printf("%s\n", dlerror());
1125 if (Entry
!= NULL
) {
1126 ImageContext
->EntryPoint
= (UINTN
)Entry
;
1127 printf ("Change %s Entrypoint to :0x%08lx\n", ImageContext
->PdbPointer
, (unsigned long)Entry
);
1130 SecUnixLoaderBreak ();
1140 SecPeCoffUnloadImageExtraAction (
1141 IN PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
1146 Handle
= RemoveHandle (ImageContext
);
1150 BOOLEAN EnabledOnEntry
;
1152 if (Handle
!= NULL
) {
1154 // Need to skip .PDB files created from VC++
1156 if (!IsPdbFile (ImageContext
->PdbPointer
)) {
1157 if (SecInterruptEanbled ()) {
1158 SecDisableInterrupt ();
1159 EnabledOnEntry
= TRUE
;
1161 EnabledOnEntry
= FALSE
;
1165 // Write the file we need for the gdb script
1167 GdbTempFile
= fopen (gGdbWorkingFileName
, "w");
1168 if (GdbTempFile
!= NULL
) {
1169 fprintf (GdbTempFile
, "remove-symbol-file %s\n", ImageContext
->PdbPointer
);
1170 fclose (GdbTempFile
);
1173 // Target for gdb breakpoint in a script that uses gGdbWorkingFileName to set a breakpoint.
1174 // Hey what can you say scripting in gdb is not that great....
1176 SecGdbScriptBreak ();
1181 if (EnabledOnEntry
) {
1182 SecEnableInterrupt ();
1189 // Don't want to confuse gdb with symbols for something that got unloaded
1191 if (Handle
!= NULL
) {