SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableDxe.c

   1 /** @file
   2   Implement all four UEFI Runtime Variable services for the nonvolatile
   3   and volatile storage space and install variable architecture protocol.
   4
   5 Copyright (C) 2013, Red Hat, Inc.
   6 Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   7 This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "Variable.h"
  18 #include "AuthService.h"
  19
  20 extern VARIABLE_STORE_HEADER   *mNvVariableCache;
  21 extern VARIABLE_INFO_ENTRY     *gVariableInfo;
  22 EFI_HANDLE                     mHandle                    = NULL;
  23 EFI_EVENT                      mVirtualAddressChangeEvent = NULL;
  24 EFI_EVENT                      mFtwRegistration           = NULL;
  25 extern LIST_ENTRY              mLockedVariableList;
  26 extern LIST_ENTRY              mVarCheckVariableList;
  27 extern UINT32                  mNumberOfHandler;
  28 extern VAR_CHECK_SET_VARIABLE_CHECK_HANDLER *mHandlerTable;
  29 extern BOOLEAN                 mEndOfDxe;
  30 EDKII_VARIABLE_LOCK_PROTOCOL   mVariableLock              = { VariableLockRequestToLock };
  31 EDKII_VAR_CHECK_PROTOCOL       mVarCheck                  = { VarCheckRegisterSetVariableCheckHandler,
  32                                                               VarCheckVariablePropertySet,
  33                                                               VarCheckVariablePropertyGet };
  34
  35 /**
  36   Return TRUE if ExitBootServices () has been called.
  37
  38   @retval TRUE If ExitBootServices () has been called.
  39 **/
  40 BOOLEAN
  41 AtRuntime (
  42   VOID
  43   )
  44 {
  45   return EfiAtRuntime ();
  46 }
  47
  48
  49 /**
  50   Initializes a basic mutual exclusion lock.
  51
  52   This function initializes a basic mutual exclusion lock to the released state
  53   and returns the lock.  Each lock provides mutual exclusion access at its task
  54   priority level.  Since there is no preemption or multiprocessor support in EFI,
  55   acquiring the lock only consists of raising to the locks TPL.
  56   If Lock is NULL, then ASSERT().
  57   If Priority is not a valid TPL value, then ASSERT().
  58
  59   @param  Lock       A pointer to the lock data structure to initialize.
  60   @param  Priority   EFI TPL is associated with the lock.
  61
  62   @return The lock.
  63
  64 **/
  65 EFI_LOCK *
  66 InitializeLock (
  67   IN OUT EFI_LOCK                         *Lock,
  68   IN     EFI_TPL                          Priority
  69   )
  70 {
  71   return EfiInitializeLock (Lock, Priority);
  72 }
  73
  74
  75 /**
  76   Acquires lock only at boot time. Simply returns at runtime.
  77
  78   This is a temperary function that will be removed when
  79   EfiAcquireLock() in UefiLib can handle the call in UEFI
  80   Runtimer driver in RT phase.
  81   It calls EfiAcquireLock() at boot time, and simply returns
  82   at runtime.
  83
  84   @param  Lock         A pointer to the lock to acquire.
  85
  86 **/
  87 VOID
  88 AcquireLockOnlyAtBootTime (
  89   IN EFI_LOCK                             *Lock
  90   )
  91 {
  92   if (!AtRuntime ()) {
  93     EfiAcquireLock (Lock);
  94   }
  95 }
  96
  97
  98 /**
  99   Releases lock only at boot time. Simply returns at runtime.
 100
 101   This is a temperary function which will be removed when
 102   EfiReleaseLock() in UefiLib can handle the call in UEFI
 103   Runtimer driver in RT phase.
 104   It calls EfiReleaseLock() at boot time and simply returns
 105   at runtime.
 106
 107   @param  Lock         A pointer to the lock to release.
 108
 109 **/
 110 VOID
 111 ReleaseLockOnlyAtBootTime (
 112   IN EFI_LOCK                             *Lock
 113   )
 114 {
 115   if (!AtRuntime ()) {
 116     EfiReleaseLock (Lock);
 117   }
 118 }
 119
 120 /**
 121   Retrive the Fault Tolerent Write protocol interface.
 122
 123   @param[out] FtwProtocol       The interface of Ftw protocol
 124
 125   @retval EFI_SUCCESS           The FTW protocol instance was found and returned in FtwProtocol.
 126   @retval EFI_NOT_FOUND         The FTW protocol instance was not found.
 127   @retval EFI_INVALID_PARAMETER SarProtocol is NULL.
 128
 129 **/
 130 EFI_STATUS
 131 GetFtwProtocol (
 132   OUT VOID                                **FtwProtocol
 133   )
 134 {
 135   EFI_STATUS                              Status;
 136
 137   //
 138   // Locate Fault Tolerent Write protocol
 139   //
 140   Status = gBS->LocateProtocol (
 141                   &gEfiFaultTolerantWriteProtocolGuid,
 142                   NULL,
 143                   FtwProtocol
 144                   );
 145   return Status;
 146 }
 147
 148 /**
 149   Retrive the FVB protocol interface by HANDLE.
 150
 151   @param[in]  FvBlockHandle     The handle of FVB protocol that provides services for
 152                                 reading, writing, and erasing the target block.
 153   @param[out] FvBlock           The interface of FVB protocol
 154
 155   @retval EFI_SUCCESS           The interface information for the specified protocol was returned.
 156   @retval EFI_UNSUPPORTED       The device does not support the FVB protocol.
 157   @retval EFI_INVALID_PARAMETER FvBlockHandle is not a valid EFI_HANDLE or FvBlock is NULL.
 158
 159 **/
 160 EFI_STATUS
 161 GetFvbByHandle (
 162   IN  EFI_HANDLE                          FvBlockHandle,
 163   OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvBlock
 164   )
 165 {
 166   //
 167   // To get the FVB protocol interface on the handle
 168   //
 169   return gBS->HandleProtocol (
 170                 FvBlockHandle,
 171                 &gEfiFirmwareVolumeBlockProtocolGuid,
 172                 (VOID **) FvBlock
 173                 );
 174 }
 175
 176
 177 /**
 178   Function returns an array of handles that support the FVB protocol
 179   in a buffer allocated from pool.
 180
 181   @param[out]  NumberHandles    The number of handles returned in Buffer.
 182   @param[out]  Buffer           A pointer to the buffer to return the requested
 183                                 array of  handles that support FVB protocol.
 184
 185   @retval EFI_SUCCESS           The array of handles was returned in Buffer, and the number of
 186                                 handles in Buffer was returned in NumberHandles.
 187   @retval EFI_NOT_FOUND         No FVB handle was found.
 188   @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the matching results.
 189   @retval EFI_INVALID_PARAMETER NumberHandles is NULL or Buffer is NULL.
 190
 191 **/
 192 EFI_STATUS
 193 GetFvbCountAndBuffer (
 194   OUT UINTN                               *NumberHandles,
 195   OUT EFI_HANDLE                          **Buffer
 196   )
 197 {
 198   EFI_STATUS                              Status;
 199
 200   //
 201   // Locate all handles of Fvb protocol
 202   //
 203   Status = gBS->LocateHandleBuffer (
 204                   ByProtocol,
 205                   &gEfiFirmwareVolumeBlockProtocolGuid,
 206                   NULL,
 207                   NumberHandles,
 208                   Buffer
 209                   );
 210   return Status;
 211 }
 212
 213
 214 /**
 215   Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.
 216
 217   This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
 218   It convers pointer to new virtual address.
 219
 220   @param  Event        Event whose notification function is being invoked.
 221   @param  Context      Pointer to the notification function's context.
 222
 223 **/
 224 VOID
 225 EFIAPI
 226 VariableClassAddressChangeEvent (
 227   IN EFI_EVENT                            Event,
 228   IN VOID                                 *Context
 229   )
 230 {
 231   EFI_STATUS     Status;
 232   UINTN          Index;
 233
 234   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetBlockSize);
 235   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetPhysicalAddress);
 236   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetAttributes);
 237   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->SetAttributes);
 238   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Read);
 239   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Write);
 240   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->EraseBlocks);
 241   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance);
 242   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLangCodes);
 243   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->LangCodes);
 244   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLang);
 245   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
 246   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
 247   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.HobVariableBase);
 248   EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
 249   EfiConvertPointer (0x0, (VOID **) &mHashCtx);
 250   EfiConvertPointer (0x0, (VOID **) &mNvVariableCache);
 251   EfiConvertPointer (0x0, (VOID **) &mPubKeyStore);
 252   EfiConvertPointer (0x0, (VOID **) &mCertDbStore);
 253   EfiConvertPointer (0x0, (VOID **) &mHandlerTable);
 254   for (Index = 0; Index < mNumberOfHandler; Index++) {
 255     EfiConvertPointer (0x0, (VOID **) &mHandlerTable[Index]);
 256   }
 257
 258   Status = EfiConvertList (0x0, &mLockedVariableList);
 259   ASSERT_EFI_ERROR (Status);
 260
 261   Status = EfiConvertList (0x0, &mVarCheckVariableList);
 262   ASSERT_EFI_ERROR (Status);
 263 }
 264
 265
 266 /**
 267   Notification function of EVT_GROUP_READY_TO_BOOT event group.
 268
 269   This is a notification function registered on EVT_GROUP_READY_TO_BOOT event group.
 270   When the Boot Manager is about to load and execute a boot option, it reclaims variable
 271   storage if free size is below the threshold.
 272
 273   @param  Event        Event whose notification function is being invoked.
 274   @param  Context      Pointer to the notification function's context.
 275
 276 **/
 277 VOID
 278 EFIAPI
 279 OnReadyToBoot (
 280   EFI_EVENT                               Event,
 281   VOID                                    *Context
 282   )
 283 {
 284   //
 285   // Set the End Of DXE bit in case the EFI_END_OF_DXE_EVENT_GROUP_GUID event is not signaled.
 286   //
 287   mEndOfDxe = TRUE;
 288   //
 289   // The initialization for variable quota.
 290   //
 291   InitializeVariableQuota ();
 292   ReclaimForOS ();
 293   if (FeaturePcdGet (PcdVariableCollectStatistics)) {
 294     gBS->InstallConfigurationTable (&gEfiAuthenticatedVariableGuid, gVariableInfo);
 295   }
 296 }
 297
 298 /**
 299   Notification function of EFI_END_OF_DXE_EVENT_GROUP_GUID event group.
 300
 301   This is a notification function registered on EFI_END_OF_DXE_EVENT_GROUP_GUID event group.
 302
 303   @param  Event        Event whose notification function is being invoked.
 304   @param  Context      Pointer to the notification function's context.
 305
 306 **/
 307 VOID
 308 EFIAPI
 309 OnEndOfDxe (
 310   EFI_EVENT                               Event,
 311   VOID                                    *Context
 312   )
 313 {
 314   mEndOfDxe = TRUE;
 315   //
 316   // The initialization for variable quota.
 317   //
 318   InitializeVariableQuota ();
 319   if (PcdGetBool (PcdReclaimVariableSpaceAtEndOfDxe)) {
 320     ReclaimForOS ();
 321   }
 322 }
 323
 324 /**
 325   Fault Tolerant Write protocol notification event handler.
 326
 327   Non-Volatile variable write may needs FTW protocol to reclaim when
 328   writting variable.
 329
 330   @param[in] Event    Event whose notification function is being invoked.
 331   @param[in] Context  Pointer to the notification function's context.
 332
 333 **/
 334 VOID
 335 EFIAPI
 336 FtwNotificationEvent (
 337   IN  EFI_EVENT                           Event,
 338   IN  VOID                                *Context
 339   )
 340 {
 341   EFI_STATUS                              Status;
 342   EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL      *FvbProtocol;
 343   EFI_FAULT_TOLERANT_WRITE_PROTOCOL       *FtwProtocol;
 344   EFI_PHYSICAL_ADDRESS                    NvStorageVariableBase;
 345   EFI_GCD_MEMORY_SPACE_DESCRIPTOR         GcdDescriptor;
 346   EFI_PHYSICAL_ADDRESS                    BaseAddress;
 347   UINT64                                  Length;
 348   EFI_PHYSICAL_ADDRESS                    VariableStoreBase;
 349   UINT64                                  VariableStoreLength;
 350   UINTN                                   FtwMaxBlockSize;
 351
 352   //
 353   // Ensure FTW protocol is installed.
 354   //
 355   Status = GetFtwProtocol ((VOID**) &FtwProtocol);
 356   if (EFI_ERROR (Status)) {
 357     return ;
 358   }
 359
 360   Status = FtwProtocol->GetMaxBlockSize (FtwProtocol, &FtwMaxBlockSize);
 361   if (!EFI_ERROR (Status)) {
 362     ASSERT (PcdGet32 (PcdFlashNvStorageVariableSize) <= FtwMaxBlockSize);
 363   }
 364
 365   //
 366   // Find the proper FVB protocol for variable.
 367   //
 368   NvStorageVariableBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);
 369   if (NvStorageVariableBase == 0) {
 370     NvStorageVariableBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);
 371   }
 372   Status = GetFvbInfoByAddress (NvStorageVariableBase, NULL, &FvbProtocol);
 373   if (EFI_ERROR (Status)) {
 374     return ;
 375   }
 376   mVariableModuleGlobal->FvbInstance = FvbProtocol;
 377
 378   //
 379   // Mark the variable storage region of the FLASH as RUNTIME.
 380   //
 381   VariableStoreBase   = NvStorageVariableBase + (((EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(NvStorageVariableBase))->HeaderLength);
 382   VariableStoreLength = ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase)->Size;
 383   BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);
 384   Length      = VariableStoreLength + (VariableStoreBase - BaseAddress);
 385   Length      = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
 386
 387   Status      = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
 388   if (EFI_ERROR (Status)) {
 389     DEBUG ((DEBUG_WARN, "Variable driver failed to get flash memory attribute.\n"));
 390   } else {
 391     Status = gDS->SetMemorySpaceAttributes (
 392                     BaseAddress,
 393                     Length,
 394                     GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME
 395                     );
 396     if (EFI_ERROR (Status)) {
 397       DEBUG ((DEBUG_WARN, "Variable driver failed to add EFI_MEMORY_RUNTIME attribute to Flash.\n"));
 398     }
 399   }
 400
 401   Status = VariableWriteServiceInitialize ();
 402   if (EFI_ERROR (Status)) {
 403     DEBUG ((DEBUG_ERROR, "Variable write service initialization failed. Status = %r\n", Status));
 404   }
 405
 406   //
 407   // Install the Variable Write Architectural protocol.
 408   //
 409   Status = gBS->InstallProtocolInterface (
 410                   &mHandle,
 411                   &gEfiVariableWriteArchProtocolGuid,
 412                   EFI_NATIVE_INTERFACE,
 413                   NULL
 414                   );
 415   ASSERT_EFI_ERROR (Status);
 416
 417   //
 418   // Close the notify event to avoid install gEfiVariableWriteArchProtocolGuid again.
 419   //
 420   gBS->CloseEvent (Event);
 421
 422 }
 423
 424
 425 /**
 426   Variable Driver main entry point. The Variable driver places the 4 EFI
 427   runtime services in the EFI System Table and installs arch protocols
 428   for variable read and write services being available. It also registers
 429   a notification function for an EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
 430
 431   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 432   @param[in] SystemTable    A pointer to the EFI System Table.
 433
 434   @retval EFI_SUCCESS       Variable service successfully initialized.
 435
 436 **/
 437 EFI_STATUS
 438 EFIAPI
 439 VariableServiceInitialize (
 440   IN EFI_HANDLE                         ImageHandle,
 441   IN EFI_SYSTEM_TABLE                   *SystemTable
 442   )
 443 {
 444   EFI_STATUS                            Status;
 445   EFI_EVENT                             ReadyToBootEvent;
 446   EFI_EVENT                             EndOfDxeEvent;
 447
 448   Status = VariableCommonInitialize ();
 449   ASSERT_EFI_ERROR (Status);
 450
 451   Status = gBS->InstallMultipleProtocolInterfaces (
 452                   &mHandle,
 453                   &gEdkiiVariableLockProtocolGuid,
 454                   &mVariableLock,
 455                   NULL
 456                   );
 457   ASSERT_EFI_ERROR (Status);
 458
 459   Status = gBS->InstallMultipleProtocolInterfaces (
 460                   &mHandle,
 461                   &gEdkiiVarCheckProtocolGuid,
 462                   &mVarCheck,
 463                   NULL
 464                   );
 465   ASSERT_EFI_ERROR (Status);
 466
 467   SystemTable->RuntimeServices->GetVariable         = VariableServiceGetVariable;
 468   SystemTable->RuntimeServices->GetNextVariableName = VariableServiceGetNextVariableName;
 469   SystemTable->RuntimeServices->SetVariable         = VariableServiceSetVariable;
 470   SystemTable->RuntimeServices->QueryVariableInfo   = VariableServiceQueryVariableInfo;
 471
 472   //
 473   // Now install the Variable Runtime Architectural protocol on a new handle.
 474   //
 475   Status = gBS->InstallProtocolInterface (
 476                   &mHandle,
 477                   &gEfiVariableArchProtocolGuid,
 478                   EFI_NATIVE_INTERFACE,
 479                   NULL
 480                   );
 481   ASSERT_EFI_ERROR (Status);
 482
 483   //
 484   // Register FtwNotificationEvent () notify function.
 485   //
 486   EfiCreateProtocolNotifyEvent (
 487     &gEfiFaultTolerantWriteProtocolGuid,
 488     TPL_CALLBACK,
 489     FtwNotificationEvent,
 490     (VOID *)SystemTable,
 491     &mFtwRegistration
 492     );
 493
 494   Status = gBS->CreateEventEx (
 495                   EVT_NOTIFY_SIGNAL,
 496                   TPL_NOTIFY,
 497                   VariableClassAddressChangeEvent,
 498                   NULL,
 499                   &gEfiEventVirtualAddressChangeGuid,
 500                   &mVirtualAddressChangeEvent
 501                   );
 502   ASSERT_EFI_ERROR (Status);
 503
 504   //
 505   // Register the event handling function to reclaim variable for OS usage.
 506   //
 507   Status = EfiCreateEventReadyToBootEx (
 508              TPL_NOTIFY,
 509              OnReadyToBoot,
 510              NULL,
 511              &ReadyToBootEvent
 512              );
 513   ASSERT_EFI_ERROR (Status);
 514
 515   //
 516   // Register the event handling function to set the End Of DXE flag.
 517   //
 518   Status = gBS->CreateEventEx (
 519                   EVT_NOTIFY_SIGNAL,
 520                   TPL_NOTIFY,
 521                   OnEndOfDxe,
 522                   NULL,
 523                   &gEfiEndOfDxeEventGroupGuid,
 524                   &EndOfDxeEvent
 525                   );
 526   ASSERT_EFI_ERROR (Status);
 527
 528   return EFI_SUCCESS;
 529 }
 530