DuetPkg/FSVariable/FSVariable.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2010, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   FSVariable.c
  15
  16 Abstract:
  17
  18   Provide support functions for variable services.
  19
  20 --*/
  21
  22 #include "FSVariable.h"
  23
  24 VARIABLE_STORE_HEADER mStoreHeaderTemplate = {
  25   VARIABLE_STORE_SIGNATURE,
  26   VOLATILE_VARIABLE_STORE_SIZE,
  27   VARIABLE_STORE_FORMATTED,
  28   VARIABLE_STORE_HEALTHY,
  29   0,
  30   0
  31 };
  32
  33 //
  34 // Don't use module globals after the SetVirtualAddress map is signaled
  35 //
  36 VARIABLE_GLOBAL  *mGlobal;
  37
  38 /**
  39   Update the variable region with Variable information. These are the same
  40   arguments as the EFI Variable services.
  41
  42   @param[in] VariableName       Name of variable
  43
  44   @param[in] VendorGuid         Guid of variable
  45
  46   @param[in] Data               Variable data
  47
  48   @param[in] DataSize           Size of data. 0 means delete
  49
  50   @param[in] Attributes         Attribues of the variable
  51
  52   @param[in] Variable           The variable information which is used to keep track of variable usage.
  53
  54   @retval EFI_SUCCESS           The update operation is success.
  55
  56   @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.
  57
  58 **/
  59 EFI_STATUS
  60 EFIAPI
  61 UpdateVariable (
  62   IN      CHAR16                 *VariableName,
  63   IN      EFI_GUID               *VendorGuid,
  64   IN      VOID                   *Data,
  65   IN      UINTN                  DataSize,
  66   IN      UINT32                 Attributes OPTIONAL,
  67   IN      VARIABLE_POINTER_TRACK *Variable
  68   );
  69
  70 VOID
  71 EFIAPI
  72 OnVirtualAddressChangeFsv (
  73   IN EFI_EVENT        Event,
  74   IN VOID             *Context
  75   );
  76
  77 VOID
  78 EFIAPI
  79 OnSimpleFileSystemInstall (
  80   IN EFI_EVENT        Event,
  81   IN VOID             *Context
  82   );
  83
  84 BOOLEAN
  85 IsValidVariableHeader (
  86   IN  VARIABLE_HEADER   *Variable
  87   )
  88 /*++
  89
  90 Routine Description:
  91
  92   This code checks if variable header is valid or not.
  93
  94 Arguments:
  95   Variable        Pointer to the Variable Header.
  96
  97 Returns:
  98   TRUE            Variable header is valid.
  99   FALSE           Variable header is not valid.
 100
 101 --*/
 102 {
 103   if (Variable == NULL || Variable->StartId != VARIABLE_DATA) {
 104     return FALSE;
 105   }
 106
 107   return TRUE;
 108 }
 109
 110 VARIABLE_STORE_STATUS
 111 GetVariableStoreStatus (
 112   IN VARIABLE_STORE_HEADER *VarStoreHeader
 113   )
 114 /*++
 115
 116 Routine Description:
 117
 118   This code gets the current status of Variable Store.
 119
 120 Arguments:
 121
 122   VarStoreHeader  Pointer to the Variable Store Header.
 123
 124 Returns:
 125
 126   EfiRaw        Variable store status is raw
 127   EfiValid      Variable store status is valid
 128   EfiInvalid    Variable store status is invalid
 129
 130 --*/
 131 {
 132   if (CompareGuid (&VarStoreHeader->Signature, &mStoreHeaderTemplate.Signature) &&
 133       (VarStoreHeader->Format == mStoreHeaderTemplate.Format) &&
 134       (VarStoreHeader->State == mStoreHeaderTemplate.State)
 135      ) {
 136     return EfiValid;
 137   } else if (((UINT32 *)(&VarStoreHeader->Signature))[0] == VAR_DEFAULT_VALUE_32 &&
 138              ((UINT32 *)(&VarStoreHeader->Signature))[1] == VAR_DEFAULT_VALUE_32 &&
 139              ((UINT32 *)(&VarStoreHeader->Signature))[2] == VAR_DEFAULT_VALUE_32 &&
 140              ((UINT32 *)(&VarStoreHeader->Signature))[3] == VAR_DEFAULT_VALUE_32 &&
 141              VarStoreHeader->Size == VAR_DEFAULT_VALUE_32 &&
 142              VarStoreHeader->Format == VAR_DEFAULT_VALUE &&
 143              VarStoreHeader->State == VAR_DEFAULT_VALUE
 144           ) {
 145
 146     return EfiRaw;
 147   } else {
 148     return EfiInvalid;
 149   }
 150 }
 151
 152 UINT8 *
 153 GetVariableDataPtr (
 154   IN  VARIABLE_HEADER   *Variable
 155   )
 156 /*++
 157
 158 Routine Description:
 159
 160   This code gets the pointer to the variable data.
 161
 162 Arguments:
 163
 164   Variable            Pointer to the Variable Header.
 165
 166 Returns:
 167
 168   UINT8*              Pointer to Variable Data
 169
 170 --*/
 171 {
 172   //
 173   // Be careful about pad size for alignment
 174   //
 175   return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
 176 }
 177
 178 VARIABLE_HEADER *
 179 GetNextVariablePtr (
 180   IN  VARIABLE_HEADER   *Variable
 181   )
 182 /*++
 183
 184 Routine Description:
 185
 186   This code gets the pointer to the next variable header.
 187
 188 Arguments:
 189
 190   Variable              Pointer to the Variable Header.
 191
 192 Returns:
 193
 194   VARIABLE_HEADER*      Pointer to next variable header.
 195
 196 --*/
 197 {
 198   if (!IsValidVariableHeader (Variable)) {
 199     return NULL;
 200   }
 201   //
 202   // Be careful about pad size for alignment
 203   //
 204   return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
 205 }
 206
 207 VARIABLE_HEADER *
 208 GetEndPointer (
 209   IN VARIABLE_STORE_HEADER       *VarStoreHeader
 210   )
 211 /*++
 212
 213 Routine Description:
 214
 215   This code gets the pointer to the last variable memory pointer byte
 216
 217 Arguments:
 218
 219   VarStoreHeader        Pointer to the Variable Store Header.
 220
 221 Returns:
 222
 223   VARIABLE_HEADER*      Pointer to last unavailable Variable Header
 224
 225 --*/
 226 {
 227   //
 228   // The end of variable store
 229   //
 230   return (VARIABLE_HEADER *) ((UINTN) VarStoreHeader + VarStoreHeader->Size);
 231 }
 232
 233 BOOLEAN
 234 ExistNewerVariable (
 235   IN  VARIABLE_HEADER         *Variable
 236   )
 237 /*++
 238
 239 Routine Description:
 240
 241   Check if exist newer variable when doing reclaim
 242
 243 Arguments:
 244
 245   Variable                    Pointer to start position
 246
 247 Returns:
 248
 249   TRUE - Exists another variable, which is newer than the current one
 250   FALSE  - Doesn't exist another vairable which is newer than the current one
 251
 252 --*/
 253 {
 254   VARIABLE_HEADER       *NextVariable;
 255   CHAR16                *VariableName;
 256   EFI_GUID              *VendorGuid;
 257
 258   VendorGuid   = &Variable->VendorGuid;
 259   VariableName = GET_VARIABLE_NAME_PTR(Variable);
 260
 261   NextVariable = GetNextVariablePtr (Variable);
 262   while (IsValidVariableHeader (NextVariable)) {
 263     if ((NextVariable->State == VAR_ADDED) || (NextVariable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
 264       //
 265       // If match Guid and Name
 266       //
 267       if (CompareGuid (VendorGuid, &NextVariable->VendorGuid)) {
 268          if (CompareMem (VariableName, GET_VARIABLE_NAME_PTR (NextVariable), StrSize (VariableName)) == 0) {
 269            return TRUE;
 270          }
 271        }
 272     }
 273     NextVariable = GetNextVariablePtr (NextVariable);
 274   }
 275   return FALSE;
 276 }
 277
 278 EFI_STATUS
 279 Reclaim (
 280   IN  VARIABLE_STORAGE_TYPE StorageType,
 281   IN  VARIABLE_HEADER       *CurrentVariable OPTIONAL
 282   )
 283 /*++
 284
 285 Routine Description:
 286
 287   Variable store garbage collection and reclaim operation
 288
 289 Arguments:
 290
 291   IsVolatile                  The variable store is volatile or not,
 292                               if it is non-volatile, need FTW
 293   CurrentVairable             If it is not NULL, it means not to process
 294                               current variable for Reclaim.
 295
 296 Returns:
 297
 298   EFI STATUS
 299
 300 --*/
 301 {
 302   VARIABLE_HEADER       *Variable;
 303   VARIABLE_HEADER       *NextVariable;
 304   VARIABLE_STORE_HEADER *VariableStoreHeader;
 305   UINT8                 *ValidBuffer;
 306   UINTN                 ValidBufferSize;
 307   UINTN                 VariableSize;
 308   UINT8                 *CurrPtr;
 309   EFI_STATUS            Status;
 310
 311   VariableStoreHeader = (VARIABLE_STORE_HEADER *) mGlobal->VariableBase[StorageType];
 312
 313   //
 314   // Start Pointers for the variable.
 315   //
 316   Variable        = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
 317
 318   //
 319   // recaluate the total size of Common/HwErr type variables in non-volatile area.
 320   //
 321   if (!StorageType) {
 322     mGlobal->CommonVariableTotalSize = 0;
 323     mGlobal->HwErrVariableTotalSize  = 0;
 324   }
 325   //
 326   // To make the reclaim, here we just allocate a memory that equal to the original memory
 327   //
 328   ValidBufferSize = sizeof (VARIABLE_STORE_HEADER) + VariableStoreHeader->Size;
 329
 330   Status = gBS->AllocatePool (
 331                   EfiBootServicesData,
 332                   ValidBufferSize,
 333                   (VOID**) &ValidBuffer
 334                   );
 335   if (EFI_ERROR (Status)) {
 336     return Status;
 337   }
 338
 339   CurrPtr = ValidBuffer;
 340
 341   //
 342   // Copy variable store header
 343   //
 344   CopyMem (CurrPtr, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));
 345   CurrPtr += sizeof (VARIABLE_STORE_HEADER);
 346
 347   //
 348   // Start Pointers for the variable.
 349   //
 350   Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
 351
 352
 353   ValidBufferSize = sizeof (VARIABLE_STORE_HEADER);
 354   while (IsValidVariableHeader (Variable)) {
 355     NextVariable = GetNextVariablePtr (Variable);
 356     //
 357     // State VAR_ADDED or VAR_IN_DELETED_TRANSITION are to kept,
 358     // The CurrentVariable, is also saved, as SetVariable may fail due to lack of space
 359     //
 360     if (Variable->State == VAR_ADDED) {
 361       VariableSize = (UINTN) NextVariable - (UINTN) Variable;
 362       CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
 363       ValidBufferSize += VariableSize;
 364       CurrPtr += VariableSize;
 365       if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 366         mGlobal->HwErrVariableTotalSize += VariableSize;
 367       } else if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 368         mGlobal->CommonVariableTotalSize += VariableSize;
 369       }
 370     } else if (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)) {
 371       //
 372       // As variables that with the same guid and name may exist in NV due to power failure during SetVariable,
 373       // we will only save the latest valid one
 374       //
 375       if (!ExistNewerVariable(Variable)) {
 376         VariableSize = (UINTN) NextVariable - (UINTN) Variable;
 377         CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
 378         //
 379         // If CurrentVariable == Variable, mark as VAR_IN_DELETED_TRANSITION
 380         //
 381         if (Variable != CurrentVariable){
 382           ((VARIABLE_HEADER *)CurrPtr)->State = VAR_ADDED;
 383         }
 384         CurrPtr += VariableSize;
 385         ValidBufferSize += VariableSize;
 386         if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 387           mGlobal->HwErrVariableTotalSize += VariableSize;
 388         } else if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
 389           mGlobal->CommonVariableTotalSize += VariableSize;
 390         }
 391       }
 392     }
 393     Variable = NextVariable;
 394   }
 395
 396   mGlobal->LastVariableOffset[StorageType] = ValidBufferSize;
 397
 398   //
 399   // TODO: cannot restore to original state, basic FTW needed
 400   //
 401   Status = mGlobal->VariableStore[StorageType]->Erase (
 402                                                   mGlobal->VariableStore[StorageType]
 403                                                   );
 404   Status = mGlobal->VariableStore[StorageType]->Write (
 405                                                     mGlobal->VariableStore[StorageType],
 406                                                     0,
 407                                                     ValidBufferSize,
 408                                                     ValidBuffer
 409                                                     );
 410
 411   if (EFI_ERROR (Status)) {
 412     //
 413     // If error, then reset the last variable offset to zero.
 414     //
 415     mGlobal->LastVariableOffset[StorageType] = 0;
 416   };
 417
 418   gBS->FreePool (ValidBuffer);
 419
 420   return Status;
 421 }
 422
 423 EFI_STATUS
 424 FindVariable (
 425   IN  CHAR16                  *VariableName,
 426   IN  EFI_GUID                *VendorGuid,
 427   OUT VARIABLE_POINTER_TRACK  *PtrTrack
 428   )
 429 /*++
 430
 431 Routine Description:
 432
 433   This code finds variable in storage blocks (Volatile or Non-Volatile)
 434
 435 Arguments:
 436
 437   VariableName                Name of the variable to be found
 438   VendorGuid                  Vendor GUID to be found.
 439   PtrTrack                    Variable Track Pointer structure that contains
 440                               Variable Information.
 441                               Contains the pointer of Variable header.
 442
 443 Returns:
 444
 445   EFI_INVALID_PARAMETER       - Invalid parameter
 446   EFI_SUCCESS                 - Find the specified variable
 447   EFI_NOT_FOUND               - Not found
 448
 449 --*/
 450 {
 451   VARIABLE_HEADER         *Variable;
 452   VARIABLE_STORE_HEADER   *VariableStoreHeader;
 453   UINTN                   Index;
 454   VARIABLE_HEADER         *InDeleteVariable;
 455   UINTN                   InDeleteIndex;
 456   VARIABLE_HEADER         *InDeleteStartPtr;
 457   VARIABLE_HEADER         *InDeleteEndPtr;
 458
 459   if (VariableName[0] != 0 && VendorGuid == NULL) {
 460     return EFI_INVALID_PARAMETER;
 461   }
 462
 463   InDeleteVariable = NULL;
 464   InDeleteIndex    = (UINTN)-1;
 465   InDeleteStartPtr = NULL;
 466   InDeleteEndPtr   = NULL;
 467
 468   for (Index = 0; Index < MaxType; Index ++) {
 469     //
 470     // 0: Non-Volatile, 1: Volatile
 471     //
 472     VariableStoreHeader = (VARIABLE_STORE_HEADER *) mGlobal->VariableBase[Index];
 473
 474     //
 475     // Start Pointers for the variable.
 476     // Actual Data Pointer where data can be written.
 477     //
 478     Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
 479
 480     //
 481     // Find the variable by walk through non-volatile and volatile variable store
 482     //
 483     PtrTrack->StartPtr = Variable;
 484     PtrTrack->EndPtr   = GetEndPointer (VariableStoreHeader);
 485
 486     while ((Variable < PtrTrack->EndPtr) && IsValidVariableHeader (Variable)) {
 487       if (Variable->State == VAR_ADDED) {
 488         if (!EfiAtRuntime () || (Variable->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
 489           if (VariableName[0] == 0) {
 490             PtrTrack->CurrPtr = Variable;
 491             PtrTrack->Type    = (VARIABLE_STORAGE_TYPE) Index;
 492             return EFI_SUCCESS;
 493           } else {
 494             if (CompareGuid (VendorGuid, &Variable->VendorGuid)) {
 495               if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable), StrSize (VariableName))) {
 496                 PtrTrack->CurrPtr = Variable;
 497                 PtrTrack->Type    = (VARIABLE_STORAGE_TYPE) Index;
 498                 return EFI_SUCCESS;
 499               }
 500             }
 501           }
 502         }
 503       } else if (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)) {
 504         //
 505         // VAR_IN_DELETED_TRANSITION should also be checked.
 506         //
 507         if (!EfiAtRuntime () || (Variable->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
 508           if (VariableName[0] == 0) {
 509             InDeleteVariable = Variable;
 510             InDeleteIndex    = Index;
 511             InDeleteStartPtr = PtrTrack->StartPtr;
 512             InDeleteEndPtr   = PtrTrack->EndPtr;
 513           } else {
 514             if (CompareGuid (VendorGuid, &Variable->VendorGuid)) {
 515               if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable), StrSize (VariableName))) {
 516                 InDeleteVariable = Variable;
 517                 InDeleteIndex    = Index;
 518                 InDeleteStartPtr = PtrTrack->StartPtr;
 519                 InDeleteEndPtr   = PtrTrack->EndPtr;
 520               }
 521             }
 522           }
 523         }
 524       }
 525
 526       Variable = GetNextVariablePtr (Variable);
 527     }
 528     //
 529     // While (...)
 530     //
 531   }
 532   //
 533   // for (...)
 534   //
 535
 536   //
 537   // if VAR_IN_DELETED_TRANSITION found, and VAR_ADDED not found,
 538   // we return it.
 539   //
 540   if (InDeleteVariable != NULL) {
 541     PtrTrack->CurrPtr  = InDeleteVariable;
 542     PtrTrack->Type     = (VARIABLE_STORAGE_TYPE) InDeleteIndex;
 543     PtrTrack->StartPtr = InDeleteStartPtr;
 544     PtrTrack->EndPtr   = InDeleteEndPtr;
 545     return EFI_SUCCESS;
 546   }
 547
 548   PtrTrack->CurrPtr = NULL;
 549   return EFI_NOT_FOUND;
 550 }
 551
 552 /**
 553   Get index from supported language codes according to language string.
 554
 555   This code is used to get corresponding index in supported language codes. It can handle
 556   RFC4646 and ISO639 language tags.
 557   In ISO639 language tags, take 3-characters as a delimitation to find matched string and calculate the index.
 558   In RFC4646 language tags, take semicolon as a delimitation to find matched string and calculate the index.
 559
 560   For example:
 561     SupportedLang  = "engfraengfra"
 562     Lang           = "eng"
 563     Iso639Language = TRUE
 564   The return value is "0".
 565   Another example:
 566     SupportedLang  = "en;fr;en-US;fr-FR"
 567     Lang           = "fr-FR"
 568     Iso639Language = FALSE
 569   The return value is "3".
 570
 571   @param  SupportedLang               Platform supported language codes.
 572   @param  Lang                        Configured language.
 573   @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.
 574
 575   @retval the index of language in the language codes.
 576
 577 **/
 578 UINTN
 579 EFIAPI
 580 GetIndexFromSupportedLangCodes(
 581   IN  CHAR8            *SupportedLang,
 582   IN  CHAR8            *Lang,
 583   IN  BOOLEAN          Iso639Language
 584   )
 585 {
 586   UINTN    Index;
 587   UINT32   CompareLength;
 588   CHAR8    *Supported;
 589
 590   Index = 0;
 591   Supported = SupportedLang;
 592   if (Iso639Language) {
 593     CompareLength = 3;
 594     for (Index = 0; Index < AsciiStrLen (SupportedLang); Index += CompareLength) {
 595       if (AsciiStrnCmp (Lang, SupportedLang + Index, CompareLength) == 0) {
 596         //
 597         // Successfully find the index of Lang string in SupportedLang string.
 598         //
 599         Index = Index / CompareLength;
 600         return Index;
 601       }
 602     }
 603     ASSERT (FALSE);
 604     return 0;
 605   } else {
 606     //
 607     // Compare RFC4646 language code
 608     //
 609     while (*Supported != '\0') {
 610       //
 611       // take semicolon as delimitation, sequentially traverse supported language codes.
 612       //
 613       for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {
 614         Supported++;
 615       }
 616       if (AsciiStrnCmp (Lang, Supported - CompareLength, CompareLength) == 0) {
 617         //
 618         // Successfully find the index of Lang string in SupportedLang string.
 619         //
 620         return Index;
 621       }
 622       Index++;
 623     }
 624     ASSERT (FALSE);
 625     return 0;
 626   }
 627 }
 628
 629 /**
 630   Get language string from supported language codes according to index.
 631
 632   This code is used to get corresponding language string in supported language codes. It can handle
 633   RFC4646 and ISO639 language tags.
 634   In ISO639 language tags, take 3-characters as a delimitation. Find language string according to the index.
 635   In RFC4646 language tags, take semicolon as a delimitation. Find language string according to the index.
 636
 637   For example:
 638     SupportedLang  = "engfraengfra"
 639     Index          = "1"
 640     Iso639Language = TRUE
 641   The return value is "fra".
 642   Another example:
 643     SupportedLang  = "en;fr;en-US;fr-FR"
 644     Index          = "1"
 645     Iso639Language = FALSE
 646   The return value is "fr".
 647
 648   @param  SupportedLang               Platform supported language codes.
 649   @param  Index                       the index in supported language codes.
 650   @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.
 651
 652   @retval the language string in the language codes.
 653
 654 **/
 655 CHAR8 *
 656 EFIAPI
 657 GetLangFromSupportedLangCodes (
 658   IN  CHAR8            *SupportedLang,
 659   IN  UINTN            Index,
 660   IN  BOOLEAN          Iso639Language
 661 )
 662 {
 663   UINTN    SubIndex;
 664   UINT32   CompareLength;
 665   CHAR8    *Supported;
 666
 667   SubIndex  = 0;
 668   Supported = SupportedLang;
 669   if (Iso639Language) {
 670     //
 671     // according to the index of Lang string in SupportedLang string to get the language.
 672     // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.
 673     // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.
 674     //
 675     CompareLength = 3;
 676     SetMem (mGlobal->Lang, sizeof(mGlobal->Lang), 0);
 677     return CopyMem (mGlobal->Lang, SupportedLang + Index * CompareLength, CompareLength);
 678
 679   } else {
 680     while (TRUE) {
 681       //
 682       // take semicolon as delimitation, sequentially traverse supported language codes.
 683       //
 684       for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {
 685         Supported++;
 686       }
 687       if ((*Supported == '\0') && (SubIndex != Index)) {
 688         //
 689         // Have completed the traverse, but not find corrsponding string.
 690         // This case is not allowed to happen.
 691         //
 692         ASSERT(FALSE);
 693         return NULL;
 694       }
 695       if (SubIndex == Index) {
 696         //
 697         // according to the index of Lang string in SupportedLang string to get the language.
 698         // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.
 699         // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.
 700         //
 701         SetMem (mGlobal->PlatformLang, sizeof (mGlobal->PlatformLang), 0);
 702         return CopyMem (mGlobal->PlatformLang, Supported - CompareLength, CompareLength);
 703       }
 704       SubIndex++;
 705     }
 706   }
 707 }
 708
 709 /**
 710   Hook the operations in PlatformLangCodes, LangCodes, PlatformLang and Lang.
 711
 712   When setting Lang/LangCodes, simultaneously update PlatformLang/PlatformLangCodes.
 713
 714   According to UEFI spec, PlatformLangCodes/LangCodes are only set once in firmware initialization,
 715   and are read-only. Therefore, in variable driver, only store the original value for other use.
 716
 717   @param[in] VariableName       Name of variable
 718
 719   @param[in] Data               Variable data
 720
 721   @param[in] DataSize           Size of data. 0 means delete
 722
 723   @retval EFI_SUCCESS  auto update operation is successful.
 724
 725 **/
 726 EFI_STATUS
 727 EFIAPI
 728 AutoUpdateLangVariable(
 729   IN  CHAR16             *VariableName,
 730   IN  VOID               *Data,
 731   IN  UINTN              DataSize
 732   )
 733 {
 734   EFI_STATUS     Status;
 735   CHAR8          *BestPlatformLang;
 736   CHAR8          *BestLang;
 737   UINTN          Index;
 738   UINT32         Attributes;
 739   VARIABLE_POINTER_TRACK Variable;
 740
 741   //
 742   // According to UEFI spec, "Lang" and "PlatformLang" is NV|BS|RT attributions.
 743   //
 744   Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
 745
 746   if (StrCmp (VariableName, L"PlatformLangCodes") == 0) {
 747     //
 748     // According to UEFI spec, PlatformLangCodes is only set once in firmware initialization, and is read-only
 749     // Therefore, in variable driver, only store the original value for other use.
 750     //
 751     AsciiStrnCpy (mGlobal->PlatformLangCodes, Data, DataSize);
 752   } else if (StrCmp (VariableName, L"LangCodes") == 0) {
 753     //
 754     // According to UEFI spec, LangCodes is only set once in firmware initialization, and is read-only
 755     // Therefore, in variable driver, only store the original value for other use.
 756     //
 757     AsciiStrnCpy (mGlobal->LangCodes, Data, DataSize);
 758   } else if ((StrCmp (VariableName, L"PlatformLang") == 0) && (DataSize != 0)) {
 759     ASSERT (AsciiStrLen (mGlobal->PlatformLangCodes) != 0);
 760
 761     //
 762     // When setting PlatformLang, firstly get most matched language string from supported language codes.
 763     //
 764     BestPlatformLang = GetBestLanguage(mGlobal->PlatformLangCodes, FALSE, Data, NULL);
 765
 766     //
 767     // Get the corresponding index in language codes.
 768     //
 769     Index = GetIndexFromSupportedLangCodes(mGlobal->PlatformLangCodes, BestPlatformLang, FALSE);
 770
 771     //
 772     // Get the corresponding ISO639 language tag according to RFC4646 language tag.
 773     //
 774     BestLang = GetLangFromSupportedLangCodes(mGlobal->LangCodes, Index, TRUE);
 775
 776     //
 777     // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.
 778     //
 779     FindVariable(L"Lang", &gEfiGlobalVariableGuid, &Variable);
 780
 781     Status = UpdateVariable(L"Lang", &gEfiGlobalVariableGuid,
 782                     BestLang, ISO_639_2_ENTRY_SIZE + 1, Attributes, &Variable);
 783
 784     DEBUG((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a\n", BestPlatformLang, BestLang));
 785
 786     ASSERT_EFI_ERROR(Status);
 787
 788   } else if ((StrCmp (VariableName, L"Lang") == 0) && (DataSize != 0)) {
 789     ASSERT (AsciiStrLen (mGlobal->LangCodes) != 0);
 790
 791     //
 792     // When setting Lang, firstly get most matched language string from supported language codes.
 793     //
 794     BestLang = GetBestLanguage(mGlobal->LangCodes, TRUE, Data, NULL);
 795
 796     //
 797     // Get the corresponding index in language codes.
 798     //
 799     Index = GetIndexFromSupportedLangCodes(mGlobal->LangCodes, BestLang, TRUE);
 800
 801     //
 802     // Get the corresponding RFC4646 language tag according to ISO639 language tag.
 803     //
 804     BestPlatformLang = GetLangFromSupportedLangCodes(mGlobal->PlatformLangCodes, Index, FALSE);
 805
 806     //
 807     // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.
 808     //
 809     FindVariable(L"PlatformLang", &gEfiGlobalVariableGuid, &Variable);
 810
 811     Status = UpdateVariable(L"PlatformLang", &gEfiGlobalVariableGuid,
 812                     BestPlatformLang, AsciiStrSize (BestPlatformLang), Attributes, &Variable);
 813
 814     DEBUG((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a\n", BestLang, BestPlatformLang));
 815     ASSERT_EFI_ERROR(Status);
 816   }
 817   return EFI_SUCCESS;
 818 }
 819
 820 /**
 821   Update the variable region with Variable information. These are the same
 822   arguments as the EFI Variable services.
 823
 824   @param[in] VariableName       Name of variable
 825
 826   @param[in] VendorGuid         Guid of variable
 827
 828   @param[in] Data               Variable data
 829
 830   @param[in] DataSize           Size of data. 0 means delete
 831
 832   @param[in] Attributes         Attribues of the variable
 833
 834   @param[in] Variable           The variable information which is used to keep track of variable usage.
 835
 836   @retval EFI_SUCCESS           The update operation is success.
 837
 838   @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.
 839
 840 **/
 841 EFI_STATUS
 842 EFIAPI
 843 UpdateVariable (
 844   IN      CHAR16                 *VariableName,
 845   IN      EFI_GUID               *VendorGuid,
 846   IN      VOID                   *Data,
 847   IN      UINTN                  DataSize,
 848   IN      UINT32                 Attributes OPTIONAL,
 849   IN      VARIABLE_POINTER_TRACK *Variable
 850   )
 851 {
 852   EFI_STATUS                          Status;
 853   VARIABLE_HEADER                     *NextVariable;
 854   UINTN                               VarNameOffset;
 855   UINTN                               VarDataOffset;
 856   UINTN                               VarNameSize;
 857   UINTN                               VarSize;
 858   UINT8                               State;
 859   BOOLEAN                             Reclaimed;
 860   VARIABLE_STORAGE_TYPE               StorageType;
 861
 862   Reclaimed         = FALSE;
 863
 864   if (Variable->CurrPtr != NULL) {
 865     //
 866     // Update/Delete existing variable
 867     //
 868
 869     if (EfiAtRuntime ()) {
 870       //
 871       // If EfiAtRuntime and the variable is Volatile and Runtime Access,
 872       // the volatile is ReadOnly, and SetVariable should be aborted and
 873       // return EFI_WRITE_PROTECTED.
 874       //
 875       if (Variable->Type == Volatile) {
 876         return EFI_WRITE_PROTECTED;
 877       }
 878       //
 879       // Only variable have NV attribute can be updated/deleted in Runtime
 880       //
 881       if (!(Variable->CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE)) {
 882         return EFI_INVALID_PARAMETER;
 883       }
 884     }
 885
 886     //
 887     // Setting a data variable with no access, or zero DataSize attributes
 888     // specified causes it to be deleted.
 889     //
 890     if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
 891       //
 892       // Found this variable in storage
 893       //
 894       State = Variable->CurrPtr->State;
 895       State &= VAR_DELETED;
 896
 897       Status = mGlobal->VariableStore[Variable->Type]->Write (
 898                                                         mGlobal->VariableStore[Variable->Type],
 899                                                         VARIABLE_MEMBER_OFFSET (State, (UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr),
 900                                                         sizeof (Variable->CurrPtr->State),
 901                                                         &State
 902                                                         );
 903       //
 904       // NOTE: Write operation at least can write data to memory cache
 905       //       Discard file writing failure here.
 906       //
 907       return EFI_SUCCESS;
 908     }
 909
 910     //
 911     // Found this variable in storage
 912     // If the variable is marked valid and the same data has been passed in
 913     // then return to the caller immediately.
 914     //
 915     if ((Variable->CurrPtr->DataSize == DataSize) &&
 916         (CompareMem (Data, GetVariableDataPtr (Variable->CurrPtr), DataSize) == 0)
 917           ) {
 918       return EFI_SUCCESS;
 919     } else if ((Variable->CurrPtr->State == VAR_ADDED) ||
 920                (Variable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
 921       //
 922       // Mark the old variable as in delete transition
 923       //
 924       State = Variable->CurrPtr->State;
 925       State &= VAR_IN_DELETED_TRANSITION;
 926
 927       Status = mGlobal->VariableStore[Variable->Type]->Write (
 928                                                         mGlobal->VariableStore[Variable->Type],
 929                                                         VARIABLE_MEMBER_OFFSET (State, (UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr),
 930                                                         sizeof (Variable->CurrPtr->State),
 931                                                         &State
 932                                                         );
 933       //
 934       // NOTE: Write operation at least can write data to memory cache
 935       //       Discard file writing failure here.
 936       //
 937     }
 938   } else {
 939     //
 940     // Create a new variable
 941     //
 942
 943     //
 944     // Make sure we are trying to create a new variable.
 945     // Setting a data variable with no access, or zero DataSize attributes means to delete it.
 946     //
 947     if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
 948       return EFI_NOT_FOUND;
 949     }
 950     //
 951     // Only variable have NV|RT attribute can be created in Runtime
 952     //
 953     if (EfiAtRuntime () &&
 954         (!(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) || !(Attributes & EFI_VARIABLE_NON_VOLATILE))) {
 955       return EFI_INVALID_PARAMETER;
 956     }
 957
 958   }
 959
 960   //
 961   // Function part - create a new variable and copy the data.
 962   // Both update a variable and create a variable will come here.
 963   // We can firstly write all the data in memory, then write them to file
 964   // This can reduce the times of write operation
 965   //
 966
 967   NextVariable = (VARIABLE_HEADER *) mGlobal->Scratch;
 968
 969   NextVariable->StartId     = VARIABLE_DATA;
 970   NextVariable->Attributes  = Attributes;
 971   NextVariable->State       = VAR_ADDED;
 972   NextVariable->Reserved    = 0;
 973   VarNameOffset             = sizeof (VARIABLE_HEADER);
 974   VarNameSize               = StrSize (VariableName);
 975   CopyMem (
 976     (UINT8 *) ((UINTN) NextVariable + VarNameOffset),
 977     VariableName,
 978     VarNameSize
 979     );
 980   VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
 981   CopyMem (
 982     (UINT8 *) ((UINTN) NextVariable + VarDataOffset),
 983     Data,
 984     DataSize
 985     );
 986   CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
 987   //
 988   // There will be pad bytes after Data, the NextVariable->NameSize and
 989   // NextVariable->DataSize should not include pad size so that variable
 990   // service can get actual size in GetVariable
 991   //
 992   NextVariable->NameSize  = (UINT32)VarNameSize;
 993   NextVariable->DataSize  = (UINT32)DataSize;
 994
 995   //
 996   // The actual size of the variable that stores in storage should
 997   // include pad size.
 998   // VarDataOffset: offset from begin of current variable header
 999   //
1000   VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
1001
1002   StorageType = (Attributes & EFI_VARIABLE_NON_VOLATILE) ? NonVolatile : Volatile;
1003
1004   if ((UINT32) (VarSize + mGlobal->LastVariableOffset[StorageType]) >
1005       ((VARIABLE_STORE_HEADER *) mGlobal->VariableBase[StorageType])->Size
1006       ) {
1007     if ((StorageType == NonVolatile) && EfiAtRuntime ()) {
1008       return EFI_OUT_OF_RESOURCES;
1009     }
1010     //
1011     // Perform garbage collection & reclaim operation
1012     //
1013     Status = Reclaim (StorageType, Variable->CurrPtr);
1014     if (EFI_ERROR (Status)) {
1015       //
1016       // Reclaim error
1017       // we cannot restore to original state, fetal error, report to user
1018       //
1019       DEBUG ((EFI_D_ERROR, "FSVariable: Recalim error (fetal error) - %r\n", Status));
1020       return Status;
1021     }
1022     //
1023     // If still no enough space, return out of resources
1024     //
1025     if ((UINT32) (VarSize + mGlobal->LastVariableOffset[StorageType]) >
1026         ((VARIABLE_STORE_HEADER *) mGlobal->VariableBase[StorageType])->Size
1027        ) {
1028       return EFI_OUT_OF_RESOURCES;
1029     }
1030
1031     Reclaimed = TRUE;
1032   }
1033   Status = mGlobal->VariableStore[StorageType]->Write (
1034                                                   mGlobal->VariableStore[StorageType],
1035                                                   mGlobal->LastVariableOffset[StorageType],
1036                                                   VarSize,
1037                                                   NextVariable
1038                                                   );
1039   //
1040   // NOTE: Write operation at least can write data to memory cache
1041   //       Discard file writing failure here.
1042   //
1043   mGlobal->LastVariableOffset[StorageType] += VarSize;
1044
1045   if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {
1046     mGlobal->HwErrVariableTotalSize += VarSize;
1047   } else {
1048     mGlobal->CommonVariableTotalSize += VarSize;
1049   }
1050
1051   //
1052   // Mark the old variable as deleted
1053   //
1054   if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != NULL) {
1055     State = Variable->CurrPtr->State;
1056     State &= VAR_DELETED;
1057
1058     Status = mGlobal->VariableStore[StorageType]->Write (
1059                                                     mGlobal->VariableStore[StorageType],
1060                                                     VARIABLE_MEMBER_OFFSET (State, (UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr),
1061                                                     sizeof (Variable->CurrPtr->State),
1062                                                     &State
1063                                                     );
1064     //
1065     // NOTE: Write operation at least can write data to memory cache
1066     //       Discard file writing failure here.
1067     //
1068   }
1069   return EFI_SUCCESS;
1070 }
1071
1072 EFI_STATUS
1073 EFIAPI
1074 DuetGetVariable (
1075   IN      CHAR16            *VariableName,
1076   IN      EFI_GUID          *VendorGuid,
1077   OUT     UINT32            *Attributes OPTIONAL,
1078   IN OUT  UINTN             *DataSize,
1079   OUT     VOID              *Data
1080   )
1081 /*++
1082
1083 Routine Description:
1084
1085   This code finds variable in storage blocks (Volatile or Non-Volatile)
1086
1087 Arguments:
1088
1089   VariableName                    Name of Variable to be found
1090   VendorGuid                      Variable vendor GUID
1091   Attributes OPTIONAL             Attribute value of the variable found
1092   DataSize                        Size of Data found. If size is less than the
1093                                   data, this value contains the required size.
1094   Data                            Data pointer
1095
1096 Returns:
1097
1098   EFI STATUS
1099
1100 --*/
1101 {
1102   VARIABLE_POINTER_TRACK  Variable;
1103   UINTN                   VarDataSize;
1104   EFI_STATUS              Status;
1105
1106   if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
1107     return EFI_INVALID_PARAMETER;
1108   }
1109
1110   //
1111   // Find existing variable
1112   //
1113   Status = FindVariable (VariableName, VendorGuid, &Variable);
1114
1115   if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
1116     return Status;
1117   }
1118   //
1119   // Get data size
1120   //
1121   VarDataSize = Variable.CurrPtr->DataSize;
1122   if (*DataSize >= VarDataSize) {
1123     if (Data == NULL) {
1124       return EFI_INVALID_PARAMETER;
1125     }
1126     CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
1127
1128     if (Attributes != NULL) {
1129       *Attributes = Variable.CurrPtr->Attributes;
1130     }
1131
1132     *DataSize = VarDataSize;
1133
1134     return EFI_SUCCESS;
1135   } else {
1136     *DataSize = VarDataSize;
1137     return EFI_BUFFER_TOO_SMALL;
1138   }
1139 }
1140
1141 EFI_STATUS
1142 EFIAPI
1143 GetNextVariableName (
1144   IN OUT  UINTN             *VariableNameSize,
1145   IN OUT  CHAR16            *VariableName,
1146   IN OUT  EFI_GUID          *VendorGuid
1147   )
1148 /*++
1149
1150 Routine Description:
1151
1152   This code Finds the Next available variable
1153
1154 Arguments:
1155
1156   VariableNameSize            Size of the variable
1157   VariableName                Pointer to variable name
1158   VendorGuid                  Variable Vendor Guid
1159
1160 Returns:
1161
1162   EFI STATUS
1163
1164 --*/
1165 {
1166   VARIABLE_POINTER_TRACK  Variable;
1167   UINTN                   VarNameSize;
1168   EFI_STATUS              Status;
1169
1170   if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
1171     return EFI_INVALID_PARAMETER;
1172   }
1173
1174   Status = FindVariable (VariableName, VendorGuid, &Variable);
1175
1176   if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
1177     return Status;
1178   }
1179
1180   if (VariableName[0] != 0) {
1181     //
1182     // If variable name is not NULL, get next variable
1183     //
1184     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
1185   }
1186
1187   while (TRUE) {
1188     //
1189     // The order we find variable is: 1). NonVolatile; 2). Volatile
1190     // If both volatile and non-volatile variable store are parsed,
1191     // return not found
1192     //
1193     if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
1194       if (Variable.Type == Volatile) {
1195         //
1196         // Since we met the end of Volatile storage, we have parsed all the stores.
1197         //
1198         return EFI_NOT_FOUND;
1199       }
1200
1201       //
1202       // End of NonVolatile, continue to parse Volatile
1203       //
1204       Variable.Type = Volatile;
1205       Variable.StartPtr = (VARIABLE_HEADER *) ((VARIABLE_STORE_HEADER *) mGlobal->VariableBase[Volatile] + 1);
1206       Variable.EndPtr   = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) mGlobal->VariableBase[Volatile]);
1207
1208       Variable.CurrPtr = Variable.StartPtr;
1209       if (!IsValidVariableHeader (Variable.CurrPtr)) {
1210         continue;
1211       }
1212     }
1213     //
1214     // Variable is found
1215     //
1216     if (IsValidVariableHeader (Variable.CurrPtr) &&
1217         ((Variable.CurrPtr->State == VAR_ADDED) ||
1218          (Variable.CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)))) {
1219       if (!EfiAtRuntime () || (Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1220         VarNameSize = Variable.CurrPtr->NameSize;
1221         if (VarNameSize <= *VariableNameSize) {
1222           CopyMem (
1223             VariableName,
1224             GET_VARIABLE_NAME_PTR (Variable.CurrPtr),
1225             VarNameSize
1226             );
1227           CopyMem (
1228             VendorGuid,
1229             &Variable.CurrPtr->VendorGuid,
1230             sizeof (EFI_GUID)
1231             );
1232           Status = EFI_SUCCESS;
1233         } else {
1234           Status = EFI_BUFFER_TOO_SMALL;
1235         }
1236
1237         *VariableNameSize = VarNameSize;
1238         return Status;
1239       }
1240     }
1241
1242     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
1243   }
1244 }
1245
1246 EFI_STATUS
1247 EFIAPI
1248 SetVariable (
1249   IN CHAR16                  *VariableName,
1250   IN EFI_GUID                *VendorGuid,
1251   IN UINT32                  Attributes,
1252   IN UINTN                   DataSize,
1253   IN VOID                    *Data
1254   )
1255 /*++
1256
1257 Routine Description:
1258
1259   This code sets variable in storage blocks (Volatile or Non-Volatile)
1260
1261 Arguments:
1262
1263   VariableName                    Name of Variable to be found
1264   VendorGuid                      Variable vendor GUID
1265   Attributes                      Attribute value of the variable found
1266   DataSize                        Size of Data found. If size is less than the
1267                                   data, this value contains the required size.
1268   Data                            Data pointer
1269
1270 Returns:
1271
1272   EFI_INVALID_PARAMETER           - Invalid parameter
1273   EFI_SUCCESS                     - Set successfully
1274   EFI_OUT_OF_RESOURCES            - Resource not enough to set variable
1275   EFI_NOT_FOUND                   - Not found
1276   EFI_DEVICE_ERROR                - Variable can not be saved due to hardware failure
1277   EFI_WRITE_PROTECTED             - Variable is read-only
1278
1279 --*/
1280 {
1281   VARIABLE_POINTER_TRACK  Variable;
1282   EFI_STATUS              Status;
1283
1284   //
1285   // Check input parameters
1286   //
1287   if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
1288     return EFI_INVALID_PARAMETER;
1289   }
1290
1291   if (DataSize != 0 && Data == NULL) {
1292     return EFI_INVALID_PARAMETER;
1293   }
1294
1295   //
1296   // Not support authenticated variable write yet.
1297   //
1298   if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {
1299     return EFI_INVALID_PARAMETER;
1300   }
1301
1302   //
1303   //  Make sure if runtime bit is set, boot service bit is set also
1304   //
1305   if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1306     return EFI_INVALID_PARAMETER;
1307   }
1308
1309   //
1310   //  The size of the VariableName, including the Unicode Null in bytes plus
1311   //  the DataSize is limited to maximum size of PcdGet32 (PcdMaxHardwareErrorVariableSize)
1312   //  bytes for HwErrRec, and PcdGet32 (PcdMaxVariableSize) bytes for the others.
1313   //
1314   if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1315     if ((DataSize > PcdGet32(PcdMaxHardwareErrorVariableSize)) ||
1316         (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > PcdGet32(PcdMaxHardwareErrorVariableSize))) {
1317       return EFI_INVALID_PARAMETER;
1318     }
1319     //
1320     // According to UEFI spec, HARDWARE_ERROR_RECORD variable name convention should be L"HwErrRecXXXX"
1321     //
1322     if (StrnCmp(VariableName, L"HwErrRec", StrLen(L"HwErrRec")) != 0) {
1323       return EFI_INVALID_PARAMETER;
1324     }
1325   } else {
1326     if ((DataSize > PcdGet32(PcdMaxVariableSize)) ||
1327         (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > PcdGet32(PcdMaxVariableSize))) {
1328       return EFI_INVALID_PARAMETER;
1329     }
1330   }
1331
1332   //
1333   // Check whether the input variable is already existed
1334   //
1335   Status = FindVariable (VariableName, VendorGuid, &Variable);
1336
1337   //
1338   // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang
1339   //
1340   AutoUpdateLangVariable (VariableName, Data, DataSize);
1341
1342   Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, &Variable);
1343
1344   return Status;
1345 }
1346
1347 EFI_STATUS
1348 EFIAPI
1349 QueryVariableInfo (
1350   IN  UINT32                 Attributes,
1351   OUT UINT64                 *MaximumVariableStorageSize,
1352   OUT UINT64                 *RemainingVariableStorageSize,
1353   OUT UINT64                 *MaximumVariableSize
1354   )
1355 /*++
1356
1357 Routine Description:
1358
1359   This code returns information about the EFI variables.
1360
1361 Arguments:
1362
1363   Attributes                      Attributes bitmask to specify the type of variables
1364                                   on which to return information.
1365   MaximumVariableStorageSize      Pointer to the maximum size of the storage space available
1366                                   for the EFI variables associated with the attributes specified.
1367   RemainingVariableStorageSize    Pointer to the remaining size of the storage space available
1368                                   for the EFI variables associated with the attributes specified.
1369   MaximumVariableSize             Pointer to the maximum size of the individual EFI variables
1370                                   associated with the attributes specified.
1371
1372 Returns:
1373
1374   EFI STATUS
1375   EFI_INVALID_PARAMETER           - An invalid combination of attribute bits was supplied.
1376   EFI_SUCCESS                     - Query successfully.
1377   EFI_UNSUPPORTED                 - The attribute is not supported on this platform.
1378
1379 --*/
1380 {
1381   VARIABLE_HEADER        *Variable;
1382   VARIABLE_HEADER        *NextVariable;
1383   UINT64                 VariableSize;
1384   VARIABLE_STORE_HEADER  *VariableStoreHeader;
1385   UINT64                 CommonVariableTotalSize;
1386   UINT64                 HwErrVariableTotalSize;
1387
1388   CommonVariableTotalSize = 0;
1389   HwErrVariableTotalSize = 0;
1390
1391   if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {
1392     return EFI_INVALID_PARAMETER;
1393   }
1394
1395   if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {
1396     //
1397     // Make sure the Attributes combination is supported by the platform.
1398     //
1399     return EFI_UNSUPPORTED;
1400   } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1401     //
1402     // Make sure if runtime bit is set, boot service bit is set also.
1403     //
1404     return EFI_INVALID_PARAMETER;
1405   } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1406     //
1407     // Make sure RT Attribute is set if we are in Runtime phase.
1408     //
1409     return EFI_INVALID_PARAMETER;
1410   } else if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1411     //
1412     // Make sure Hw Attribute is set with NV.
1413     //
1414     return EFI_INVALID_PARAMETER;
1415   } else if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {
1416     //
1417     // Not support authentiated variable write yet.
1418     //
1419     return EFI_UNSUPPORTED;
1420   }
1421
1422   VariableStoreHeader = (VARIABLE_STORE_HEADER *) mGlobal->VariableBase[
1423                                 (Attributes & EFI_VARIABLE_NON_VOLATILE) ? NonVolatile : Volatile
1424                                 ];
1425   //
1426   // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1427   // with the storage size (excluding the storage header size).
1428   //
1429   *MaximumVariableStorageSize   = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1430
1431   //
1432   // Harware error record variable needs larger size.
1433   //
1434   if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
1435     *MaximumVariableStorageSize = PcdGet32(PcdHwErrStorageSize);
1436     *MaximumVariableSize = PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER);
1437   } else {
1438     if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {
1439       ASSERT (PcdGet32(PcdHwErrStorageSize) < VariableStoreHeader->Size);
1440       *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32(PcdHwErrStorageSize);
1441     }
1442
1443     //
1444     // Let *MaximumVariableSize be PcdGet32(PcdMaxVariableSize) with the exception of the variable header size.
1445     //
1446     *MaximumVariableSize = PcdGet32(PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);
1447   }
1448
1449   //
1450   // Point to the starting address of the variables.
1451   //
1452   Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1453
1454   //
1455   // Now walk through the related variable store.
1456   //
1457   while ((Variable < GetEndPointer (VariableStoreHeader)) && IsValidVariableHeader (Variable)) {
1458     NextVariable = GetNextVariablePtr (Variable);
1459     VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
1460
1461     if (EfiAtRuntime ()) {
1462       //
1463       // we don't take the state of the variables in mind
1464       // when calculating RemainingVariableStorageSize,
1465       // since the space occupied by variables not marked with
1466       // VAR_ADDED is not allowed to be reclaimed in Runtime.
1467       //
1468       if ((NextVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1469         HwErrVariableTotalSize += VariableSize;
1470       } else {
1471         CommonVariableTotalSize += VariableSize;
1472       }
1473     } else {
1474       //
1475       // Only care about Variables with State VAR_ADDED,because
1476       // the space not marked as VAR_ADDED is reclaimable now.
1477       //
1478       if ((Variable->State == VAR_ADDED) || (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1479         if ((NextVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1480           HwErrVariableTotalSize += VariableSize;
1481         } else {
1482           CommonVariableTotalSize += VariableSize;
1483         }
1484       }
1485     }
1486
1487     //
1488     // Go to the next one
1489     //
1490     Variable = NextVariable;
1491   }
1492
1493   if ((Attributes  & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){
1494     *RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;
1495   } else {
1496     *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;
1497   }
1498
1499   return EFI_SUCCESS;
1500 }
1501
1502 EFI_STATUS
1503 EFIAPI
1504 VariableServiceInitialize (
1505   IN EFI_HANDLE         ImageHandle,
1506   IN EFI_SYSTEM_TABLE   *SystemTable
1507   )
1508 /*++
1509
1510 Routine Description:
1511   This function does initialization for variable services
1512
1513 Arguments:
1514
1515   ImageHandle   - The firmware allocated handle for the EFI image.
1516   SystemTable   - A pointer to the EFI System Table.
1517
1518 Returns:
1519
1520   Status code.
1521
1522   EFI_NOT_FOUND     - Variable store area not found.
1523   EFI_SUCCESS       - Variable services successfully initialized.
1524
1525 --*/
1526 {
1527   EFI_STATUS                      Status;
1528   EFI_HANDLE                      NewHandle;
1529   VS_DEV                          *Dev;
1530   EFI_PEI_HOB_POINTERS            GuidHob;
1531   VARIABLE_HEADER                 *Variable;
1532   VARIABLE_HEADER                 *NextVariable;
1533   VARIABLE_STORE_HEADER           *VariableStoreHeader;
1534   EFI_FLASH_MAP_FS_ENTRY_DATA     *FlashMapEntryData;
1535   EFI_FLASH_SUBAREA_ENTRY         VariableStoreEntry;
1536   UINT64                          BaseAddress;
1537   UINT64                          Length;
1538   EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
1539
1540   Status = gBS->AllocatePool (
1541                   EfiRuntimeServicesData,
1542                   (UINTN) sizeof (VARIABLE_GLOBAL),
1543                   (VOID**) &mGlobal
1544                   );
1545   if (EFI_ERROR (Status)) {
1546     return Status;
1547   }
1548
1549   ZeroMem (mGlobal, (UINTN) sizeof (VARIABLE_GLOBAL));
1550
1551   GuidHob.Raw = GetHobList ();
1552   FlashMapEntryData = NULL;
1553   while ((GuidHob.Raw = GetNextGuidHob (&gEfiFlashMapHobGuid, GuidHob.Raw)) != NULL) {
1554     FlashMapEntryData = (EFI_FLASH_MAP_FS_ENTRY_DATA *) GET_GUID_HOB_DATA (GuidHob.Guid);
1555     if (FlashMapEntryData->AreaType == EFI_FLASH_AREA_EFI_VARIABLES) {
1556       break;
1557     }
1558     GuidHob.Raw = GET_NEXT_HOB (GuidHob);
1559   }
1560
1561   if (FlashMapEntryData == NULL) {
1562     DEBUG ((EFI_D_ERROR, "FSVariable: Could not find flash area for variable!\n"));
1563     Status = EFI_NOT_FOUND;
1564     return Status;
1565   }
1566
1567   CopyMem(
1568     (VOID*)&VariableStoreEntry,
1569     (VOID*)&FlashMapEntryData->Entries[0],
1570     sizeof(EFI_FLASH_SUBAREA_ENTRY)
1571     );
1572
1573   //
1574   // Mark the variable storage region of the FLASH as RUNTIME
1575   //
1576   BaseAddress = VariableStoreEntry.Base & (~EFI_PAGE_MASK);
1577   Length      = VariableStoreEntry.Length + (VariableStoreEntry.Base - BaseAddress);
1578   Length      = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
1579   Status      = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
1580   if (EFI_ERROR (Status)) {
1581     Status = EFI_UNSUPPORTED;
1582     return Status;
1583   }
1584   Status = gDS->SetMemorySpaceAttributes (
1585                   BaseAddress,
1586                   Length,
1587                   GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME
1588                   );
1589   if (EFI_ERROR (Status)) {
1590     Status = EFI_UNSUPPORTED;
1591     return Status;
1592   }
1593
1594   Status = FileStorageConstructor (
1595              &mGlobal->VariableStore[NonVolatile],
1596              &mGlobal->GoVirtualChildEvent[NonVolatile],
1597              VariableStoreEntry.Base,
1598              (UINT32) VariableStoreEntry.Length,
1599              FlashMapEntryData->VolumeId,
1600              FlashMapEntryData->FilePath
1601              );
1602   ASSERT_EFI_ERROR (Status);
1603
1604   //
1605   // Volatile Storage
1606   //
1607   Status = MemStorageConstructor (
1608              &mGlobal->VariableStore[Volatile],
1609              &mGlobal->GoVirtualChildEvent[Volatile],
1610              VOLATILE_VARIABLE_STORE_SIZE
1611              );
1612   ASSERT_EFI_ERROR (Status);
1613
1614   //
1615   // Scratch
1616   //
1617   Status = gBS->AllocatePool (
1618                   EfiRuntimeServicesData,
1619                   VARIABLE_SCRATCH_SIZE,
1620                   &mGlobal->Scratch
1621                   );
1622   ASSERT_EFI_ERROR (Status);
1623
1624   //
1625   // 1. NV Storage
1626   //
1627   Dev = DEV_FROM_THIS (mGlobal->VariableStore[NonVolatile]);
1628   VariableStoreHeader = (VARIABLE_STORE_HEADER *) VAR_DATA_PTR (Dev);
1629   if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
1630     if (~VariableStoreHeader->Size == 0) {
1631       VariableStoreHeader->Size = (UINT32) VariableStoreEntry.Length;
1632     }
1633   }
1634   //
1635   // Calculate LastVariableOffset
1636   //
1637   Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1638   while (IsValidVariableHeader (Variable)) {
1639     UINTN VariableSize = 0;
1640     NextVariable = GetNextVariablePtr (Variable);
1641     VariableSize = NextVariable - Variable;
1642     if ((NextVariable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
1643       mGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VariableSize);
1644     } else {
1645       mGlobal->CommonVariableTotalSize += HEADER_ALIGN (VariableSize);
1646     }
1647     Variable = NextVariable;
1648   }
1649
1650   mGlobal->LastVariableOffset[NonVolatile] = (UINTN) Variable - (UINTN) VariableStoreHeader;
1651   mGlobal->VariableBase[NonVolatile]       = VariableStoreHeader;
1652
1653   //
1654   // Reclaim if remaining space is too small
1655   //
1656   if ((VariableStoreHeader->Size - mGlobal->LastVariableOffset[NonVolatile]) < VARIABLE_RECLAIM_THRESHOLD) {
1657     Status = Reclaim (NonVolatile, NULL);
1658     if (EFI_ERROR (Status)) {
1659       //
1660       // Reclaim error
1661       // we cannot restore to original state
1662       //
1663       DEBUG ((EFI_D_ERROR, "FSVariable: Reclaim error (fatal error) - %r\n", Status));
1664       ASSERT_EFI_ERROR (Status);
1665     }
1666   }
1667
1668   //
1669   // 2. Volatile Storage
1670   //
1671   Dev = DEV_FROM_THIS (mGlobal->VariableStore[Volatile]);
1672   VariableStoreHeader = (VARIABLE_STORE_HEADER *) VAR_DATA_PTR (Dev);
1673   mGlobal->VariableBase[Volatile] = VAR_DATA_PTR (Dev);
1674   mGlobal->LastVariableOffset[Volatile] = sizeof (VARIABLE_STORE_HEADER);
1675   //
1676   // init store_header & body in memory.
1677   //
1678   mGlobal->VariableStore[Volatile]->Erase (mGlobal->VariableStore[Volatile]);
1679   mGlobal->VariableStore[Volatile]->Write (
1680                                    mGlobal->VariableStore[Volatile],
1681                                    0,
1682                                    sizeof (VARIABLE_STORE_HEADER),
1683                                    &mStoreHeaderTemplate
1684                                    );
1685
1686
1687   SystemTable->RuntimeServices->GetVariable         = DuetGetVariable;
1688   SystemTable->RuntimeServices->GetNextVariableName = GetNextVariableName;
1689   SystemTable->RuntimeServices->SetVariable         = SetVariable;
1690
1691   SystemTable->RuntimeServices->QueryVariableInfo   = QueryVariableInfo;
1692
1693   //
1694   // Now install the Variable Runtime Architectural Protocol on a new handle
1695   //
1696   NewHandle = NULL;
1697   Status = gBS->InstallMultipleProtocolInterfaces (
1698                   &NewHandle,
1699                   &gEfiVariableArchProtocolGuid,
1700                   NULL,
1701                   &gEfiVariableWriteArchProtocolGuid,
1702                   NULL,
1703                   NULL
1704                   );
1705   ASSERT_EFI_ERROR (Status);
1706
1707   return Status;
1708 }
1709
1710
1711
1712 VOID
1713 EFIAPI
1714 OnVirtualAddressChangeFsv (
1715   IN EFI_EVENT        Event,
1716   IN VOID             *Context
1717   )
1718 {
1719   UINTN Index;
1720
1721   for (Index = 0; Index < MaxType; Index++) {
1722     mGlobal->GoVirtualChildEvent[Index] (Event, mGlobal->VariableStore[Index]);
1723     EfiConvertPointer (0, (VOID**) &mGlobal->VariableStore[Index]);
1724     EfiConvertPointer (0, &mGlobal->VariableBase[Index]);
1725   }
1726   EfiConvertPointer (0, &mGlobal->Scratch);
1727   EfiConvertPointer (0, (VOID**) &mGlobal);
1728 }