InOsEmuPkg/Unix/Sec/SecMain.c

   1 /*++ @file
   2
   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
   9
  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.
  12
  13 **/
  14
  15 #include "SecMain.h"
  16
  17 #ifdef __APPLE__
  18 #define MAP_ANONYMOUS MAP_ANON
  19 char *gGdbWorkingFileName = NULL;
  20 #endif
  21
  22
  23 //
  24 // Globals
  25 //
  26
  27 EMU_THUNK_PPI mSecEmuThunkPpi = {
  28   GasketSecUnixPeiAutoScan,
  29   GasketSecUnixFdAddress,
  30   GasketSecEmuThunkAddress
  31 };
  32
  33
  34
  35
  36 //
  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.
  42 //
  43 UINTN       gFdInfoCount = 0;
  44 EMU_FD_INFO *gFdInfo;
  45
  46 //
  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.
  51 //
  52 UINTN              gSystemMemoryCount = 0;
  53 EMU_SYSTEM_MEMORY  *gSystemMemory;
  54
  55
  56
  57 UINTN                        mImageContextModHandleArraySize = 0;
  58 IMAGE_CONTEXT_TO_MOD_HANDLE  *mImageContextModHandleArray = NULL;
  59
  60 EFI_PEI_PPI_DESCRIPTOR  *gPpiList;
  61
  62 /*++
  63
  64 Routine Description:
  65   Main entry point to SEC for Unix. This is a unix program
  66
  67 Arguments:
  68   Argc - Number of command line arguments
  69   Argv - Array of command line argument strings
  70   Envp - Array of environmemt variable strings
  71
  72 Returns:
  73   0 - Normal exit
  74   1 - Abnormal exit
  75
  76 **/
  77 int
  78 main (
  79   IN  int   Argc,
  80   IN  char  **Argv,
  81   IN  char  **Envp
  82   )
  83 {
  84   EFI_STATUS            Status;
  85   EFI_PHYSICAL_ADDRESS  InitialStackMemory;
  86   UINT64                InitialStackMemorySize;
  87   UINTN                 Index;
  88   UINTN                 Index1;
  89   UINTN                 Index2;
  90   UINTN                 PeiIndex;
  91   CHAR8                 *FileName;
  92   BOOLEAN               Done;
  93   EFI_PEI_FILE_HANDLE   FileHandle;
  94   VOID                  *SecFile;
  95   CHAR16                *MemorySizeStr;
  96   CHAR16                *FirmwareVolumesStr;
  97   UINTN                 *StackPointer;
  98
  99   setbuf (stdout, 0);
 100   setbuf (stderr, 0);
 101
 102   MemorySizeStr      = (CHAR16 *) PcdGetPtr (PcdEmuMemorySize);
 103   FirmwareVolumesStr = (CHAR16 *) PcdGetPtr (PcdEmuFirmwareVolume);
 104
 105   printf ("\nEDK II UNIX Emulation Environment from edk2.sourceforge.net\n");
 106
 107   //
 108   // PPIs pased into PEI_CORE
 109   //
 110   AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, &mSecEmuThunkPpi);
 111
 112   SecInitThunkProtocol ();
 113
 114   //
 115   // Emulator Bus Driver Thunks
 116   //
 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);
 121
 122   //
 123   // Emulator other Thunks
 124   //
 125   AddThunkProtocol (&gPthreadThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuApCount), FALSE);
 126
 127   // EmuSecLibConstructor ();
 128
 129   gPpiList = GetThunkPpiList ();
 130
 131
 132 #ifdef __APPLE__
 133   //
 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.
 137   //
 138   Index = strlen (*Argv);
 139   gGdbWorkingFileName = malloc (Index + strlen(".gdb") + 1);
 140   strcpy (gGdbWorkingFileName, *Argv);
 141   strcat (gGdbWorkingFileName, ".gdb");
 142 #endif
 143
 144
 145   //
 146   // Allocate space for gSystemMemory Array
 147   //
 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");
 152     exit (1);
 153   }
 154   //
 155   // Allocate space for gSystemMemory Array
 156   //
 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");
 161     exit (1);
 162   }
 163
 164   printf ("  BootMode 0x%02x\n", (unsigned int)PcdGet32 (PcdEmuBootMode));
 165
 166   //
 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
 170   //
 171   InitialStackMemorySize  = STACK_SIZE;
 172   InitialStackMemory = (UINTN)MapMemory (
 173                                 0, (UINT32) InitialStackMemorySize,
 174                                 PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE
 175                                 );
 176   if (InitialStackMemory == 0) {
 177     printf ("ERROR : Can not open SecStack Exiting\n");
 178     exit (1);
 179   }
 180
 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
 184     );
 185
 186   for (StackPointer = (UINTN*) (UINTN) InitialStackMemory;
 187      StackPointer < (UINTN*)(UINTN)((UINTN) InitialStackMemory + (UINT64) InitialStackMemorySize);
 188      StackPointer ++) {
 189     *StackPointer = 0x5AA55AA5;
 190   }
 191
 192   //
 193   // Open All the firmware volumes and remember the info in the gFdInfo global
 194   //
 195   FileName = (CHAR8 *)malloc (StrLen (FirmwareVolumesStr) + 1);
 196   if (FileName == NULL) {
 197     printf ("ERROR : Can not allocate memory for firmware volume string\n");
 198     exit (1);
 199   }
 200
 201   Index2 = 0;
 202   for (Done = FALSE, Index = 0, PeiIndex = 0, SecFile = NULL;
 203        FirmwareVolumesStr[Index2] != 0;
 204        Index++) {
 205     for (Index1 = 0; (FirmwareVolumesStr[Index2] != '!') && (FirmwareVolumesStr[Index2] != 0); Index2++) {
 206       FileName[Index1++] = FirmwareVolumesStr[Index2];
 207     }
 208     if (FirmwareVolumesStr[Index2] == '!') {
 209       Index2++;
 210     }
 211     FileName[Index1]  = '\0';
 212
 213     if (Index == 0) {
 214       // Map FV Recovery Read Only and other areas Read/Write
 215       Status = MapFd0 (
 216                 FileName,
 217                 &gFdInfo[0].Address,
 218                 &gFdInfo[0].Size
 219                 );
 220     } else {
 221       //
 222       // Open the FD and remmeber where it got mapped into our processes address space
 223       // Maps Read Only
 224       //
 225       Status = MapFile (
 226                 FileName,
 227                 &gFdInfo[Index].Address,
 228                 &gFdInfo[Index].Size
 229                 );
 230     }
 231     if (EFI_ERROR (Status)) {
 232       printf ("ERROR : Can not open Firmware Device File %s (%x).  Exiting.\n", FileName, (unsigned int)Status);
 233       exit (1);
 234     }
 235
 236     printf ("  FD loaded from %s at 0x%08lx",FileName, (unsigned long)gFdInfo[Index].Address);
 237
 238     if (SecFile == NULL) {
 239       //
 240       // Assume the beginning of the FD is an FV and look for the SEC Core.
 241       // Load the first one we find.
 242       //
 243       FileHandle = NULL;
 244       Status = PeiServicesFfsFindNextFile (
 245                   EFI_FV_FILETYPE_SECURITY_CORE,
 246                   (EFI_PEI_FV_HANDLE)(UINTN)gFdInfo[Index].Address,
 247                   &FileHandle
 248                   );
 249       if (!EFI_ERROR (Status)) {
 250         Status = PeiServicesFfsFindSectionData (EFI_SECTION_PE32, FileHandle, &SecFile);
 251         if (!EFI_ERROR (Status)) {
 252           PeiIndex = Index;
 253           printf (" contains SEC Core");
 254         }
 255       }
 256     }
 257
 258     printf ("\n");
 259   }
 260   //
 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.
 264   //
 265   Index1 = 0;
 266   Index = 0;
 267   while (1) {
 268     UINTN val = 0;
 269     //
 270     // Save the size of the memory.
 271     //
 272     while (MemorySizeStr[Index1] >= '0' && MemorySizeStr[Index1] <= '9') {
 273       val = val * 10 + MemorySizeStr[Index1] - '0';
 274       Index1++;
 275     }
 276     gSystemMemory[Index++].Size = val * 0x100000;
 277     if (MemorySizeStr[Index1] == 0) {
 278       break;
 279     }
 280     Index1++;
 281   }
 282
 283   printf ("\n");
 284
 285   //
 286   // Hand off to SEC
 287   //
 288   SecLoadFromCore ((UINTN) InitialStackMemory, (UINTN) InitialStackMemorySize, (UINTN) gFdInfo[0].Address, SecFile);
 289
 290   //
 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.
 293   //
 294   printf ("ERROR : SEC returned\n");
 295   exit (1);
 296 }
 297
 298
 299 EFI_PHYSICAL_ADDRESS *
 300 MapMemory (
 301   IN INTN   fd,
 302   IN UINT64 length,
 303   IN INTN   prot,
 304   IN INTN   flags
 305   )
 306 {
 307   STATIC UINTN base  = 0x40000000;
 308   CONST UINTN  align = (1 << 24);
 309   VOID         *res  = NULL;
 310   BOOLEAN      isAligned = 0;
 311
 312   //
 313   // Try to get an aligned block somewhere in the address space of this
 314   // process.
 315   //
 316   while((!isAligned) && (base != 0)) {
 317     res = mmap ((void *)base, length, prot, flags, fd, 0);
 318     if (res == MAP_FAILED) {
 319       return NULL;
 320     }
 321     if ((((UINTN)res) & ~(align-1)) == (UINTN)res) {
 322       isAligned=1;
 323     } else {
 324       munmap(res, length);
 325       base += align;
 326     }
 327   }
 328   return res;
 329 }
 330
 331
 332 /*++
 333
 334 Routine Description:
 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.
 337
 338 Arguments:
 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
 348
 349 Returns:
 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
 353
 354 **/
 355 EFI_STATUS
 356 MapFile (
 357   IN  CHAR8                     *FileName,
 358   IN OUT  EFI_PHYSICAL_ADDRESS  *BaseAddress,
 359   OUT UINT64                    *Length
 360   )
 361 {
 362   int     fd;
 363   VOID    *res;
 364   UINTN   FileSize;
 365
 366   fd = open (FileName, O_RDWR);
 367   if (fd < 0) {
 368     return EFI_NOT_FOUND;
 369   }
 370   FileSize = lseek (fd, 0, SEEK_END);
 371
 372
 373   res = MapMemory (fd, FileSize, PROT_READ | PROT_EXEC, MAP_PRIVATE);
 374
 375   close (fd);
 376
 377   if (res == NULL) {
 378     perror ("MapFile() Failed");
 379     return EFI_DEVICE_ERROR;
 380   }
 381
 382   *Length = (UINT64) FileSize;
 383   *BaseAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) res;
 384
 385   return EFI_SUCCESS;
 386 }
 387
 388 EFI_STATUS
 389 MapFd0 (
 390   IN  CHAR8                     *FileName,
 391   IN OUT  EFI_PHYSICAL_ADDRESS  *BaseAddress,
 392   OUT UINT64                    *Length
 393   )
 394 {
 395   int     fd;
 396   void    *res, *res2, *res3;
 397   UINTN   FileSize;
 398   UINTN   FvSize;
 399   void    *EmuMagicPage;
 400
 401   fd = open (FileName, O_RDWR);
 402   if (fd < 0) {
 403     return EFI_NOT_FOUND;
 404   }
 405   FileSize = lseek (fd, 0, SEEK_END);
 406
 407   FvSize = FixedPcdGet64 (PcdEmuFlashFvRecoverySize);
 408
 409   // Assume start of FD is Recovery FV, and make it write protected
 410   res = mmap (
 411           (void *)(UINTN)FixedPcdGet64 (PcdEmuFlashFvRecoveryBase),
 412           FvSize,
 413           PROT_READ | PROT_EXEC,
 414           MAP_PRIVATE,
 415           fd,
 416           0
 417           );
 418   if (res == MAP_FAILED) {
 419     perror ("MapFd0() Failed res =");
 420     close (fd);
 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);
 425     res = mmap (
 426             (void *)(UINTN)FixedPcdGet64 (PcdEmuFlashFvRecoveryBase),
 427             FvSize,
 428             PROT_READ | PROT_WRITE | PROT_EXEC,
 429             MAP_PRIVATE,
 430             fd,
 431             0
 432             );
 433     if (res == MAP_FAILED) {
 434       perror ("MapFd0() Failed res =");
 435       close (fd);
 436       return EFI_DEVICE_ERROR;
 437     }
 438   }
 439
 440   // Map the rest of the FD as read/write
 441   res2 = mmap (
 442           (void *)(UINTN)(FixedPcdGet64 (PcdEmuFlashFvRecoveryBase) + FvSize),
 443           FileSize - FvSize,
 444           PROT_READ | PROT_WRITE | PROT_EXEC,
 445           MAP_SHARED,
 446           fd,
 447           FvSize
 448           );
 449   close (fd);
 450   if (res2 == MAP_FAILED) {
 451     perror ("MapFd0() Failed res2 =");
 452     return EFI_DEVICE_ERROR;
 453   }
 454
 455   //
 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
 460   //
 461   EmuMagicPage = (void *)(UINTN)FixedPcdGet64 (PcdPeiServicesTablePage);
 462   if (EmuMagicPage != NULL) {
 463     res3 =  mmap (
 464               (void *)EmuMagicPage,
 465               4096,
 466               PROT_READ | PROT_WRITE,
 467               MAP_PRIVATE | MAP_ANONYMOUS,
 468               0,
 469               0
 470               );
 471     if (res3 != EmuMagicPage) {
 472       printf ("MapFd0(): Could not allocate PeiServicesTablePage @ %lx\n", (long unsigned int)EmuMagicPage);
 473       return EFI_DEVICE_ERROR;
 474     }
 475   }
 476
 477   *Length = (UINT64) FileSize;
 478   *BaseAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) res;
 479
 480   return EFI_SUCCESS;
 481 }
 482
 483
 484 /*++
 485
 486 Routine Description:
 487   This is the service to load the SEC Core from the Firmware Volume
 488
 489 Arguments:
 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
 494
 495 Returns:
 496   Success means control is transfered and thus we should never return
 497
 498 **/
 499 VOID
 500 SecLoadFromCore (
 501   IN  UINTN   LargestRegion,
 502   IN  UINTN   LargestRegionSize,
 503   IN  UINTN   BootFirmwareVolumeBase,
 504   IN  VOID    *PeiCorePe32File
 505   )
 506 {
 507   EFI_STATUS                  Status;
 508   EFI_PHYSICAL_ADDRESS        TopOfMemory;
 509   VOID                        *TopOfStack;
 510   EFI_PHYSICAL_ADDRESS        PeiCoreEntryPoint;
 511   EFI_SEC_PEI_HAND_OFF        *SecCoreData;
 512   UINTN                       PeiStackSize;
 513
 514   //
 515   // Compute Top Of Memory for Stack and PEI Core Allocations
 516   //
 517   TopOfMemory  = LargestRegion + LargestRegionSize;
 518   PeiStackSize = (UINTN)RShiftU64((UINT64)STACK_SIZE,1);
 519
 520   //
 521   // |-----------| <---- TemporaryRamBase + TemporaryRamSize
 522   // |   Heap    |
 523   // |           |
 524   // |-----------| <---- StackBase / PeiTemporaryMemoryBase
 525   // |           |
 526   // |  Stack    |
 527   // |-----------| <---- TemporaryRamBase
 528   //
 529   TopOfStack  = (VOID *)(LargestRegion + PeiStackSize);
 530   TopOfMemory = LargestRegion + PeiStackSize;
 531
 532   //
 533   // Reservet space for storing PeiCore's parament in stack.
 534   //
 535   TopOfStack  = (VOID *)((UINTN)TopOfStack - sizeof (EFI_SEC_PEI_HAND_OFF) - CPU_STACK_ALIGNMENT);
 536   TopOfStack  = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
 537
 538
 539   //
 540   // Bind this information into the SEC hand-off state
 541   //
 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;
 552
 553   //
 554   // Find the SEC Core Entry Point
 555   //
 556   Status = SecPeCoffGetEntryPoint (PeiCorePe32File, (VOID **)&PeiCoreEntryPoint);
 557   if (EFI_ERROR (Status)) {
 558     return ;
 559   }
 560
 561   //
 562   // Transfer control to the SEC Core
 563   //
 564   PeiSwitchStacks (
 565     (SWITCH_STACK_ENTRY_POINT) (UINTN) PeiCoreEntryPoint,
 566     SecCoreData,
 567     (VOID *)gPpiList,
 568     TopOfStack
 569     );
 570   //
 571   // If we get here, then the SEC Core returned.  This is an error
 572   //
 573   return ;
 574 }
 575
 576
 577 /*++
 578
 579 Routine Description:
 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
 585   UnixOpenFile.
 586
 587 Arguments:
 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
 591
 592 Returns:
 593   EFI_SUCCESS - If memory region was mapped
 594   EFI_UNSUPPORTED - If Index is not supported
 595
 596 **/
 597 EFI_STATUS
 598 EFIAPI
 599 SecUnixPeiAutoScan (
 600   IN  UINTN                 Index,
 601   OUT EFI_PHYSICAL_ADDRESS  *MemoryBase,
 602   OUT UINT64                *MemorySize
 603   )
 604 {
 605   void *res;
 606
 607   if (Index >= gSystemMemoryCount) {
 608     return EFI_UNSUPPORTED;
 609   }
 610
 611   *MemoryBase = 0;
 612   res = MapMemory (
 613           0, gSystemMemory[Index].Size,
 614           PROT_READ | PROT_WRITE | PROT_EXEC,
 615           MAP_PRIVATE | MAP_ANONYMOUS
 616           );
 617   if (res == MAP_FAILED) {
 618     return EFI_DEVICE_ERROR;
 619   }
 620   *MemorySize = gSystemMemory[Index].Size;
 621   *MemoryBase = (UINTN)res;
 622   gSystemMemory[Index].Memory = *MemoryBase;
 623
 624   return EFI_SUCCESS;
 625 }
 626
 627
 628 /*++
 629
 630 Routine Description:
 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.
 633
 634 Arguments:
 635   InterfaceSize - sizeof (EFI_WIN_NT_THUNK_PROTOCOL);
 636   InterfaceBase - Address of the gUnix global
 637
 638 Returns:
 639   EFI_SUCCESS - Data returned
 640
 641 **/
 642 VOID *
 643 EFIAPI
 644 SecEmuThunkAddress (
 645   VOID
 646   )
 647 {
 648   return &gEmuThunkProtocol;
 649 }
 650
 651
 652
 653 RETURN_STATUS
 654 EFIAPI
 655 SecPeCoffGetEntryPoint (
 656   IN     VOID  *Pe32Data,
 657   IN OUT VOID  **EntryPoint
 658   )
 659 {
 660   EFI_STATUS                    Status;
 661   PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;
 662
 663   ZeroMem (&ImageContext, sizeof (ImageContext));
 664   ImageContext.Handle     = Pe32Data;
 665   ImageContext.ImageRead  = (PE_COFF_LOADER_READ_FILE) SecImageRead;
 666
 667   Status                  = PeCoffLoaderGetImageInfo (&ImageContext);
 668   if (EFI_ERROR (Status)) {
 669     return Status;
 670   }
 671
 672   if (ImageContext.ImageAddress != (UINTN)Pe32Data) {
 673     //
 674     // Relocate image to match the address where it resides
 675     //
 676     ImageContext.ImageAddress = (UINTN)Pe32Data;
 677     Status = PeCoffLoaderLoadImage (&ImageContext);
 678     if (EFI_ERROR (Status)) {
 679       return Status;
 680     }
 681
 682     Status = PeCoffLoaderRelocateImage (&ImageContext);
 683     if (EFI_ERROR (Status)) {
 684       return Status;
 685     }
 686   } else {
 687     //
 688     // Or just return image entry point
 689     //
 690     ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer (Pe32Data);
 691     Status = PeCoffLoaderGetEntryPoint (Pe32Data, EntryPoint);
 692     if (EFI_ERROR (Status)) {
 693       return Status;
 694     }
 695     ImageContext.EntryPoint = (UINTN)*EntryPoint;
 696   }
 697
 698   // On Unix a dlopen is done that will change the entry point
 699   SecPeCoffRelocateImageExtraAction (&ImageContext);
 700   *EntryPoint = (VOID *)(UINTN)ImageContext.EntryPoint;
 701
 702   return Status;
 703 }
 704
 705
 706
 707 /*++
 708
 709 Routine Description:
 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.
 712
 713 Arguments:
 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
 718
 719 Returns:
 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
 722
 723 **/
 724 EFI_STATUS
 725 EFIAPI
 726 SecUnixFdAddress (
 727   IN     UINTN                 Index,
 728   IN OUT EFI_PHYSICAL_ADDRESS  *FdBase,
 729   IN OUT UINT64                *FdSize,
 730   IN OUT EFI_PHYSICAL_ADDRESS  *FixUp
 731   )
 732 {
 733   if (Index >= gFdInfoCount) {
 734     return EFI_UNSUPPORTED;
 735   }
 736
 737   *FdBase = gFdInfo[Index].Address;
 738   *FdSize = gFdInfo[Index].Size;
 739   *FixUp  = 0;
 740
 741   if (*FdBase == 0 && *FdSize == 0) {
 742     return EFI_UNSUPPORTED;
 743   }
 744
 745   if (Index == 0) {
 746     //
 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.
 750     //
 751     *FixUp = *FdBase - PcdGet64 (PcdEmuFdBaseAddress);
 752   }
 753
 754   return EFI_SUCCESS;
 755 }
 756
 757
 758 /*++
 759
 760 Routine Description:
 761   Count the number of seperators in String
 762
 763 Arguments:
 764   String    - String to process
 765   Seperator - Item to count
 766
 767 Returns:
 768   Number of Seperator in String
 769
 770 **/
 771 UINTN
 772 CountSeperatorsInString (
 773   IN  const CHAR16   *String,
 774   IN  CHAR16         Seperator
 775   )
 776 {
 777   UINTN Count;
 778
 779   for (Count = 0; *String != '\0'; String++) {
 780     if (*String == Seperator) {
 781       Count++;
 782     }
 783   }
 784
 785   return Count;
 786 }
 787
 788
 789 EFI_STATUS
 790 SecImageRead (
 791   IN     VOID    *FileHandle,
 792   IN     UINTN   FileOffset,
 793   IN OUT UINTN   *ReadSize,
 794   OUT    VOID    *Buffer
 795   )
 796 /*++
 797
 798 Routine Description:
 799   Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
 800
 801 Arguments:
 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.
 806
 807 Returns:
 808   EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
 809
 810 **/
 811 {
 812   CHAR8 *Destination8;
 813   CHAR8 *Source8;
 814   UINTN Length;
 815
 816   Destination8  = Buffer;
 817   Source8       = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
 818   Length        = *ReadSize;
 819   while (Length--) {
 820     *(Destination8++) = *(Source8++);
 821   }
 822
 823   return EFI_SUCCESS;
 824 }
 825
 826
 827 /*++
 828
 829 Routine Description:
 830   Store the ModHandle in an array indexed by the Pdb File name.
 831   The ModHandle is needed to unload the image.
 832
 833 Arguments:
 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
 837                  FreeLibrary().
 838
 839 Returns:
 840   EFI_SUCCESS - ModHandle was stored.
 841
 842 **/
 843 EFI_STATUS
 844 AddHandle (
 845   IN  PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext,
 846   IN  VOID                                 *ModHandle
 847   )
 848 {
 849   UINTN                       Index;
 850   IMAGE_CONTEXT_TO_MOD_HANDLE *Array;
 851   UINTN                       PreviousSize;
 852
 853
 854   Array = mImageContextModHandleArray;
 855   for (Index = 0; Index < mImageContextModHandleArraySize; Index++, Array++) {
 856     if (Array->ImageContext == NULL) {
 857       //
 858       // Make a copy of the stirng and store the ModHandle
 859       //
 860       Array->ImageContext = ImageContext;
 861       Array->ModHandle    = ModHandle;
 862       return EFI_SUCCESS;
 863     }
 864   }
 865
 866   //
 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.
 871   //
 872   PreviousSize = mImageContextModHandleArraySize * sizeof (IMAGE_CONTEXT_TO_MOD_HANDLE);
 873   mImageContextModHandleArraySize += MAX_IMAGE_CONTEXT_TO_MOD_HANDLE_ARRAY_SIZE;
 874
 875   mImageContextModHandleArray = realloc (mImageContextModHandleArray, mImageContextModHandleArraySize * sizeof (IMAGE_CONTEXT_TO_MOD_HANDLE));
 876   if (mImageContextModHandleArray == NULL) {
 877     ASSERT (FALSE);
 878     return EFI_OUT_OF_RESOURCES;
 879   }
 880
 881   memset (mImageContextModHandleArray + PreviousSize, 0, MAX_IMAGE_CONTEXT_TO_MOD_HANDLE_ARRAY_SIZE * sizeof (IMAGE_CONTEXT_TO_MOD_HANDLE));
 882
 883   return AddHandle (ImageContext, ModHandle);
 884 }
 885
 886
 887 /*++
 888
 889 Routine Description:
 890   Return the ModHandle and delete the entry in the array.
 891
 892 Arguments:
 893   ImageContext - Input data returned from PE Laoder Library. Used to find the
 894                  .PDB file name of the PE Image.
 895
 896 Returns:
 897   ModHandle - ModHandle assoicated with ImageContext is returned
 898   NULL      - No ModHandle associated with ImageContext
 899
 900 **/
 901 VOID *
 902 RemoveHandle (
 903   IN  PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext
 904   )
 905 {
 906   UINTN                        Index;
 907   IMAGE_CONTEXT_TO_MOD_HANDLE  *Array;
 908
 909   if (ImageContext->PdbPointer == NULL) {
 910     //
 911     // If no PDB pointer there is no ModHandle so return NULL
 912     //
 913     return NULL;
 914   }
 915
 916   Array = mImageContextModHandleArray;
 917   for (Index = 0; Index < mImageContextModHandleArraySize; Index++, Array++) {
 918     if (Array->ImageContext == ImageContext) {
 919       //
 920       // If you find a match return it and delete the entry
 921       //
 922       Array->ImageContext = NULL;
 923       return Array->ModHandle;
 924     }
 925   }
 926
 927   return NULL;
 928 }
 929
 930
 931
 932 //
 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....
 935 //
 936 // Put .gdbinit in the CWD where you do gdb SecMain.dll for source level debug
 937 //
 938 // cat .gdbinit
 939 // b SecGdbScriptBreak
 940 // command
 941 // silent
 942 // source SecMain.gdb
 943 // c
 944 // end
 945 //
 946 VOID
 947 SecGdbScriptBreak (
 948   VOID
 949   )
 950 {
 951 }
 952
 953 VOID
 954 SecUnixLoaderBreak (
 955   VOID
 956   )
 957 {
 958 }
 959
 960 BOOLEAN
 961 IsPdbFile (
 962   IN  CHAR8   *PdbFileName
 963   )
 964 {
 965   UINTN Len;
 966
 967   if (PdbFileName == NULL) {
 968     return FALSE;
 969   }
 970
 971   Len = strlen (PdbFileName);
 972   if ((Len < 5)|| (PdbFileName[Len - 4] != '.')) {
 973     return FALSE;
 974   }
 975
 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')) {
 979     return TRUE;
 980   }
 981
 982   return FALSE;
 983 }
 984
 985
 986 #define MAX_SPRINT_BUFFER_SIZE 0x200
 987
 988 void
 989 PrintLoadAddress (
 990   IN PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext
 991   )
 992 {
 993   if (ImageContext->PdbPointer == NULL) {
 994     fprintf (stderr,
 995       "0x%08lx Loading NO DEBUG with entry point 0x%08lx\n",
 996       (unsigned long)(ImageContext->ImageAddress),
 997       (unsigned long)ImageContext->EntryPoint
 998       );
 999   } else {
1000     fprintf (stderr,
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
1005       );
1006   }
1007   // Keep output synced up
1008   fflush (stderr);
1009 }
1010
1011
1012 VOID
1013 EFIAPI
1014 SecPeCoffRelocateImageExtraAction (
1015   IN OUT PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext
1016   )
1017 {
1018
1019 #ifdef __APPLE__
1020   BOOLEAN EnabledOnEntry;
1021
1022    //
1023    // Make sure writting of the file is an atomic operation
1024    //
1025    if (SecInterruptEanbled ()) {
1026      SecDisableInterrupt ();
1027      EnabledOnEntry = TRUE;
1028    } else {
1029      EnabledOnEntry = FALSE;
1030    }
1031
1032   PrintLoadAddress (ImageContext);
1033
1034   //
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.
1038   //
1039   FILE  *GdbTempFile;
1040
1041   //
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.
1044   //
1045   if (ImageContext->PdbPointer != NULL && !IsPdbFile (ImageContext->PdbPointer)) {
1046     //
1047     // Now we have a database of the images that are currently loaded
1048     //
1049
1050     //
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.
1054     //
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.
1057     //
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.
1061     //
1062     // We could use qXfer:libraries:read, but OS X GDB does not currently support it.
1063     //  <library-list>
1064     //    <library name="/lib/libc.so.6">   // ImageContext->PdbPointer
1065     //      <segment address="0x10000000"/> // ImageContext->ImageAddress + ImageContext->SizeOfHeaders
1066     //    </library>
1067     //  </library-list>
1068     //
1069
1070     //
1071     // Write the file we need for the gdb script
1072     //
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);
1077
1078       //
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....
1081       //
1082       SecGdbScriptBreak ();
1083     } else {
1084       ASSERT (FALSE);
1085     }
1086
1087     AddHandle (ImageContext, ImageContext->PdbPointer);
1088
1089     if (EnabledOnEntry) {
1090       SecEnableInterrupt ();
1091     }
1092
1093
1094   }
1095
1096 #else
1097
1098   void        *Handle = NULL;
1099   void        *Entry = NULL;
1100
1101   if (ImageContext->PdbPointer == NULL) {
1102     return;
1103   }
1104
1105   if (!IsPdbFile (ImageContext->PdbPointer)) {
1106     return;
1107   }
1108
1109   fprintf (
1110      stderr,
1111      "Loading %s 0x%08lx - entry point 0x%08lx\n",
1112      ImageContext->PdbPointer,
1113      (unsigned long)ImageContext->ImageAddress,
1114      (unsigned long)ImageContext->EntryPoint
1115      );
1116
1117   Handle = dlopen (ImageContext->PdbPointer, RTLD_NOW);
1118
1119   if (Handle) {
1120     Entry = dlsym (Handle, "_ModuleEntryPoint");
1121   } else {
1122     printf("%s\n", dlerror());
1123   }
1124
1125   if (Entry != NULL) {
1126     ImageContext->EntryPoint = (UINTN)Entry;
1127     printf ("Change %s Entrypoint to :0x%08lx\n", ImageContext->PdbPointer, (unsigned long)Entry);
1128   }
1129
1130   SecUnixLoaderBreak ();
1131
1132 #endif
1133
1134   return;
1135 }
1136
1137
1138 VOID
1139 EFIAPI
1140 SecPeCoffUnloadImageExtraAction (
1141   IN PE_COFF_LOADER_IMAGE_CONTEXT         *ImageContext
1142   )
1143 {
1144   VOID *Handle;
1145
1146   Handle = RemoveHandle (ImageContext);
1147
1148 #ifdef __APPLE__
1149   FILE  *GdbTempFile;
1150   BOOLEAN EnabledOnEntry;
1151
1152   if (Handle != NULL) {
1153     //
1154     // Need to skip .PDB files created from VC++
1155     //
1156     if (!IsPdbFile (ImageContext->PdbPointer)) {
1157        if (SecInterruptEanbled ()) {
1158          SecDisableInterrupt ();
1159          EnabledOnEntry = TRUE;
1160        } else {
1161          EnabledOnEntry = FALSE;
1162        }
1163
1164       //
1165       // Write the file we need for the gdb script
1166       //
1167       GdbTempFile = fopen (gGdbWorkingFileName, "w");
1168       if (GdbTempFile != NULL) {
1169         fprintf (GdbTempFile, "remove-symbol-file %s\n", ImageContext->PdbPointer);
1170         fclose (GdbTempFile);
1171
1172         //
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....
1175         //
1176         SecGdbScriptBreak ();
1177       } else {
1178         ASSERT (FALSE);
1179       }
1180
1181       if (EnabledOnEntry) {
1182         SecEnableInterrupt ();
1183       }
1184     }
1185   }
1186
1187 #else
1188   //
1189   // Don't want to confuse gdb with symbols for something that got unloaded
1190   //
1191   if (Handle != NULL) {
1192     dlclose (Handle);
1193   }
1194
1195 #endif
1196   return;
1197 }
1198
1199