Nt32Pkg/Sec/SecMain.c

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