MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/ScriptExecute.c

   1 /** @file
   2   This is the code for Boot Script Executer module.
   3
   4   This driver is dispatched by Dxe core and the driver will reload itself to ACPI NVS memory
   5   in the entry point. The functionality is to interpret and restore the S3 boot script
   6
   7 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
   8
   9 This program and the accompanying materials
  10 are licensed and made available under the terms and conditions of the BSD License
  11 which accompanies this distribution.  The full text of the license may be found at
  12 http://opensource.org/licenses/bsd-license.php
  13
  14 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16
  17 **/
  18
  19 #include "ScriptExecute.h"
  20
  21 EFI_PHYSICAL_ADDRESS  mPerfDataMemAddress;
  22 UINT64                mS3BootScriptEntryTick;
  23 UINT64                mScriptStartTick;
  24 UINT64                mScriptEndTick;
  25
  26 EFI_GUID              mBootScriptExecutorImageGuid = {
  27   0x9a8d3433, 0x9fe8, 0x42b6, 0x87, 0xb, 0x1e, 0x31, 0xc8, 0x4e, 0xbe, 0x3b
  28 };
  29
  30 /**
  31   The event callback is used to get the base address of boot performance data structure on
  32   LegacyBoot event and ExitBootServices event.
  33
  34   @param  Event    The event handle.
  35   @param  Context  The event context.
  36
  37 **/
  38 VOID
  39 EFIAPI
  40 OnBootEvent (
  41   IN EFI_EVENT        Event,
  42   IN VOID             *Context
  43   )
  44 {
  45   EFI_STATUS Status;
  46   UINTN      VarSize;
  47
  48   VarSize = sizeof (EFI_PHYSICAL_ADDRESS);
  49   Status = gRT->GetVariable (
  50                   L"PerfDataMemAddr",
  51                   &gPerformanceProtocolGuid,
  52                   NULL,
  53                   &VarSize,
  54                   &mPerfDataMemAddress
  55                   );
  56   if (EFI_ERROR (Status)) {
  57     mPerfDataMemAddress = 0;
  58   }
  59 }
  60
  61 /**
  62   Record S3 Script execution time and adjust total S3 resume time for script running.
  63 **/
  64 VOID
  65 WriteToOsS3PerformanceData (
  66   VOID
  67   )
  68 {
  69   UINT64               Ticker;
  70   UINT64               StartValue;
  71   UINT64               EndValue;
  72   UINT64               Freq;
  73   UINT64               ScriptExecuteTicks;
  74   PERF_HEADER          *PerfHeader;
  75   PERF_DATA            *PerfData;
  76
  77   Ticker = GetPerformanceCounter ();
  78
  79   PerfHeader = (PERF_HEADER *)(UINTN)mPerfDataMemAddress;
  80   if (PerfHeader == NULL) {
  81     return;
  82   }
  83
  84   Freq   = GetPerformanceCounterProperties (&StartValue, &EndValue);
  85   Freq   = DivU64x32 (Freq, 1000);
  86
  87   if (EndValue >= StartValue) {
  88     ScriptExecuteTicks = mScriptEndTick - mScriptStartTick;
  89     PerfHeader->S3Resume += Ticker - mS3BootScriptEntryTick;
  90   } else {
  91     ScriptExecuteTicks = mScriptStartTick - mScriptEndTick;
  92     PerfHeader->S3Resume += mS3BootScriptEntryTick - Ticker;
  93   }
  94   if (PerfHeader->S3EntryNum < PERF_PEI_ENTRY_MAX_NUM) {
  95     PerfData = &PerfHeader->S3Entry[PerfHeader->S3EntryNum];
  96     PerfData->Duration = (UINT32) DivU64x32 (ScriptExecuteTicks, (UINT32) Freq);;
  97     AsciiStrnCpy (PerfData->Token, "ScriptExec", PERF_TOKEN_LENGTH);
  98     PerfHeader->S3EntryNum++;
  99   }
 100 }
 101
 102 /**
 103   Entry function of Boot script exector. This function will be executed in
 104   S3 boot path.
 105   This function should not return, because it is invoked by switch stack.
 106
 107   @param  AcpiS3Context    a pointer to a structure of ACPI_S3_CONTEXT
 108   @param  PeiS3ResumeState a pointer to a structure of PEI_S3_RESUME_STATE
 109
 110   @retval EFI_INVALID_PARAMETER - OS waking vector not found
 111   @retval EFI_UNSUPPORTED - something wrong when we resume to OS
 112 **/
 113 EFI_STATUS
 114 EFIAPI
 115 S3BootScriptExecutorEntryFunction (
 116   IN ACPI_S3_CONTEXT       *AcpiS3Context,
 117   IN PEI_S3_RESUME_STATE   *PeiS3ResumeState
 118   )
 119 {
 120   EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE  *Facs;
 121   EFI_STATUS                                    Status;
 122   UINTN                                         TempStackTop;
 123   UINTN                                         TempStack[0x10];
 124   UINTN                                         AsmTransferControl16Address;
 125
 126   PERF_CODE (
 127     mS3BootScriptEntryTick = GetPerformanceCounter ();
 128     );
 129
 130   //
 131   // Disable interrupt of Debug timer, since new IDT table cannot handle it.
 132   //
 133   SaveAndSetDebugTimerInterrupt (FALSE);
 134
 135   //
 136   // Restore IDT for debug
 137   //
 138   SetIdtEntry (AcpiS3Context);
 139
 140   //
 141   // Initialize Debug Agent to support source level debug in S3 path.
 142   //
 143   InitializeDebugAgent (DEBUG_AGENT_INIT_S3, NULL, NULL);
 144
 145   //
 146   // Because not install BootScriptExecute PPI(used just in this module), So just pass NULL
 147   // for that parameter.
 148   //
 149   PERF_CODE (
 150     mScriptStartTick = GetPerformanceCounter ();
 151     );
 152   Status = S3BootScriptExecute ();
 153   PERF_CODE (
 154     mScriptEndTick = GetPerformanceCounter ();
 155     );
 156   if (EFI_ERROR (Status)) {
 157     return Status;
 158   }
 159
 160   AsmWbinvd ();
 161
 162   //
 163   // Get ACPI Table Address
 164   //
 165   Facs = (EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *) ((UINTN) (AcpiS3Context->AcpiFacsTable));
 166
 167   if ((Facs == NULL) ||
 168       (Facs->Signature != EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) ||
 169       ((Facs->FirmwareWakingVector == 0) && (Facs->XFirmwareWakingVector == 0)) ) {
 170     CpuDeadLoop();
 171     return EFI_INVALID_PARAMETER;
 172   }
 173
 174   //
 175   // We need turn back to S3Resume - install boot script done ppi and report status code on S3resume.
 176   //
 177   if (PeiS3ResumeState != 0) {
 178     if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
 179       //
 180       // X64 S3 Resume
 181       //
 182       DEBUG ((EFI_D_ERROR, "Call AsmDisablePaging64() to return to S3 Resume in PEI Phase\n"));
 183       PeiS3ResumeState->AsmTransferControl = (EFI_PHYSICAL_ADDRESS)(UINTN)AsmTransferControl32;
 184
 185       //
 186       // more step needed - because relative address is handled differently between X64 and IA32.
 187       //
 188       AsmTransferControl16Address = (UINTN)AsmTransferControl16;
 189       AsmFixAddress16 = (UINT32)AsmTransferControl16Address;
 190       AsmJmpAddr32 = (UINT32)((Facs->FirmwareWakingVector & 0xF) | ((Facs->FirmwareWakingVector & 0xFFFF0) << 12));
 191
 192       AsmDisablePaging64 (
 193         PeiS3ResumeState->ReturnCs,
 194         (UINT32)PeiS3ResumeState->ReturnEntryPoint,
 195         (UINT32)(UINTN)AcpiS3Context,
 196         (UINT32)(UINTN)PeiS3ResumeState,
 197         (UINT32)PeiS3ResumeState->ReturnStackPointer
 198         );
 199     } else {
 200       //
 201       // IA32 S3 Resume
 202       //
 203       DEBUG ((EFI_D_ERROR, "Call SwitchStack() to return to S3 Resume in PEI Phase\n"));
 204       PeiS3ResumeState->AsmTransferControl = (EFI_PHYSICAL_ADDRESS)(UINTN)AsmTransferControl;
 205
 206       SwitchStack (
 207         (SWITCH_STACK_ENTRY_POINT)(UINTN)PeiS3ResumeState->ReturnEntryPoint,
 208         (VOID *)(UINTN)AcpiS3Context,
 209         (VOID *)(UINTN)PeiS3ResumeState,
 210         (VOID *)(UINTN)PeiS3ResumeState->ReturnStackPointer
 211         );
 212     }
 213
 214     //
 215     // Never run to here
 216     //
 217     CpuDeadLoop();
 218     return EFI_UNSUPPORTED;
 219   }
 220
 221   PERF_CODE (
 222     WriteToOsS3PerformanceData ();
 223     );
 224
 225   if (Facs->XFirmwareWakingVector != 0) {
 226     //
 227     // Switch to native waking vector
 228     //
 229     TempStackTop = (UINTN)&TempStack + sizeof(TempStack);
 230     if ((Facs->Version == EFI_ACPI_4_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION) &&
 231         ((Facs->Flags & EFI_ACPI_4_0_64BIT_WAKE_SUPPORTED_F) != 0) &&
 232         ((Facs->Flags & EFI_ACPI_4_0_OSPM_64BIT_WAKE__F) != 0)) {
 233       //
 234       // X64 long mode waking vector
 235       //
 236       DEBUG (( EFI_D_ERROR, "Transfer to 64bit OS waking vector - %x\r\n", (UINTN)Facs->XFirmwareWakingVector));
 237       if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
 238         SwitchStack (
 239           (SWITCH_STACK_ENTRY_POINT)(UINTN)Facs->XFirmwareWakingVector,
 240           NULL,
 241           NULL,
 242           (VOID *)(UINTN)TempStackTop
 243           );
 244       } else {
 245         // Unsupported for 32bit DXE, 64bit OS vector
 246         DEBUG (( EFI_D_ERROR, "Unsupported for 32bit DXE transfer to 64bit OS waking vector!\r\n"));
 247         ASSERT (FALSE);
 248       }
 249     } else {
 250       //
 251       // IA32 protected mode waking vector (Page disabled)
 252       //
 253       DEBUG (( EFI_D_ERROR, "Transfer to 32bit OS waking vector - %x\r\n", (UINTN)Facs->XFirmwareWakingVector));
 254       if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
 255         AsmDisablePaging64 (
 256           0x10,
 257           (UINT32)Facs->XFirmwareWakingVector,
 258           0,
 259           0,
 260           (UINT32)TempStackTop
 261           );
 262       } else {
 263         SwitchStack (
 264           (SWITCH_STACK_ENTRY_POINT)(UINTN)Facs->XFirmwareWakingVector,
 265           NULL,
 266           NULL,
 267           (VOID *)(UINTN)TempStackTop
 268           );
 269       }
 270     }
 271   } else {
 272     //
 273     // 16bit Realmode waking vector
 274     //
 275     DEBUG (( EFI_D_ERROR, "Transfer to 16bit OS waking vector - %x\r\n", (UINTN)Facs->FirmwareWakingVector));
 276     AsmTransferControl (Facs->FirmwareWakingVector, 0x0);
 277   }
 278
 279   //
 280   // Never run to here
 281   //
 282   CpuDeadLoop();
 283   return EFI_UNSUPPORTED;
 284 }
 285 /**
 286   Entrypoint of Boot script exector driver, this function will be executed in
 287   normal boot phase and invoked by DXE dispatch.
 288
 289   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 290   @param[in] SystemTable    A pointer to the EFI System Table.
 291
 292   @retval EFI_SUCCESS       The entry point is executed successfully.
 293   @retval other             Some error occurs when executing this entry point.
 294 **/
 295 EFI_STATUS
 296 EFIAPI
 297 BootScriptExecutorEntryPoint (
 298   IN EFI_HANDLE           ImageHandle,
 299   IN EFI_SYSTEM_TABLE     *SystemTable
 300   )
 301 {
 302   UINT8                                         *Buffer;
 303   UINTN                                         BufferSize;
 304   UINTN                                         Pages;
 305   EFI_PHYSICAL_ADDRESS                          FfsBuffer;
 306   PE_COFF_LOADER_IMAGE_CONTEXT                  ImageContext;
 307   BOOT_SCRIPT_EXECUTOR_VARIABLE                 *EfiBootScriptExecutorVariable;
 308   EFI_PHYSICAL_ADDRESS                          BootScriptExecutorBuffer;
 309   EFI_STATUS                                    Status;
 310   VOID                                          *DevicePath;
 311   EFI_HANDLE                                    NewImageHandle;
 312
 313   //
 314   // Test if the gEfiCallerIdGuid of this image is already installed. if not, the entry
 315   // point is loaded by DXE code which is the first time loaded. or else, it is already
 316   // be reloaded be itself.This is a work-around
 317   //
 318   Status = gBS->LocateProtocol (&gEfiCallerIdGuid, NULL, &DevicePath);
 319   if (EFI_ERROR (Status)) {
 320
 321       //
 322       // This is the first-time loaded by DXE core. reload itself to NVS mem
 323       //
 324       //
 325       // A workarouond: Here we install a dummy handle
 326       //
 327       NewImageHandle = NULL;
 328       Status = gBS->InstallProtocolInterface (
 329                   &NewImageHandle,
 330                   &gEfiCallerIdGuid,
 331                   EFI_NATIVE_INTERFACE,
 332                   NULL
 333                   );
 334
 335       Status = GetSectionFromAnyFv  (
 336                  &gEfiCallerIdGuid,
 337                  EFI_SECTION_PE32,
 338                  0,
 339                  (VOID **) &Buffer,
 340                  &BufferSize
 341                  );
 342       ImageContext.Handle    = Buffer;
 343       ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
 344       //
 345       // Get information about the image being loaded
 346       //
 347       Status = PeCoffLoaderGetImageInfo (&ImageContext);
 348       if (EFI_ERROR (Status)) {
 349         return Status;
 350       }
 351       Pages = EFI_SIZE_TO_PAGES(BufferSize + ImageContext.SectionAlignment);
 352       FfsBuffer = 0xFFFFFFFF;
 353       Status = gBS->AllocatePages (
 354                     AllocateMaxAddress,
 355                     EfiACPIMemoryNVS,
 356                     Pages,
 357                     &FfsBuffer
 358                     );
 359       if (EFI_ERROR (Status)) {
 360         return EFI_OUT_OF_RESOURCES;
 361       }
 362       ImageContext.ImageAddress = (PHYSICAL_ADDRESS)(UINTN)FfsBuffer;
 363       //
 364       // Align buffer on section boundry
 365       //
 366       ImageContext.ImageAddress += ImageContext.SectionAlignment - 1;
 367       ImageContext.ImageAddress &= ~(ImageContext.SectionAlignment - 1);
 368       //
 369       // Load the image to our new buffer
 370       //
 371       Status = PeCoffLoaderLoadImage (&ImageContext);
 372       if (EFI_ERROR (Status)) {
 373         gBS->FreePages (FfsBuffer, Pages);
 374         return Status;
 375       }
 376
 377       //
 378       // Relocate the image in our new buffer
 379       //
 380       Status = PeCoffLoaderRelocateImage (&ImageContext);
 381
 382       if (EFI_ERROR (Status)) {
 383         PeCoffLoaderUnloadImage (&ImageContext);
 384         gBS->FreePages (FfsBuffer, Pages);
 385         return Status;
 386       }
 387       //
 388       // Flush the instruction cache so the image data is written before we execute it
 389       //
 390       InvalidateInstructionCacheRange ((VOID *)(UINTN)ImageContext.ImageAddress, (UINTN)ImageContext.ImageSize);
 391       Status = ((EFI_IMAGE_ENTRY_POINT)(UINTN)(ImageContext.EntryPoint)) (NewImageHandle, SystemTable);
 392       if (EFI_ERROR (Status)) {
 393         gBS->FreePages (FfsBuffer, Pages);
 394         return Status;
 395       }
 396       //
 397       // Additional step for BootScript integrity
 398       // Save BootScriptExecutor image
 399       //
 400       Status = SaveLockBox (
 401                  &mBootScriptExecutorImageGuid,
 402                  (VOID *)(UINTN)ImageContext.ImageAddress,
 403                  (UINTN)ImageContext.ImageSize
 404                  );
 405       ASSERT_EFI_ERROR (Status);
 406
 407       Status = SetLockBoxAttributes (&mBootScriptExecutorImageGuid, LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE);
 408       ASSERT_EFI_ERROR (Status);
 409
 410     } else {
 411       //
 412       // the entry point is invoked after reloading. following code only run in  ACPI NVS
 413       //
 414       BufferSize = sizeof (BOOT_SCRIPT_EXECUTOR_VARIABLE);
 415
 416       BootScriptExecutorBuffer = 0xFFFFFFFF;
 417       Pages = EFI_SIZE_TO_PAGES(BufferSize);
 418       Status = gBS->AllocatePages (
 419                       AllocateMaxAddress,
 420                       EfiACPIMemoryNVS,
 421                       Pages,
 422                       &BootScriptExecutorBuffer
 423                       );
 424       if (EFI_ERROR (Status)) {
 425         return EFI_OUT_OF_RESOURCES;
 426       }
 427
 428       EfiBootScriptExecutorVariable = (BOOT_SCRIPT_EXECUTOR_VARIABLE *)(UINTN)BootScriptExecutorBuffer;
 429       EfiBootScriptExecutorVariable->BootScriptExecutorEntrypoint = (UINTN) S3BootScriptExecutorEntryFunction ;
 430
 431       Status = SaveLockBox (
 432                  &gEfiBootScriptExecutorVariableGuid,
 433                  &BootScriptExecutorBuffer,
 434                  sizeof(BootScriptExecutorBuffer)
 435                  );
 436       ASSERT_EFI_ERROR (Status);
 437
 438       //
 439       // Additional step for BootScript integrity
 440       // Save BootScriptExecutor context
 441       //
 442       Status = SaveLockBox (
 443                  &gEfiBootScriptExecutorContextGuid,
 444                  EfiBootScriptExecutorVariable,
 445                  sizeof(*EfiBootScriptExecutorVariable)
 446                  );
 447       ASSERT_EFI_ERROR (Status);
 448
 449       Status = SetLockBoxAttributes (&gEfiBootScriptExecutorContextGuid, LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE);
 450       ASSERT_EFI_ERROR (Status);
 451
 452       PERF_CODE (
 453         EFI_EVENT Event;
 454
 455         gBS->CreateEventEx (
 456               EVT_NOTIFY_SIGNAL,
 457               TPL_NOTIFY,
 458               OnBootEvent,
 459               NULL,
 460               &gEfiEventExitBootServicesGuid,
 461               &Event
 462               );
 463
 464         EfiCreateEventLegacyBootEx(
 465           TPL_NOTIFY,
 466           OnBootEvent,
 467           NULL,
 468           &Event
 469           );
 470         );
 471     }
 472
 473     return EFI_SUCCESS;
 474 }
 475
 476
 477