MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c

   1 /** @file
   2
   3   The common variable operation routines shared by DXE_RUNTIME variable
   4   module and DXE_SMM variable module.
   5
   6 Copyright (c) 2006 - 2013, 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
  19 VARIABLE_MODULE_GLOBAL  *mVariableModuleGlobal;
  20
  21 ///
  22 /// Define a memory cache that improves the search performance for a variable.
  23 ///
  24 VARIABLE_STORE_HEADER  *mNvVariableCache      = NULL;
  25
  26 ///
  27 /// The memory entry used for variable statistics data.
  28 ///
  29 VARIABLE_INFO_ENTRY    *gVariableInfo         = NULL;
  30
  31 ///
  32 /// The list to store the variables which cannot be set after the EFI_END_OF_DXE_EVENT_GROUP_GUID
  33 /// or EVT_GROUP_READY_TO_BOOT event.
  34 ///
  35 LIST_ENTRY             mLockedVariableList    = INITIALIZE_LIST_HEAD_VARIABLE (mLockedVariableList);
  36
  37 ///
  38 /// The flag to indicate whether the platform has left the DXE phase of execution.
  39 ///
  40 BOOLEAN                mEndOfDxe              = FALSE;
  41
  42 ///
  43 /// The flag to indicate whether the variable storage locking is enabled.
  44 ///
  45 BOOLEAN                mEnableLocking         = TRUE;
  46
  47 //
  48 // To prevent name collisions with possible future globally defined variables,
  49 // other internal firmware data variables that are not defined here must be
  50 // saved with a unique VendorGuid other than EFI_GLOBAL_VARIABLE or
  51 // any other GUID defined by the UEFI Specification. Implementations must
  52 // only permit the creation of variables with a UEFI Specification-defined
  53 // VendorGuid when these variables are documented in the UEFI Specification.
  54 //
  55 GLOBAL_VARIABLE_ENTRY mGlobalVariableList[] = {
  56   {EFI_LANG_CODES_VARIABLE_NAME,             VARIABLE_ATTRIBUTE_BS_RT},
  57   {EFI_LANG_VARIABLE_NAME,                   VARIABLE_ATTRIBUTE_NV_BS_RT},
  58   {EFI_TIME_OUT_VARIABLE_NAME,               VARIABLE_ATTRIBUTE_NV_BS_RT},
  59   {EFI_PLATFORM_LANG_CODES_VARIABLE_NAME,    VARIABLE_ATTRIBUTE_BS_RT},
  60   {EFI_PLATFORM_LANG_VARIABLE_NAME,          VARIABLE_ATTRIBUTE_NV_BS_RT},
  61   {EFI_CON_IN_VARIABLE_NAME,                 VARIABLE_ATTRIBUTE_NV_BS_RT},
  62   {EFI_CON_OUT_VARIABLE_NAME,                VARIABLE_ATTRIBUTE_NV_BS_RT},
  63   {EFI_ERR_OUT_VARIABLE_NAME,                VARIABLE_ATTRIBUTE_NV_BS_RT},
  64   {EFI_CON_IN_DEV_VARIABLE_NAME,             VARIABLE_ATTRIBUTE_BS_RT},
  65   {EFI_CON_OUT_DEV_VARIABLE_NAME,            VARIABLE_ATTRIBUTE_BS_RT},
  66   {EFI_ERR_OUT_DEV_VARIABLE_NAME,            VARIABLE_ATTRIBUTE_BS_RT},
  67   {EFI_BOOT_ORDER_VARIABLE_NAME,             VARIABLE_ATTRIBUTE_NV_BS_RT},
  68   {EFI_BOOT_NEXT_VARIABLE_NAME,              VARIABLE_ATTRIBUTE_NV_BS_RT},
  69   {EFI_BOOT_CURRENT_VARIABLE_NAME,           VARIABLE_ATTRIBUTE_BS_RT},
  70   {EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME,    VARIABLE_ATTRIBUTE_BS_RT},
  71   {EFI_DRIVER_ORDER_VARIABLE_NAME,           VARIABLE_ATTRIBUTE_NV_BS_RT},
  72   {EFI_HW_ERR_REC_SUPPORT_VARIABLE_NAME,     VARIABLE_ATTRIBUTE_NV_BS_RT},
  73   {EFI_SETUP_MODE_NAME,                      VARIABLE_ATTRIBUTE_BS_RT},
  74   {EFI_KEY_EXCHANGE_KEY_NAME,                VARIABLE_ATTRIBUTE_NV_BS_RT_AT},
  75   {EFI_PLATFORM_KEY_NAME,                    VARIABLE_ATTRIBUTE_NV_BS_RT_AT},
  76   {EFI_SIGNATURE_SUPPORT_NAME,               VARIABLE_ATTRIBUTE_BS_RT},
  77   {EFI_SECURE_BOOT_MODE_NAME,                VARIABLE_ATTRIBUTE_BS_RT},
  78   {EFI_KEK_DEFAULT_VARIABLE_NAME,            VARIABLE_ATTRIBUTE_BS_RT},
  79   {EFI_PK_DEFAULT_VARIABLE_NAME,             VARIABLE_ATTRIBUTE_BS_RT},
  80   {EFI_DB_DEFAULT_VARIABLE_NAME,             VARIABLE_ATTRIBUTE_BS_RT},
  81   {EFI_DBX_DEFAULT_VARIABLE_NAME,            VARIABLE_ATTRIBUTE_BS_RT},
  82   {EFI_DBT_DEFAULT_VARIABLE_NAME,            VARIABLE_ATTRIBUTE_BS_RT},
  83   {EFI_OS_INDICATIONS_SUPPORT_VARIABLE_NAME, VARIABLE_ATTRIBUTE_BS_RT},
  84   {EFI_OS_INDICATIONS_VARIABLE_NAME,         VARIABLE_ATTRIBUTE_NV_BS_RT},
  85   {EFI_VENDOR_KEYS_VARIABLE_NAME,            VARIABLE_ATTRIBUTE_BS_RT},
  86 };
  87 GLOBAL_VARIABLE_ENTRY mGlobalVariableList2[] = {
  88   {L"Boot####",                              VARIABLE_ATTRIBUTE_NV_BS_RT},
  89   {L"Driver####",                            VARIABLE_ATTRIBUTE_NV_BS_RT},
  90   {L"Key####",                               VARIABLE_ATTRIBUTE_NV_BS_RT},
  91 };
  92
  93 /**
  94   Routine used to track statistical information about variable usage.
  95   The data is stored in the EFI system table so it can be accessed later.
  96   VariableInfo.efi can dump out the table. Only Boot Services variable
  97   accesses are tracked by this code. The PcdVariableCollectStatistics
  98   build flag controls if this feature is enabled.
  99
 100   A read that hits in the cache will have Read and Cache true for
 101   the transaction. Data is allocated by this routine, but never
 102   freed.
 103
 104   @param[in] VariableName   Name of the Variable to track.
 105   @param[in] VendorGuid     Guid of the Variable to track.
 106   @param[in] Volatile       TRUE if volatile FALSE if non-volatile.
 107   @param[in] Read           TRUE if GetVariable() was called.
 108   @param[in] Write          TRUE if SetVariable() was called.
 109   @param[in] Delete         TRUE if deleted via SetVariable().
 110   @param[in] Cache          TRUE for a cache hit.
 111
 112 **/
 113 VOID
 114 UpdateVariableInfo (
 115   IN  CHAR16                  *VariableName,
 116   IN  EFI_GUID                *VendorGuid,
 117   IN  BOOLEAN                 Volatile,
 118   IN  BOOLEAN                 Read,
 119   IN  BOOLEAN                 Write,
 120   IN  BOOLEAN                 Delete,
 121   IN  BOOLEAN                 Cache
 122   )
 123 {
 124   VARIABLE_INFO_ENTRY   *Entry;
 125
 126   if (FeaturePcdGet (PcdVariableCollectStatistics)) {
 127
 128     if (AtRuntime ()) {
 129       // Don't collect statistics at runtime.
 130       return;
 131     }
 132
 133     if (gVariableInfo == NULL) {
 134       //
 135       // On the first call allocate a entry and place a pointer to it in
 136       // the EFI System Table.
 137       //
 138       gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
 139       ASSERT (gVariableInfo != NULL);
 140
 141       CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);
 142       gVariableInfo->Name = AllocatePool (StrSize (VariableName));
 143       ASSERT (gVariableInfo->Name != NULL);
 144       StrCpy (gVariableInfo->Name, VariableName);
 145       gVariableInfo->Volatile = Volatile;
 146     }
 147
 148
 149     for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) {
 150       if (CompareGuid (VendorGuid, &Entry->VendorGuid)) {
 151         if (StrCmp (VariableName, Entry->Name) == 0) {
 152           if (Read) {
 153             Entry->ReadCount++;
 154           }
 155           if (Write) {
 156             Entry->WriteCount++;
 157           }
 158           if (Delete) {
 159             Entry->DeleteCount++;
 160           }
 161           if (Cache) {
 162             Entry->CacheCount++;
 163           }
 164
 165           return;
 166         }
 167       }
 168
 169       if (Entry->Next == NULL) {
 170         //
 171         // If the entry is not in the table add it.
 172         // Next iteration of the loop will fill in the data.
 173         //
 174         Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
 175         ASSERT (Entry->Next != NULL);
 176
 177         CopyGuid (&Entry->Next->VendorGuid, VendorGuid);
 178         Entry->Next->Name = AllocatePool (StrSize (VariableName));
 179         ASSERT (Entry->Next->Name != NULL);
 180         StrCpy (Entry->Next->Name, VariableName);
 181         Entry->Next->Volatile = Volatile;
 182       }
 183
 184     }
 185   }
 186 }
 187
 188
 189 /**
 190
 191   This code checks if variable header is valid or not.
 192
 193   @param Variable        Pointer to the Variable Header.
 194
 195   @retval TRUE           Variable header is valid.
 196   @retval FALSE          Variable header is not valid.
 197
 198 **/
 199 BOOLEAN
 200 IsValidVariableHeader (
 201   IN  VARIABLE_HEADER   *Variable
 202   )
 203 {
 204   if (Variable == NULL || Variable->StartId != VARIABLE_DATA) {
 205     return FALSE;
 206   }
 207
 208   return TRUE;
 209 }
 210
 211
 212 /**
 213
 214   This function writes data to the FWH at the correct LBA even if the LBAs
 215   are fragmented.
 216
 217   @param Global                  Pointer to VARAIBLE_GLOBAL structure.
 218   @param Volatile                Point out the Variable is Volatile or Non-Volatile.
 219   @param SetByIndex              TRUE if target pointer is given as index.
 220                                  FALSE if target pointer is absolute.
 221   @param Fvb                     Pointer to the writable FVB protocol.
 222   @param DataPtrIndex            Pointer to the Data from the end of VARIABLE_STORE_HEADER
 223                                  structure.
 224   @param DataSize                Size of data to be written.
 225   @param Buffer                  Pointer to the buffer from which data is written.
 226
 227   @retval EFI_INVALID_PARAMETER  Parameters not valid.
 228   @retval EFI_SUCCESS            Variable store successfully updated.
 229
 230 **/
 231 EFI_STATUS
 232 UpdateVariableStore (
 233   IN  VARIABLE_GLOBAL                     *Global,
 234   IN  BOOLEAN                             Volatile,
 235   IN  BOOLEAN                             SetByIndex,
 236   IN  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb,
 237   IN  UINTN                               DataPtrIndex,
 238   IN  UINT32                              DataSize,
 239   IN  UINT8                               *Buffer
 240   )
 241 {
 242   EFI_FV_BLOCK_MAP_ENTRY      *PtrBlockMapEntry;
 243   UINTN                       BlockIndex2;
 244   UINTN                       LinearOffset;
 245   UINTN                       CurrWriteSize;
 246   UINTN                       CurrWritePtr;
 247   UINT8                       *CurrBuffer;
 248   EFI_LBA                     LbaNumber;
 249   UINTN                       Size;
 250   EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
 251   VARIABLE_STORE_HEADER       *VolatileBase;
 252   EFI_PHYSICAL_ADDRESS        FvVolHdr;
 253   EFI_PHYSICAL_ADDRESS        DataPtr;
 254   EFI_STATUS                  Status;
 255
 256   FwVolHeader = NULL;
 257   DataPtr     = DataPtrIndex;
 258
 259   //
 260   // Check if the Data is Volatile.
 261   //
 262   if (!Volatile) {
 263     ASSERT (Fvb != NULL);
 264     Status = Fvb->GetPhysicalAddress(Fvb, &FvVolHdr);
 265     ASSERT_EFI_ERROR (Status);
 266
 267     FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
 268     //
 269     // Data Pointer should point to the actual Address where data is to be
 270     // written.
 271     //
 272     if (SetByIndex) {
 273       DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;
 274     }
 275
 276     if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {
 277       return EFI_INVALID_PARAMETER;
 278     }
 279   } else {
 280     //
 281     // Data Pointer should point to the actual Address where data is to be
 282     // written.
 283     //
 284     VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
 285     if (SetByIndex) {
 286       DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;
 287     }
 288
 289     if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {
 290       return EFI_INVALID_PARAMETER;
 291     }
 292
 293     //
 294     // If Volatile Variable just do a simple mem copy.
 295     //
 296     CopyMem ((UINT8 *)(UINTN)DataPtr, Buffer, DataSize);
 297     return EFI_SUCCESS;
 298   }
 299
 300   //
 301   // If we are here we are dealing with Non-Volatile Variables.
 302   //
 303   LinearOffset  = (UINTN) FwVolHeader;
 304   CurrWritePtr  = (UINTN) DataPtr;
 305   CurrWriteSize = DataSize;
 306   CurrBuffer    = Buffer;
 307   LbaNumber     = 0;
 308
 309   if (CurrWritePtr < LinearOffset) {
 310     return EFI_INVALID_PARAMETER;
 311   }
 312
 313   for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {
 314     for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {
 315       //
 316       // Check to see if the Variable Writes are spanning through multiple
 317       // blocks.
 318       //
 319       if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->Length)) {
 320         if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->Length)) {
 321           Status = Fvb->Write (
 322                     Fvb,
 323                     LbaNumber,
 324                     (UINTN) (CurrWritePtr - LinearOffset),
 325                     &CurrWriteSize,
 326                     CurrBuffer
 327                     );
 328           return Status;
 329         } else {
 330           Size = (UINT32) (LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);
 331           Status = Fvb->Write (
 332                     Fvb,
 333                     LbaNumber,
 334                     (UINTN) (CurrWritePtr - LinearOffset),
 335                     &Size,
 336                     CurrBuffer
 337                     );
 338           if (EFI_ERROR (Status)) {
 339             return Status;
 340           }
 341
 342           CurrWritePtr  = LinearOffset + PtrBlockMapEntry->Length;
 343           CurrBuffer    = CurrBuffer + Size;
 344           CurrWriteSize = CurrWriteSize - Size;
 345         }
 346       }
 347
 348       LinearOffset += PtrBlockMapEntry->Length;
 349       LbaNumber++;
 350     }
 351   }
 352
 353   return EFI_SUCCESS;
 354 }
 355
 356
 357 /**
 358
 359   This code gets the current status of Variable Store.
 360
 361   @param VarStoreHeader  Pointer to the Variable Store Header.
 362
 363   @retval EfiRaw         Variable store status is raw.
 364   @retval EfiValid       Variable store status is valid.
 365   @retval EfiInvalid     Variable store status is invalid.
 366
 367 **/
 368 VARIABLE_STORE_STATUS
 369 GetVariableStoreStatus (
 370   IN VARIABLE_STORE_HEADER *VarStoreHeader
 371   )
 372 {
 373   if (CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid) &&
 374       VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
 375       VarStoreHeader->State == VARIABLE_STORE_HEALTHY
 376       ) {
 377
 378     return EfiValid;
 379   } else if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&
 380              ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&
 381              ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&
 382              ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&
 383              VarStoreHeader->Size == 0xffffffff &&
 384              VarStoreHeader->Format == 0xff &&
 385              VarStoreHeader->State == 0xff
 386           ) {
 387
 388     return EfiRaw;
 389   } else {
 390     return EfiInvalid;
 391   }
 392 }
 393
 394
 395 /**
 396
 397   This code gets the size of name of variable.
 398
 399   @param Variable        Pointer to the Variable Header.
 400
 401   @return UINTN          Size of variable in bytes.
 402
 403 **/
 404 UINTN
 405 NameSizeOfVariable (
 406   IN  VARIABLE_HEADER   *Variable
 407   )
 408 {
 409   if (Variable->State    == (UINT8) (-1) ||
 410       Variable->DataSize == (UINT32) (-1) ||
 411       Variable->NameSize == (UINT32) (-1) ||
 412       Variable->Attributes == (UINT32) (-1)) {
 413     return 0;
 414   }
 415   return (UINTN) Variable->NameSize;
 416 }
 417
 418 /**
 419
 420   This code gets the size of variable data.
 421
 422   @param Variable        Pointer to the Variable Header.
 423
 424   @return Size of variable in bytes.
 425
 426 **/
 427 UINTN
 428 DataSizeOfVariable (
 429   IN  VARIABLE_HEADER   *Variable
 430   )
 431 {
 432   if (Variable->State    == (UINT8)  (-1) ||
 433       Variable->DataSize == (UINT32) (-1) ||
 434       Variable->NameSize == (UINT32) (-1) ||
 435       Variable->Attributes == (UINT32) (-1)) {
 436     return 0;
 437   }
 438   return (UINTN) Variable->DataSize;
 439 }
 440
 441 /**
 442
 443   This code gets the pointer to the variable name.
 444
 445   @param Variable        Pointer to the Variable Header.
 446
 447   @return Pointer to Variable Name which is Unicode encoding.
 448
 449 **/
 450 CHAR16 *
 451 GetVariableNamePtr (
 452   IN  VARIABLE_HEADER   *Variable
 453   )
 454 {
 455
 456   return (CHAR16 *) (Variable + 1);
 457 }
 458
 459 /**
 460
 461   This code gets the pointer to the variable data.
 462
 463   @param Variable        Pointer to the Variable Header.
 464
 465   @return Pointer to Variable Data.
 466
 467 **/
 468 UINT8 *
 469 GetVariableDataPtr (
 470   IN  VARIABLE_HEADER   *Variable
 471   )
 472 {
 473   UINTN Value;
 474
 475   //
 476   // Be careful about pad size for alignment.
 477   //
 478   Value =  (UINTN) GetVariableNamePtr (Variable);
 479   Value += NameSizeOfVariable (Variable);
 480   Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));
 481
 482   return (UINT8 *) Value;
 483 }
 484
 485
 486 /**
 487
 488   This code gets the pointer to the next variable header.
 489
 490   @param Variable        Pointer to the Variable Header.
 491
 492   @return Pointer to next variable header.
 493
 494 **/
 495 VARIABLE_HEADER *
 496 GetNextVariablePtr (
 497   IN  VARIABLE_HEADER   *Variable
 498   )
 499 {
 500   UINTN Value;
 501
 502   if (!IsValidVariableHeader (Variable)) {
 503     return NULL;
 504   }
 505
 506   Value =  (UINTN) GetVariableDataPtr (Variable);
 507   Value += DataSizeOfVariable (Variable);
 508   Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));
 509
 510   //
 511   // Be careful about pad size for alignment.
 512   //
 513   return (VARIABLE_HEADER *) HEADER_ALIGN (Value);
 514 }
 515
 516 /**
 517
 518   Gets the pointer to the first variable header in given variable store area.
 519
 520   @param VarStoreHeader  Pointer to the Variable Store Header.
 521
 522   @return Pointer to the first variable header.
 523
 524 **/
 525 VARIABLE_HEADER *
 526 GetStartPointer (
 527   IN VARIABLE_STORE_HEADER       *VarStoreHeader
 528   )
 529 {
 530   //
 531   // The end of variable store.
 532   //
 533   return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);
 534 }
 535
 536 /**
 537
 538   Gets the pointer to the end of the variable storage area.
 539
 540   This function gets pointer to the end of the variable storage
 541   area, according to the input variable store header.
 542
 543   @param VarStoreHeader  Pointer to the Variable Store Header.
 544
 545   @return Pointer to the end of the variable storage area.
 546
 547 **/
 548 VARIABLE_HEADER *
 549 GetEndPointer (
 550   IN VARIABLE_STORE_HEADER       *VarStoreHeader
 551   )
 552 {
 553   //
 554   // The end of variable store
 555   //
 556   return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);
 557 }
 558
 559
 560 /**
 561
 562   Variable store garbage collection and reclaim operation.
 563
 564   @param VariableBase            Base address of variable store.
 565   @param LastVariableOffset      Offset of last variable.
 566   @param IsVolatile              The variable store is volatile or not;
 567                                  if it is non-volatile, need FTW.
 568   @param UpdatingPtrTrack        Pointer to updating variable pointer track structure.
 569   @param NewVariable             Pointer to new variable.
 570   @param NewVariableSize         New variable size.
 571
 572   @return EFI_OUT_OF_RESOURCES
 573   @return EFI_SUCCESS
 574   @return Others
 575
 576 **/
 577 EFI_STATUS
 578 Reclaim (
 579   IN  EFI_PHYSICAL_ADDRESS  VariableBase,
 580   OUT UINTN                 *LastVariableOffset,
 581   IN  BOOLEAN               IsVolatile,
 582   IN OUT VARIABLE_POINTER_TRACK *UpdatingPtrTrack,
 583   IN  VARIABLE_HEADER       *NewVariable,
 584   IN  UINTN                 NewVariableSize
 585   )
 586 {
 587   VARIABLE_HEADER       *Variable;
 588   VARIABLE_HEADER       *AddedVariable;
 589   VARIABLE_HEADER       *NextVariable;
 590   VARIABLE_HEADER       *NextAddedVariable;
 591   VARIABLE_STORE_HEADER *VariableStoreHeader;
 592   UINT8                 *ValidBuffer;
 593   UINTN                 MaximumBufferSize;
 594   UINTN                 VariableSize;
 595   UINTN                 NameSize;
 596   UINT8                 *CurrPtr;
 597   VOID                  *Point0;
 598   VOID                  *Point1;
 599   BOOLEAN               FoundAdded;
 600   EFI_STATUS            Status;
 601   UINTN                 CommonVariableTotalSize;
 602   UINTN                 HwErrVariableTotalSize;
 603   VARIABLE_HEADER       *UpdatingVariable;
 604   VARIABLE_HEADER       *UpdatingInDeletedTransition;
 605
 606   UpdatingVariable = NULL;
 607   UpdatingInDeletedTransition = NULL;
 608   if (UpdatingPtrTrack != NULL) {
 609     UpdatingVariable = UpdatingPtrTrack->CurrPtr;
 610     UpdatingInDeletedTransition = UpdatingPtrTrack->InDeletedTransitionPtr;
 611   }
 612
 613   VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);
 614
 615   CommonVariableTotalSize = 0;
 616   HwErrVariableTotalSize  = 0;
 617
 618   if (IsVolatile) {
 619     //
 620     // Start Pointers for the variable.
 621     //
 622     Variable          = GetStartPointer (VariableStoreHeader);
 623     MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);
 624
 625     while (IsValidVariableHeader (Variable)) {
 626       NextVariable = GetNextVariablePtr (Variable);
 627       if ((Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) &&
 628           Variable != UpdatingVariable &&
 629           Variable != UpdatingInDeletedTransition
 630          ) {
 631         VariableSize = (UINTN) NextVariable - (UINTN) Variable;
 632         MaximumBufferSize += VariableSize;
 633       }
 634
 635       Variable = NextVariable;
 636     }
 637
 638     if (NewVariable != NULL) {
 639       //
 640       // Add the new variable size.
 641       //
 642       MaximumBufferSize += NewVariableSize;
 643     }
 644
 645     //
 646     // Reserve the 1 Bytes with Oxff to identify the
 647     // end of the variable buffer.
 648     //
 649     MaximumBufferSize += 1;
 650     ValidBuffer = AllocatePool (MaximumBufferSize);
 651     if (ValidBuffer == NULL) {
 652       return EFI_OUT_OF_RESOURCES;
 653     }
 654   } else {
 655     //
 656     // For NV variable reclaim, don't allocate pool here and just use mNvVariableCache
 657     // as the buffer to reduce SMRAM consumption for SMM variable driver.
 658     //
 659     MaximumBufferSize = mNvVariableCache->Size;
 660     ValidBuffer = (UINT8 *) mNvVariableCache;
 661   }
 662
 663   SetMem (ValidBuffer, MaximumBufferSize, 0xff);
 664
 665   //
 666   // Copy variable store header.
 667   //
 668   CopyMem (ValidBuffer, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));
 669   CurrPtr = (UINT8 *) GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);
 670
 671   //
 672   // Reinstall all ADDED variables as long as they are not identical to Updating Variable.
 673   //
 674   Variable = GetStartPointer (VariableStoreHeader);
 675   while (IsValidVariableHeader (Variable)) {
 676     NextVariable = GetNextVariablePtr (Variable);
 677     if (Variable != UpdatingVariable && Variable->State == VAR_ADDED) {
 678       VariableSize = (UINTN) NextVariable - (UINTN) Variable;
 679       CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
 680       CurrPtr += VariableSize;
 681       if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 682         HwErrVariableTotalSize += VariableSize;
 683       } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 684         CommonVariableTotalSize += VariableSize;
 685       }
 686     }
 687     Variable = NextVariable;
 688   }
 689
 690   //
 691   // Reinstall all in delete transition variables.
 692   //
 693   Variable = GetStartPointer (VariableStoreHeader);
 694   while (IsValidVariableHeader (Variable)) {
 695     NextVariable = GetNextVariablePtr (Variable);
 696     if (Variable != UpdatingVariable && Variable != UpdatingInDeletedTransition && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
 697
 698       //
 699       // Buffer has cached all ADDED variable.
 700       // Per IN_DELETED variable, we have to guarantee that
 701       // no ADDED one in previous buffer.
 702       //
 703
 704       FoundAdded = FALSE;
 705       AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);
 706       while (IsValidVariableHeader (AddedVariable)) {
 707         NextAddedVariable = GetNextVariablePtr (AddedVariable);
 708         NameSize = NameSizeOfVariable (AddedVariable);
 709         if (CompareGuid (&AddedVariable->VendorGuid, &Variable->VendorGuid) &&
 710             NameSize == NameSizeOfVariable (Variable)
 711            ) {
 712           Point0 = (VOID *) GetVariableNamePtr (AddedVariable);
 713           Point1 = (VOID *) GetVariableNamePtr (Variable);
 714           if (CompareMem (Point0, Point1, NameSize) == 0) {
 715             FoundAdded = TRUE;
 716             break;
 717           }
 718         }
 719         AddedVariable = NextAddedVariable;
 720       }
 721       if (!FoundAdded) {
 722         //
 723         // Promote VAR_IN_DELETED_TRANSITION to VAR_ADDED.
 724         //
 725         VariableSize = (UINTN) NextVariable - (UINTN) Variable;
 726         CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
 727         ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;
 728         CurrPtr += VariableSize;
 729         if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 730           HwErrVariableTotalSize += VariableSize;
 731         } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 732           CommonVariableTotalSize += VariableSize;
 733         }
 734       }
 735     }
 736
 737     Variable = NextVariable;
 738   }
 739
 740   //
 741   // Install the new variable if it is not NULL.
 742   //
 743   if (NewVariable != NULL) {
 744     if ((UINTN) (CurrPtr - ValidBuffer) + NewVariableSize > VariableStoreHeader->Size) {
 745       //
 746       // No enough space to store the new variable.
 747       //
 748       Status = EFI_OUT_OF_RESOURCES;
 749       goto Done;
 750     }
 751     if (!IsVolatile) {
 752       if ((NewVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
 753         HwErrVariableTotalSize += NewVariableSize;
 754       } else if ((NewVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
 755         CommonVariableTotalSize += NewVariableSize;
 756       }
 757       if ((HwErrVariableTotalSize > PcdGet32 (PcdHwErrStorageSize)) ||
 758           (CommonVariableTotalSize > VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize))) {
 759         //
 760         // No enough space to store the new variable by NV or NV+HR attribute.
 761         //
 762         Status = EFI_OUT_OF_RESOURCES;
 763         goto Done;
 764       }
 765     }
 766
 767     CopyMem (CurrPtr, (UINT8 *) NewVariable, NewVariableSize);
 768     ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;
 769     if (UpdatingVariable != NULL) {
 770       UpdatingPtrTrack->CurrPtr = (VARIABLE_HEADER *)((UINTN)UpdatingPtrTrack->StartPtr + ((UINTN)CurrPtr - (UINTN)GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer)));
 771       UpdatingPtrTrack->InDeletedTransitionPtr = NULL;
 772     }
 773     CurrPtr += NewVariableSize;
 774   }
 775
 776   if (IsVolatile) {
 777     //
 778     // If volatile variable store, just copy valid buffer.
 779     //
 780     SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);
 781     CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, (UINTN) (CurrPtr - ValidBuffer));
 782     *LastVariableOffset = (UINTN) (CurrPtr - ValidBuffer);
 783     Status  = EFI_SUCCESS;
 784   } else {
 785     //
 786     // If non-volatile variable store, perform FTW here.
 787     //
 788     Status = FtwVariableSpace (
 789               VariableBase,
 790               (VARIABLE_STORE_HEADER *) ValidBuffer
 791               );
 792     if (!EFI_ERROR (Status)) {
 793       *LastVariableOffset = (UINTN) (CurrPtr - ValidBuffer);
 794       mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;
 795       mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;
 796     } else {
 797       NextVariable  = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase);
 798       while (IsValidVariableHeader (NextVariable)) {
 799         VariableSize = NextVariable->NameSize + NextVariable->DataSize + sizeof (VARIABLE_HEADER);
 800         if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
 801           mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VariableSize);
 802         } else if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
 803           mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VariableSize);
 804         }
 805
 806         NextVariable = GetNextVariablePtr (NextVariable);
 807       }
 808       *LastVariableOffset = (UINTN) NextVariable - (UINTN) VariableBase;
 809     }
 810   }
 811
 812 Done:
 813   if (IsVolatile) {
 814     FreePool (ValidBuffer);
 815   } else {
 816     //
 817     // For NV variable reclaim, we use mNvVariableCache as the buffer, so copy the data back.
 818     //
 819     CopyMem (mNvVariableCache, (UINT8 *)(UINTN)VariableBase, VariableStoreHeader->Size);
 820   }
 821
 822   return Status;
 823 }
 824
 825 /**
 826   Find the variable in the specified variable store.
 827
 828   @param  VariableName        Name of the variable to be found
 829   @param  VendorGuid          Vendor GUID to be found.
 830   @param  IgnoreRtCheck       Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute
 831                               check at runtime when searching variable.
 832   @param  PtrTrack            Variable Track Pointer structure that contains Variable Information.
 833
 834   @retval  EFI_SUCCESS            Variable found successfully
 835   @retval  EFI_NOT_FOUND          Variable not found
 836 **/
 837 EFI_STATUS
 838 FindVariableEx (
 839   IN     CHAR16                  *VariableName,
 840   IN     EFI_GUID                *VendorGuid,
 841   IN     BOOLEAN                 IgnoreRtCheck,
 842   IN OUT VARIABLE_POINTER_TRACK  *PtrTrack
 843   )
 844 {
 845   VARIABLE_HEADER                *InDeletedVariable;
 846   VOID                           *Point;
 847
 848   PtrTrack->InDeletedTransitionPtr = NULL;
 849
 850   //
 851   // Find the variable by walk through HOB, volatile and non-volatile variable store.
 852   //
 853   InDeletedVariable  = NULL;
 854
 855   for ( PtrTrack->CurrPtr = PtrTrack->StartPtr
 856       ; (PtrTrack->CurrPtr < PtrTrack->EndPtr) && IsValidVariableHeader (PtrTrack->CurrPtr)
 857       ; PtrTrack->CurrPtr = GetNextVariablePtr (PtrTrack->CurrPtr)
 858       ) {
 859     if (PtrTrack->CurrPtr->State == VAR_ADDED ||
 860         PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)
 861        ) {
 862       if (IgnoreRtCheck || !AtRuntime () || ((PtrTrack->CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {
 863         if (VariableName[0] == 0) {
 864           if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
 865             InDeletedVariable   = PtrTrack->CurrPtr;
 866           } else {
 867             PtrTrack->InDeletedTransitionPtr = InDeletedVariable;
 868             return EFI_SUCCESS;
 869           }
 870         } else {
 871           if (CompareGuid (VendorGuid, &PtrTrack->CurrPtr->VendorGuid)) {
 872             Point = (VOID *) GetVariableNamePtr (PtrTrack->CurrPtr);
 873
 874             ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr) != 0);
 875             if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr)) == 0) {
 876               if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
 877                 InDeletedVariable     = PtrTrack->CurrPtr;
 878               } else {
 879                 PtrTrack->InDeletedTransitionPtr = InDeletedVariable;
 880                 return EFI_SUCCESS;
 881               }
 882             }
 883           }
 884         }
 885       }
 886     }
 887   }
 888
 889   PtrTrack->CurrPtr = InDeletedVariable;
 890   return (PtrTrack->CurrPtr  == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;
 891 }
 892
 893
 894 /**
 895   Finds variable in storage blocks of volatile and non-volatile storage areas.
 896
 897   This code finds variable in storage blocks of volatile and non-volatile storage areas.
 898   If VariableName is an empty string, then we just return the first
 899   qualified variable without comparing VariableName and VendorGuid.
 900   If IgnoreRtCheck is TRUE, then we ignore the EFI_VARIABLE_RUNTIME_ACCESS attribute check
 901   at runtime when searching existing variable, only VariableName and VendorGuid are compared.
 902   Otherwise, variables without EFI_VARIABLE_RUNTIME_ACCESS are not visible at runtime.
 903
 904   @param  VariableName                Name of the variable to be found.
 905   @param  VendorGuid                  Vendor GUID to be found.
 906   @param  PtrTrack                    VARIABLE_POINTER_TRACK structure for output,
 907                                       including the range searched and the target position.
 908   @param  Global                      Pointer to VARIABLE_GLOBAL structure, including
 909                                       base of volatile variable storage area, base of
 910                                       NV variable storage area, and a lock.
 911   @param  IgnoreRtCheck               Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute
 912                                       check at runtime when searching variable.
 913
 914   @retval EFI_INVALID_PARAMETER       If VariableName is not an empty string, while
 915                                       VendorGuid is NULL.
 916   @retval EFI_SUCCESS                 Variable successfully found.
 917   @retval EFI_NOT_FOUND               Variable not found
 918
 919 **/
 920 EFI_STATUS
 921 FindVariable (
 922   IN  CHAR16                  *VariableName,
 923   IN  EFI_GUID                *VendorGuid,
 924   OUT VARIABLE_POINTER_TRACK  *PtrTrack,
 925   IN  VARIABLE_GLOBAL         *Global,
 926   IN  BOOLEAN                 IgnoreRtCheck
 927   )
 928 {
 929   EFI_STATUS              Status;
 930   VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];
 931   VARIABLE_STORE_TYPE     Type;
 932
 933   if (VariableName[0] != 0 && VendorGuid == NULL) {
 934     return EFI_INVALID_PARAMETER;
 935   }
 936
 937   //
 938   // 0: Volatile, 1: HOB, 2: Non-Volatile.
 939   // The index and attributes mapping must be kept in this order as RuntimeServiceGetNextVariableName
 940   // make use of this mapping to implement search algorithm.
 941   //
 942   VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) Global->VolatileVariableBase;
 943   VariableStoreHeader[VariableStoreTypeHob]      = (VARIABLE_STORE_HEADER *) (UINTN) Global->HobVariableBase;
 944   VariableStoreHeader[VariableStoreTypeNv]       = mNvVariableCache;
 945
 946   //
 947   // Find the variable by walk through HOB, volatile and non-volatile variable store.
 948   //
 949   for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {
 950     if (VariableStoreHeader[Type] == NULL) {
 951       continue;
 952     }
 953
 954     PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Type]);
 955     PtrTrack->EndPtr   = GetEndPointer   (VariableStoreHeader[Type]);
 956     PtrTrack->Volatile = (BOOLEAN) (Type == VariableStoreTypeVolatile);
 957
 958     Status = FindVariableEx (VariableName, VendorGuid, IgnoreRtCheck, PtrTrack);
 959     if (!EFI_ERROR (Status)) {
 960       return Status;
 961     }
 962   }
 963   return EFI_NOT_FOUND;
 964 }
 965
 966 /**
 967   Get index from supported language codes according to language string.
 968
 969   This code is used to get corresponding index in supported language codes. It can handle
 970   RFC4646 and ISO639 language tags.
 971   In ISO639 language tags, take 3-characters as a delimitation to find matched string and calculate the index.
 972   In RFC4646 language tags, take semicolon as a delimitation to find matched string and calculate the index.
 973
 974   For example:
 975     SupportedLang  = "engfraengfra"
 976     Lang           = "eng"
 977     Iso639Language = TRUE
 978   The return value is "0".
 979   Another example:
 980     SupportedLang  = "en;fr;en-US;fr-FR"
 981     Lang           = "fr-FR"
 982     Iso639Language = FALSE
 983   The return value is "3".
 984
 985   @param  SupportedLang               Platform supported language codes.
 986   @param  Lang                        Configured language.
 987   @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.
 988
 989   @retval The index of language in the language codes.
 990
 991 **/
 992 UINTN
 993 GetIndexFromSupportedLangCodes(
 994   IN  CHAR8            *SupportedLang,
 995   IN  CHAR8            *Lang,
 996   IN  BOOLEAN          Iso639Language
 997   )
 998 {
 999   UINTN    Index;
1000   UINTN    CompareLength;
1001   UINTN    LanguageLength;
1002
1003   if (Iso639Language) {
1004     CompareLength = ISO_639_2_ENTRY_SIZE;
1005     for (Index = 0; Index < AsciiStrLen (SupportedLang); Index += CompareLength) {
1006       if (AsciiStrnCmp (Lang, SupportedLang + Index, CompareLength) == 0) {
1007         //
1008         // Successfully find the index of Lang string in SupportedLang string.
1009         //
1010         Index = Index / CompareLength;
1011         return Index;
1012       }
1013     }
1014     ASSERT (FALSE);
1015     return 0;
1016   } else {
1017     //
1018     // Compare RFC4646 language code
1019     //
1020     Index = 0;
1021     for (LanguageLength = 0; Lang[LanguageLength] != '\0'; LanguageLength++);
1022
1023     for (Index = 0; *SupportedLang != '\0'; Index++, SupportedLang += CompareLength) {
1024       //
1025       // Skip ';' characters in SupportedLang
1026       //
1027       for (; *SupportedLang != '\0' && *SupportedLang == ';'; SupportedLang++);
1028       //
1029       // Determine the length of the next language code in SupportedLang
1030       //
1031       for (CompareLength = 0; SupportedLang[CompareLength] != '\0' && SupportedLang[CompareLength] != ';'; CompareLength++);
1032
1033       if ((CompareLength == LanguageLength) &&
1034           (AsciiStrnCmp (Lang, SupportedLang, CompareLength) == 0)) {
1035         //
1036         // Successfully find the index of Lang string in SupportedLang string.
1037         //
1038         return Index;
1039       }
1040     }
1041     ASSERT (FALSE);
1042     return 0;
1043   }
1044 }
1045
1046 /**
1047   Get language string from supported language codes according to index.
1048
1049   This code is used to get corresponding language strings in supported language codes. It can handle
1050   RFC4646 and ISO639 language tags.
1051   In ISO639 language tags, take 3-characters as a delimitation. Find language string according to the index.
1052   In RFC4646 language tags, take semicolon as a delimitation. Find language string according to the index.
1053
1054   For example:
1055     SupportedLang  = "engfraengfra"
1056     Index          = "1"
1057     Iso639Language = TRUE
1058   The return value is "fra".
1059   Another example:
1060     SupportedLang  = "en;fr;en-US;fr-FR"
1061     Index          = "1"
1062     Iso639Language = FALSE
1063   The return value is "fr".
1064
1065   @param  SupportedLang               Platform supported language codes.
1066   @param  Index                       The index in supported language codes.
1067   @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.
1068
1069   @retval The language string in the language codes.
1070
1071 **/
1072 CHAR8 *
1073 GetLangFromSupportedLangCodes (
1074   IN  CHAR8            *SupportedLang,
1075   IN  UINTN            Index,
1076   IN  BOOLEAN          Iso639Language
1077 )
1078 {
1079   UINTN    SubIndex;
1080   UINTN    CompareLength;
1081   CHAR8    *Supported;
1082
1083   SubIndex  = 0;
1084   Supported = SupportedLang;
1085   if (Iso639Language) {
1086     //
1087     // According to the index of Lang string in SupportedLang string to get the language.
1088     // This code will be invoked in RUNTIME, therefore there is not a memory allocate/free operation.
1089     // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.
1090     //
1091     CompareLength = ISO_639_2_ENTRY_SIZE;
1092     mVariableModuleGlobal->Lang[CompareLength] = '\0';
1093     return CopyMem (mVariableModuleGlobal->Lang, SupportedLang + Index * CompareLength, CompareLength);
1094
1095   } else {
1096     while (TRUE) {
1097       //
1098       // Take semicolon as delimitation, sequentially traverse supported language codes.
1099       //
1100       for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {
1101         Supported++;
1102       }
1103       if ((*Supported == '\0') && (SubIndex != Index)) {
1104         //
1105         // Have completed the traverse, but not find corrsponding string.
1106         // This case is not allowed to happen.
1107         //
1108         ASSERT(FALSE);
1109         return NULL;
1110       }
1111       if (SubIndex == Index) {
1112         //
1113         // According to the index of Lang string in SupportedLang string to get the language.
1114         // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.
1115         // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.
1116         //
1117         mVariableModuleGlobal->PlatformLang[CompareLength] = '\0';
1118         return CopyMem (mVariableModuleGlobal->PlatformLang, Supported - CompareLength, CompareLength);
1119       }
1120       SubIndex++;
1121
1122       //
1123       // Skip ';' characters in Supported
1124       //
1125       for (; *Supported != '\0' && *Supported == ';'; Supported++);
1126     }
1127   }
1128 }
1129
1130 /**
1131   Returns a pointer to an allocated buffer that contains the best matching language
1132   from a set of supported languages.
1133
1134   This function supports both ISO 639-2 and RFC 4646 language codes, but language
1135   code types may not be mixed in a single call to this function. This function
1136   supports a variable argument list that allows the caller to pass in a prioritized
1137   list of language codes to test against all the language codes in SupportedLanguages.
1138
1139   If SupportedLanguages is NULL, then ASSERT().
1140
1141   @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string that
1142                                   contains a set of language codes in the format
1143                                   specified by Iso639Language.
1144   @param[in]  Iso639Language      If TRUE, then all language codes are assumed to be
1145                                   in ISO 639-2 format.  If FALSE, then all language
1146                                   codes are assumed to be in RFC 4646 language format
1147   @param[in]  ...                 A variable argument list that contains pointers to
1148                                   Null-terminated ASCII strings that contain one or more
1149                                   language codes in the format specified by Iso639Language.
1150                                   The first language code from each of these language
1151                                   code lists is used to determine if it is an exact or
1152                                   close match to any of the language codes in
1153                                   SupportedLanguages.  Close matches only apply to RFC 4646
1154                                   language codes, and the matching algorithm from RFC 4647
1155                                   is used to determine if a close match is present.  If
1156                                   an exact or close match is found, then the matching
1157                                   language code from SupportedLanguages is returned.  If
1158                                   no matches are found, then the next variable argument
1159                                   parameter is evaluated.  The variable argument list
1160                                   is terminated by a NULL.
1161
1162   @retval NULL   The best matching language could not be found in SupportedLanguages.
1163   @retval NULL   There are not enough resources available to return the best matching
1164                  language.
1165   @retval Other  A pointer to a Null-terminated ASCII string that is the best matching
1166                  language in SupportedLanguages.
1167
1168 **/
1169 CHAR8 *
1170 EFIAPI
1171 VariableGetBestLanguage (
1172   IN CONST CHAR8  *SupportedLanguages,
1173   IN BOOLEAN      Iso639Language,
1174   ...
1175   )
1176 {
1177   VA_LIST      Args;
1178   CHAR8        *Language;
1179   UINTN        CompareLength;
1180   UINTN        LanguageLength;
1181   CONST CHAR8  *Supported;
1182   CHAR8        *Buffer;
1183
1184   ASSERT (SupportedLanguages != NULL);
1185
1186   VA_START (Args, Iso639Language);
1187   while ((Language = VA_ARG (Args, CHAR8 *)) != NULL) {
1188     //
1189     // Default to ISO 639-2 mode
1190     //
1191     CompareLength  = 3;
1192     LanguageLength = MIN (3, AsciiStrLen (Language));
1193
1194     //
1195     // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language
1196     //
1197     if (!Iso639Language) {
1198       for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);
1199     }
1200
1201     //
1202     // Trim back the length of Language used until it is empty
1203     //
1204     while (LanguageLength > 0) {
1205       //
1206       // Loop through all language codes in SupportedLanguages
1207       //
1208       for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {
1209         //
1210         // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages
1211         //
1212         if (!Iso639Language) {
1213           //
1214           // Skip ';' characters in Supported
1215           //
1216           for (; *Supported != '\0' && *Supported == ';'; Supported++);
1217           //
1218           // Determine the length of the next language code in Supported
1219           //
1220           for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);
1221           //
1222           // If Language is longer than the Supported, then skip to the next language
1223           //
1224           if (LanguageLength > CompareLength) {
1225             continue;
1226           }
1227         }
1228         //
1229         // See if the first LanguageLength characters in Supported match Language
1230         //
1231         if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {
1232           VA_END (Args);
1233
1234           Buffer = Iso639Language ? mVariableModuleGlobal->Lang : mVariableModuleGlobal->PlatformLang;
1235           Buffer[CompareLength] = '\0';
1236           return CopyMem (Buffer, Supported, CompareLength);
1237         }
1238       }
1239
1240       if (Iso639Language) {
1241         //
1242         // If ISO 639 mode, then each language can only be tested once
1243         //
1244         LanguageLength = 0;
1245       } else {
1246         //
1247         // If RFC 4646 mode, then trim Language from the right to the next '-' character
1248         //
1249         for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);
1250       }
1251     }
1252   }
1253   VA_END (Args);
1254
1255   //
1256   // No matches were found
1257   //
1258   return NULL;
1259 }
1260
1261 /**
1262   Hook the operations in PlatformLangCodes, LangCodes, PlatformLang and Lang.
1263
1264   When setting Lang/LangCodes, simultaneously update PlatformLang/PlatformLangCodes.
1265
1266   According to UEFI spec, PlatformLangCodes/LangCodes are only set once in firmware initialization,
1267   and are read-only. Therefore, in variable driver, only store the original value for other use.
1268
1269   @param[in] VariableName       Name of variable.
1270
1271   @param[in] Data               Variable data.
1272
1273   @param[in] DataSize           Size of data. 0 means delete.
1274
1275 **/
1276 VOID
1277 AutoUpdateLangVariable (
1278   IN  CHAR16             *VariableName,
1279   IN  VOID               *Data,
1280   IN  UINTN              DataSize
1281   )
1282 {
1283   EFI_STATUS             Status;
1284   CHAR8                  *BestPlatformLang;
1285   CHAR8                  *BestLang;
1286   UINTN                  Index;
1287   UINT32                 Attributes;
1288   VARIABLE_POINTER_TRACK Variable;
1289   BOOLEAN                SetLanguageCodes;
1290
1291   //
1292   // Don't do updates for delete operation
1293   //
1294   if (DataSize == 0) {
1295     return;
1296   }
1297
1298   SetLanguageCodes = FALSE;
1299
1300   if (StrCmp (VariableName, EFI_PLATFORM_LANG_CODES_VARIABLE_NAME) == 0) {
1301     //
1302     // PlatformLangCodes is a volatile variable, so it can not be updated at runtime.
1303     //
1304     if (AtRuntime ()) {
1305       return;
1306     }
1307
1308     SetLanguageCodes = TRUE;
1309
1310     //
1311     // According to UEFI spec, PlatformLangCodes is only set once in firmware initialization, and is read-only
1312     // Therefore, in variable driver, only store the original value for other use.
1313     //
1314     if (mVariableModuleGlobal->PlatformLangCodes != NULL) {
1315       FreePool (mVariableModuleGlobal->PlatformLangCodes);
1316     }
1317     mVariableModuleGlobal->PlatformLangCodes = AllocateRuntimeCopyPool (DataSize, Data);
1318     ASSERT (mVariableModuleGlobal->PlatformLangCodes != NULL);
1319
1320     //
1321     // PlatformLang holds a single language from PlatformLangCodes,
1322     // so the size of PlatformLangCodes is enough for the PlatformLang.
1323     //
1324     if (mVariableModuleGlobal->PlatformLang != NULL) {
1325       FreePool (mVariableModuleGlobal->PlatformLang);
1326     }
1327     mVariableModuleGlobal->PlatformLang = AllocateRuntimePool (DataSize);
1328     ASSERT (mVariableModuleGlobal->PlatformLang != NULL);
1329
1330   } else if (StrCmp (VariableName, EFI_LANG_CODES_VARIABLE_NAME) == 0) {
1331     //
1332     // LangCodes is a volatile variable, so it can not be updated at runtime.
1333     //
1334     if (AtRuntime ()) {
1335       return;
1336     }
1337
1338     SetLanguageCodes = TRUE;
1339
1340     //
1341     // According to UEFI spec, LangCodes is only set once in firmware initialization, and is read-only
1342     // Therefore, in variable driver, only store the original value for other use.
1343     //
1344     if (mVariableModuleGlobal->LangCodes != NULL) {
1345       FreePool (mVariableModuleGlobal->LangCodes);
1346     }
1347     mVariableModuleGlobal->LangCodes = AllocateRuntimeCopyPool (DataSize, Data);
1348     ASSERT (mVariableModuleGlobal->LangCodes != NULL);
1349   }
1350
1351   if (SetLanguageCodes
1352       && (mVariableModuleGlobal->PlatformLangCodes != NULL)
1353       && (mVariableModuleGlobal->LangCodes != NULL)) {
1354     //
1355     // Update Lang if PlatformLang is already set
1356     // Update PlatformLang if Lang is already set
1357     //
1358     Status = FindVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);
1359     if (!EFI_ERROR (Status)) {
1360       //
1361       // Update Lang
1362       //
1363       VariableName = EFI_PLATFORM_LANG_VARIABLE_NAME;
1364       Data         = GetVariableDataPtr (Variable.CurrPtr);
1365       DataSize     = Variable.CurrPtr->DataSize;
1366     } else {
1367       Status = FindVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);
1368       if (!EFI_ERROR (Status)) {
1369         //
1370         // Update PlatformLang
1371         //
1372         VariableName = EFI_LANG_VARIABLE_NAME;
1373         Data         = GetVariableDataPtr (Variable.CurrPtr);
1374         DataSize     = Variable.CurrPtr->DataSize;
1375       } else {
1376         //
1377         // Neither PlatformLang nor Lang is set, directly return
1378         //
1379         return;
1380       }
1381     }
1382   }
1383
1384   //
1385   // According to UEFI spec, "Lang" and "PlatformLang" is NV|BS|RT attributions.
1386   //
1387   Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
1388
1389   if (StrCmp (VariableName, EFI_PLATFORM_LANG_VARIABLE_NAME) == 0) {
1390     //
1391     // Update Lang when PlatformLangCodes/LangCodes were set.
1392     //
1393     if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {
1394       //
1395       // When setting PlatformLang, firstly get most matched language string from supported language codes.
1396       //
1397       BestPlatformLang = VariableGetBestLanguage (mVariableModuleGlobal->PlatformLangCodes, FALSE, Data, NULL);
1398       if (BestPlatformLang != NULL) {
1399         //
1400         // Get the corresponding index in language codes.
1401         //
1402         Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, BestPlatformLang, FALSE);
1403
1404         //
1405         // Get the corresponding ISO639 language tag according to RFC4646 language tag.
1406         //
1407         BestLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, Index, TRUE);
1408
1409         //
1410         // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.
1411         //
1412         FindVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);
1413
1414         Status = UpdateVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, BestLang,
1415                                  ISO_639_2_ENTRY_SIZE + 1, Attributes, &Variable);
1416
1417         DEBUG ((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a\n", BestPlatformLang, BestLang));
1418
1419         ASSERT_EFI_ERROR(Status);
1420       }
1421     }
1422
1423   } else if (StrCmp (VariableName, EFI_LANG_VARIABLE_NAME) == 0) {
1424     //
1425     // Update PlatformLang when PlatformLangCodes/LangCodes were set.
1426     //
1427     if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {
1428       //
1429       // When setting Lang, firstly get most matched language string from supported language codes.
1430       //
1431       BestLang = VariableGetBestLanguage (mVariableModuleGlobal->LangCodes, TRUE, Data, NULL);
1432       if (BestLang != NULL) {
1433         //
1434         // Get the corresponding index in language codes.
1435         //
1436         Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, BestLang, TRUE);
1437
1438         //
1439         // Get the corresponding RFC4646 language tag according to ISO639 language tag.
1440         //
1441         BestPlatformLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, Index, FALSE);
1442
1443         //
1444         // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.
1445         //
1446         FindVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);
1447
1448         Status = UpdateVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, BestPlatformLang,
1449                                  AsciiStrSize (BestPlatformLang), Attributes, &Variable);
1450
1451         DEBUG ((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a\n", BestLang, BestPlatformLang));
1452         ASSERT_EFI_ERROR (Status);
1453       }
1454     }
1455   }
1456 }
1457
1458 /**
1459   Update the variable region with Variable information. These are the same
1460   arguments as the EFI Variable services.
1461
1462   @param[in] VariableName       Name of variable.
1463   @param[in] VendorGuid         Guid of variable.
1464   @param[in] Data               Variable data.
1465   @param[in] DataSize           Size of data. 0 means delete.
1466   @param[in] Attributes         Attribues of the variable.
1467   @param[in, out] CacheVariable The variable information which is used to keep track of variable usage.
1468
1469   @retval EFI_SUCCESS           The update operation is success.
1470   @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.
1471
1472 **/
1473 EFI_STATUS
1474 UpdateVariable (
1475   IN      CHAR16                      *VariableName,
1476   IN      EFI_GUID                    *VendorGuid,
1477   IN      VOID                        *Data,
1478   IN      UINTN                       DataSize,
1479   IN      UINT32                      Attributes      OPTIONAL,
1480   IN OUT  VARIABLE_POINTER_TRACK      *CacheVariable
1481   )
1482 {
1483   EFI_STATUS                          Status;
1484   VARIABLE_HEADER                     *NextVariable;
1485   UINTN                               ScratchSize;
1486   UINTN                               NonVolatileVarableStoreSize;
1487   UINTN                               VarNameOffset;
1488   UINTN                               VarDataOffset;
1489   UINTN                               VarNameSize;
1490   UINTN                               VarSize;
1491   BOOLEAN                             Volatile;
1492   EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;
1493   UINT8                               State;
1494   VARIABLE_POINTER_TRACK              *Variable;
1495   VARIABLE_POINTER_TRACK              NvVariable;
1496   VARIABLE_STORE_HEADER               *VariableStoreHeader;
1497   UINTN                               CacheOffset;
1498
1499   if ((mVariableModuleGlobal->FvbInstance == NULL) && ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0)) {
1500     //
1501     // The FVB protocol is not ready. Trying to update NV variable prior to the installation
1502     // of EFI_VARIABLE_WRITE_ARCH_PROTOCOL.
1503     //
1504     return EFI_NOT_AVAILABLE_YET;
1505   }
1506
1507   if ((CacheVariable->CurrPtr == NULL) || CacheVariable->Volatile) {
1508     Variable = CacheVariable;
1509   } else {
1510     //
1511     // Update/Delete existing NV variable.
1512     // CacheVariable points to the variable in the memory copy of Flash area
1513     // Now let Variable points to the same variable in Flash area.
1514     //
1515     VariableStoreHeader  = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1516     Variable = &NvVariable;
1517     Variable->StartPtr = GetStartPointer (VariableStoreHeader);
1518     Variable->EndPtr   = GetEndPointer (VariableStoreHeader);
1519     Variable->CurrPtr  = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));
1520     if (CacheVariable->InDeletedTransitionPtr != NULL) {
1521       Variable->InDeletedTransitionPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->InDeletedTransitionPtr - (UINTN)CacheVariable->StartPtr));
1522     } else {
1523       Variable->InDeletedTransitionPtr = NULL;
1524     }
1525     Variable->Volatile = FALSE;
1526   }
1527
1528   Fvb       = mVariableModuleGlobal->FvbInstance;
1529
1530   if (Variable->CurrPtr != NULL) {
1531     //
1532     // Update/Delete existing variable.
1533     //
1534     if (AtRuntime ()) {
1535       //
1536       // If AtRuntime and the variable is Volatile and Runtime Access,
1537       // the volatile is ReadOnly, and SetVariable should be aborted and
1538       // return EFI_WRITE_PROTECTED.
1539       //
1540       if (Variable->Volatile) {
1541         Status = EFI_WRITE_PROTECTED;
1542         goto Done;
1543       }
1544       //
1545       // Only variable that have NV|RT attributes can be updated/deleted in Runtime.
1546       //
1547       if (((Variable->CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Variable->CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE) == 0)) {
1548         Status = EFI_INVALID_PARAMETER;
1549         goto Done;
1550       }
1551     }
1552
1553     //
1554     // Setting a data variable with no access, or zero DataSize attributes
1555     // causes it to be deleted.
1556     //
1557     if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1558       if (Variable->InDeletedTransitionPtr != NULL) {
1559         //
1560         // Both ADDED and IN_DELETED_TRANSITION variable are present,
1561         // set IN_DELETED_TRANSITION one to DELETED state first.
1562         //
1563         State = Variable->InDeletedTransitionPtr->State;
1564         State &= VAR_DELETED;
1565         Status = UpdateVariableStore (
1566                    &mVariableModuleGlobal->VariableGlobal,
1567                    Variable->Volatile,
1568                    FALSE,
1569                    Fvb,
1570                    (UINTN) &Variable->InDeletedTransitionPtr->State,
1571                    sizeof (UINT8),
1572                    &State
1573                    );
1574         if (!EFI_ERROR (Status)) {
1575           if (!Variable->Volatile) {
1576             ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);
1577             CacheVariable->InDeletedTransitionPtr->State = State;
1578           }
1579         } else {
1580           goto Done;
1581         }
1582       }
1583
1584       State = Variable->CurrPtr->State;
1585       State &= VAR_DELETED;
1586
1587       Status = UpdateVariableStore (
1588                  &mVariableModuleGlobal->VariableGlobal,
1589                  Variable->Volatile,
1590                  FALSE,
1591                  Fvb,
1592                  (UINTN) &Variable->CurrPtr->State,
1593                  sizeof (UINT8),
1594                  &State
1595                  );
1596       if (!EFI_ERROR (Status)) {
1597         UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, FALSE, TRUE, FALSE);
1598         if (!Variable->Volatile) {
1599           CacheVariable->CurrPtr->State = State;
1600           FlushHobVariableToFlash (VariableName, VendorGuid);
1601         }
1602       }
1603       goto Done;
1604     }
1605     //
1606     // If the variable is marked valid, and the same data has been passed in,
1607     // then return to the caller immediately.
1608     //
1609     if (DataSizeOfVariable (Variable->CurrPtr) == DataSize &&
1610         (CompareMem (Data, GetVariableDataPtr (Variable->CurrPtr), DataSize) == 0)) {
1611
1612       UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, TRUE, FALSE, FALSE);
1613       Status = EFI_SUCCESS;
1614       goto Done;
1615     } else if ((Variable->CurrPtr->State == VAR_ADDED) ||
1616                (Variable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1617
1618       //
1619       // Mark the old variable as in delete transition.
1620       //
1621       State = Variable->CurrPtr->State;
1622       State &= VAR_IN_DELETED_TRANSITION;
1623
1624       Status = UpdateVariableStore (
1625                  &mVariableModuleGlobal->VariableGlobal,
1626                  Variable->Volatile,
1627                  FALSE,
1628                  Fvb,
1629                  (UINTN) &Variable->CurrPtr->State,
1630                  sizeof (UINT8),
1631                  &State
1632                  );
1633       if (EFI_ERROR (Status)) {
1634         goto Done;
1635       }
1636       if (!Variable->Volatile) {
1637         CacheVariable->CurrPtr->State = State;
1638       }
1639     }
1640   } else {
1641     //
1642     // Not found existing variable. Create a new variable.
1643     //
1644
1645     //
1646     // Make sure we are trying to create a new variable.
1647     // Setting a data variable with zero DataSize or no access attributes means to delete it.
1648     //
1649     if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1650       Status = EFI_NOT_FOUND;
1651       goto Done;
1652     }
1653
1654     //
1655     // Only variable have NV|RT attribute can be created in Runtime.
1656     //
1657     if (AtRuntime () &&
1658         (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0))) {
1659       Status = EFI_INVALID_PARAMETER;
1660       goto Done;
1661     }
1662   }
1663
1664   //
1665   // Function part - create a new variable and copy the data.
1666   // Both update a variable and create a variable will come here.
1667
1668   //
1669   // Tricky part: Use scratch data area at the end of volatile variable store
1670   // as a temporary storage.
1671   //
1672   NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
1673   ScratchSize = MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize));
1674
1675   SetMem (NextVariable, ScratchSize, 0xff);
1676
1677   NextVariable->StartId     = VARIABLE_DATA;
1678   NextVariable->Attributes  = Attributes;
1679   //
1680   // NextVariable->State = VAR_ADDED;
1681   //
1682   NextVariable->Reserved        = 0;
1683   VarNameOffset                 = sizeof (VARIABLE_HEADER);
1684   VarNameSize                   = StrSize (VariableName);
1685   CopyMem (
1686     (UINT8 *) ((UINTN) NextVariable + VarNameOffset),
1687     VariableName,
1688     VarNameSize
1689     );
1690   VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
1691   CopyMem (
1692     (UINT8 *) ((UINTN) NextVariable + VarDataOffset),
1693     Data,
1694     DataSize
1695     );
1696   CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
1697   //
1698   // There will be pad bytes after Data, the NextVariable->NameSize and
1699   // NextVariable->DataSize should not include pad size so that variable
1700   // service can get actual size in GetVariable.
1701   //
1702   NextVariable->NameSize  = (UINT32)VarNameSize;
1703   NextVariable->DataSize  = (UINT32)DataSize;
1704
1705   //
1706   // The actual size of the variable that stores in storage should
1707   // include pad size.
1708   //
1709   VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
1710   if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {
1711     //
1712     // Create a nonvolatile variable.
1713     //
1714     Volatile = FALSE;
1715     NonVolatileVarableStoreSize = ((VARIABLE_STORE_HEADER *)(UINTN)(mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase))->Size;
1716     if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0)
1717       && ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))
1718       || (((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0)
1719       && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > NonVolatileVarableStoreSize - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize)))) {
1720       if (AtRuntime ()) {
1721         Status = EFI_OUT_OF_RESOURCES;
1722         goto Done;
1723       }
1724       //
1725       // Perform garbage collection & reclaim operation, and integrate the new variable at the same time.
1726       //
1727       Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
1728                         &mVariableModuleGlobal->NonVolatileLastVariableOffset, FALSE, Variable, NextVariable, HEADER_ALIGN (VarSize));
1729       if (!EFI_ERROR (Status)) {
1730         //
1731         // The new variable has been integrated successfully during reclaiming.
1732         //
1733         if (Variable->CurrPtr != NULL) {
1734           CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));
1735           CacheVariable->InDeletedTransitionPtr = NULL;
1736         }
1737         UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, TRUE, FALSE, FALSE);
1738         FlushHobVariableToFlash (VariableName, VendorGuid);
1739       }
1740       goto Done;
1741     }
1742     //
1743     // Four steps
1744     // 1. Write variable header
1745     // 2. Set variable state to header valid
1746     // 3. Write variable data
1747     // 4. Set variable state to valid
1748     //
1749     //
1750     // Step 1:
1751     //
1752     CacheOffset = mVariableModuleGlobal->NonVolatileLastVariableOffset;
1753     Status = UpdateVariableStore (
1754                &mVariableModuleGlobal->VariableGlobal,
1755                FALSE,
1756                TRUE,
1757                Fvb,
1758                mVariableModuleGlobal->NonVolatileLastVariableOffset,
1759                sizeof (VARIABLE_HEADER),
1760                (UINT8 *) NextVariable
1761                );
1762
1763     if (EFI_ERROR (Status)) {
1764       goto Done;
1765     }
1766
1767     //
1768     // Step 2:
1769     //
1770     NextVariable->State = VAR_HEADER_VALID_ONLY;
1771     Status = UpdateVariableStore (
1772                &mVariableModuleGlobal->VariableGlobal,
1773                FALSE,
1774                TRUE,
1775                Fvb,
1776                mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),
1777                sizeof (UINT8),
1778                &NextVariable->State
1779                );
1780
1781     if (EFI_ERROR (Status)) {
1782       goto Done;
1783     }
1784     //
1785     // Step 3:
1786     //
1787     Status = UpdateVariableStore (
1788                &mVariableModuleGlobal->VariableGlobal,
1789                FALSE,
1790                TRUE,
1791                Fvb,
1792                mVariableModuleGlobal->NonVolatileLastVariableOffset + sizeof (VARIABLE_HEADER),
1793                (UINT32) VarSize - sizeof (VARIABLE_HEADER),
1794                (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)
1795                );
1796
1797     if (EFI_ERROR (Status)) {
1798       goto Done;
1799     }
1800     //
1801     // Step 4:
1802     //
1803     NextVariable->State = VAR_ADDED;
1804     Status = UpdateVariableStore (
1805                &mVariableModuleGlobal->VariableGlobal,
1806                FALSE,
1807                TRUE,
1808                Fvb,
1809                mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),
1810                sizeof (UINT8),
1811                &NextVariable->State
1812                );
1813
1814     if (EFI_ERROR (Status)) {
1815       goto Done;
1816     }
1817
1818     mVariableModuleGlobal->NonVolatileLastVariableOffset += HEADER_ALIGN (VarSize);
1819
1820     if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {
1821       mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VarSize);
1822     } else {
1823       mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VarSize);
1824     }
1825     //
1826     // update the memory copy of Flash region.
1827     //
1828     CopyMem ((UINT8 *)mNvVariableCache + CacheOffset, (UINT8 *)NextVariable, VarSize);
1829   } else {
1830     //
1831     // Create a volatile variable.
1832     //
1833     Volatile = TRUE;
1834
1835     if ((UINT32) (VarSize + mVariableModuleGlobal->VolatileLastVariableOffset) >
1836         ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {
1837       //
1838       // Perform garbage collection & reclaim operation, and integrate the new variable at the same time.
1839       //
1840       Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase,
1841                           &mVariableModuleGlobal->VolatileLastVariableOffset, TRUE, Variable, NextVariable, HEADER_ALIGN (VarSize));
1842       if (!EFI_ERROR (Status)) {
1843         //
1844         // The new variable has been integrated successfully during reclaiming.
1845         //
1846         if (Variable->CurrPtr != NULL) {
1847           CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));
1848           CacheVariable->InDeletedTransitionPtr = NULL;
1849         }
1850         UpdateVariableInfo (VariableName, VendorGuid, TRUE, FALSE, TRUE, FALSE, FALSE);
1851       }
1852       goto Done;
1853     }
1854
1855     NextVariable->State = VAR_ADDED;
1856     Status = UpdateVariableStore (
1857                &mVariableModuleGlobal->VariableGlobal,
1858                TRUE,
1859                TRUE,
1860                Fvb,
1861                mVariableModuleGlobal->VolatileLastVariableOffset,
1862                (UINT32) VarSize,
1863                (UINT8 *) NextVariable
1864                );
1865
1866     if (EFI_ERROR (Status)) {
1867       goto Done;
1868     }
1869
1870     mVariableModuleGlobal->VolatileLastVariableOffset += HEADER_ALIGN (VarSize);
1871   }
1872
1873   //
1874   // Mark the old variable as deleted.
1875   //
1876   if (!EFI_ERROR (Status) && Variable->CurrPtr != NULL) {
1877     if (Variable->InDeletedTransitionPtr != NULL) {
1878       //
1879       // Both ADDED and IN_DELETED_TRANSITION old variable are present,
1880       // set IN_DELETED_TRANSITION one to DELETED state first.
1881       //
1882       State = Variable->InDeletedTransitionPtr->State;
1883       State &= VAR_DELETED;
1884       Status = UpdateVariableStore (
1885                  &mVariableModuleGlobal->VariableGlobal,
1886                  Variable->Volatile,
1887                  FALSE,
1888                  Fvb,
1889                  (UINTN) &Variable->InDeletedTransitionPtr->State,
1890                  sizeof (UINT8),
1891                  &State
1892                  );
1893       if (!EFI_ERROR (Status)) {
1894         if (!Variable->Volatile) {
1895           ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);
1896           CacheVariable->InDeletedTransitionPtr->State = State;
1897         }
1898       } else {
1899         goto Done;
1900       }
1901     }
1902
1903     State = Variable->CurrPtr->State;
1904     State &= VAR_DELETED;
1905
1906     Status = UpdateVariableStore (
1907              &mVariableModuleGlobal->VariableGlobal,
1908              Variable->Volatile,
1909              FALSE,
1910              Fvb,
1911              (UINTN) &Variable->CurrPtr->State,
1912              sizeof (UINT8),
1913              &State
1914              );
1915     if (!EFI_ERROR (Status) && !Variable->Volatile) {
1916       CacheVariable->CurrPtr->State = State;
1917     }
1918   }
1919
1920   if (!EFI_ERROR (Status)) {
1921     UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1922     if (!Volatile) {
1923       FlushHobVariableToFlash (VariableName, VendorGuid);
1924     }
1925   }
1926
1927 Done:
1928   return Status;
1929 }
1930
1931 /**
1932   Check if a Unicode character is a hexadecimal character.
1933
1934   This function checks if a Unicode character is a
1935   hexadecimal character.  The valid hexadecimal character is
1936   L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
1937
1938
1939   @param Char           The character to check against.
1940
1941   @retval TRUE          If the Char is a hexadecmial character.
1942   @retval FALSE         If the Char is not a hexadecmial character.
1943
1944 **/
1945 BOOLEAN
1946 EFIAPI
1947 IsHexaDecimalDigitCharacter (
1948   IN CHAR16             Char
1949   )
1950 {
1951   return (BOOLEAN) ((Char >= L'0' && Char <= L'9') || (Char >= L'A' && Char <= L'F') || (Char >= L'a' && Char <= L'f'));
1952 }
1953
1954 /**
1955
1956   This code checks if variable is hardware error record variable or not.
1957
1958   According to UEFI spec, hardware error record variable should use the EFI_HARDWARE_ERROR_VARIABLE VendorGuid
1959   and have the L"HwErrRec####" name convention, #### is a printed hex value and no 0x or h is included in the hex value.
1960
1961   @param VariableName   Pointer to variable name.
1962   @param VendorGuid     Variable Vendor Guid.
1963
1964   @retval TRUE          Variable is hardware error record variable.
1965   @retval FALSE         Variable is not hardware error record variable.
1966
1967 **/
1968 BOOLEAN
1969 EFIAPI
1970 IsHwErrRecVariable (
1971   IN CHAR16             *VariableName,
1972   IN EFI_GUID           *VendorGuid
1973   )
1974 {
1975   if (!CompareGuid (VendorGuid, &gEfiHardwareErrorVariableGuid) ||
1976       (StrLen (VariableName) != StrLen (L"HwErrRec####")) ||
1977       (StrnCmp(VariableName, L"HwErrRec", StrLen (L"HwErrRec")) != 0) ||
1978       !IsHexaDecimalDigitCharacter (VariableName[0x8]) ||
1979       !IsHexaDecimalDigitCharacter (VariableName[0x9]) ||
1980       !IsHexaDecimalDigitCharacter (VariableName[0xA]) ||
1981       !IsHexaDecimalDigitCharacter (VariableName[0xB])) {
1982     return FALSE;
1983   }
1984
1985   return TRUE;
1986 }
1987
1988 /**
1989   This code checks if variable guid is global variable guid first.
1990   If yes, further check if variable name is in mGlobalVariableList or mGlobalVariableList2 and attributes matched.
1991
1992   @param[in] VariableName       Pointer to variable name.
1993   @param[in] VendorGuid         Variable Vendor Guid.
1994   @param[in] Attributes         Attributes of the variable.
1995
1996   @retval EFI_SUCCESS           Variable is not global variable, or Variable is global variable, variable name is in the lists and attributes matched.
1997   @retval EFI_INVALID_PARAMETER Variable is global variable, but variable name is not in the lists or attributes unmatched.
1998
1999 **/
2000 EFI_STATUS
2001 EFIAPI
2002 CheckEfiGlobalVariable (
2003   IN CHAR16             *VariableName,
2004   IN EFI_GUID           *VendorGuid,
2005   IN UINT32             Attributes
2006   )
2007 {
2008   UINTN     Index;
2009   UINTN     NameLength;
2010
2011   if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid)){
2012     //
2013     // Try list 1, exactly match.
2014     //
2015     for (Index = 0; Index < sizeof (mGlobalVariableList)/sizeof (mGlobalVariableList[0]); Index++) {
2016       if ((StrCmp (mGlobalVariableList[Index].Name, VariableName) == 0) &&
2017           (Attributes == 0 || Attributes == mGlobalVariableList[Index].Attributes)) {
2018         return EFI_SUCCESS;
2019       }
2020     }
2021
2022     //
2023     // Try list 2.
2024     //
2025     NameLength = StrLen (VariableName) - 4;
2026     for (Index = 0; Index < sizeof (mGlobalVariableList2)/sizeof (mGlobalVariableList2[0]); Index++) {
2027       if ((StrLen (VariableName) == StrLen (mGlobalVariableList2[Index].Name)) &&
2028           (StrnCmp (mGlobalVariableList2[Index].Name, VariableName, NameLength) == 0) &&
2029           IsHexaDecimalDigitCharacter (VariableName[NameLength]) &&
2030           IsHexaDecimalDigitCharacter (VariableName[NameLength + 1]) &&
2031           IsHexaDecimalDigitCharacter (VariableName[NameLength + 2]) &&
2032           IsHexaDecimalDigitCharacter (VariableName[NameLength + 3]) &&
2033           (Attributes == 0 || Attributes == mGlobalVariableList2[Index].Attributes)) {
2034         return EFI_SUCCESS;
2035       }
2036     }
2037
2038     DEBUG ((EFI_D_INFO, "[Variable]: set global variable with invalid variable name or attributes - %g:%s:%x\n", VendorGuid, VariableName, Attributes));
2039     return EFI_INVALID_PARAMETER;
2040   }
2041
2042   return EFI_SUCCESS;
2043 }
2044
2045 /**
2046   Mark a variable that will become read-only after leaving the DXE phase of execution.
2047
2048   @param[in] This          The VARIABLE_LOCK_PROTOCOL instance.
2049   @param[in] VariableName  A pointer to the variable name that will be made read-only subsequently.
2050   @param[in] VendorGuid    A pointer to the vendor GUID that will be made read-only subsequently.
2051
2052   @retval EFI_SUCCESS           The variable specified by the VariableName and the VendorGuid was marked
2053                                 as pending to be read-only.
2054   @retval EFI_INVALID_PARAMETER VariableName or VendorGuid is NULL.
2055                                 Or VariableName is an empty string.
2056   @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
2057                                 already been signaled.
2058   @retval EFI_OUT_OF_RESOURCES  There is not enough resource to hold the lock request.
2059 **/
2060 EFI_STATUS
2061 EFIAPI
2062 VariableLockRequestToLock (
2063   IN CONST EDKII_VARIABLE_LOCK_PROTOCOL *This,
2064   IN       CHAR16                       *VariableName,
2065   IN       EFI_GUID                     *VendorGuid
2066   )
2067 {
2068   VARIABLE_ENTRY                  *Entry;
2069
2070   if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
2071     return EFI_INVALID_PARAMETER;
2072   }
2073
2074   if (mEndOfDxe) {
2075     return EFI_ACCESS_DENIED;
2076   }
2077
2078   Entry = AllocateRuntimePool (sizeof (*Entry) + StrSize (VariableName));
2079   if (Entry == NULL) {
2080     return EFI_OUT_OF_RESOURCES;
2081   }
2082
2083   DEBUG ((EFI_D_INFO, "[Variable] Lock: %g:%s\n", VendorGuid, VariableName));
2084
2085   AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2086
2087   Entry->Name = (CHAR16 *) (Entry + 1);
2088   StrCpy   (Entry->Name, VariableName);
2089   CopyGuid (&Entry->Guid, VendorGuid);
2090   InsertTailList (&mLockedVariableList, &Entry->Link);
2091
2092   ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2093
2094   return EFI_SUCCESS;
2095 }
2096
2097 /**
2098
2099   This code finds variable in storage blocks (Volatile or Non-Volatile).
2100
2101   @param VariableName               Name of Variable to be found.
2102   @param VendorGuid                 Variable vendor GUID.
2103   @param Attributes                 Attribute value of the variable found.
2104   @param DataSize                   Size of Data found. If size is less than the
2105                                     data, this value contains the required size.
2106   @param Data                       Data pointer.
2107
2108   @return EFI_INVALID_PARAMETER     Invalid parameter.
2109   @return EFI_SUCCESS               Find the specified variable.
2110   @return EFI_NOT_FOUND             Not found.
2111   @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result.
2112
2113 **/
2114 EFI_STATUS
2115 EFIAPI
2116 VariableServiceGetVariable (
2117   IN      CHAR16            *VariableName,
2118   IN      EFI_GUID          *VendorGuid,
2119   OUT     UINT32            *Attributes OPTIONAL,
2120   IN OUT  UINTN             *DataSize,
2121   OUT     VOID              *Data
2122   )
2123 {
2124   EFI_STATUS              Status;
2125   VARIABLE_POINTER_TRACK  Variable;
2126   UINTN                   VarDataSize;
2127
2128   if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
2129     return EFI_INVALID_PARAMETER;
2130   }
2131
2132   AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2133
2134   Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);
2135   if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
2136     goto Done;
2137   }
2138
2139   //
2140   // Get data size
2141   //
2142   VarDataSize = DataSizeOfVariable (Variable.CurrPtr);
2143   ASSERT (VarDataSize != 0);
2144
2145   if (*DataSize >= VarDataSize) {
2146     if (Data == NULL) {
2147       Status = EFI_INVALID_PARAMETER;
2148       goto Done;
2149     }
2150
2151     CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
2152     if (Attributes != NULL) {
2153       *Attributes = Variable.CurrPtr->Attributes;
2154     }
2155
2156     *DataSize = VarDataSize;
2157     UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);
2158
2159     Status = EFI_SUCCESS;
2160     goto Done;
2161   } else {
2162     *DataSize = VarDataSize;
2163     Status = EFI_BUFFER_TOO_SMALL;
2164     goto Done;
2165   }
2166
2167 Done:
2168   ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2169   return Status;
2170 }
2171
2172
2173
2174 /**
2175
2176   This code Finds the Next available variable.
2177
2178   @param VariableNameSize           Size of the variable name.
2179   @param VariableName               Pointer to variable name.
2180   @param VendorGuid                 Variable Vendor Guid.
2181
2182   @return EFI_INVALID_PARAMETER     Invalid parameter.
2183   @return EFI_SUCCESS               Find the specified variable.
2184   @return EFI_NOT_FOUND             Not found.
2185   @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result.
2186
2187 **/
2188 EFI_STATUS
2189 EFIAPI
2190 VariableServiceGetNextVariableName (
2191   IN OUT  UINTN             *VariableNameSize,
2192   IN OUT  CHAR16            *VariableName,
2193   IN OUT  EFI_GUID          *VendorGuid
2194   )
2195 {
2196   VARIABLE_STORE_TYPE     Type;
2197   VARIABLE_POINTER_TRACK  Variable;
2198   VARIABLE_POINTER_TRACK  VariableInHob;
2199   VARIABLE_POINTER_TRACK  VariablePtrTrack;
2200   UINTN                   VarNameSize;
2201   EFI_STATUS              Status;
2202   VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];
2203
2204   if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
2205     return EFI_INVALID_PARAMETER;
2206   }
2207
2208   AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2209
2210   Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);
2211   if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
2212     goto Done;
2213   }
2214
2215   if (VariableName[0] != 0) {
2216     //
2217     // If variable name is not NULL, get next variable.
2218     //
2219     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
2220   }
2221
2222   //
2223   // 0: Volatile, 1: HOB, 2: Non-Volatile.
2224   // The index and attributes mapping must be kept in this order as FindVariable
2225   // makes use of this mapping to implement search algorithm.
2226   //
2227   VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;
2228   VariableStoreHeader[VariableStoreTypeHob]      = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;
2229   VariableStoreHeader[VariableStoreTypeNv]       = mNvVariableCache;
2230
2231   while (TRUE) {
2232     //
2233     // Switch from Volatile to HOB, to Non-Volatile.
2234     //
2235     while ((Variable.CurrPtr >= Variable.EndPtr) ||
2236            (Variable.CurrPtr == NULL)            ||
2237            !IsValidVariableHeader (Variable.CurrPtr)
2238           ) {
2239       //
2240       // Find current storage index
2241       //
2242       for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {
2243         if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {
2244           break;
2245         }
2246       }
2247       ASSERT (Type < VariableStoreTypeMax);
2248       //
2249       // Switch to next storage
2250       //
2251       for (Type++; Type < VariableStoreTypeMax; Type++) {
2252         if (VariableStoreHeader[Type] != NULL) {
2253           break;
2254         }
2255       }
2256       //
2257       // Capture the case that
2258       // 1. current storage is the last one, or
2259       // 2. no further storage
2260       //
2261       if (Type == VariableStoreTypeMax) {
2262         Status = EFI_NOT_FOUND;
2263         goto Done;
2264       }
2265       Variable.StartPtr = GetStartPointer (VariableStoreHeader[Type]);
2266       Variable.EndPtr   = GetEndPointer   (VariableStoreHeader[Type]);
2267       Variable.CurrPtr  = Variable.StartPtr;
2268     }
2269
2270     //
2271     // Variable is found
2272     //
2273     if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
2274       if (!AtRuntime () || ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {
2275         if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
2276           //
2277           // If it is a IN_DELETED_TRANSITION variable,
2278           // and there is also a same ADDED one at the same time,
2279           // don't return it.
2280           //
2281           VariablePtrTrack.StartPtr = Variable.StartPtr;
2282           VariablePtrTrack.EndPtr = Variable.EndPtr;
2283           Status = FindVariableEx (
2284                      GetVariableNamePtr (Variable.CurrPtr),
2285                      &Variable.CurrPtr->VendorGuid,
2286                      FALSE,
2287                      &VariablePtrTrack
2288                      );
2289           if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {
2290             Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
2291             continue;
2292           }
2293         }
2294
2295         //
2296         // Don't return NV variable when HOB overrides it
2297         //
2298         if ((VariableStoreHeader[VariableStoreTypeHob] != NULL) && (VariableStoreHeader[VariableStoreTypeNv] != NULL) &&
2299             (Variable.StartPtr == GetStartPointer (VariableStoreHeader[VariableStoreTypeNv]))
2300            ) {
2301           VariableInHob.StartPtr = GetStartPointer (VariableStoreHeader[VariableStoreTypeHob]);
2302           VariableInHob.EndPtr   = GetEndPointer   (VariableStoreHeader[VariableStoreTypeHob]);
2303           Status = FindVariableEx (
2304                      GetVariableNamePtr (Variable.CurrPtr),
2305                      &Variable.CurrPtr->VendorGuid,
2306                      FALSE,
2307                      &VariableInHob
2308                      );
2309           if (!EFI_ERROR (Status)) {
2310             Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
2311             continue;
2312           }
2313         }
2314
2315         VarNameSize = NameSizeOfVariable (Variable.CurrPtr);
2316         ASSERT (VarNameSize != 0);
2317
2318         if (VarNameSize <= *VariableNameSize) {
2319           CopyMem (VariableName, GetVariableNamePtr (Variable.CurrPtr), VarNameSize);
2320           CopyMem (VendorGuid, &Variable.CurrPtr->VendorGuid, sizeof (EFI_GUID));
2321           Status = EFI_SUCCESS;
2322         } else {
2323           Status = EFI_BUFFER_TOO_SMALL;
2324         }
2325
2326         *VariableNameSize = VarNameSize;
2327         goto Done;
2328       }
2329     }
2330
2331     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
2332   }
2333
2334 Done:
2335   ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2336   return Status;
2337 }
2338
2339 /**
2340
2341   This code sets variable in storage blocks (Volatile or Non-Volatile).
2342
2343   @param VariableName                     Name of Variable to be found.
2344   @param VendorGuid                       Variable vendor GUID.
2345   @param Attributes                       Attribute value of the variable found
2346   @param DataSize                         Size of Data found. If size is less than the
2347                                           data, this value contains the required size.
2348   @param Data                             Data pointer.
2349
2350   @return EFI_INVALID_PARAMETER           Invalid parameter.
2351   @return EFI_SUCCESS                     Set successfully.
2352   @return EFI_OUT_OF_RESOURCES            Resource not enough to set variable.
2353   @return EFI_NOT_FOUND                   Not found.
2354   @return EFI_WRITE_PROTECTED             Variable is read-only.
2355
2356 **/
2357 EFI_STATUS
2358 EFIAPI
2359 VariableServiceSetVariable (
2360   IN CHAR16                  *VariableName,
2361   IN EFI_GUID                *VendorGuid,
2362   IN UINT32                  Attributes,
2363   IN UINTN                   DataSize,
2364   IN VOID                    *Data
2365   )
2366 {
2367   VARIABLE_POINTER_TRACK              Variable;
2368   EFI_STATUS                          Status;
2369   VARIABLE_HEADER                     *NextVariable;
2370   EFI_PHYSICAL_ADDRESS                Point;
2371   LIST_ENTRY                          *Link;
2372   VARIABLE_ENTRY                      *Entry;
2373
2374   //
2375   // Check input parameters.
2376   //
2377   if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
2378     return EFI_INVALID_PARAMETER;
2379   }
2380
2381   if (DataSize != 0 && Data == NULL) {
2382     return EFI_INVALID_PARAMETER;
2383   }
2384
2385   //
2386   // Not support authenticated or append variable write yet.
2387   //
2388   if ((Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_APPEND_WRITE)) != 0) {
2389     return EFI_INVALID_PARAMETER;
2390   }
2391
2392   //
2393   //  Make sure if runtime bit is set, boot service bit is set also.
2394   //
2395   if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
2396     return EFI_INVALID_PARAMETER;
2397   }
2398
2399   if ((UINTN)(~0) - DataSize < StrSize(VariableName)){
2400     //
2401     // Prevent whole variable size overflow
2402     //
2403     return EFI_INVALID_PARAMETER;
2404   }
2405
2406   //
2407   //  The size of the VariableName, including the Unicode Null in bytes plus
2408   //  the DataSize is limited to maximum size of PcdGet32 (PcdMaxHardwareErrorVariableSize)
2409   //  bytes for HwErrRec, and PcdGet32 (PcdMaxVariableSize) bytes for the others.
2410   //
2411   if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
2412     if ( StrSize (VariableName) + DataSize > PcdGet32 (PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER)) {
2413       return EFI_INVALID_PARAMETER;
2414     }
2415     if (!IsHwErrRecVariable(VariableName, VendorGuid)) {
2416       return EFI_INVALID_PARAMETER;
2417     }
2418   } else {
2419     //
2420     //  The size of the VariableName, including the Unicode Null in bytes plus
2421     //  the DataSize is limited to maximum size of PcdGet32 (PcdMaxVariableSize) bytes.
2422     //
2423     if (StrSize (VariableName) + DataSize > PcdGet32 (PcdMaxVariableSize) - sizeof (VARIABLE_HEADER)) {
2424       return EFI_INVALID_PARAMETER;
2425     }
2426   }
2427
2428   Status = CheckEfiGlobalVariable (VariableName, VendorGuid, Attributes);
2429   if (EFI_ERROR (Status)) {
2430     return Status;
2431   }
2432
2433   AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2434
2435   //
2436   // Consider reentrant in MCA/INIT/NMI. It needs be reupdated.
2437   //
2438   if (1 < InterlockedIncrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState)) {
2439     Point = mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;
2440     //
2441     // Parse non-volatile variable data and get last variable offset.
2442     //
2443     NextVariable  = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point);
2444     while ((NextVariable < GetEndPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point))
2445         && IsValidVariableHeader (NextVariable)) {
2446       NextVariable = GetNextVariablePtr (NextVariable);
2447     }
2448     mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;
2449   }
2450
2451   if (mEndOfDxe && mEnableLocking) {
2452     //
2453     // Treat the variables listed in the forbidden variable list as read-only after leaving DXE phase.
2454     //
2455     for ( Link = GetFirstNode (&mLockedVariableList)
2456         ; !IsNull (&mLockedVariableList, Link)
2457         ; Link = GetNextNode (&mLockedVariableList, Link)
2458         ) {
2459       Entry = BASE_CR (Link, VARIABLE_ENTRY, Link);
2460       if (CompareGuid (&Entry->Guid, VendorGuid) && (StrCmp (Entry->Name, VariableName) == 0)) {
2461         Status = EFI_WRITE_PROTECTED;
2462         DEBUG ((EFI_D_INFO, "[Variable]: Changing readonly variable after leaving DXE phase - %g:%s\n", VendorGuid, VariableName));
2463         goto Done;
2464       }
2465     }
2466   }
2467
2468   //
2469   // Check whether the input variable is already existed.
2470   //
2471   Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, TRUE);
2472   if (!EFI_ERROR (Status)) {
2473     if (((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) && AtRuntime ()) {
2474       Status = EFI_WRITE_PROTECTED;
2475       goto Done;
2476     }
2477     if (Attributes != 0 && Attributes != Variable.CurrPtr->Attributes) {
2478       //
2479       // If a preexisting variable is rewritten with different attributes, SetVariable() shall not
2480       // modify the variable and shall return EFI_INVALID_PARAMETER. Two exceptions to this rule:
2481       // 1. No access attributes specified
2482       // 2. The only attribute differing is EFI_VARIABLE_APPEND_WRITE
2483       //
2484       Status = EFI_INVALID_PARAMETER;
2485       goto Done;
2486     }
2487   }
2488
2489   //
2490   // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang.
2491   //
2492   AutoUpdateLangVariable (VariableName, Data, DataSize);
2493
2494   Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, &Variable);
2495
2496 Done:
2497   InterlockedDecrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState);
2498   ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2499
2500   return Status;
2501 }
2502
2503 /**
2504
2505   This code returns information about the EFI variables.
2506
2507   @param Attributes                     Attributes bitmask to specify the type of variables
2508                                         on which to return information.
2509   @param MaximumVariableStorageSize     Pointer to the maximum size of the storage space available
2510                                         for the EFI variables associated with the attributes specified.
2511   @param RemainingVariableStorageSize   Pointer to the remaining size of the storage space available
2512                                         for EFI variables associated with the attributes specified.
2513   @param MaximumVariableSize            Pointer to the maximum size of an individual EFI variables
2514                                         associated with the attributes specified.
2515
2516   @return EFI_INVALID_PARAMETER         An invalid combination of attribute bits was supplied.
2517   @return EFI_SUCCESS                   Query successfully.
2518   @return EFI_UNSUPPORTED               The attribute is not supported on this platform.
2519
2520 **/
2521 EFI_STATUS
2522 EFIAPI
2523 VariableServiceQueryVariableInfo (
2524   IN  UINT32                 Attributes,
2525   OUT UINT64                 *MaximumVariableStorageSize,
2526   OUT UINT64                 *RemainingVariableStorageSize,
2527   OUT UINT64                 *MaximumVariableSize
2528   )
2529 {
2530   VARIABLE_HEADER        *Variable;
2531   VARIABLE_HEADER        *NextVariable;
2532   UINT64                 VariableSize;
2533   VARIABLE_STORE_HEADER  *VariableStoreHeader;
2534   UINT64                 CommonVariableTotalSize;
2535   UINT64                 HwErrVariableTotalSize;
2536
2537   CommonVariableTotalSize = 0;
2538   HwErrVariableTotalSize = 0;
2539
2540   if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {
2541     return EFI_INVALID_PARAMETER;
2542   }
2543
2544   if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {
2545     //
2546     // Make sure the Attributes combination is supported by the platform.
2547     //
2548     return EFI_UNSUPPORTED;
2549   } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
2550     //
2551     // Make sure if runtime bit is set, boot service bit is set also.
2552     //
2553     return EFI_INVALID_PARAMETER;
2554   } else if (AtRuntime () && ((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) {
2555     //
2556     // Make sure RT Attribute is set if we are in Runtime phase.
2557     //
2558     return EFI_INVALID_PARAMETER;
2559   } else if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
2560     //
2561     // Make sure Hw Attribute is set with NV.
2562     //
2563     return EFI_INVALID_PARAMETER;
2564   } else if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {
2565     //
2566     // Not support authentiated variable write yet.
2567     //
2568     return EFI_UNSUPPORTED;
2569   }
2570
2571   AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2572
2573   if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
2574     //
2575     // Query is Volatile related.
2576     //
2577     VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
2578   } else {
2579     //
2580     // Query is Non-Volatile related.
2581     //
2582     VariableStoreHeader = mNvVariableCache;
2583   }
2584
2585   //
2586   // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
2587   // with the storage size (excluding the storage header size).
2588   //
2589   *MaximumVariableStorageSize   = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
2590
2591   //
2592   // Harware error record variable needs larger size.
2593   //
2594   if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
2595     *MaximumVariableStorageSize = PcdGet32 (PcdHwErrStorageSize);
2596     *MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER);
2597   } else {
2598     if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {
2599       ASSERT (PcdGet32 (PcdHwErrStorageSize) < VariableStoreHeader->Size);
2600       *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize);
2601     }
2602
2603     //
2604     // Let *MaximumVariableSize be PcdGet32 (PcdMaxVariableSize) with the exception of the variable header size.
2605     //
2606     *MaximumVariableSize = PcdGet32 (PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);
2607   }
2608
2609   //
2610   // Point to the starting address of the variables.
2611   //
2612   Variable = GetStartPointer (VariableStoreHeader);
2613
2614   //
2615   // Now walk through the related variable store.
2616   //
2617   while ((Variable < GetEndPointer (VariableStoreHeader)) && IsValidVariableHeader (Variable)) {
2618     NextVariable = GetNextVariablePtr (Variable);
2619     VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
2620
2621     if (AtRuntime ()) {
2622       //
2623       // We don't take the state of the variables in mind
2624       // when calculating RemainingVariableStorageSize,
2625       // since the space occupied by variables not marked with
2626       // VAR_ADDED is not allowed to be reclaimed in Runtime.
2627       //
2628       if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
2629         HwErrVariableTotalSize += VariableSize;
2630       } else {
2631         CommonVariableTotalSize += VariableSize;
2632       }
2633     } else {
2634       //
2635       // Only care about Variables with State VAR_ADDED, because
2636       // the space not marked as VAR_ADDED is reclaimable now.
2637       //
2638       if (Variable->State == VAR_ADDED) {
2639         if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
2640           HwErrVariableTotalSize += VariableSize;
2641         } else {
2642           CommonVariableTotalSize += VariableSize;
2643         }
2644       }
2645     }
2646
2647     //
2648     // Go to the next one.
2649     //
2650     Variable = NextVariable;
2651   }
2652
2653   if ((Attributes  & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){
2654     *RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;
2655   }else {
2656     *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;
2657   }
2658
2659   if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {
2660     *MaximumVariableSize = 0;
2661   } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {
2662     *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);
2663   }
2664
2665   ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
2666   return EFI_SUCCESS;
2667 }
2668
2669
2670 /**
2671   This function reclaims variable storage if free size is below the threshold.
2672
2673 **/
2674 VOID
2675 ReclaimForOS(
2676   VOID
2677   )
2678 {
2679   EFI_STATUS                     Status;
2680   UINTN                          CommonVariableSpace;
2681   UINTN                          RemainingCommonVariableSpace;
2682   UINTN                          RemainingHwErrVariableSpace;
2683
2684   Status  = EFI_SUCCESS;
2685
2686   CommonVariableSpace = ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32(PcdHwErrStorageSize); //Allowable max size of common variable storage space
2687
2688   RemainingCommonVariableSpace = CommonVariableSpace - mVariableModuleGlobal->CommonVariableTotalSize;
2689
2690   RemainingHwErrVariableSpace = PcdGet32 (PcdHwErrStorageSize) - mVariableModuleGlobal->HwErrVariableTotalSize;
2691   //
2692   // Check if the free area is blow a threshold.
2693   //
2694   if ((RemainingCommonVariableSpace < PcdGet32 (PcdMaxVariableSize))
2695     || ((PcdGet32 (PcdHwErrStorageSize) != 0) &&
2696        (RemainingHwErrVariableSpace < PcdGet32 (PcdMaxHardwareErrorVariableSize)))){
2697     Status = Reclaim (
2698             mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
2699             &mVariableModuleGlobal->NonVolatileLastVariableOffset,
2700             FALSE,
2701             NULL,
2702             NULL,
2703             0
2704             );
2705     ASSERT_EFI_ERROR (Status);
2706   }
2707 }
2708
2709 /**
2710   Init non-volatile variable store.
2711
2712   @retval EFI_SUCCESS           Function successfully executed.
2713   @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.
2714   @retval EFI_VOLUME_CORRUPTED  Variable Store or Firmware Volume for Variable Store is corrupted.
2715
2716 **/
2717 EFI_STATUS
2718 InitNonVolatileVariableStore (
2719   VOID
2720   )
2721 {
2722   EFI_FIRMWARE_VOLUME_HEADER            *FvHeader;
2723   VARIABLE_HEADER                       *NextVariable;
2724   EFI_PHYSICAL_ADDRESS                  VariableStoreBase;
2725   UINT64                                VariableStoreLength;
2726   UINTN                                 VariableSize;
2727   EFI_HOB_GUID_TYPE                     *GuidHob;
2728   EFI_PHYSICAL_ADDRESS                  NvStorageBase;
2729   UINT8                                 *NvStorageData;
2730   UINT32                                NvStorageSize;
2731   FAULT_TOLERANT_WRITE_LAST_WRITE_DATA  *FtwLastWriteData;
2732   UINT32                                BackUpOffset;
2733   UINT32                                BackUpSize;
2734
2735   mVariableModuleGlobal->FvbInstance = NULL;
2736
2737   //
2738   // Note that in EdkII variable driver implementation, Hardware Error Record type variable
2739   // is stored with common variable in the same NV region. So the platform integrator should
2740   // ensure that the value of PcdHwErrStorageSize is less than or equal to the value of
2741   // PcdFlashNvStorageVariableSize.
2742   //
2743   ASSERT (PcdGet32 (PcdHwErrStorageSize) <= PcdGet32 (PcdFlashNvStorageVariableSize));
2744
2745   //
2746   // Allocate runtime memory used for a memory copy of the FLASH region.
2747   // Keep the memory and the FLASH in sync as updates occur.
2748   //
2749   NvStorageSize = PcdGet32 (PcdFlashNvStorageVariableSize);
2750   NvStorageData = AllocateRuntimeZeroPool (NvStorageSize);
2751   if (NvStorageData == NULL) {
2752     return EFI_OUT_OF_RESOURCES;
2753   }
2754
2755   NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);
2756   if (NvStorageBase == 0) {
2757     NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);
2758   }
2759   //
2760   // Copy NV storage data to the memory buffer.
2761   //
2762   CopyMem (NvStorageData, (UINT8 *) (UINTN) NvStorageBase, NvStorageSize);
2763
2764   //
2765   // Check the FTW last write data hob.
2766   //
2767   GuidHob = GetFirstGuidHob (&gEdkiiFaultTolerantWriteGuid);
2768   if (GuidHob != NULL) {
2769     FtwLastWriteData = (FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *) GET_GUID_HOB_DATA (GuidHob);
2770     if (FtwLastWriteData->TargetAddress == NvStorageBase) {
2771       DEBUG ((EFI_D_INFO, "Variable: NV storage is backed up in spare block: 0x%x\n", (UINTN) FtwLastWriteData->SpareAddress));
2772       //
2773       // Copy the backed up NV storage data to the memory buffer from spare block.
2774       //
2775       CopyMem (NvStorageData, (UINT8 *) (UINTN) (FtwLastWriteData->SpareAddress), NvStorageSize);
2776     } else if ((FtwLastWriteData->TargetAddress > NvStorageBase) &&
2777                (FtwLastWriteData->TargetAddress < (NvStorageBase + NvStorageSize))) {
2778       //
2779       // Flash NV storage from the offset is backed up in spare block.
2780       //
2781       BackUpOffset = (UINT32) (FtwLastWriteData->TargetAddress - NvStorageBase);
2782       BackUpSize = NvStorageSize - BackUpOffset;
2783       DEBUG ((EFI_D_INFO, "Variable: High partial NV storage from offset: %x is backed up in spare block: 0x%x\n", BackUpOffset, (UINTN) FtwLastWriteData->SpareAddress));
2784       //
2785       // Copy the partial backed up NV storage data to the memory buffer from spare block.
2786       //
2787       CopyMem (NvStorageData + BackUpOffset, (UINT8 *) (UINTN) FtwLastWriteData->SpareAddress, BackUpSize);
2788     }
2789   }
2790
2791   FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) NvStorageData;
2792
2793   //
2794   // Check if the Firmware Volume is not corrupted
2795   //
2796   if ((FvHeader->Signature != EFI_FVH_SIGNATURE) || (!CompareGuid (&gEfiSystemNvDataFvGuid, &FvHeader->FileSystemGuid))) {
2797     FreePool (NvStorageData);
2798     DEBUG ((EFI_D_ERROR, "Firmware Volume for Variable Store is corrupted\n"));
2799     return EFI_VOLUME_CORRUPTED;
2800   }
2801
2802   VariableStoreBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) FvHeader + FvHeader->HeaderLength);
2803   VariableStoreLength = (UINT64) (NvStorageSize - FvHeader->HeaderLength);
2804
2805   mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
2806   mNvVariableCache = (VARIABLE_STORE_HEADER *) (UINTN) VariableStoreBase;
2807   if (GetVariableStoreStatus (mNvVariableCache) != EfiValid) {
2808     FreePool (NvStorageData);
2809     DEBUG((EFI_D_ERROR, "Variable Store header is corrupted\n"));
2810     return EFI_VOLUME_CORRUPTED;
2811   }
2812   ASSERT(mNvVariableCache->Size == VariableStoreLength);
2813
2814   //
2815   // The max variable or hardware error variable size should be < variable store size.
2816   //
2817   ASSERT(MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize)) < VariableStoreLength);
2818
2819   //
2820   // Parse non-volatile variable data and get last variable offset.
2821   //
2822   NextVariable  = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase);
2823   while (IsValidVariableHeader (NextVariable)) {
2824     VariableSize = NextVariable->NameSize + NextVariable->DataSize + sizeof (VARIABLE_HEADER);
2825     if ((NextVariable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
2826       mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VariableSize);
2827     } else {
2828       mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VariableSize);
2829     }
2830
2831     NextVariable = GetNextVariablePtr (NextVariable);
2832   }
2833   mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) VariableStoreBase;
2834
2835   return EFI_SUCCESS;
2836 }
2837
2838 /**
2839   Flush the HOB variable to flash.
2840
2841   @param[in] VariableName       Name of variable has been updated or deleted.
2842   @param[in] VendorGuid         Guid of variable has been updated or deleted.
2843
2844 **/
2845 VOID
2846 FlushHobVariableToFlash (
2847   IN CHAR16                     *VariableName,
2848   IN EFI_GUID                   *VendorGuid
2849   )
2850 {
2851   EFI_STATUS                    Status;
2852   VARIABLE_STORE_HEADER         *VariableStoreHeader;
2853   VARIABLE_HEADER               *Variable;
2854   VOID                          *VariableData;
2855   BOOLEAN                       ErrorFlag;
2856
2857   ErrorFlag = FALSE;
2858
2859   //
2860   // Flush the HOB variable to flash.
2861   //
2862   if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {
2863     VariableStoreHeader = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;
2864     //
2865     // Set HobVariableBase to 0, it can avoid SetVariable to call back.
2866     //
2867     mVariableModuleGlobal->VariableGlobal.HobVariableBase = 0;
2868     for ( Variable = GetStartPointer (VariableStoreHeader)
2869         ; (Variable < GetEndPointer (VariableStoreHeader) && IsValidVariableHeader (Variable))
2870         ; Variable = GetNextVariablePtr (Variable)
2871         ) {
2872       if (Variable->State != VAR_ADDED) {
2873         //
2874         // The HOB variable has been set to DELETED state in local.
2875         //
2876         continue;
2877       }
2878       ASSERT ((Variable->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0);
2879       if (VendorGuid == NULL || VariableName == NULL ||
2880           !CompareGuid (VendorGuid, &Variable->VendorGuid) ||
2881           StrCmp (VariableName, GetVariableNamePtr (Variable)) != 0) {
2882         VariableData = GetVariableDataPtr (Variable);
2883         Status = VariableServiceSetVariable (
2884                    GetVariableNamePtr (Variable),
2885                    &Variable->VendorGuid,
2886                    Variable->Attributes,
2887                    Variable->DataSize,
2888                    VariableData
2889                    );
2890         DEBUG ((EFI_D_INFO, "Variable driver flush the HOB variable to flash: %g %s %r\n", &Variable->VendorGuid, GetVariableNamePtr (Variable), Status));
2891       } else {
2892         //
2893         // The updated or deleted variable is matched with the HOB variable.
2894         // Don't break here because we will try to set other HOB variables
2895         // since this variable could be set successfully.
2896         //
2897         Status = EFI_SUCCESS;
2898       }
2899       if (!EFI_ERROR (Status)) {
2900         //
2901         // If set variable successful, or the updated or deleted variable is matched with the HOB variable,
2902         // set the HOB variable to DELETED state in local.
2903         //
2904         DEBUG ((EFI_D_INFO, "Variable driver set the HOB variable to DELETED state in local: %g %s\n", &Variable->VendorGuid, GetVariableNamePtr (Variable)));
2905         Variable->State &= VAR_DELETED;
2906       } else {
2907         ErrorFlag = TRUE;
2908       }
2909     }
2910     if (ErrorFlag) {
2911       //
2912       // We still have HOB variable(s) not flushed in flash.
2913       //
2914       mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStoreHeader;
2915     } else {
2916       //
2917       // All HOB variables have been flushed in flash.
2918       //
2919       DEBUG ((EFI_D_INFO, "Variable driver: all HOB variables have been flushed in flash.\n"));
2920       if (!AtRuntime ()) {
2921         FreePool ((VOID *) VariableStoreHeader);
2922       }
2923     }
2924   }
2925
2926 }
2927
2928 /**
2929   Initializes variable write service after FTW was ready.
2930
2931   @retval EFI_SUCCESS          Function successfully executed.
2932   @retval Others               Fail to initialize the variable service.
2933
2934 **/
2935 EFI_STATUS
2936 VariableWriteServiceInitialize (
2937   VOID
2938   )
2939 {
2940   EFI_STATUS                      Status;
2941   VARIABLE_STORE_HEADER           *VariableStoreHeader;
2942   UINTN                           Index;
2943   UINT8                           Data;
2944   EFI_PHYSICAL_ADDRESS            VariableStoreBase;
2945   EFI_PHYSICAL_ADDRESS            NvStorageBase;
2946
2947   NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);
2948   if (NvStorageBase == 0) {
2949     NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);
2950   }
2951   VariableStoreBase = NvStorageBase + (((EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(NvStorageBase))->HeaderLength);
2952
2953   //
2954   // Let NonVolatileVariableBase point to flash variable store base directly after FTW ready.
2955   //
2956   mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
2957   VariableStoreHeader = (VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase;
2958
2959   //
2960   // Check if the free area is really free.
2961   //
2962   for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) {
2963     Data = ((UINT8 *) mNvVariableCache)[Index];
2964     if (Data != 0xff) {
2965       //
2966       // There must be something wrong in variable store, do reclaim operation.
2967       //
2968       Status = Reclaim (
2969                  mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
2970                  &mVariableModuleGlobal->NonVolatileLastVariableOffset,
2971                  FALSE,
2972                  NULL,
2973                  NULL,
2974                  0
2975                  );
2976       if (EFI_ERROR (Status)) {
2977         return Status;
2978       }
2979       break;
2980     }
2981   }
2982
2983   FlushHobVariableToFlash (NULL, NULL);
2984
2985   return EFI_SUCCESS;
2986 }
2987
2988
2989 /**
2990   Initializes variable store area for non-volatile and volatile variable.
2991
2992   @retval EFI_SUCCESS           Function successfully executed.
2993   @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.
2994
2995 **/
2996 EFI_STATUS
2997 VariableCommonInitialize (
2998   VOID
2999   )
3000 {
3001   EFI_STATUS                      Status;
3002   VARIABLE_STORE_HEADER           *VolatileVariableStore;
3003   VARIABLE_STORE_HEADER           *VariableStoreHeader;
3004   UINT64                          VariableStoreLength;
3005   UINTN                           ScratchSize;
3006   EFI_HOB_GUID_TYPE               *GuidHob;
3007
3008   //
3009   // Allocate runtime memory for variable driver global structure.
3010   //
3011   mVariableModuleGlobal = AllocateRuntimeZeroPool (sizeof (VARIABLE_MODULE_GLOBAL));
3012   if (mVariableModuleGlobal == NULL) {
3013     return EFI_OUT_OF_RESOURCES;
3014   }
3015
3016   InitializeLock (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);
3017
3018   //
3019   // Get HOB variable store.
3020   //
3021   GuidHob = GetFirstGuidHob (&gEfiVariableGuid);
3022   if (GuidHob != NULL) {
3023     VariableStoreHeader = GET_GUID_HOB_DATA (GuidHob);
3024     VariableStoreLength = (UINT64) (GuidHob->Header.HobLength - sizeof (EFI_HOB_GUID_TYPE));
3025     if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
3026       mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) AllocateRuntimeCopyPool ((UINTN) VariableStoreLength, (VOID *) VariableStoreHeader);
3027       if (mVariableModuleGlobal->VariableGlobal.HobVariableBase == 0) {
3028         FreePool (mVariableModuleGlobal);
3029         return EFI_OUT_OF_RESOURCES;
3030       }
3031     } else {
3032       DEBUG ((EFI_D_ERROR, "HOB Variable Store header is corrupted!\n"));
3033     }
3034   }
3035
3036   //
3037   // Allocate memory for volatile variable store, note that there is a scratch space to store scratch data.
3038   //
3039   ScratchSize = MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize));
3040   VolatileVariableStore = AllocateRuntimePool (PcdGet32 (PcdVariableStoreSize) + ScratchSize);
3041   if (VolatileVariableStore == NULL) {
3042     if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {
3043       FreePool ((VOID *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase);
3044     }
3045     FreePool (mVariableModuleGlobal);
3046     return EFI_OUT_OF_RESOURCES;
3047   }
3048
3049   SetMem (VolatileVariableStore, PcdGet32 (PcdVariableStoreSize) + ScratchSize, 0xff);
3050
3051   //
3052   // Initialize Variable Specific Data.
3053   //
3054   mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;
3055   mVariableModuleGlobal->VolatileLastVariableOffset = (UINTN) GetStartPointer (VolatileVariableStore) - (UINTN) VolatileVariableStore;
3056
3057   CopyGuid (&VolatileVariableStore->Signature, &gEfiVariableGuid);
3058   VolatileVariableStore->Size        = PcdGet32 (PcdVariableStoreSize);
3059   VolatileVariableStore->Format      = VARIABLE_STORE_FORMATTED;
3060   VolatileVariableStore->State       = VARIABLE_STORE_HEALTHY;
3061   VolatileVariableStore->Reserved    = 0;
3062   VolatileVariableStore->Reserved1   = 0;
3063
3064   //
3065   // Init non-volatile variable store.
3066   //
3067   Status = InitNonVolatileVariableStore ();
3068   if (EFI_ERROR (Status)) {
3069     if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {
3070       FreePool ((VOID *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase);
3071     }
3072     FreePool (mVariableModuleGlobal);
3073     FreePool (VolatileVariableStore);
3074   }
3075
3076   return Status;
3077 }
3078
3079
3080 /**
3081   Get the proper fvb handle and/or fvb protocol by the given Flash address.
3082
3083   @param[in] Address        The Flash address.
3084   @param[out] FvbHandle     In output, if it is not NULL, it points to the proper FVB handle.
3085   @param[out] FvbProtocol   In output, if it is not NULL, it points to the proper FVB protocol.
3086
3087 **/
3088 EFI_STATUS
3089 GetFvbInfoByAddress (
3090   IN  EFI_PHYSICAL_ADDRESS                Address,
3091   OUT EFI_HANDLE                          *FvbHandle OPTIONAL,
3092   OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvbProtocol OPTIONAL
3093   )
3094 {
3095   EFI_STATUS                              Status;
3096   EFI_HANDLE                              *HandleBuffer;
3097   UINTN                                   HandleCount;
3098   UINTN                                   Index;
3099   EFI_PHYSICAL_ADDRESS                    FvbBaseAddress;
3100   EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL      *Fvb;
3101   EFI_FIRMWARE_VOLUME_HEADER              *FwVolHeader;
3102   EFI_FVB_ATTRIBUTES_2                    Attributes;
3103
3104   //
3105   // Get all FVB handles.
3106   //
3107   Status = GetFvbCountAndBuffer (&HandleCount, &HandleBuffer);
3108   if (EFI_ERROR (Status)) {
3109     return EFI_NOT_FOUND;
3110   }
3111
3112   //
3113   // Get the FVB to access variable store.
3114   //
3115   Fvb = NULL;
3116   for (Index = 0; Index < HandleCount; Index += 1, Status = EFI_NOT_FOUND, Fvb = NULL) {
3117     Status = GetFvbByHandle (HandleBuffer[Index], &Fvb);
3118     if (EFI_ERROR (Status)) {
3119       Status = EFI_NOT_FOUND;
3120       break;
3121     }
3122
3123     //
3124     // Ensure this FVB protocol supported Write operation.
3125     //
3126     Status = Fvb->GetAttributes (Fvb, &Attributes);
3127     if (EFI_ERROR (Status) || ((Attributes & EFI_FVB2_WRITE_STATUS) == 0)) {
3128       continue;
3129     }
3130
3131     //
3132     // Compare the address and select the right one.
3133     //
3134     Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);
3135     if (EFI_ERROR (Status)) {
3136       continue;
3137     }
3138
3139     FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);
3140     if ((Address >= FvbBaseAddress) && (Address < (FvbBaseAddress + FwVolHeader->FvLength))) {
3141       if (FvbHandle != NULL) {
3142         *FvbHandle  = HandleBuffer[Index];
3143       }
3144       if (FvbProtocol != NULL) {
3145         *FvbProtocol = Fvb;
3146       }
3147       Status = EFI_SUCCESS;
3148       break;
3149     }
3150   }
3151   FreePool (HandleBuffer);
3152
3153   if (Fvb == NULL) {
3154     Status = EFI_NOT_FOUND;
3155   }
3156
3157   return Status;
3158 }
3159