MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c

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