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