EdkModulePkg/Universal/Runtime/RuntimeDxe/Runtime.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   Runtime.c
  15
  16 Abstract:
  17
  18   Runtime Architectural Protocol as defined in the DXE CIS
  19
  20   This code is used to produce the EFI runtime virtual switch over
  21
  22   THIS IS VERY DANGEROUS CODE BE VERY CAREFUL IF YOU CHANGE IT
  23
  24   The transition for calling EFI Runtime functions in physical mode to calling
  25   them in virtual mode is very very complex. Every pointer in needs to be
  26   converted from physical mode to virtual mode. Be very careful walking linked
  27   lists! Then to make it really hard the code it's self needs be relocated into
  28   the new virtual address space.
  29
  30   So here is the concept. The code in this module will never ever be called in
  31   virtual mode. This is the code that collects the information needed to convert
  32   to virtual mode (DXE core registers runtime stuff with this code). Since this
  33   code is used to fixup all runtime images, it CAN NOT fix it's self up. So some
  34   code has to stay behind and that is us.
  35
  36   Also you need to be careful about when you allocate memory, as once we are in
  37   runtime (including our EVT_SIGNAL_EXIT_BOOT_SERVICES event) you can no longer
  38   allocate memory.
  39
  40   Any runtime driver that gets loaded before us will not be callable in virtual
  41   mode. This is due to the fact that the DXE core can not register the info
  42   needed with us. This is good, since it keeps the code in this file from
  43   getting registered.
  44
  45
  46 Revision History:
  47
  48   - Move the CalculateCrc32 function from Runtime Arch Protocol to Boot Service.
  49   Runtime Arch Protocol definition no longer contains CalculateCrc32. Boot Service
  50   Table now contains an item named CalculateCrc32.
  51
  52 --*/
  53
  54
  55 #include "Runtime.h"
  56
  57 //
  58 // Global Variables
  59 //
  60 EFI_MEMORY_DESCRIPTOR         *mVirtualMap                = NULL;
  61 UINTN                         mVirtualMapDescriptorSize;
  62 UINTN                         mVirtualMapMaxIndex;
  63 VOID                          *mMyImageBase;
  64
  65 //
  66 // The handle onto which the Runtime Architectural Protocol instance is installed
  67 //
  68 EFI_HANDLE                    mRuntimeHandle = NULL;
  69
  70 //
  71 // The Runtime Architectural Protocol instance produced by this driver
  72 //
  73 EFI_RUNTIME_ARCH_PROTOCOL     mRuntime = {
  74   INITIALIZE_LIST_HEAD_VARIABLE (mRuntime.ImageHead),
  75   INITIALIZE_LIST_HEAD_VARIABLE (mRuntime.EventHead),
  76
  77   //
  78   // Make sure Size != sizeof (EFI_MEMORY_DESCRIPTOR). This will
  79   // prevent people from having pointer math bugs in their code.
  80   // now you have to use *DescriptorSize to make things work.
  81   //
  82   sizeof (EFI_MEMORY_DESCRIPTOR) + sizeof (UINT64) - (sizeof (EFI_MEMORY_DESCRIPTOR) % sizeof (UINT64)),
  83   EFI_MEMORY_DESCRIPTOR_VERSION,
  84   0,
  85   NULL,
  86   NULL,
  87   FALSE,
  88   FALSE
  89 };
  90
  91 //
  92 // Worker Functions
  93 //
  94 STATIC
  95 VOID
  96 RuntimeDriverCalculateEfiHdrCrc (
  97   IN OUT EFI_TABLE_HEADER  *Hdr
  98   )
  99 /*++
 100
 101 Routine Description:
 102
 103   Calcualte the 32-bit CRC in a EFI table using the Runtime Drivers
 104   internal function.  The EFI Boot Services Table can not be used because
 105   the EFI Boot Services Table was destroyed at ExitBootServices()
 106
 107 Arguments:
 108
 109   Hdr  - Pointer to an EFI standard header
 110
 111 Returns:
 112
 113   None
 114
 115 --*/
 116 {
 117   UINT32  Crc;
 118
 119   Hdr->CRC32  = 0;
 120
 121   Crc         = 0;
 122   RuntimeDriverCalculateCrc32 ((UINT8 *) Hdr, Hdr->HeaderSize, &Crc);
 123   Hdr->CRC32 = Crc;
 124 }
 125
 126 EFI_STATUS
 127 EFIAPI
 128 RuntimeDriverConvertPointer (
 129   IN     UINTN  DebugDisposition,
 130   IN OUT VOID   **ConvertAddress
 131   )
 132 /*++
 133
 134 Routine Description:
 135
 136   Determines the new virtual address that is to be used on subsequent memory accesses.
 137
 138 Arguments:
 139
 140   DebugDisposition    - Supplies type information for the pointer being converted.
 141   ConvertAddress      - A pointer to a pointer that is to be fixed to be the value needed
 142                         for the new virtual address mappings being applied.
 143
 144 Returns:
 145
 146   EFI_SUCCESS             - The pointer pointed to by Address was modified.
 147   EFI_NOT_FOUND           - The pointer pointed to by Address was not found to be part
 148                             of the current memory map. This is normally fatal.
 149   EFI_INVALID_PARAMETER   - One of the parameters has an invalid value.
 150
 151 --*/
 152 {
 153   UINTN                 Address;
 154   VOID                  *PlabelConvertAddress;
 155   UINT64                VirtEndOfRange;
 156   EFI_MEMORY_DESCRIPTOR *VirtEntry;
 157   UINTN                 Index;
 158
 159   //
 160   // Make sure ConvertAddress is a valid pointer
 161   //
 162   if (ConvertAddress == NULL) {
 163     return EFI_INVALID_PARAMETER;
 164   }
 165   //
 166   // Get the address to convert
 167   //
 168   Address = (UINTN) *ConvertAddress;
 169
 170   //
 171   // If this is a null pointer, return if it's allowed
 172   //
 173   if (Address == 0) {
 174     if (DebugDisposition & EFI_OPTIONAL_POINTER) {
 175       return EFI_SUCCESS;
 176     }
 177
 178     return EFI_INVALID_PARAMETER;
 179   }
 180
 181   PlabelConvertAddress  = NULL;
 182   VirtEntry             = mVirtualMap;
 183   for (Index = 0; Index < mVirtualMapMaxIndex; Index++) {
 184     //
 185     // To prevent the inclusion of 64-bit math functions a UINTN was placed in
 186     //  front of VirtEntry->NumberOfPages to cast it to a 32-bit thing on IA-32
 187     //  platforms. If you get this ASSERT remove the UINTN and do a 64-bit
 188     //  multiply.
 189     //
 190     ASSERT (((UINTN) VirtEntry->NumberOfPages < 0xffffffff) || (sizeof (UINTN) > 4));
 191
 192     if ((VirtEntry->Attribute & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME) {
 193       if (Address >= VirtEntry->PhysicalStart) {
 194         VirtEndOfRange = VirtEntry->PhysicalStart + (((UINTN) VirtEntry->NumberOfPages) * EFI_PAGE_SIZE);
 195         if (Address < VirtEndOfRange) {
 196           //
 197           // Compute new address
 198           //
 199           *ConvertAddress = (VOID *) (Address - (UINTN) VirtEntry->PhysicalStart + (UINTN) VirtEntry->VirtualStart);
 200           return EFI_SUCCESS;
 201         } else if (Address < (VirtEndOfRange + 0x200000)) {
 202           //
 203           // On Itanium GP defines a window +/- 2 MB inside an image.
 204           // The compiler may asign a GP value outside of the image. Thus
 205           // it could fall out side of any of our valid regions
 206           //
 207           PlabelConvertAddress = (VOID *) (Address - (UINTN) VirtEntry->PhysicalStart + (UINTN) VirtEntry->VirtualStart);
 208         }
 209       }
 210     }
 211
 212     VirtEntry = NextMemoryDescriptor (VirtEntry, mVirtualMapDescriptorSize);
 213   }
 214
 215   if (DebugDisposition & EFI_IPF_GP_POINTER) {
 216     //
 217     // If it's an IPF GP and the GP was outside the image handle that case.
 218     //
 219     if (PlabelConvertAddress != NULL) {
 220       *ConvertAddress = PlabelConvertAddress;
 221       return EFI_SUCCESS;
 222     }
 223   }
 224
 225   return EFI_NOT_FOUND;
 226 }
 227
 228 STATIC
 229 EFI_STATUS
 230 RuntimeDriverConvertInternalPointer (
 231   IN OUT VOID   **ConvertAddress
 232   )
 233 /*++
 234
 235 Routine Description:
 236
 237   Determines the new virtual address that is to be used on subsequent memory accesses
 238   for internal pointers.
 239
 240 Arguments:
 241
 242   ConvertAddress  - A pointer to a pointer that is to be fixed to be the value needed
 243                     for the new virtual address mappings being applied.
 244
 245 Returns:
 246
 247   EFI_SUCCESS             - The pointer pointed to by Address was modified.
 248   EFI_NOT_FOUND           - The pointer pointed to by Address was not found to be part
 249                             of the current memory map. This is normally fatal.
 250   EFI_INVALID_PARAMETER   - One of the parameters has an invalid value.
 251
 252 --*/
 253 {
 254   return RuntimeDriverConvertPointer (0x0, ConvertAddress);
 255 }
 256
 257 EFI_STATUS
 258 EFIAPI
 259 RuntimeDriverSetVirtualAddressMap (
 260   IN UINTN                  MemoryMapSize,
 261   IN UINTN                  DescriptorSize,
 262   IN UINT32                 DescriptorVersion,
 263   IN EFI_MEMORY_DESCRIPTOR  *VirtualMap
 264   )
 265 /*++
 266
 267 Routine Description:
 268
 269   Changes the runtime addressing mode of EFI firmware from physical to virtual.
 270
 271 Arguments:
 272
 273   MemoryMapSize     - The size in bytes of VirtualMap.
 274   DescriptorSize    - The size in bytes of an entry in the VirtualMap.
 275   DescriptorVersion - The version of the structure entries in VirtualMap.
 276   VirtualMap        - An array of memory descriptors which contain new virtual
 277                       address mapping information for all runtime ranges.
 278
 279 Returns:
 280
 281   EFI_SUCCESS           - The virtual address map has been applied.
 282   EFI_UNSUPPORTED       - EFI firmware is not at runtime, or the EFI firmware is already in
 283                           virtual address mapped mode.
 284   EFI_INVALID_PARAMETER - DescriptorSize or DescriptorVersion is invalid.
 285   EFI_NO_MAPPING        - A virtual address was not supplied for a range in the memory
 286                           map that requires a mapping.
 287   EFI_NOT_FOUND         - A virtual address was supplied for an address that is not found
 288                           in the memory map.
 289
 290 --*/
 291 {
 292   EFI_STATUS                    Status;
 293   EFI_RUNTIME_EVENT_ENTRY       *RuntimeEvent;
 294   EFI_RUNTIME_IMAGE_ENTRY       *RuntimeImage;
 295   LIST_ENTRY                    *Link;
 296   UINTN                         Index;
 297   UINTN                         Index1;
 298   EFI_DRIVER_OS_HANDOFF_HEADER  *DriverOsHandoffHeader;
 299   EFI_DRIVER_OS_HANDOFF         *DriverOsHandoff;
 300   EFI_PHYSICAL_ADDRESS          VirtImageBase;
 301 #if (EFI_SPECIFICATION_VERSION >= 0x00020000)
 302   EFI_CAPSULE_TABLE             *CapsuleTable;
 303 #endif
 304
 305   //
 306   // Can only switch to virtual addresses once the memory map is locked down,
 307   // and can only set it once
 308   //
 309   if (!mRuntime.AtRuntime || mRuntime.VirtualMode) {
 310     return EFI_UNSUPPORTED;
 311   }
 312   //
 313   // Only understand the original descriptor format
 314   //
 315   if (DescriptorVersion != EFI_MEMORY_DESCRIPTOR_VERSION || DescriptorSize < sizeof (EFI_MEMORY_DESCRIPTOR)) {
 316     return EFI_INVALID_PARAMETER;
 317   }
 318   //
 319   // We are now committed to go to virtual mode, so lets get to it!
 320   //
 321   mRuntime.VirtualMode = TRUE;
 322
 323   //
 324   // ConvertPointer() needs this mVirtualMap to do the conversion. So set up
 325   // globals we need to parse the virtual address map.
 326   //
 327   mVirtualMapDescriptorSize = DescriptorSize;
 328   mVirtualMapMaxIndex       = MemoryMapSize / DescriptorSize;
 329   mVirtualMap               = VirtualMap;
 330
 331   //
 332   // Currently the bug in StatusCode/RuntimeLib has been fixed, it will
 333   // check whether in Runtime or not (this is judged by looking at
 334   // mEfiAtRuntime global So this ReportStatusCode will work
 335   //
 336   REPORT_STATUS_CODE (
 337           EFI_PROGRESS_CODE,
 338           (EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_RS_PC_SET_VIRTUAL_ADDRESS_MAP)
 339           );
 340
 341   //
 342   // Signal all the EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE events.
 343   // All runtime events are stored in a list in Runtime AP.
 344   //
 345   for (Link = mRuntime.EventHead.ForwardLink; Link != &mRuntime.EventHead; Link = Link->ForwardLink) {
 346     RuntimeEvent = _CR (Link, EFI_RUNTIME_EVENT_ENTRY, Link);
 347     if ((RuntimeEvent->Type & EFI_EVENT_SIGNAL_VIRTUAL_ADDRESS_CHANGE) == EFI_EVENT_SIGNAL_VIRTUAL_ADDRESS_CHANGE) {
 348       RuntimeEvent->NotifyFunction (
 349                       RuntimeEvent->Event,
 350                       RuntimeEvent->NotifyContext
 351                       );
 352     }
 353   }
 354
 355   //
 356   // Relocate runtime images. All runtime images are stored in a list in Runtime AP.
 357   //
 358   for (Link = mRuntime.ImageHead.ForwardLink; Link != &mRuntime.ImageHead; Link = Link->ForwardLink) {
 359     RuntimeImage = _CR (Link, EFI_RUNTIME_IMAGE_ENTRY, Link);
 360     //
 361     // We don't want to relocate our selves, as we only run in physical mode.
 362     //
 363     if (mMyImageBase != RuntimeImage->ImageBase) {
 364
 365       VirtImageBase = (EFI_PHYSICAL_ADDRESS) (UINTN) RuntimeImage->ImageBase;
 366       Status  = RuntimeDriverConvertPointer (0, (VOID **) &VirtImageBase);
 367       ASSERT_EFI_ERROR (Status);
 368
 369       PeCoffLoaderRelocateImageForRuntime (
 370         (EFI_PHYSICAL_ADDRESS) (UINTN) RuntimeImage->ImageBase,
 371         VirtImageBase,
 372         (UINTN) RuntimeImage->ImageSize,
 373         RuntimeImage->RelocationData
 374         );
 375
 376       InvalidateInstructionCacheRange (RuntimeImage->ImageBase, (UINTN)RuntimeImage->ImageSize);
 377     }
 378   }
 379
 380   //
 381   // Convert all the Runtime Services except ConvertPointer() and SetVirtualAddressMap()
 382   // and recompute the CRC-32
 383   //
 384   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->GetTime);
 385   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->SetTime);
 386   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->GetWakeupTime);
 387   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->SetWakeupTime);
 388   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->ResetSystem);
 389 #if (EFI_SPECIFICATION_VERSION < 0x00020000)
 390   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->ReportStatusCode);
 391 #endif
 392   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->GetNextHighMonotonicCount);
 393   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->GetVariable);
 394   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->SetVariable);
 395   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->GetNextVariableName);
 396 #if (EFI_SPECIFICATION_VERSION >= 0x00020000)
 397   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->QueryVariableInfo);
 398   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->UpdateCapsule);
 399   RuntimeDriverConvertInternalPointer ((VOID **) &gRT->QueryCapsuleCapabilities);
 400 #endif
 401   RuntimeDriverCalculateEfiHdrCrc (&gRT->Hdr);
 402
 403   //
 404   // Convert the UGA OS Handoff Table if it is present in the Configuration Table
 405   //
 406   for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
 407     if (CompareGuid (&gEfiUgaIoProtocolGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
 408       DriverOsHandoffHeader = gST->ConfigurationTable[Index].VendorTable;
 409       for (Index1 = 0; Index1 < DriverOsHandoffHeader->NumberOfEntries; Index1++) {
 410         DriverOsHandoff = (EFI_DRIVER_OS_HANDOFF *)
 411           (
 412             (UINTN) DriverOsHandoffHeader +
 413             DriverOsHandoffHeader->HeaderSize +
 414             Index1 *
 415             DriverOsHandoffHeader->SizeOfEntries
 416           );
 417         RuntimeDriverConvertPointer (EFI_OPTIONAL_POINTER, (VOID **) &DriverOsHandoff->DevicePath);
 418         RuntimeDriverConvertPointer (EFI_OPTIONAL_POINTER, (VOID **) &DriverOsHandoff->PciRomImage);
 419       }
 420
 421       RuntimeDriverConvertPointer (EFI_OPTIONAL_POINTER, (VOID **) &(gST->ConfigurationTable[Index].VendorTable));
 422     }
 423
 424 #if (EFI_SPECIFICATION_VERSION >= 0x00020000)
 425     if (CompareGuid (&gEfiCapsuleGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
 426       CapsuleTable = gST->ConfigurationTable[Index].VendorTable;
 427       for (Index1 = 0; Index1 < CapsuleTable->CapsuleArrayNumber; Index1++) {
 428         RuntimeDriverConvertPointer (EFI_OPTIONAL_POINTER, (VOID **) &CapsuleTable->CapsulePtr[Index1]);
 429       }
 430       RuntimeDriverConvertPointer (EFI_OPTIONAL_POINTER, (VOID **) &(gST->ConfigurationTable[Index].VendorTable));
 431     }
 432 #endif
 433   }
 434   //
 435   // Convert the runtime fields of the EFI System Table and recompute the CRC-32
 436   //
 437   RuntimeDriverConvertInternalPointer ((VOID **) &gST->FirmwareVendor);
 438   RuntimeDriverConvertInternalPointer ((VOID **) &gST->ConfigurationTable);
 439   RuntimeDriverConvertInternalPointer ((VOID **) &gST->RuntimeServices);
 440   RuntimeDriverCalculateEfiHdrCrc (&gST->Hdr);
 441
 442   //
 443   // At this point, gRT and gST are physical pointers, but the contents of these tables
 444   // have been converted to runtime.
 445   //
 446   //
 447   // mVirtualMap is only valid during SetVirtualAddressMap() call
 448   //
 449   mVirtualMap = NULL;
 450
 451   return EFI_SUCCESS;
 452 }
 453
 454 EFI_STATUS
 455 EFIAPI
 456 RuntimeDriverInitialize (
 457   IN EFI_HANDLE                            ImageHandle,
 458   IN EFI_SYSTEM_TABLE                      *SystemTable
 459   )
 460 /*++
 461
 462 Routine Description:
 463   Install Runtime AP. This code includes the EfiDriverLib, but it functions at
 464   RT in physical mode. The only Lib services are gBS, gRT, and the DEBUG and
 465   ASSERT macros (they do ReportStatusCode).
 466
 467 Arguments:
 468   (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
 469
 470 Returns:
 471
 472   EFI_SUCEESS - Runtime Driver Architectural Protocol Installed
 473
 474   Other       - Return value from gBS->InstallMultipleProtocolInterfaces
 475
 476 --*/
 477 {
 478   EFI_STATUS                Status;
 479   EFI_LOADED_IMAGE_PROTOCOL *MyLoadedImage;
 480
 481   //
 482   // This image needs to be exclued from relocation for virtual mode, so cache
 483   // a copy of the Loaded Image protocol to test later.
 484   //
 485   Status = gBS->HandleProtocol (
 486                   ImageHandle,
 487                   &gEfiLoadedImageProtocolGuid,
 488                   (VOID**)&MyLoadedImage
 489                   );
 490   ASSERT_EFI_ERROR (Status);
 491   mMyImageBase = MyLoadedImage->ImageBase;
 492
 493   //
 494   // Initialize the table used to compute 32-bit CRCs
 495   //
 496   RuntimeDriverInitializeCrc32Table ();
 497
 498   //
 499   // Fill in the entries of the EFI Boot Services and EFI Runtime Services Tables
 500   //
 501   gBS->CalculateCrc32       = RuntimeDriverCalculateCrc32;
 502   gRT->SetVirtualAddressMap = RuntimeDriverSetVirtualAddressMap;
 503   gRT->ConvertPointer       = RuntimeDriverConvertPointer;
 504
 505   //
 506   // Install the Runtime Architectural Protocol onto a new handle
 507   //
 508   Status = gBS->InstallMultipleProtocolInterfaces (
 509                   &mRuntimeHandle,
 510                   &gEfiRuntimeArchProtocolGuid,
 511                   &mRuntime,
 512                   NULL
 513                   );
 514   ASSERT_EFI_ERROR (Status);
 515
 516   return EFI_SUCCESS;
 517 }