DuetPkg/FSVariable/FSVariable.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2009, 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) {
 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) {
 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   //
1292   //  Make sure if runtime bit is set, boot service bit is set also
1293   //
1294   if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1295     return EFI_INVALID_PARAMETER;
1296   }
1297
1298   //
1299   //  The size of the VariableName, including the Unicode Null in bytes plus
1300   //  the DataSize is limited to maximum size of FixedPcdGet32(PcdMaxHardwareErrorVariableSize)
1301   //  bytes for HwErrRec, and FixedPcdGet32(PcdMaxVariableSize) bytes for the others.
1302   //
1303   if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1304     if ((DataSize > FixedPcdGet32(PcdMaxHardwareErrorVariableSize)) ||
1305         (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > FixedPcdGet32(PcdMaxHardwareErrorVariableSize))) {
1306       return EFI_INVALID_PARAMETER;
1307     }
1308     //
1309     // According to UEFI spec, HARDWARE_ERROR_RECORD variable name convention should be L"HwErrRecXXXX"
1310     //
1311     if (StrnCmp(VariableName, L"HwErrRec", StrLen(L"HwErrRec")) != 0) {
1312       return EFI_INVALID_PARAMETER;
1313     }
1314   } else {
1315     if ((DataSize > FixedPcdGet32(PcdMaxVariableSize)) ||
1316         (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > FixedPcdGet32(PcdMaxVariableSize))) {
1317       return EFI_INVALID_PARAMETER;
1318     }
1319   }
1320
1321   //
1322   // Check whether the input variable is already existed
1323   //
1324   Status = FindVariable (VariableName, VendorGuid, &Variable);
1325
1326   //
1327   // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang
1328   //
1329   AutoUpdateLangVariable (VariableName, Data, DataSize);
1330
1331   Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, &Variable);
1332
1333   return Status;
1334 }
1335
1336 EFI_STATUS
1337 EFIAPI
1338 QueryVariableInfo (
1339   IN  UINT32                 Attributes,
1340   OUT UINT64                 *MaximumVariableStorageSize,
1341   OUT UINT64                 *RemainingVariableStorageSize,
1342   OUT UINT64                 *MaximumVariableSize
1343   )
1344 /*++
1345
1346 Routine Description:
1347
1348   This code returns information about the EFI variables.
1349
1350 Arguments:
1351
1352   Attributes                      Attributes bitmask to specify the type of variables
1353                                   on which to return information.
1354   MaximumVariableStorageSize      Pointer to the maximum size of the storage space available
1355                                   for the EFI variables associated with the attributes specified.
1356   RemainingVariableStorageSize    Pointer to the remaining size of the storage space available
1357                                   for the EFI variables associated with the attributes specified.
1358   MaximumVariableSize             Pointer to the maximum size of the individual EFI variables
1359                                   associated with the attributes specified.
1360
1361 Returns:
1362
1363   EFI STATUS
1364   EFI_INVALID_PARAMETER           - An invalid combination of attribute bits was supplied.
1365   EFI_SUCCESS                     - Query successfully.
1366   EFI_UNSUPPORTED                 - The attribute is not supported on this platform.
1367
1368 --*/
1369 {
1370   VARIABLE_HEADER        *Variable;
1371   VARIABLE_HEADER        *NextVariable;
1372   UINT64                 VariableSize;
1373   VARIABLE_STORE_HEADER  *VariableStoreHeader;
1374   UINT64                 CommonVariableTotalSize;
1375   UINT64                 HwErrVariableTotalSize;
1376
1377   CommonVariableTotalSize = 0;
1378   HwErrVariableTotalSize = 0;
1379
1380   if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {
1381     return EFI_INVALID_PARAMETER;
1382   }
1383
1384   if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {
1385     //
1386     // Make sure the Attributes combination is supported by the platform.
1387     //
1388     return EFI_UNSUPPORTED;
1389   }
1390   else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1391     //
1392     // Make sure if runtime bit is set, boot service bit is set also.
1393     //
1394     return EFI_INVALID_PARAMETER;
1395   } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1396     //
1397     // Make sure RT Attribute is set if we are in Runtime phase.
1398     //
1399     return EFI_INVALID_PARAMETER;
1400   } else if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1401     //
1402     // Make sure Hw Attribute is set with NV.
1403     //
1404     return EFI_INVALID_PARAMETER;
1405   }
1406
1407   VariableStoreHeader = (VARIABLE_STORE_HEADER *) mGlobal->VariableBase[
1408                                 (Attributes & EFI_VARIABLE_NON_VOLATILE) ? NonVolatile : Volatile
1409                                 ];
1410   //
1411   // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1412   // with the storage size (excluding the storage header size).
1413   //
1414   *MaximumVariableStorageSize   = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1415
1416   //
1417   // Harware error record variable needs larger size.
1418   //
1419   if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
1420     *MaximumVariableStorageSize = FixedPcdGet32(PcdHwErrStorageSize);
1421     *MaximumVariableSize = FixedPcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER);
1422   } else {
1423     if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {
1424       ASSERT (FixedPcdGet32(PcdHwErrStorageSize) < VariableStoreHeader->Size);
1425       *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER) - FixedPcdGet32(PcdHwErrStorageSize);
1426     }
1427
1428     //
1429     // Let *MaximumVariableSize be FixedPcdGet32(PcdMaxVariableSize) with the exception of the variable header size.
1430     //
1431     *MaximumVariableSize = FixedPcdGet32(PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);
1432   }
1433
1434   //
1435   // Point to the starting address of the variables.
1436   //
1437   Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1438
1439   //
1440   // Now walk through the related variable store.
1441   //
1442   while ((Variable < GetEndPointer (VariableStoreHeader)) && IsValidVariableHeader (Variable)) {
1443     NextVariable = GetNextVariablePtr (Variable);
1444     VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
1445
1446     if (EfiAtRuntime ()) {
1447       //
1448       // we don't take the state of the variables in mind
1449       // when calculating RemainingVariableStorageSize,
1450       // since the space occupied by variables not marked with
1451       // VAR_ADDED is not allowed to be reclaimed in Runtime.
1452       //
1453       if ((NextVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1454         HwErrVariableTotalSize += VariableSize;
1455       } else {
1456         CommonVariableTotalSize += VariableSize;
1457       }
1458     } else {
1459       //
1460       // Only care about Variables with State VAR_ADDED,because
1461       // the space not marked as VAR_ADDED is reclaimable now.
1462       //
1463       if ((Variable->State == VAR_ADDED) || (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1464         if ((NextVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1465           HwErrVariableTotalSize += VariableSize;
1466         } else {
1467           CommonVariableTotalSize += VariableSize;
1468         }
1469       }
1470     }
1471
1472     //
1473     // Go to the next one
1474     //
1475     Variable = NextVariable;
1476   }
1477
1478   if ((Attributes  & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){
1479     *RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;
1480   } else {
1481     *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;
1482   }
1483
1484   return EFI_SUCCESS;
1485 }
1486
1487 EFI_STATUS
1488 EFIAPI
1489 VariableServiceInitialize (
1490   IN EFI_HANDLE         ImageHandle,
1491   IN EFI_SYSTEM_TABLE   *SystemTable
1492   )
1493 /*++
1494
1495 Routine Description:
1496   This function does initialization for variable services
1497
1498 Arguments:
1499
1500   ImageHandle   - The firmware allocated handle for the EFI image.
1501   SystemTable   - A pointer to the EFI System Table.
1502
1503 Returns:
1504
1505   Status code.
1506
1507   EFI_NOT_FOUND     - Variable store area not found.
1508   EFI_SUCCESS       - Variable services successfully initialized.
1509
1510 --*/
1511 {
1512   EFI_STATUS                      Status;
1513   EFI_HANDLE                      NewHandle;
1514   VS_DEV                          *Dev;
1515   EFI_PEI_HOB_POINTERS            GuidHob;
1516   VARIABLE_HEADER                 *Variable;
1517   VARIABLE_HEADER                 *NextVariable;
1518   VARIABLE_STORE_HEADER           *VariableStoreHeader;
1519   EFI_FLASH_MAP_FS_ENTRY_DATA     *FlashMapEntryData;
1520   EFI_FLASH_SUBAREA_ENTRY         VariableStoreEntry;
1521   UINT64                          BaseAddress;
1522   UINT64                          Length;
1523   EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
1524
1525   Status = gBS->AllocatePool (
1526                   EfiRuntimeServicesData,
1527                   (UINTN) sizeof (VARIABLE_GLOBAL),
1528                   (VOID**) &mGlobal
1529                   );
1530   if (EFI_ERROR (Status)) {
1531     return Status;
1532   }
1533
1534   ZeroMem (mGlobal, (UINTN) sizeof (VARIABLE_GLOBAL));
1535
1536   GuidHob.Raw = GetHobList ();
1537   FlashMapEntryData = NULL;
1538   while ((GuidHob.Raw = GetNextGuidHob (&gEfiFlashMapHobGuid, GuidHob.Raw)) != NULL) {
1539     FlashMapEntryData = (EFI_FLASH_MAP_FS_ENTRY_DATA *) GET_GUID_HOB_DATA (GuidHob.Guid);
1540     if (FlashMapEntryData->AreaType == EFI_FLASH_AREA_EFI_VARIABLES) {
1541       break;
1542     }
1543     GuidHob.Raw = GET_NEXT_HOB (GuidHob);
1544   }
1545
1546   if (FlashMapEntryData == NULL) {
1547     DEBUG ((EFI_D_ERROR, "FSVariable: Could not find flash area for variable!\n"));
1548     Status = EFI_NOT_FOUND;
1549     return Status;
1550   }
1551
1552   CopyMem(
1553     (VOID*)&VariableStoreEntry,
1554     (VOID*)&FlashMapEntryData->Entries[0],
1555     sizeof(EFI_FLASH_SUBAREA_ENTRY)
1556     );
1557
1558   //
1559   // Mark the variable storage region of the FLASH as RUNTIME
1560   //
1561   BaseAddress = VariableStoreEntry.Base & (~EFI_PAGE_MASK);
1562   Length      = VariableStoreEntry.Length + (VariableStoreEntry.Base - BaseAddress);
1563   Length      = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
1564   Status      = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
1565   if (EFI_ERROR (Status)) {
1566     Status = EFI_UNSUPPORTED;
1567     return Status;
1568   }
1569   Status = gDS->SetMemorySpaceAttributes (
1570                   BaseAddress,
1571                   Length,
1572                   GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME
1573                   );
1574   if (EFI_ERROR (Status)) {
1575     Status = EFI_UNSUPPORTED;
1576     return Status;
1577   }
1578
1579   Status = FileStorageConstructor (
1580              &mGlobal->VariableStore[NonVolatile],
1581              &mGlobal->GoVirtualChildEvent[NonVolatile],
1582              VariableStoreEntry.Base,
1583              (UINT32) VariableStoreEntry.Length,
1584              FlashMapEntryData->VolumeId,
1585              FlashMapEntryData->FilePath
1586              );
1587   ASSERT_EFI_ERROR (Status);
1588
1589   //
1590   // Volatile Storage
1591   //
1592   Status = MemStorageConstructor (
1593              &mGlobal->VariableStore[Volatile],
1594              &mGlobal->GoVirtualChildEvent[Volatile],
1595              VOLATILE_VARIABLE_STORE_SIZE
1596              );
1597   ASSERT_EFI_ERROR (Status);
1598
1599   //
1600   // Scratch
1601   //
1602   Status = gBS->AllocatePool (
1603                   EfiRuntimeServicesData,
1604                   VARIABLE_SCRATCH_SIZE,
1605                   &mGlobal->Scratch
1606                   );
1607   ASSERT_EFI_ERROR (Status);
1608
1609   //
1610   // 1. NV Storage
1611   //
1612   Dev = DEV_FROM_THIS (mGlobal->VariableStore[NonVolatile]);
1613   VariableStoreHeader = (VARIABLE_STORE_HEADER *) VAR_DATA_PTR (Dev);
1614   if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
1615     if (~VariableStoreHeader->Size == 0) {
1616       VariableStoreHeader->Size = (UINT32) VariableStoreEntry.Length;
1617     }
1618   }
1619   //
1620   // Calculate LastVariableOffset
1621   //
1622   Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1623   while (IsValidVariableHeader (Variable)) {
1624     UINTN VariableSize = 0;
1625     NextVariable = GetNextVariablePtr (Variable);
1626     VariableSize = NextVariable - Variable;
1627     if ((NextVariable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
1628       mGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VariableSize);
1629     } else {
1630       mGlobal->CommonVariableTotalSize += HEADER_ALIGN (VariableSize);
1631     }
1632     Variable = NextVariable;
1633   }
1634
1635   mGlobal->LastVariableOffset[NonVolatile] = (UINTN) Variable - (UINTN) VariableStoreHeader;
1636   mGlobal->VariableBase[NonVolatile]       = VariableStoreHeader;
1637
1638   //
1639   // Reclaim if remaining space is too small
1640   //
1641   if ((VariableStoreHeader->Size - mGlobal->LastVariableOffset[NonVolatile]) < VARIABLE_RECLAIM_THRESHOLD) {
1642     Status = Reclaim (NonVolatile, NULL);
1643     if (EFI_ERROR (Status)) {
1644       //
1645       // Reclaim error
1646       // we cannot restore to original state
1647       //
1648       DEBUG ((EFI_D_ERROR, "FSVariable: Reclaim error (fatal error) - %r\n", Status));
1649       ASSERT_EFI_ERROR (Status);
1650     }
1651   }
1652
1653   //
1654   // 2. Volatile Storage
1655   //
1656   Dev = DEV_FROM_THIS (mGlobal->VariableStore[Volatile]);
1657   VariableStoreHeader = (VARIABLE_STORE_HEADER *) VAR_DATA_PTR (Dev);
1658   mGlobal->VariableBase[Volatile] = VAR_DATA_PTR (Dev);
1659   mGlobal->LastVariableOffset[Volatile] = sizeof (VARIABLE_STORE_HEADER);
1660   //
1661   // init store_header & body in memory.
1662   //
1663   mGlobal->VariableStore[Volatile]->Erase (mGlobal->VariableStore[Volatile]);
1664   mGlobal->VariableStore[Volatile]->Write (
1665                                    mGlobal->VariableStore[Volatile],
1666                                    0,
1667                                    sizeof (VARIABLE_STORE_HEADER),
1668                                    &mStoreHeaderTemplate
1669                                    );
1670
1671
1672   SystemTable->RuntimeServices->GetVariable         = DuetGetVariable;
1673   SystemTable->RuntimeServices->GetNextVariableName = GetNextVariableName;
1674   SystemTable->RuntimeServices->SetVariable         = SetVariable;
1675
1676   SystemTable->RuntimeServices->QueryVariableInfo   = QueryVariableInfo;
1677
1678   //
1679   // Now install the Variable Runtime Architectural Protocol on a new handle
1680   //
1681   NewHandle = NULL;
1682   Status = gBS->InstallMultipleProtocolInterfaces (
1683                   &NewHandle,
1684                   &gEfiVariableArchProtocolGuid,
1685                   NULL,
1686                   &gEfiVariableWriteArchProtocolGuid,
1687                   NULL,
1688                   NULL
1689                   );
1690   ASSERT_EFI_ERROR (Status);
1691
1692   return Status;
1693 }
1694
1695
1696
1697 VOID
1698 EFIAPI
1699 OnVirtualAddressChangeFsv (
1700   IN EFI_EVENT        Event,
1701   IN VOID             *Context
1702   )
1703 {
1704   UINTN Index;
1705
1706   for (Index = 0; Index < MaxType; Index++) {
1707     mGlobal->GoVirtualChildEvent[Index] (Event, mGlobal->VariableStore[Index]);
1708     EfiConvertPointer (0, (VOID**) &mGlobal->VariableStore[Index]);
1709     EfiConvertPointer (0, &mGlobal->VariableBase[Index]);
1710   }
1711   EfiConvertPointer (0, &mGlobal->Scratch);
1712   EfiConvertPointer (0, (VOID**) &mGlobal);
1713 }