/*++ Routine Description: Main entry point to SEC for Unix. This is a unix program Arguments: Argc - Number of command line arguments Argv - Array of command line argument strings Envp - Array of environment variable strings Returns: 0 - Normal exit 1 - Abnormal exit **/ int main ( IN int Argc, IN char **Argv, IN char **Envp ) { EFI_STATUS Status; EFI_PHYSICAL_ADDRESS InitialStackMemory; UINT64 InitialStackMemorySize; UINTN Index; UINTN Index1; UINTN Index2; UINTN PeiIndex; CHAR8 *FileName; BOOLEAN Done; EFI_PEI_FILE_HANDLE FileHandle; VOID *SecFile; CHAR16 *MemorySizeStr; CHAR16 *FirmwareVolumesStr; UINTN *StackPointer; FILE *GdbTempFile; // // Xcode does not support sourcing gdb scripts directly, so the Xcode XML // has a break point script to source the GdbRun script. // SecGdbConfigBreak (); // // If dlopen doesn't work, then we build a gdb script to allow the // symbols to be loaded. // Index = strlen (*Argv); gGdbWorkingFileName = AllocatePool (Index + strlen(".gdb") + 1); strcpy (gGdbWorkingFileName, *Argv); strcat (gGdbWorkingFileName, ".gdb"); // // Empty out the gdb symbols script file. // GdbTempFile = fopen (gGdbWorkingFileName, "w"); if (GdbTempFile != NULL) { fclose (GdbTempFile); } printf ("\nEDK II UNIX Host Emulation Environment from http://www.tianocore.org/edk2/\n"); setbuf (stdout, 0); setbuf (stderr, 0); MemorySizeStr = (CHAR16 *) PcdGetPtr (PcdEmuMemorySize); FirmwareVolumesStr = (CHAR16 *) PcdGetPtr (PcdEmuFirmwareVolume); // // PPIs pased into PEI_CORE // AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, &mSecEmuThunkPpi); SecInitThunkProtocol (); // // Emulator Bus Driver Thunks // AddThunkProtocol (&gX11ThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuGop), TRUE); AddThunkProtocol (&gPosixFileSystemThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuFileSystem), TRUE); AddThunkProtocol (&gBlockIoThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuVirtualDisk), TRUE); AddThunkProtocol (&gSnpThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuNetworkInterface), TRUE); // // Emulator other Thunks // AddThunkProtocol (&gPthreadThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuApCount), FALSE); // EmuSecLibConstructor (); gPpiList = GetThunkPpiList (); // // Allocate space for gSystemMemory Array // gSystemMemoryCount = CountSeparatorsInString (MemorySizeStr, '!') + 1; gSystemMemory = AllocateZeroPool (gSystemMemoryCount * sizeof (EMU_SYSTEM_MEMORY)); if (gSystemMemory == NULL) { printf ("ERROR : Can not allocate memory for system. Exiting.\n"); exit (1); } // // Allocate space for gSystemMemory Array // gFdInfoCount = CountSeparatorsInString (FirmwareVolumesStr, '!') + 1; gFdInfo = AllocateZeroPool (gFdInfoCount * sizeof (EMU_FD_INFO)); if (gFdInfo == NULL) { printf ("ERROR : Can not allocate memory for fd info. Exiting.\n"); exit (1); } printf (" BootMode 0x%02x\n", (unsigned int)PcdGet32 (PcdEmuBootMode)); // // Open up a 128K file to emulate temp memory for SEC. // on a real platform this would be SRAM, or using the cache as RAM. // Set InitialStackMemory to zero so UnixOpenFile will allocate a new mapping // InitialStackMemorySize = STACK_SIZE; InitialStackMemory = (UINTN)MapMemory ( 0, (UINT32) InitialStackMemorySize, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE ); if (InitialStackMemory == 0) { printf ("ERROR : Can not open SecStack Exiting\n"); exit (1); } printf (" OS Emulator passing in %u KB of temp RAM at 0x%08lx to SEC\n", (unsigned int)(InitialStackMemorySize / 1024), (unsigned long)InitialStackMemory ); for (StackPointer = (UINTN*) (UINTN) InitialStackMemory; StackPointer < (UINTN*)(UINTN)((UINTN) InitialStackMemory + (UINT64) InitialStackMemorySize); StackPointer ++) { *StackPointer = 0x5AA55AA5; } // // Open All the firmware volumes and remember the info in the gFdInfo global // FileName = (CHAR8 *) AllocatePool (StrLen (FirmwareVolumesStr) + 1); if (FileName == NULL) { printf ("ERROR : Can not allocate memory for firmware volume string\n"); exit (1); } Index2 = 0; for (Done = FALSE, Index = 0, PeiIndex = 0, SecFile = NULL; FirmwareVolumesStr[Index2] != 0; Index++) { for (Index1 = 0; (FirmwareVolumesStr[Index2] != '!') && (FirmwareVolumesStr[Index2] != 0); Index2++) { FileName[Index1++] = FirmwareVolumesStr[Index2]; } if (FirmwareVolumesStr[Index2] == '!') { Index2++; } FileName[Index1] = '\0'; if (Index == 0) { // Map FV Recovery Read Only and other areas Read/Write Status = MapFd0 ( FileName, &gFdInfo[0].Address, &gFdInfo[0].Size ); } else { // // Open the FD and remember where it got mapped into our processes address space // Maps Read Only // Status = MapFile ( FileName, &gFdInfo[Index].Address, &gFdInfo[Index].Size ); } if (EFI_ERROR (Status)) { printf ("ERROR : Can not open Firmware Device File %s (%x). Exiting.\n", FileName, (unsigned int)Status); exit (1); } printf (" FD loaded from %s at 0x%08lx",FileName, (unsigned long)gFdInfo[Index].Address); if (SecFile == NULL) { // // Assume the beginning of the FD is an FV and look for the SEC Core. // Load the first one we find. // FileHandle = NULL; Status = PeiServicesFfsFindNextFile ( EFI_FV_FILETYPE_SECURITY_CORE, (EFI_PEI_FV_HANDLE)(UINTN)gFdInfo[Index].Address, &FileHandle ); if (!EFI_ERROR (Status)) { Status = PeiServicesFfsFindSectionData (EFI_SECTION_PE32, FileHandle, &SecFile); if (!EFI_ERROR (Status)) { PeiIndex = Index; printf (" contains SEC Core"); } } } printf ("\n"); } if (SecFile == NULL) { printf ("ERROR : SEC not found!\n"); exit (1); } // // Calculate memory regions and store the information in the gSystemMemory // global for later use. The autosizing code will use this data to // map this memory into the SEC process memory space. // Index1 = 0; Index = 0; while (1) { UINTN val = 0; // // Save the size of the memory. // while (MemorySizeStr[Index1] >= '0' && MemorySizeStr[Index1] <= '9') { val = val * 10 + MemorySizeStr[Index1] - '0'; Index1++; } gSystemMemory[Index++].Size = val * 0x100000; if (MemorySizeStr[Index1] == 0) { break; } Index1++; } printf ("\n"); // // Hand off to SEC // SecLoadFromCore ((UINTN) InitialStackMemory, (UINTN) InitialStackMemorySize, (UINTN) gFdInfo[0].Address, SecFile); // // If we get here, then the SEC Core returned. This is an error as SEC should // always hand off to PEI Core and then on to DXE Core. // printf ("ERROR : SEC returned\n"); exit (1); }
VOID SecLoadSecCore ( IN UINTN TemporaryRam, IN UINTN TemporaryRamSize, IN VOID *BootFirmwareVolumeBase, IN UINTN BootFirmwareVolumeSize, IN VOID *SecCorePe32File ) /*++ Routine Description: This is the service to load the SEC Core from the Firmware Volume Arguments: TemporaryRam - Memory to use for SEC. TemporaryRamSize - Size of Memory to use for SEC BootFirmwareVolumeBase - Start of the Boot FV SecCorePe32File - SEC Core PE32 Returns: Success means control is transfered and thus we should never return --*/ { EFI_STATUS Status; VOID *TopOfStack; VOID *SecCoreEntryPoint; EFI_SEC_PEI_HAND_OFF *SecCoreData; UINTN SecStackSize; // // Compute Top Of Memory for Stack and PEI Core Allocations // SecStackSize = TemporaryRamSize >> 1; // // |-----------| <---- TemporaryRamBase + TemporaryRamSize // | Heap | // | | // |-----------| <---- StackBase / PeiTemporaryMemoryBase // | | // | Stack | // |-----------| <---- TemporaryRamBase // TopOfStack = (VOID *)(TemporaryRam + SecStackSize); // // Reservet space for storing PeiCore's parament in stack. // TopOfStack = (VOID *)((UINTN)TopOfStack - sizeof (EFI_SEC_PEI_HAND_OFF) - CPU_STACK_ALIGNMENT); TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT); // // Bind this information into the SEC hand-off state // SecCoreData = (EFI_SEC_PEI_HAND_OFF*)(UINTN)TopOfStack; SecCoreData->DataSize = sizeof (EFI_SEC_PEI_HAND_OFF); SecCoreData->BootFirmwareVolumeBase = BootFirmwareVolumeBase; SecCoreData->BootFirmwareVolumeSize = BootFirmwareVolumeSize; SecCoreData->TemporaryRamBase = (VOID*)TemporaryRam; SecCoreData->TemporaryRamSize = TemporaryRamSize; SecCoreData->StackBase = SecCoreData->TemporaryRamBase; SecCoreData->StackSize = SecStackSize; SecCoreData->PeiTemporaryRamBase = (VOID*) ((UINTN) SecCoreData->TemporaryRamBase + SecStackSize); SecCoreData->PeiTemporaryRamSize = TemporaryRamSize - SecStackSize; // // Load the PEI Core from a Firmware Volume // Status = SecPeCoffGetEntryPoint ( SecCorePe32File, &SecCoreEntryPoint ); if (EFI_ERROR (Status)) { return ; } // // Transfer control to the SEC Core // SwitchStack ( (SWITCH_STACK_ENTRY_POINT)(UINTN)SecCoreEntryPoint, SecCoreData, GetThunkPpiList (), TopOfStack ); // // If we get here, then the SEC Core returned. This is an error // return ; }