MdeModulePkg: Move to new location

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Guo Mang <mang.guo@intel.com>

31 files changed, 0 insertions, 13724 deletions

diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c
deleted file mode 100644
index 27ea1496a0..0000000000
--- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c
+++ /dev/null
@@ -1,1789 +0,0 @@
-/** @file

-

-  Emulation Variable services operate on the runtime volatile memory.

-  The nonvolatile variable space doesn't exist.

-

-Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-///

-/// Don't use module globals after the SetVirtualAddress map is signaled

-///

-ESAL_VARIABLE_GLOBAL  *mVariableModuleGlobal;

-

-VARIABLE_INFO_ENTRY *gVariableInfo = NULL;

-

-///

-/// The size of a 3 character ISO639 language code.

-///

-#define ISO_639_2_ENTRY_SIZE    3

-

-/**

-  Update the variable region with Variable information. These are the same 

-  arguments as the EFI Variable services.

-

-  @param[in] VariableName       Name of variable

-

-  @param[in] VendorGuid         Guid of variable

-

-  @param[in] Data               Variable data

-

-  @param[in] DataSize           Size of data. 0 means delete

-

-  @param[in] Attributes 	      Attribues of the variable

-

-  @param[in] Variable           The variable information which is used to keep track of variable usage.

-

-  @retval EFI_SUCCESS           The update operation is success.

-

-  @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.

-

-**/

-EFI_STATUS

-EFIAPI

-UpdateVariable (

-  IN      CHAR16                 *VariableName,

-  IN      EFI_GUID               *VendorGuid,

-  IN      VOID                   *Data,

-  IN      UINTN                  DataSize,

-  IN      UINT32                 Attributes OPTIONAL,

-  IN      VARIABLE_POINTER_TRACK *Variable

-  );

-

-/**

-  Finds variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-  Otherwise, VariableName and VendorGuid are compared.

-

-  @param  VariableName                Name of the variable to be found.

-  @param  VendorGuid                  Vendor GUID to be found.

-  @param  PtrTrack                    VARIABLE_POINTER_TRACK structure for output,

-                                      including the range searched and the target position.

-  @param  Global                      Pointer to VARIABLE_GLOBAL structure, including

-                                      base of volatile variable storage area, base of

-                                      NV variable storage area, and a lock.

-

-  @retval EFI_INVALID_PARAMETER       If VariableName is not an empty string, while

-                                      VendorGuid is NULL.

-  @retval EFI_SUCCESS                 Variable successfully found.

-  @retval EFI_NOT_FOUND               Variable not found.

-

-**/

-EFI_STATUS

-FindVariable (

-  IN  CHAR16                  *VariableName,

-  IN  EFI_GUID                *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK  *PtrTrack,

-  IN  VARIABLE_GLOBAL         *Global

-  );

-

-/**

-  Acquires lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function which will be removed when

-  EfiAcquireLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiAcquireLock() at boot time, and simply returns

-  at runtime

-

-  @param  Lock         A pointer to the lock to acquire

-

-**/

-VOID

-AcquireLockOnlyAtBootTime (

-  IN EFI_LOCK  *Lock

-  )

-{

-  if (!EfiAtRuntime ()) {

-    EfiAcquireLock (Lock);

-  }

-}

-

-/**

-  Releases lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function which will be removed when

-  EfiReleaseLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiReleaseLock() at boot time, and simply returns

-  at runtime

-

-  @param  Lock         A pointer to the lock to release

-

-**/

-VOID

-ReleaseLockOnlyAtBootTime (

-  IN EFI_LOCK  *Lock

-  )

-{

-  if (!EfiAtRuntime ()) {

-    EfiReleaseLock (Lock);

-  }

-}

-

-/**

-  Gets pointer to the variable data.

-

-  This function gets the pointer to the variable data according

-  to the input pointer to the variable header.

-

-  @param  Variable      Pointer to the variable header.

-

-  @return Pointer to variable data

-

-**/

-UINT8 *

-GetVariableDataPtr (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  if (Variable->StartId != VARIABLE_DATA) {

-    return NULL;

-  }

-  //

-  // Be careful about pad size for alignment

-  //

-  return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));

-}

-

-/**

-  Gets pointer to header of the next potential variable.

-

-  This function gets the pointer to the next potential variable header

-  according to the input point to the variable header.  The return value

-  is not a valid variable if the input variable was the last variable

-  in the variabl store.

-

-  @param  Variable      Pointer to header of the next variable

-

-  @return Pointer to next variable header.

-  @retval NULL  Input was not a valid variable header.

-

-**/

-VARIABLE_HEADER *

-GetNextPotentialVariablePtr (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  VARIABLE_HEADER *VarHeader;

-

-  if (Variable->StartId != VARIABLE_DATA) {

-    return NULL;

-  }

-  //

-  // Be careful about pad size for alignment

-  //

-  VarHeader = (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));

-

-  return VarHeader;

-}

-

-/**

-  Gets pointer to header of the next variable.

-

-  This function gets the pointer to the next variable header according

-  to the input point to the variable header.

-

-  @param  Variable      Pointer to header of the next variable

-

-  @return Pointer to next variable header.

-

-**/

-VARIABLE_HEADER *

-GetNextVariablePtr (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  VARIABLE_HEADER *VarHeader;

-

-  VarHeader = GetNextPotentialVariablePtr (Variable);

-

-  if ((VarHeader == NULL) || (VarHeader->StartId != VARIABLE_DATA)) {

-    return NULL;

-  }

-

-  return VarHeader;

-}

-

-/**

-  Updates LastVariableOffset variable for the given variable store.

-

-  LastVariableOffset points to the offset to use for the next variable

-  when updating the variable store.

-

-  @param[in]   VariableStore       Pointer to the start of the variable store

-  @param[out]  LastVariableOffset  Offset to put the next new variable in

-

-**/

-VOID

-InitializeLocationForLastVariableOffset (

-  IN  VARIABLE_STORE_HEADER *VariableStore,

-  OUT UINTN                 *LastVariableOffset

-  )

-{

-  VARIABLE_HEADER *VarHeader;

-

-  *LastVariableOffset       = sizeof (VARIABLE_STORE_HEADER);

-  VarHeader = (VARIABLE_HEADER*) ((UINT8*)VariableStore + *LastVariableOffset);

-  while (VarHeader->StartId == VARIABLE_DATA) {

-    VarHeader = GetNextPotentialVariablePtr (VarHeader);

-

-    if (VarHeader != NULL) {

-      *LastVariableOffset = (UINTN) VarHeader - (UINTN) VariableStore;

-    } else {

-      return;

-    }

-  }

-}

-

-/**

-  Gets pointer to the end of the variable storage area.

-

-  This function gets pointer to the end of the variable storage

-  area, according to the input variable store header.

-

-  @param  VolHeader     Pointer to the variale store header

-

-  @return Pointer to the end of the variable storage area.

-

-**/

-VARIABLE_HEADER *

-GetEndPointer (

-  IN VARIABLE_STORE_HEADER       *VolHeader

-  )

-{

-  //

-  // The end of variable store

-  //

-  return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VolHeader + VolHeader->Size);

-}

-

-/**

-  Routine used to track statistical information about variable usage. 

-  The data is stored in the EFI system table so it can be accessed later.

-  VariableInfo.efi can dump out the table. Only Boot Services variable 

-  accesses are tracked by this code. The PcdVariableCollectStatistics

-  build flag controls if this feature is enabled. 

-

-  A read that hits in the cache will have Read and Cache true for 

-  the transaction. Data is allocated by this routine, but never

-  freed.

-

-  @param[in] VariableName   Name of the Variable to track

-  @param[in] VendorGuid     Guid of the Variable to track

-  @param[in] Volatile       TRUE if volatile FALSE if non-volatile

-  @param[in] Read           TRUE if GetVariable() was called

-  @param[in] Write          TRUE if SetVariable() was called

-  @param[in] Delete         TRUE if deleted via SetVariable()

-  @param[in] Cache          TRUE for a cache hit.

-

-**/

-VOID

-UpdateVariableInfo (

-  IN  CHAR16                  *VariableName,

-  IN  EFI_GUID                *VendorGuid,

-  IN  BOOLEAN                 Volatile,

-  IN  BOOLEAN                 Read,

-  IN  BOOLEAN                 Write,

-  IN  BOOLEAN                 Delete,

-  IN  BOOLEAN                 Cache

-  )

-{

-  VARIABLE_INFO_ENTRY   *Entry;

-

-  if (FeaturePcdGet (PcdVariableCollectStatistics)) {

-

-    if (EfiAtRuntime ()) {

-      // Don't collect statistics at runtime

-      return;

-    }

-

-    if (gVariableInfo == NULL) {

-      //

-      // on the first call allocate a entry and place a pointer to it in

-      // the EFI System Table

-      //

-      gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));

-      ASSERT (gVariableInfo != NULL);

-

-      CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);

-      gVariableInfo->Name = AllocateZeroPool (StrSize (VariableName));

-      ASSERT (gVariableInfo->Name != NULL);

-      StrCpyS (gVariableInfo->Name, StrSize(VariableName)/sizeof(CHAR16), VariableName);

-      gVariableInfo->Volatile = Volatile;

-

-      gBS->InstallConfigurationTable (&gEfiVariableGuid, gVariableInfo);

-    }

-

-    

-    for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) {

-      if (CompareGuid (VendorGuid, &Entry->VendorGuid)) {

-        if (StrCmp (VariableName, Entry->Name) == 0) {

-          if (Read) {

-            Entry->ReadCount++;

-          }

-          if (Write) {

-            Entry->WriteCount++;

-          }

-          if (Delete) {

-            Entry->DeleteCount++;

-          }

-          if (Cache) {

-            Entry->CacheCount++;

-          }

-

-          return;

-        }

-      }

-

-      if (Entry->Next == NULL) {

-        //

-        // If the entry is not in the table add it.

-        // Next iteration of the loop will fill in the data

-        //

-        Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));

-        ASSERT (Entry->Next != NULL);

-

-        CopyGuid (&Entry->Next->VendorGuid, VendorGuid);

-        Entry->Next->Name = AllocateZeroPool (StrSize (VariableName));

-        ASSERT (Entry->Next->Name != NULL);

-        StrCpyS (Entry->Next->Name, StrSize(VariableName)/sizeof(CHAR16), VariableName);

-        Entry->Next->Volatile = Volatile;

-      }

-

-    }

-  }

-}

-

-/**

-  Get index from supported language codes according to language string.

-

-  This code is used to get corresponding index in supported language codes. It can handle

-  RFC4646 and ISO639 language tags.

-  In ISO639 language tags, take 3-characters as a delimitation to find matched string and calculate the index.

-  In RFC4646 language tags, take semicolon as a delimitation to find matched string and calculate the index.

-

-  For example:

-    SupportedLang  = "engfraengfra"

-    Lang           = "eng"

-    Iso639Language = TRUE

-  The return value is "0".

-  Another example:

-    SupportedLang  = "en;fr;en-US;fr-FR"

-    Lang           = "fr-FR"

-    Iso639Language = FALSE

-  The return value is "3".

-

-  @param  SupportedLang               Platform supported language codes.

-  @param  Lang                        Configured language.

-  @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.

-

-  @retval the index of language in the language codes.

-

-**/

-UINTN

-GetIndexFromSupportedLangCodes(

-  IN  CHAR8            *SupportedLang,

-  IN  CHAR8            *Lang,

-  IN  BOOLEAN          Iso639Language

-  ) 

-{

-  UINTN    Index;

-  UINTN    CompareLength;

-  UINTN    LanguageLength;

-

-  if (Iso639Language) {

-    CompareLength = ISO_639_2_ENTRY_SIZE;

-    for (Index = 0; Index < AsciiStrLen (SupportedLang); Index += CompareLength) {

-      if (AsciiStrnCmp (Lang, SupportedLang + Index, CompareLength) == 0) {

-        //

-        // Successfully find the index of Lang string in SupportedLang string.

-        //

-        Index = Index / CompareLength;

-        return Index;

-      }

-    }

-    ASSERT (FALSE);

-    return 0;

-  } else {

-    //

-    // Compare RFC4646 language code

-    //

-    Index = 0;

-    for (LanguageLength = 0; Lang[LanguageLength] != '\0'; LanguageLength++);

-

-    for (Index = 0; *SupportedLang != '\0'; Index++, SupportedLang += CompareLength) {

-      //

-      // Skip ';' characters in SupportedLang

-      //

-      for (; *SupportedLang != '\0' && *SupportedLang == ';'; SupportedLang++);

-      //

-      // Determine the length of the next language code in SupportedLang

-      //

-      for (CompareLength = 0; SupportedLang[CompareLength] != '\0' && SupportedLang[CompareLength] != ';'; CompareLength++);

-      

-      if ((CompareLength == LanguageLength) && 

-          (AsciiStrnCmp (Lang, SupportedLang, CompareLength) == 0)) {

-        //

-        // Successfully find the index of Lang string in SupportedLang string.

-        //

-        return Index;

-      }

-    }

-    ASSERT (FALSE);

-    return 0;

-  }

-}

-

-/**

-  Get language string from supported language codes according to index.

-

-  This code is used to get corresponding language string in supported language codes. It can handle

-  RFC4646 and ISO639 language tags.

-  In ISO639 language tags, take 3-characters as a delimitation. Find language string according to the index.

-  In RFC4646 language tags, take semicolon as a delimitation. Find language string according to the index.

-

-  For example:

-    SupportedLang  = "engfraengfra"

-    Index          = "1"

-    Iso639Language = TRUE

-  The return value is "fra".

-  Another example:

-    SupportedLang  = "en;fr;en-US;fr-FR"

-    Index          = "1"

-    Iso639Language = FALSE

-  The return value is "fr".

-

-  @param  SupportedLang               Platform supported language codes.

-  @param  Index                       the index in supported language codes.

-  @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.

-

-  @retval the language string in the language codes.

-

-**/

-CHAR8 *

-GetLangFromSupportedLangCodes (

-  IN  CHAR8            *SupportedLang,

-  IN  UINTN            Index,

-  IN  BOOLEAN          Iso639Language

-)

-{

-  UINTN    SubIndex;

-  UINTN    CompareLength;

-  CHAR8    *Supported;

-

-  SubIndex  = 0;

-  Supported = SupportedLang;

-  if (Iso639Language) {

-    //

-    // according to the index of Lang string in SupportedLang string to get the language.

-    // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.

-    // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.

-    //

-    CompareLength = ISO_639_2_ENTRY_SIZE;

-    mVariableModuleGlobal->Lang[CompareLength] = '\0';

-    return CopyMem (mVariableModuleGlobal->Lang, SupportedLang + Index * CompareLength, CompareLength);

-

-  } else {

-    while (TRUE) {

-      //

-      // take semicolon as delimitation, sequentially traverse supported language codes.

-      //

-      for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {

-        Supported++;

-      }

-      if ((*Supported == '\0') && (SubIndex != Index)) {

-        //

-        // Have completed the traverse, but not find corrsponding string.

-        // This case is not allowed to happen.

-        //

-        ASSERT(FALSE);

-        return NULL;

-      }

-      if (SubIndex == Index) {

-        //

-        // according to the index of Lang string in SupportedLang string to get the language.

-        // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.

-        // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.

-        //

-        mVariableModuleGlobal->PlatformLang[CompareLength] = '\0';

-        return CopyMem (mVariableModuleGlobal->PlatformLang, Supported - CompareLength, CompareLength);

-      }

-      SubIndex++;

-      

-      //

-      // Skip ';' characters in Supported

-      //

-      for (; *Supported != '\0' && *Supported == ';'; Supported++);

-    }

-  }

-}

-

-/**

-  Returns a pointer to an allocated buffer that contains the best matching language 

-  from a set of supported languages.  

-  

-  This function supports both ISO 639-2 and RFC 4646 language codes, but language 

-  code types may not be mixed in a single call to this function. This function

-  supports a variable argument list that allows the caller to pass in a prioritized

-  list of language codes to test against all the language codes in SupportedLanguages.

-

-  If SupportedLanguages is NULL, then ASSERT().

-

-  @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string that

-                                  contains a set of language codes in the format 

-                                  specified by Iso639Language.

-  @param[in]  Iso639Language      If TRUE, then all language codes are assumed to be

-                                  in ISO 639-2 format.  If FALSE, then all language

-                                  codes are assumed to be in RFC 4646 language format

-  @param[in]  ...                 A variable argument list that contains pointers to 

-                                  Null-terminated ASCII strings that contain one or more

-                                  language codes in the format specified by Iso639Language.

-                                  The first language code from each of these language

-                                  code lists is used to determine if it is an exact or

-                                  close match to any of the language codes in 

-                                  SupportedLanguages.  Close matches only apply to RFC 4646

-                                  language codes, and the matching algorithm from RFC 4647

-                                  is used to determine if a close match is present.  If 

-                                  an exact or close match is found, then the matching

-                                  language code from SupportedLanguages is returned.  If

-                                  no matches are found, then the next variable argument

-                                  parameter is evaluated.  The variable argument list 

-                                  is terminated by a NULL.

-

-  @retval NULL   The best matching language could not be found in SupportedLanguages.

-  @retval NULL   There are not enough resources available to return the best matching 

-                 language.

-  @retval Other  A pointer to a Null-terminated ASCII string that is the best matching 

-                 language in SupportedLanguages.

-

-**/

-CHAR8 *

-EFIAPI

-VariableGetBestLanguage (

-  IN CONST CHAR8  *SupportedLanguages, 

-  IN BOOLEAN      Iso639Language,

-  ...

-  )

-{

-  VA_LIST      Args;

-  CHAR8        *Language;

-  UINTN        CompareLength;

-  UINTN        LanguageLength;

-  CONST CHAR8  *Supported;

-  CHAR8        *Buffer;

-

-  ASSERT (SupportedLanguages != NULL);

-

-  VA_START (Args, Iso639Language);

-  while ((Language = VA_ARG (Args, CHAR8 *)) != NULL) {

-    //

-    // Default to ISO 639-2 mode

-    //

-    CompareLength  = 3;

-    LanguageLength = MIN (3, AsciiStrLen (Language));

-

-    //

-    // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language

-    //

-    if (!Iso639Language) {

-      for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);

-    }

-

-    //

-    // Trim back the length of Language used until it is empty

-    //

-    while (LanguageLength > 0) {

-      //

-      // Loop through all language codes in SupportedLanguages

-      //

-      for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {

-        //

-        // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages

-        //

-        if (!Iso639Language) {

-          //

-          // Skip ';' characters in Supported

-          //

-          for (; *Supported != '\0' && *Supported == ';'; Supported++);

-          //

-          // Determine the length of the next language code in Supported

-          //

-          for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);

-          //

-          // If Language is longer than the Supported, then skip to the next language

-          //

-          if (LanguageLength > CompareLength) {

-            continue;

-          }

-        }

-        //

-        // See if the first LanguageLength characters in Supported match Language

-        //

-        if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {

-          VA_END (Args);

-

-          Buffer = Iso639Language ? mVariableModuleGlobal->Lang : mVariableModuleGlobal->PlatformLang;

-          Buffer[CompareLength] = '\0';

-          return CopyMem (Buffer, Supported, CompareLength);

-        }

-      }

-

-      if (Iso639Language) {

-        //

-        // If ISO 639 mode, then each language can only be tested once

-        //

-        LanguageLength = 0;

-      } else {

-        //

-        // If RFC 4646 mode, then trim Language from the right to the next '-' character 

-        //

-        for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);

-      }

-    }

-  }

-  VA_END (Args);

-

-  //

-  // No matches were found 

-  //

-  return NULL;

-}

-

-/**

-  Hook the operations in PlatformLangCodes, LangCodes, PlatformLang and Lang.

-

-  When setting Lang/LangCodes, simultaneously update PlatformLang/PlatformLangCodes.

-

-  According to UEFI spec, PlatformLangCodes/LangCodes are only set once in firmware initialization,

-  and are read-only. Therefore, in variable driver, only store the original value for other use.

-

-  @param[in] VariableName       Name of variable

-

-  @param[in] Data               Variable data

-

-  @param[in] DataSize           Size of data. 0 means delete

-

-**/

-VOID

-AutoUpdateLangVariable(

-  IN  CHAR16             *VariableName,

-  IN  VOID               *Data,

-  IN  UINTN              DataSize

-  )

-{

-  EFI_STATUS             Status;

-  CHAR8                  *BestPlatformLang;

-  CHAR8                  *BestLang;

-  UINTN                  Index;

-  UINT32                 Attributes;

-  VARIABLE_POINTER_TRACK Variable;

-  BOOLEAN                SetLanguageCodes;

-

-  //

-  // Don't do updates for delete operation

-  //

-  if (DataSize == 0) {

-    return;

-  }

-

-  SetLanguageCodes = FALSE;

-

-  if (StrCmp (VariableName, L"PlatformLangCodes") == 0) {

-    //

-    // PlatformLangCodes is a volatile variable, so it can not be updated at runtime.

-    //

-    if (EfiAtRuntime ()) {

-      return;

-    }

-

-    SetLanguageCodes = TRUE;

-

-    //

-    // According to UEFI spec, PlatformLangCodes is only set once in firmware initialization, and is read-only

-    // Therefore, in variable driver, only store the original value for other use.

-    //

-    if (mVariableModuleGlobal->PlatformLangCodes != NULL) {

-      FreePool (mVariableModuleGlobal->PlatformLangCodes);

-    }

-    mVariableModuleGlobal->PlatformLangCodes = AllocateRuntimeCopyPool (DataSize, Data);

-    ASSERT (mVariableModuleGlobal->PlatformLangCodes != NULL);

-

-    //

-    // PlatformLang holds a single language from PlatformLangCodes, 

-    // so the size of PlatformLangCodes is enough for the PlatformLang.

-    //

-    if (mVariableModuleGlobal->PlatformLang != NULL) {

-      FreePool (mVariableModuleGlobal->PlatformLang);

-    }

-    mVariableModuleGlobal->PlatformLang = AllocateRuntimePool (DataSize);

-    ASSERT (mVariableModuleGlobal->PlatformLang != NULL);

-

-  } else if (StrCmp (VariableName, L"LangCodes") == 0) {

-    //

-    // LangCodes is a volatile variable, so it can not be updated at runtime.

-    //

-    if (EfiAtRuntime ()) {

-      return;

-    }

-

-    SetLanguageCodes = TRUE;

-

-    //

-    // According to UEFI spec, LangCodes is only set once in firmware initialization, and is read-only

-    // Therefore, in variable driver, only store the original value for other use.

-    //

-    if (mVariableModuleGlobal->LangCodes != NULL) {

-      FreePool (mVariableModuleGlobal->LangCodes);

-    }

-    mVariableModuleGlobal->LangCodes = AllocateRuntimeCopyPool (DataSize, Data);

-    ASSERT (mVariableModuleGlobal->LangCodes != NULL);

-  }

-

-  if (SetLanguageCodes 

-      && (mVariableModuleGlobal->PlatformLangCodes != NULL)

-      && (mVariableModuleGlobal->LangCodes != NULL)) {

-    //

-    // Update Lang if PlatformLang is already set

-    // Update PlatformLang if Lang is already set

-    //

-    Status = FindVariable (L"PlatformLang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *) mVariableModuleGlobal);

-    if (!EFI_ERROR (Status)) {

-      //

-      // Update Lang

-      //

-      VariableName = L"PlatformLang";

-      Data         = GetVariableDataPtr (Variable.CurrPtr);

-      DataSize     = Variable.CurrPtr->DataSize;

-    } else {

-      Status = FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *) mVariableModuleGlobal);

-      if (!EFI_ERROR (Status)) {

-        //

-        // Update PlatformLang

-        //

-        VariableName = L"Lang";

-        Data         = GetVariableDataPtr (Variable.CurrPtr);

-        DataSize     = Variable.CurrPtr->DataSize;

-      } else {

-        //

-        // Neither PlatformLang nor Lang is set, directly return

-        //

-        return;

-      }

-    }

-  }

-  

-  //

-  // According to UEFI spec, "Lang" and "PlatformLang" is NV|BS|RT attributions.

-  //

-  Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;

-

-  if (StrCmp (VariableName, L"PlatformLang") == 0) {

-    //

-    // Update Lang when PlatformLangCodes/LangCodes were set.

-    //

-    if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {

-      //

-      // When setting PlatformLang, firstly get most matched language string from supported language codes.

-      //

-      BestPlatformLang = VariableGetBestLanguage (mVariableModuleGlobal->PlatformLangCodes, FALSE, Data, NULL);

-      if (BestPlatformLang != NULL) {

-        //

-        // Get the corresponding index in language codes.

-        //

-        Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, BestPlatformLang, FALSE);

-

-        //

-        // Get the corresponding ISO639 language tag according to RFC4646 language tag.

-        //

-        BestLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, Index, TRUE);

-

-        //

-        // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.

-        //

-        FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *)mVariableModuleGlobal);

-

-        Status = UpdateVariable (L"Lang", &gEfiGlobalVariableGuid, BestLang, ISO_639_2_ENTRY_SIZE + 1, Attributes, &Variable);

-

-        DEBUG ((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a\n", BestPlatformLang, BestLang));

-

-        ASSERT_EFI_ERROR(Status);

-      }

-    }

-

-  } else if (StrCmp (VariableName, L"Lang") == 0) {

-    //

-    // Update PlatformLang when PlatformLangCodes/LangCodes were set.

-    //

-    if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {

-      //

-      // When setting Lang, firstly get most matched language string from supported language codes.

-      //

-      BestLang = VariableGetBestLanguage (mVariableModuleGlobal->LangCodes, TRUE, Data, NULL);

-      if (BestLang != NULL) {

-        //

-        // Get the corresponding index in language codes.

-        //

-        Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, BestLang, TRUE);

-

-        //

-        // Get the corresponding RFC4646 language tag according to ISO639 language tag.

-        //

-        BestPlatformLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, Index, FALSE);

-

-        //

-        // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.

-        //

-        FindVariable (L"PlatformLang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *)mVariableModuleGlobal);

-

-        Status = UpdateVariable (L"PlatformLang", &gEfiGlobalVariableGuid, BestPlatformLang, 

-                                 AsciiStrSize (BestPlatformLang), Attributes, &Variable);

-

-        DEBUG ((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a\n", BestLang, BestPlatformLang));

-        ASSERT_EFI_ERROR (Status);

-      }

-    }

-  }

-}

-

-/**

-  Update the variable region with Variable information. These are the same 

-  arguments as the EFI Variable services.

-

-  @param[in] VariableName       Name of variable

-

-  @param[in] VendorGuid         Guid of variable

-

-  @param[in] Data               Variable data

-

-  @param[in] DataSize           Size of data. 0 means delete

-

-  @param[in] Attributes         Attribues of the variable

-

-  @param[in] Variable           The variable information which is used to keep track of variable usage.

-

-  @retval EFI_SUCCESS           The update operation is success.

-

-  @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.

-

-**/

-EFI_STATUS

-EFIAPI

-UpdateVariable (

-  IN      CHAR16          *VariableName,

-  IN      EFI_GUID        *VendorGuid,

-  IN      VOID            *Data,

-  IN      UINTN           DataSize,

-  IN      UINT32          Attributes OPTIONAL,

-  IN      VARIABLE_POINTER_TRACK *Variable

-  )

-{

-  EFI_STATUS              Status;

-  VARIABLE_HEADER         *NextVariable;

-  UINTN                   VarNameSize;

-  UINTN                   VarNameOffset;

-  UINTN                   VarDataOffset;

-  UINTN                   VarSize;

-  VARIABLE_GLOBAL         *Global;

-  UINTN                   NonVolatileVarableStoreSize;

-

-  Global = &mVariableModuleGlobal->VariableGlobal[Physical];

-

-  if (Variable->CurrPtr != NULL) {

-    //

-    // Update/Delete existing variable

-    //

-

-    if (EfiAtRuntime ()) {        

-      //

-      // If EfiAtRuntime and the variable is Volatile and Runtime Access,  

-      // the volatile is ReadOnly, and SetVariable should be aborted and 

-      // return EFI_WRITE_PROTECTED.

-      //

-      if (Variable->Volatile) {

-        Status = EFI_WRITE_PROTECTED;

-        goto Done;

-      }

-      //

-      // Only variable have NV attribute can be updated/deleted in Runtime

-      //

-      if ((Variable->CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {

-        Status = EFI_INVALID_PARAMETER;

-        goto Done;

-      }

-    }

-

-    //

-    // Setting a data variable with no access, or zero DataSize attributes

-    // specified causes it to be deleted.

-    //

-    if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {

-      Variable->CurrPtr->State &= VAR_DELETED;

-      UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, FALSE, TRUE, FALSE);

-      Status = EFI_SUCCESS;

-      goto Done;

-    }

-

-    //

-    // If the variable is marked valid and the same data has been passed in

-    // then return to the caller immediately.

-    //

-    if (Variable->CurrPtr->DataSize == DataSize &&

-        CompareMem (Data, GetVariableDataPtr (Variable->CurrPtr), DataSize) == 0

-          ) {

-      Status = EFI_SUCCESS;

-      goto Done;

-    } else if (Variable->CurrPtr->State == VAR_ADDED) {

-      //

-      // Mark the old variable as in delete transition

-      //

-      Variable->CurrPtr->State &= VAR_IN_DELETED_TRANSITION;

-    }

-    

-  } else {

-    //

-    // No found existing variable, Create a new variable

-    //  

-    

-    //

-    // Make sure we are trying to create a new variable.

-    // Setting a data variable with no access, or zero DataSize attributes means to delete it.    

-    //

-    if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {

-      Status = EFI_NOT_FOUND;

-      goto Done;

-    }

-        

-    //

-    // Only variable have NV|RT attribute can be created in Runtime

-    //

-    if (EfiAtRuntime () &&

-        (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0))) {

-      Status = EFI_INVALID_PARAMETER;

-      goto Done;

-    }         

-  }

-  

-  //

-  // Function part - create a new variable and copy the data.

-  // Both update a variable and create a variable will come here.

-  //

-  

-  VarNameOffset = sizeof (VARIABLE_HEADER);

-  VarNameSize   = StrSize (VariableName);

-  VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);

-  VarSize       = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);

-

-  if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {

-    NonVolatileVarableStoreSize = ((VARIABLE_STORE_HEADER *)(UINTN)(Global->NonVolatileVariableBase))->Size;

-    if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) 

-      && ((HEADER_ALIGN (VarSize) + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))

-      || (((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0) 

-      && ((HEADER_ALIGN (VarSize) + mVariableModuleGlobal->CommonVariableTotalSize) > NonVolatileVarableStoreSize - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize)))) {

-      Status = EFI_OUT_OF_RESOURCES;

-      goto Done;

-    }

-

-    NextVariable  = (VARIABLE_HEADER *) (UINT8 *) (mVariableModuleGlobal->NonVolatileLastVariableOffset

-                      + (UINTN) Global->NonVolatileVariableBase);

-    mVariableModuleGlobal->NonVolatileLastVariableOffset += HEADER_ALIGN (VarSize);

-

-    if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {

-      mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VarSize);

-    } else {

-      mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VarSize);

-    }

-  } else {

-    if ((UINT32) (HEADER_ALIGN (VarSize) + mVariableModuleGlobal->VolatileLastVariableOffset) >

-          ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size

-          ) {

-      Status = EFI_OUT_OF_RESOURCES;

-      goto Done;

-    }

-

-    NextVariable    = (VARIABLE_HEADER *) (UINT8 *) (mVariableModuleGlobal->VolatileLastVariableOffset

-                        + (UINTN) Global->VolatileVariableBase);

-    mVariableModuleGlobal->VolatileLastVariableOffset += HEADER_ALIGN (VarSize);

-  }

-

-  NextVariable->StartId     = VARIABLE_DATA;

-  NextVariable->Attributes  = Attributes;

-  NextVariable->State       = VAR_ADDED;

-  NextVariable->Reserved    = 0;

-

-  //

-  // There will be pad bytes after Data, the NextVariable->NameSize and

-  // NextVariable->NameSize should not include pad size so that variable

-  // service can get actual size in GetVariable

-  //

-  NextVariable->NameSize  = (UINT32)VarNameSize;

-  NextVariable->DataSize  = (UINT32)DataSize;

-

-  CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));

-  CopyMem (

-    (UINT8 *) ((UINTN) NextVariable + VarNameOffset),

-    VariableName,

-    VarNameSize

-    );

-  CopyMem (

-    (UINT8 *) ((UINTN) NextVariable + VarDataOffset),

-    Data,

-    DataSize

-    );

-

-  //

-  // Mark the old variable as deleted

-  //

-  if (Variable->CurrPtr != NULL) {

-    Variable->CurrPtr->State &= VAR_DELETED;

-  }

-

-  UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, TRUE, FALSE, FALSE);

-

-  Status = EFI_SUCCESS;

-

-Done:

-  return Status;

-}

-

-/**

-  Finds variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-  Otherwise, VariableName and VendorGuid are compared.

-

-  @param  VariableName                Name of the variable to be found.

-  @param  VendorGuid                  Vendor GUID to be found.

-  @param  PtrTrack                    VARIABLE_POINTER_TRACK structure for output,

-                                      including the range searched and the target position.

-  @param  Global                      Pointer to VARIABLE_GLOBAL structure, including

-                                      base of volatile variable storage area, base of

-                                      NV variable storage area, and a lock.

-

-  @retval EFI_INVALID_PARAMETER       If VariableName is not an empty string, while

-                                      VendorGuid is NULL.

-  @retval EFI_SUCCESS                 Variable successfully found.

-  @retval EFI_NOT_FOUND               Variable not found.

-

-**/

-EFI_STATUS

-FindVariable (

-  IN  CHAR16                  *VariableName,

-  IN  EFI_GUID                *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK  *PtrTrack,

-  IN  VARIABLE_GLOBAL         *Global

-  )

-{

-  VARIABLE_HEADER       *Variable[2];

-  VARIABLE_STORE_HEADER *VariableStoreHeader[2];

-  UINTN                 Index;

-

-  //

-  // 0: Non-Volatile, 1: Volatile

-  //

-  VariableStoreHeader[0]  = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);

-  VariableStoreHeader[1]  = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);

-

-  //

-  // Start Pointers for the variable.

-  // Actual Data Pointer where data can be written.

-  //

-  Variable[0] = (VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader[0] + 1);

-  Variable[1] = (VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader[1] + 1);

-

-  if (VariableName[0] != 0 && VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-  //

-  // Find the variable by walk through non-volatile and volatile variable store

-  //

-  for (Index = 0; Index < 2; Index++) {

-    PtrTrack->StartPtr  = (VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader[Index] + 1);

-    PtrTrack->EndPtr    = GetEndPointer (VariableStoreHeader[Index]);

-

-    while ((Variable[Index] < GetEndPointer (VariableStoreHeader[Index])) && (Variable[Index] != NULL)) {

-      if (Variable[Index]->StartId == VARIABLE_DATA && Variable[Index]->State == VAR_ADDED) {

-        if (!(EfiAtRuntime () && ((Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0))) {

-          if (VariableName[0] == 0) {

-            PtrTrack->CurrPtr   = Variable[Index];

-            PtrTrack->Volatile  = (BOOLEAN) Index;

-            return EFI_SUCCESS;

-          } else {

-            if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {

-              if (CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize) == 0) {

-                PtrTrack->CurrPtr   = Variable[Index];

-                PtrTrack->Volatile  = (BOOLEAN) Index;

-                return EFI_SUCCESS;

-              }

-            }

-          }

-        }

-      }

-

-      Variable[Index] = GetNextVariablePtr (Variable[Index]);

-    }

-  }

-  PtrTrack->CurrPtr = NULL;

-  return EFI_NOT_FOUND;

-}

-

-/**

-  This code finds variable in storage blocks (Volatile or Non-Volatile).

-  

-  @param  VariableName           A Null-terminated Unicode string that is the name of

-                                 the vendor's variable.

-  @param  VendorGuid             A unique identifier for the vendor.

-  @param  Attributes             If not NULL, a pointer to the memory location to return the 

-                                 attributes bitmask for the variable.

-  @param  DataSize               Size of Data found. If size is less than the

-                                 data, this value contains the required size.

-  @param  Data                   On input, the size in bytes of the return Data buffer.  

-                                 On output, the size of data returned in Data.

-  @param  Global                 Pointer to VARIABLE_GLOBAL structure

-

-  @retval EFI_SUCCESS            The function completed successfully. 

-  @retval EFI_NOT_FOUND          The variable was not found.

-  @retval EFI_BUFFER_TOO_SMALL   DataSize is too small for the result.  DataSize has 

-                                 been updated with the size needed to complete the request.

-  @retval EFI_INVALID_PARAMETER  VariableName or VendorGuid or DataSize is NULL.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuGetVariable (

-  IN      CHAR16            *VariableName,

-  IN      EFI_GUID          *VendorGuid,

-  OUT     UINT32            *Attributes OPTIONAL,

-  IN OUT  UINTN             *DataSize,

-  OUT     VOID              *Data,

-  IN      VARIABLE_GLOBAL   *Global

-  )

-{

-  VARIABLE_POINTER_TRACK  Variable;

-  UINTN                   VarDataSize;

-  EFI_STATUS              Status;

-  UINT8                   *VariableDataPtr;

-

-  if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (VariableName[0] == 0) {

-    return EFI_NOT_FOUND;

-  }

-

-  AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);

-

-  //

-  // Find existing variable

-  //

-  Status = FindVariable (VariableName, VendorGuid, &Variable, Global);

-

-  if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {

-    goto Done;

-  }

-  //

-  // Get data size

-  //

-  VarDataSize = Variable.CurrPtr->DataSize;

-  if (*DataSize >= VarDataSize) {

-    if (Data == NULL) {

-      Status = EFI_INVALID_PARAMETER;

-      goto Done;

-    }

-    VariableDataPtr = GetVariableDataPtr (Variable.CurrPtr);

-    ASSERT (VariableDataPtr != NULL);

-    

-    CopyMem (Data, VariableDataPtr, VarDataSize);

-    if (Attributes != NULL) {

-      *Attributes = Variable.CurrPtr->Attributes;

-    }

-

-    *DataSize = VarDataSize;

-    UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);

-    Status = EFI_SUCCESS;

-    goto Done;

-  } else {

-    *DataSize = VarDataSize;

-    Status = EFI_BUFFER_TOO_SMALL;

-    goto Done;

-  }

-

-Done:

-  ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);

-  return Status;

-}

-

-/**

-

-  This code Finds the Next available variable.

-

-  @param  VariableNameSize       Size of the variable.

-  @param  VariableName           On input, supplies the last VariableName that was returned by GetNextVariableName().

-                                 On output, returns the Null-terminated Unicode string of the current variable.

-  @param  VendorGuid             On input, supplies the last VendorGuid that was returned by GetNextVariableName().

-                                 On output, returns the VendorGuid of the current variable.  

-  @param  Global                 Pointer to VARIABLE_GLOBAL structure.

-

-  @retval EFI_SUCCESS            The function completed successfully. 

-  @retval EFI_NOT_FOUND          The next variable was not found.

-  @retval EFI_BUFFER_TOO_SMALL   VariableNameSize is too small for the result. 

-                                 VariableNameSize has been updated with the size needed to complete the request.

-  @retval EFI_INVALID_PARAMETER  VariableNameSize or VariableName or VendorGuid is NULL.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuGetNextVariableName (

-  IN OUT  UINTN             *VariableNameSize,

-  IN OUT  CHAR16            *VariableName,

-  IN OUT  EFI_GUID          *VendorGuid,

-  IN      VARIABLE_GLOBAL   *Global

-  )

-{

-  VARIABLE_POINTER_TRACK  Variable;

-  UINTN                   VarNameSize;

-  EFI_STATUS              Status;

-

-  if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);

-

-  Status = FindVariable (VariableName, VendorGuid, &Variable, Global);

-

-  if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  while (TRUE) {

-    if (VariableName[0] != 0) {

-      //

-      // If variable name is not NULL, get next variable

-      //

-      Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

-    }

-    //

-    // If both volatile and non-volatile variable store are parsed,

-    // return not found

-    //

-    if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {

-      Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));

-      if (Variable.Volatile) {

-        Variable.StartPtr = (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) (Global->VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));

-        Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase));

-      } else {

-        Status = EFI_NOT_FOUND;

-        goto Done;

-      }

-

-      Variable.CurrPtr = Variable.StartPtr;

-      if (Variable.CurrPtr->StartId != VARIABLE_DATA) {

-        continue;

-      }

-    }

-    //

-    // Variable is found

-    //

-    if (Variable.CurrPtr->StartId == VARIABLE_DATA && Variable.CurrPtr->State == VAR_ADDED) {

-      if (!(EfiAtRuntime () && ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0))) {

-        VarNameSize = Variable.CurrPtr->NameSize;

-        if (VarNameSize <= *VariableNameSize) {

-          CopyMem (

-            VariableName,

-            GET_VARIABLE_NAME_PTR (Variable.CurrPtr),

-            VarNameSize

-            );

-          CopyMem (

-            VendorGuid,

-            &Variable.CurrPtr->VendorGuid,

-            sizeof (EFI_GUID)

-            );

-          Status = EFI_SUCCESS;

-        } else {

-          Status = EFI_BUFFER_TOO_SMALL;

-        }

-

-        *VariableNameSize = VarNameSize;

-        goto Done;

-      }

-    }

-  }

-

-Done:

-  ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);

-  return Status;

-

-}

-

-/**

-

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  @param  VariableName           A Null-terminated Unicode string that is the name of the vendor's

-                                 variable.  Each VariableName is unique for each 

-                                 VendorGuid.  VariableName must contain 1 or more 

-                                 Unicode characters.  If VariableName is an empty Unicode 

-                                 string, then EFI_INVALID_PARAMETER is returned.

-  @param  VendorGuid             A unique identifier for the vendor

-  @param  Attributes             Attributes bitmask to set for the variable

-  @param  DataSize               The size in bytes of the Data buffer.  A size of zero causes the

-                                 variable to be deleted.

-  @param  Data                   The contents for the variable

-  @param  Global                 Pointer to VARIABLE_GLOBAL structure

-  @param  VolatileOffset         The offset of last volatile variable

-  @param  NonVolatileOffset      The offset of last non-volatile variable

-

-  @retval EFI_SUCCESS            The firmware has successfully stored the variable and its data as 

-                                 defined by the Attributes.

-  @retval EFI_INVALID_PARAMETER  An invalid combination of attribute bits was supplied, or the 

-                                 DataSize exceeds the maximum allowed, or VariableName is an empty 

-                                 Unicode string, or VendorGuid is NULL.

-  @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.

-  @retval EFI_DEVICE_ERROR       The variable could not be saved due to a hardware failure.

-  @retval EFI_WRITE_PROTECTED    The variable in question is read-only or cannot be deleted.

-  @retval EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuSetVariable (

-  IN CHAR16                  *VariableName,

-  IN EFI_GUID                *VendorGuid,

-  IN UINT32                  Attributes,

-  IN UINTN                   DataSize,

-  IN VOID                    *Data,

-  IN VARIABLE_GLOBAL         *Global,

-  IN UINTN                   *VolatileOffset,

-  IN UINTN                   *NonVolatileOffset

-  )

-{

-  VARIABLE_POINTER_TRACK  Variable;

-  EFI_STATUS              Status;

-

-  //

-  // Check input parameters

-  //

-  if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }  

-

-  if (DataSize != 0 && Data == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  // Not support authenticated variable write yet.

-  //

-  if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  //  Make sure if runtime bit is set, boot service bit is set also

-  //

-  if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  

-  if ((UINTN)(~0) - DataSize < StrSize(VariableName)){

-    //

-    // Prevent whole variable size overflow 

-    // 

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  //  The size of the VariableName, including the Unicode Null in bytes plus

-  //  the DataSize is limited to maximum size of PcdGet32 (PcdMaxHardwareErrorVariableSize)

-  //  bytes for HwErrRec, and PcdGet32 (PcdMaxVariableSize) bytes for the others.

-  //

-  if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-    if (StrSize (VariableName) + DataSize > PcdGet32 (PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER)) {

-      return EFI_INVALID_PARAMETER;

-    }

-    //

-    // According to UEFI spec, HARDWARE_ERROR_RECORD variable name convention should be L"HwErrRecXXXX"

-    //

-    if (StrnCmp(VariableName, L"HwErrRec", StrLen(L"HwErrRec")) != 0) {

-      return EFI_INVALID_PARAMETER;

-    }

-  } else {

-  //

-  //  The size of the VariableName, including the Unicode Null in bytes plus

-  //  the DataSize is limited to maximum size of PcdGet32 (PcdMaxVariableSize) bytes.

-  //

-    if (StrSize (VariableName) + DataSize > PcdGet32 (PcdMaxVariableSize) - sizeof (VARIABLE_HEADER)) {

-      return EFI_INVALID_PARAMETER;

-    }  

-  }

-

-  AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);

-

-  //

-  // Check whether the input variable is already existed

-  //

-  

-  Status = FindVariable (VariableName, VendorGuid, &Variable, Global);

-

-  //

-  // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang

-  //

-  AutoUpdateLangVariable (VariableName, Data, DataSize);

-

-  Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, &Variable);

-

-  ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);

-  return Status;

-}

-

-/**

-

-  This code returns information about the EFI variables.

-

-  @param  Attributes                   Attributes bitmask to specify the type of variables

-                                       on which to return information.

-  @param  MaximumVariableStorageSize   On output the maximum size of the storage space available for 

-                                       the EFI variables associated with the attributes specified.  

-  @param  RemainingVariableStorageSize Returns the remaining size of the storage space available for EFI 

-                                       variables associated with the attributes specified.

-  @param  MaximumVariableSize          Returns the maximum size of an individual EFI variable 

-                                       associated with the attributes specified.

-  @param  Global                       Pointer to VARIABLE_GLOBAL structure.

-

-  @retval EFI_SUCCESS                  Valid answer returned.

-  @retval EFI_INVALID_PARAMETER        An invalid combination of attribute bits was supplied

-  @retval EFI_UNSUPPORTED              The attribute is not supported on this platform, and the 

-                                       MaximumVariableStorageSize, RemainingVariableStorageSize, 

-                                       MaximumVariableSize are undefined.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuQueryVariableInfo (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize,

-  IN  VARIABLE_GLOBAL        *Global

-  )

-{

-  VARIABLE_HEADER        *Variable;

-  VARIABLE_HEADER        *NextVariable;

-  UINT64                 VariableSize;

-  VARIABLE_STORE_HEADER  *VariableStoreHeader;

-  UINT64                 CommonVariableTotalSize;

-  UINT64                 HwErrVariableTotalSize;

-

-  CommonVariableTotalSize = 0;

-  HwErrVariableTotalSize = 0;

-

-  if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {

-    return EFI_INVALID_PARAMETER;

-  }

-  

-  if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {

-    //

-    // Make sure the Attributes combination is supported by the platform.

-    //

-    return EFI_UNSUPPORTED;  

-  } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {

-    //

-    // Make sure if runtime bit is set, boot service bit is set also.

-    //

-    return EFI_INVALID_PARAMETER;

-  } else if (EfiAtRuntime () && ((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) {

-    //

-    //   Make sure RT Attribute is set if we are in Runtime phase.

-    //

-    return EFI_INVALID_PARAMETER;

-  } else if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-    //

-    // Make sure Hw Attribute is set with NV.

-    //

-    return EFI_INVALID_PARAMETER;

-  } else if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {

-    //

-    // Not support authentiated variable write yet.

-    //

-    return EFI_UNSUPPORTED;

-  }

-

-  AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);

-

-  if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {

-    //

-    // Query is Volatile related.

-    //

-    VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);

-  } else {

-    //

-    // Query is Non-Volatile related.

-    //

-    VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);

-  }

-

-  //

-  // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize

-  // with the storage size (excluding the storage header size)

-  //

-  *MaximumVariableStorageSize   = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);

-

-  //

-  // Harware error record variable needs larger size.

-  //

-  if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-    *MaximumVariableStorageSize = PcdGet32 (PcdHwErrStorageSize);

-    *MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER);

-  } else {

-    if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {

-      ASSERT (PcdGet32 (PcdHwErrStorageSize) < VariableStoreHeader->Size);

-      *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize);

-    }

-

-    //

-    // Let *MaximumVariableSize be PcdGet32 (PcdMaxVariableSize) with the exception of the variable header size.

-    //

-    *MaximumVariableSize = PcdGet32 (PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);

-  }

-

-  //

-  // Point to the starting address of the variables.

-  //

-  Variable = (VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader + 1);

-

-  //

-  // Now walk through the related variable store.

-  //

-  while (Variable < GetEndPointer (VariableStoreHeader)) {

-    NextVariable = GetNextVariablePtr(Variable);

-    if (NextVariable == NULL) {

-      break;

-    }

-    VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;

-

-    if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-      HwErrVariableTotalSize += VariableSize;

-    } else {

-      CommonVariableTotalSize += VariableSize;

-    }

-

-    //

-    // Go to the next one.

-    //

-    Variable = NextVariable;

-  }

-

-  if ((Attributes  & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){

-    *RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;

-  } else {

-    *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;

-  }

-

-  if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {

-    *MaximumVariableSize = 0;

-  } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {

-    *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);

-  }

-  

-  ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);

-  return EFI_SUCCESS;

-}

-

-/**

-  Initializes variable store area.

-

-  This function allocates memory space for variable store area and initializes its attributes.

-

-  @param  VolatileStore  Indicates if the variable store is volatile.

-

-**/

-EFI_STATUS

-InitializeVariableStore (

-  IN  BOOLEAN               VolatileStore

-  )

-{

-  EFI_STATUS            Status;

-  VARIABLE_STORE_HEADER *VariableStore;

-  BOOLEAN               FullyInitializeStore;

-  EFI_PHYSICAL_ADDRESS  *VariableBase;

-  UINTN                 *LastVariableOffset;

-  VARIABLE_STORE_HEADER *VariableStoreHeader;

-  VARIABLE_HEADER       *Variable;

-  VOID                  *VariableData;

-  EFI_HOB_GUID_TYPE     *GuidHob;

-

-  FullyInitializeStore = TRUE;

-

-  if (VolatileStore) {

-    VariableBase = &mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase;

-    LastVariableOffset = &mVariableModuleGlobal->VolatileLastVariableOffset;

-  } else {

-    VariableBase = &mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase;

-    LastVariableOffset = &mVariableModuleGlobal->NonVolatileLastVariableOffset;

-  }

-

-  //

-  // Note that in EdkII variable driver implementation, Hardware Error Record type variable

-  // is stored with common variable in the same NV region. So the platform integrator should

-  // ensure that the value of PcdHwErrStorageSize is less than or equal to the value of 

-  // PcdVariableStoreSize.

-  //

-  ASSERT (PcdGet32 (PcdHwErrStorageSize) <= PcdGet32 (PcdVariableStoreSize));

-

-  //

-  // Allocate memory for variable store.

-  //

-  if (VolatileStore || (PcdGet64 (PcdEmuVariableNvStoreReserved) == 0)) {

-    VariableStore = (VARIABLE_STORE_HEADER *) AllocateRuntimePool (PcdGet32 (PcdVariableStoreSize));

-  } else {

-    //

-    // A memory location has been reserved for the NV variable store.  Certain

-    // platforms may be able to preserve a memory range across system resets,

-    // thereby providing better NV variable emulation.

-    //

-    VariableStore =

-      (VARIABLE_STORE_HEADER *)(VOID*)(UINTN)

-        PcdGet64 (PcdEmuVariableNvStoreReserved);

-    if (

-         (VariableStore->Size == PcdGet32 (PcdVariableStoreSize)) &&

-         (VariableStore->Format == VARIABLE_STORE_FORMATTED) &&

-         (VariableStore->State == VARIABLE_STORE_HEALTHY)

-       ) {

-      DEBUG((

-        EFI_D_INFO,

-        "Variable Store reserved at %p appears to be valid\n",

-        VariableStore

-        ));

-      FullyInitializeStore = FALSE;

-    }

-  }

-

-  if (NULL == VariableStore) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  if (FullyInitializeStore) {

-    SetMem (VariableStore, PcdGet32 (PcdVariableStoreSize), 0xff);

-  }

-

-  //

-  // Variable Specific Data

-  //

-  *VariableBase             = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStore;

-  InitializeLocationForLastVariableOffset (VariableStore, LastVariableOffset);

-

-  CopyGuid (&VariableStore->Signature, &gEfiVariableGuid);

-  VariableStore->Size       = PcdGet32 (PcdVariableStoreSize);

-  VariableStore->Format     = VARIABLE_STORE_FORMATTED;

-  VariableStore->State      = VARIABLE_STORE_HEALTHY;

-  VariableStore->Reserved   = 0;

-  VariableStore->Reserved1  = 0;

-

-  if (!VolatileStore) {

-    //

-    // Get HOB variable store.

-    //

-    GuidHob = GetFirstGuidHob (&gEfiVariableGuid);

-    if (GuidHob != NULL) {

-      VariableStoreHeader = (VARIABLE_STORE_HEADER *) GET_GUID_HOB_DATA (GuidHob);

-      if (CompareGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid) &&

-          (VariableStoreHeader->Format == VARIABLE_STORE_FORMATTED) &&

-          (VariableStoreHeader->State == VARIABLE_STORE_HEALTHY)

-         ) {

-        DEBUG ((EFI_D_INFO, "HOB Variable Store appears to be valid.\n"));

-        //

-        // Flush the HOB variable to Emulation Variable storage.

-        //

-        for ( Variable = (VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader + 1)

-            ; (Variable < GetEndPointer (VariableStoreHeader) && (Variable != NULL))

-            ; Variable = GetNextVariablePtr (Variable)

-            ) {

-          ASSERT (Variable->State == VAR_ADDED);

-          ASSERT ((Variable->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0);

-          VariableData = GetVariableDataPtr (Variable);

-          Status = EmuSetVariable (

-                     GET_VARIABLE_NAME_PTR (Variable),

-                     &Variable->VendorGuid,

-                     Variable->Attributes,

-                     Variable->DataSize,

-                     VariableData,

-                     &mVariableModuleGlobal->VariableGlobal[Physical],

-                     &mVariableModuleGlobal->VolatileLastVariableOffset,

-                     &mVariableModuleGlobal->NonVolatileLastVariableOffset

-                     );

-          ASSERT_EFI_ERROR (Status);

-        }

-      }

-    }

-  }

-

-  return EFI_SUCCESS;

-}

-

-/**

-  Initializes variable store area for non-volatile and volatile variable.

-

-  This function allocates and initializes memory space for global context of ESAL

-  variable service and variable store area for non-volatile and volatile variable.

-

-  @param  ImageHandle           The Image handle of this driver.

-  @param  SystemTable           The pointer of EFI_SYSTEM_TABLE.

-

-  @retval EFI_SUCCESS           Function successfully executed.

-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableCommonInitialize (

-  IN EFI_HANDLE         ImageHandle,

-  IN EFI_SYSTEM_TABLE   *SystemTable

-  )

-{

-  EFI_STATUS  Status;

-

-  //

-  // Allocate memory for mVariableModuleGlobal

-  //

-  mVariableModuleGlobal = (ESAL_VARIABLE_GLOBAL *) AllocateRuntimeZeroPool (

-                                                    sizeof (ESAL_VARIABLE_GLOBAL)

-                                                   );

-  if (NULL == mVariableModuleGlobal) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal[Physical].VariableServicesLock, TPL_NOTIFY);

-

-  //

-  // Intialize volatile variable store

-  //

-  Status = InitializeVariableStore (TRUE);

-  if (EFI_ERROR (Status)) {

-    FreePool(mVariableModuleGlobal);

-    return Status;

-  }

-  //

-  // Intialize non volatile variable store

-  //

-  Status = InitializeVariableStore (FALSE);

-

-  return Status;

-}

diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf
deleted file mode 100644
index 0dafddee55..0000000000
--- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf
+++ /dev/null
@@ -1,88 +0,0 @@
-## @file

-# Emulation Variable for EFI_RUNTIME_SERVICES.

-#

-# This module installs variable arch protocol and variable write arch protocol to provide

-# four EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo.

-#

-# Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>

-#

-#  This program and the accompanying materials

-#  are licensed and made available under the terms and conditions of the BSD License

-#  which accompanies this distribution. The full text of the license may be found at

-#  http://opensource.org/licenses/bsd-license.php

-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-#

-#

-##

-

-[Defines]

-  INF_VERSION                    = 0x00010005

-  BASE_NAME                      = EmuVariableRuntimeDxe

-  MODULE_UNI_FILE                = EmuVariableRuntimeDxe.uni

-  FILE_GUID                      = 02B01AD5-7E59-43e8-A6D8-238180613A5A

-  MODULE_TYPE                    = DXE_RUNTIME_DRIVER

-  VERSION_STRING                 = 1.0

-  ENTRY_POINT                    = VariableServiceInitialize

-

-#

-# The following information is for reference only and not required by the build tools.

-#

-#  VALID_ARCHITECTURES           = IA32 X64 EBC

-#

-

-[Sources]

-  InitVariable.c

-  EmuVariable.c

-  Variable.h

-

-

-[Packages]

-  MdePkg/MdePkg.dec

-  MdeModulePkg/MdeModulePkg.dec

-

-

-[LibraryClasses]

-  BaseLib

-  UefiLib

-  UefiBootServicesTableLib

-  UefiDriverEntryPoint

-  UefiRuntimeLib

-  DebugLib

-  MemoryAllocationLib

-  BaseMemoryLib

-  HobLib

-  PcdLib

-

-[Protocols]

-  gEfiVariableArchProtocolGuid                  ## PRODUCES

-  gEfiVariableWriteArchProtocolGuid             ## PRODUCES

-

-[Guids]

-  gEfiEventVirtualAddressChangeGuid             ## CONSUMES             ## Event

-  ## SOMETIMES_CONSUMES   ## Variable:L"PlatformLang"

-  ## SOMETIMES_PRODUCES   ## Variable:L"PlatformLang"

-  ## SOMETIMES_CONSUMES   ## Variable:L"Lang"

-  ## SOMETIMES_PRODUCES   ## Variable:L"Lang"

-  gEfiGlobalVariableGuid

-  ## PRODUCES             ## GUID # Signature of Variable store header

-  ## CONSUMES             ## GUID # Signature of Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  ## SOMETIMES_PRODUCES   ## SystemTable

-  gEfiVariableGuid

-

-[Pcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdEmuVariableNvStoreReserved      ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxVariableSize                 ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxHardwareErrorVariableSize    ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdVariableStoreSize               ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdHwErrStorageSize                ## CONSUMES

-

-[FeaturePcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdVariableCollectStatistics   ## CONSUMES # statistic the information of variable.

-

-[Depex]

-  TRUE

-

-[UserExtensions.TianoCore."ExtraFiles"]

-  EmuVariableRuntimeDxeExtra.uni
\ No newline at end of file
diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.uni b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.uni
deleted file mode 100644
index 6ad6018121..0000000000
--- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.uni
+++ /dev/null
@@ -1,22 +0,0 @@
-// /** @file

-// Emulation Variable for EFI_RUNTIME_SERVICES.

-//

-// This module installs variable arch protocol and variable write arch protocol to provide

-// four EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo.

-//

-// Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-

-#string STR_MODULE_ABSTRACT             #language en-US "Emulation Variable for EFI_RUNTIME_SERVICES"

-

-#string STR_MODULE_DESCRIPTION          #language en-US "This module installs variable arch protocol and variable write arch protocol to provide four EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo."

-

diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxeExtra.uni b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxeExtra.uni
deleted file mode 100644
index c3bbd2bf7b..0000000000
--- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxeExtra.uni
+++ /dev/null
@@ -1,19 +0,0 @@
-// /** @file

-// EmuVariableRuntimeDxe Localized Strings and Content

-//

-// Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-#string STR_PROPERTIES_MODULE_NAME 

-#language en-US 

-"Emulation Variable DXE Driver"

-

-

diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/InitVariable.c b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/InitVariable.c
deleted file mode 100644
index 1feedc07c3..0000000000
--- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/InitVariable.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/** @file

-

-  Implment all four UEFI runtime variable services and 

-  install variable architeture protocol.

-  

-Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-EFI_EVENT   mVirtualAddressChangeEvent = NULL;

-

-/**

-

-  This code finds variable in storage blocks (Volatile or Non-Volatile).

-

-  @param VariableName               Name of Variable to be found.

-  @param VendorGuid                 Variable vendor GUID.

-  @param Attributes                 Attribute value of the variable found.

-  @param DataSize                   Size of Data found. If size is less than the

-                                    data, this value contains the required size.

-  @param Data                       The buffer to return the contents of the variable. May be NULL

-                                    with a zero DataSize in order to determine the size buffer needed.

-                      

-  @return EFI_INVALID_PARAMETER     Invalid parameter

-  @return EFI_SUCCESS               Find the specified variable

-  @return EFI_NOT_FOUND             Not found

-  @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceGetVariable (

-  IN CHAR16        *VariableName,

-  IN EFI_GUID      *VendorGuid,

-  OUT UINT32       *Attributes OPTIONAL,

-  IN OUT UINTN     *DataSize,

-  OUT VOID         *Data OPTIONAL

-  )

-{

-  return EmuGetVariable (

-          VariableName,

-          VendorGuid,

-          Attributes OPTIONAL,

-          DataSize,

-          Data,

-          &mVariableModuleGlobal->VariableGlobal[Physical]

-          );

-}

-

-/**

-

-  This code Finds the Next available variable.

-

-  @param VariableNameSize           Size of the variable name

-  @param VariableName               Pointer to variable name

-  @param VendorGuid                 Variable Vendor Guid

-

-  @return EFI_INVALID_PARAMETER     Invalid parameter

-  @return EFI_SUCCESS               Find the specified variable

-  @return EFI_NOT_FOUND             Not found

-  @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceGetNextVariableName (

-  IN OUT UINTN     *VariableNameSize,

-  IN OUT CHAR16    *VariableName,

-  IN OUT EFI_GUID  *VendorGuid

-  )

-{

-  return EmuGetNextVariableName (

-          VariableNameSize,

-          VariableName,

-          VendorGuid,

-          &mVariableModuleGlobal->VariableGlobal[Physical]

-          );

-}

-

-/**

-

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  @param VariableName                     Name of Variable to be found

-  @param VendorGuid                       Variable vendor GUID

-  @param Attributes                       Attribute value of the variable found

-  @param DataSize                         Size of Data found. If size is less than the

-                                          data, this value contains the required size.

-  @param Data                             Data pointer

-

-  @return EFI_INVALID_PARAMETER           Invalid parameter

-  @return EFI_SUCCESS                     Set successfully

-  @return EFI_OUT_OF_RESOURCES            Resource not enough to set variable

-  @return EFI_NOT_FOUND                   Not found

-  @return EFI_WRITE_PROTECTED             Variable is read-only

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceSetVariable (

-  IN CHAR16        *VariableName,

-  IN EFI_GUID      *VendorGuid,

-  IN UINT32        Attributes,

-  IN UINTN         DataSize,

-  IN VOID          *Data

-  )

-{

-  return EmuSetVariable (

-          VariableName,

-          VendorGuid,

-          Attributes,

-          DataSize,

-          Data,

-          &mVariableModuleGlobal->VariableGlobal[Physical],

-          &mVariableModuleGlobal->VolatileLastVariableOffset,

-          &mVariableModuleGlobal->NonVolatileLastVariableOffset

-          );

-}

-

-/**

-

-  This code returns information about the EFI variables.

-

-  @param Attributes                     Attributes bitmask to specify the type of variables

-                                        on which to return information.

-  @param MaximumVariableStorageSize     Pointer to the maximum size of the storage space available

-                                        for the EFI variables associated with the attributes specified.

-  @param RemainingVariableStorageSize   Pointer to the remaining size of the storage space available

-                                        for EFI variables associated with the attributes specified.

-  @param MaximumVariableSize            Pointer to the maximum size of an individual EFI variables

-                                        associated with the attributes specified.

-

-  @return EFI_INVALID_PARAMETER         An invalid combination of attribute bits was supplied.

-  @return EFI_SUCCESS                   Query successfully.

-  @return EFI_UNSUPPORTED               The attribute is not supported on this platform.

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceQueryVariableInfo (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize

-  )

-{

-  return EmuQueryVariableInfo (

-          Attributes,

-          MaximumVariableStorageSize,

-          RemainingVariableStorageSize,

-          MaximumVariableSize,

-          &mVariableModuleGlobal->VariableGlobal[Physical]

-          );

-}

-

-/**

-  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.

-

-  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-  It convers pointer to new virtual address.

-

-  @param  Event        Event whose notification function is being invoked.

-  @param  Context      Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-VariableClassAddressChangeEvent (

-  IN EFI_EVENT        Event,

-  IN VOID             *Context

-  )

-{

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLangCodes);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->LangCodes);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLang);

-  EfiConvertPointer (

-    0x0,

-    (VOID **) &mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase

-    );

-  EfiConvertPointer (

-    0x0,

-    (VOID **) &mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase

-    );

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);

-}

-

-/**

-  EmuVariable Driver main entry point. The Variable driver places the 4 EFI

-  runtime services in the EFI System Table and installs arch protocols 

-  for variable read and write services being available. It also registers

-  notification function for EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-

-  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  

-  @param[in] SystemTable    A pointer to the EFI System Table.

-  

-  @retval EFI_SUCCESS       Variable service successfully initialized.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceInitialize (

-  IN EFI_HANDLE         ImageHandle,

-  IN EFI_SYSTEM_TABLE   *SystemTable

-  )

-{

-  EFI_HANDLE  NewHandle;

-  EFI_STATUS  Status;

-

-  Status = VariableCommonInitialize (ImageHandle, SystemTable);

-  ASSERT_EFI_ERROR (Status);

-

-  SystemTable->RuntimeServices->GetVariable         = RuntimeServiceGetVariable;

-  SystemTable->RuntimeServices->GetNextVariableName = RuntimeServiceGetNextVariableName;

-  SystemTable->RuntimeServices->SetVariable         = RuntimeServiceSetVariable;

-  SystemTable->RuntimeServices->QueryVariableInfo   = RuntimeServiceQueryVariableInfo;

-

-  //

-  // Now install the Variable Runtime Architectural Protocol on a new handle

-  //

-  NewHandle = NULL;

-  Status = gBS->InstallMultipleProtocolInterfaces (

-                  &NewHandle,

-                  &gEfiVariableArchProtocolGuid,

-                  NULL,

-                  &gEfiVariableWriteArchProtocolGuid,

-                  NULL,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  Status = gBS->CreateEventEx (

-                  EVT_NOTIFY_SIGNAL,

-                  TPL_NOTIFY,

-                  VariableClassAddressChangeEvent,

-                  NULL,

-                  &gEfiEventVirtualAddressChangeGuid,

-                  &mVirtualAddressChangeEvent

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  return EFI_SUCCESS;

-}

diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/Variable.h b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/Variable.h
deleted file mode 100644
index 81a45681a2..0000000000
--- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/Variable.h
+++ /dev/null
@@ -1,272 +0,0 @@
-/** @file

-

-  The internal header file includes the common header files, defines

-  internal structure and functions used by EmuVariable module.

-

-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#ifndef _VARIABLE_H_

-#define _VARIABLE_H_

-

-#include <Uefi.h>

-

-#include <Protocol/VariableWrite.h>

-#include <Protocol/Variable.h>

-

-#include <Library/BaseMemoryLib.h>

-#include <Library/MemoryAllocationLib.h>

-#include <Library/DebugLib.h>

-#include <Library/UefiRuntimeLib.h>

-#include <Library/UefiDriverEntryPoint.h>

-#include <Library/UefiBootServicesTableLib.h>

-#include <Library/UefiLib.h>

-#include <Library/BaseLib.h>

-#include <Library/PcdLib.h>

-#include <Library/HobLib.h>

-#include <Guid/VariableFormat.h>

-#include <Guid/GlobalVariable.h>

-

-#include <Guid/EventGroup.h>

-

-#define GET_VARIABLE_NAME_PTR(a)  (CHAR16 *) ((UINTN) (a) + sizeof (VARIABLE_HEADER))

-

-///

-/// The size of a 3 character ISO639 language code.

-///

-#define ISO_639_2_ENTRY_SIZE    3

-

-typedef enum {

-  Physical,

-  Virtual

-} VARIABLE_POINTER_TYPE;

-

-typedef struct {

-  VARIABLE_HEADER *CurrPtr;

-  VARIABLE_HEADER *EndPtr;

-  VARIABLE_HEADER *StartPtr;

-  BOOLEAN         Volatile;

-} VARIABLE_POINTER_TRACK;

-

-typedef struct {

-  EFI_PHYSICAL_ADDRESS  VolatileVariableBase;

-  EFI_PHYSICAL_ADDRESS  NonVolatileVariableBase;

-  EFI_LOCK              VariableServicesLock;

-} VARIABLE_GLOBAL;

-

-typedef struct {

-  VARIABLE_GLOBAL VariableGlobal[2];

-  UINTN           VolatileLastVariableOffset;

-  UINTN           NonVolatileLastVariableOffset;

-  UINTN           CommonVariableTotalSize;

-  UINTN           HwErrVariableTotalSize;

-  CHAR8           *PlatformLangCodes;

-  CHAR8           *LangCodes;

-  CHAR8           *PlatformLang;

-  CHAR8           Lang[ISO_639_2_ENTRY_SIZE + 1];

-} ESAL_VARIABLE_GLOBAL;

-

-///

-/// Don't use module globals after the SetVirtualAddress map is signaled

-///

-extern ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;

-

-/**

-  Initializes variable store area for non-volatile and volatile variable.

-

-  This function allocates and initializes memory space for global context of ESAL

-  variable service and variable store area for non-volatile and volatile variable.

-

-  @param  ImageHandle           The Image handle of this driver.

-  @param  SystemTable           The pointer of EFI_SYSTEM_TABLE.

-

-  @retval EFI_SUCCESS           Function successfully executed.

-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableCommonInitialize (

-  IN EFI_HANDLE         ImageHandle,

-  IN EFI_SYSTEM_TABLE   *SystemTable

-  );

-

-/**

-  Entry point of EmuVariable service module.

-

-  This function is the entry point of EmuVariable service module.

-  It registers all interfaces of Variable Services, initializes

-  variable store for non-volatile and volatile variables, and registers

-  notification function for EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-

-  @param  ImageHandle   The Image handle of this driver.

-  @param  SystemTable   The pointer of EFI_SYSTEM_TABLE.

-

-  @retval EFI_SUCCESS   Variable service successfully initialized.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceInitialize (

-  IN EFI_HANDLE         ImageHandle,

-  IN EFI_SYSTEM_TABLE   *SystemTable

-  );

-

-/**

-  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.

-

-  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-  It convers pointer to new virtual address.

-

-  @param  Event        Event whose notification function is being invoked.

-  @param  Context      Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-VariableClassAddressChangeEvent (

-  IN EFI_EVENT        Event,

-  IN VOID             *Context

-  );

-

-/**

-  This code finds variable in storage blocks (Volatile or Non-Volatile).

-  

-  @param  VariableName           A Null-terminated Unicode string that is the name of

-                                 the vendor's variable.

-  @param  VendorGuid             A unique identifier for the vendor.

-  @param  Attributes             If not NULL, a pointer to the memory location to return the 

-                                 attributes bitmask for the variable.

-  @param  DataSize               Size of Data found. If size is less than the

-                                 data, this value contains the required size.

-  @param  Data                   On input, the size in bytes of the return Data buffer.  

-                                 On output, the size of data returned in Data.

-  @param  Global                 Pointer to VARIABLE_GLOBAL structure

-

-  @retval EFI_SUCCESS            The function completed successfully. 

-  @retval EFI_NOT_FOUND          The variable was not found.

-  @retval EFI_BUFFER_TOO_SMALL   DataSize is too small for the result.  DataSize has 

-                                 been updated with the size needed to complete the request.

-  @retval EFI_INVALID_PARAMETER  VariableName or VendorGuid or DataSize is NULL.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuGetVariable (

-  IN      CHAR16            *VariableName,

-  IN      EFI_GUID          *VendorGuid,

-  OUT     UINT32            *Attributes OPTIONAL,

-  IN OUT  UINTN             *DataSize,

-  OUT     VOID              *Data,

-  IN      VARIABLE_GLOBAL   *Global

-  );

-

-/**

-

-  This code finds the next available variable.

-

-  @param  VariableNameSize       Size of the variable.

-  @param  VariableName           On input, supplies the last VariableName that was returned by GetNextVariableName().

-                                 On output, returns the Null-terminated Unicode string of the current variable.

-  @param  VendorGuid             On input, supplies the last VendorGuid that was returned by GetNextVariableName().

-                                 On output, returns the VendorGuid of the current variable.  

-  @param  Global                 Pointer to VARIABLE_GLOBAL structure.

-

-  @retval EFI_SUCCESS            The function completed successfully. 

-  @retval EFI_NOT_FOUND          The next variable was not found.

-  @retval EFI_BUFFER_TOO_SMALL   VariableNameSize is too small for the result. 

-                                 VariableNameSize has been updated with the size needed to complete the request.

-  @retval EFI_INVALID_PARAMETER  VariableNameSize or VariableName or VendorGuid is NULL.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuGetNextVariableName (

-  IN OUT  UINTN             *VariableNameSize,

-  IN OUT  CHAR16            *VariableName,

-  IN OUT  EFI_GUID          *VendorGuid,

-  IN      VARIABLE_GLOBAL   *Global

-  );

-

-/**

-

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  @param  VariableName           A Null-terminated Unicode string that is the name of the vendor's

-                                 variable.  Each VariableName is unique for each 

-                                 VendorGuid.  VariableName must contain 1 or more 

-                                 Unicode characters.  If VariableName is an empty Unicode 

-                                 string, then EFI_INVALID_PARAMETER is returned.

-  @param  VendorGuid             A unique identifier for the vendor

-  @param  Attributes             Attributes bitmask to set for the variable

-  @param  DataSize               The size in bytes of the Data buffer.  A size of zero causes the

-                                 variable to be deleted.

-  @param  Data                   The contents for the variable

-  @param  Global                 Pointer to VARIABLE_GLOBAL structure

-  @param  VolatileOffset         The offset of last volatile variable

-  @param  NonVolatileOffset      The offset of last non-volatile variable

-

-  @retval EFI_SUCCESS            The firmware has successfully stored the variable and its data as 

-                                 defined by the Attributes.

-  @retval EFI_INVALID_PARAMETER  An invalid combination of attribute bits was supplied, or the 

-                                 DataSize exceeds the maximum allowed, or VariableName is an empty 

-                                 Unicode string, or VendorGuid is NULL.

-  @retval EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.

-  @retval EFI_DEVICE_ERROR       The variable could not be saved due to a hardware failure.

-  @retval EFI_WRITE_PROTECTED    The variable in question is read-only or cannot be deleted.

-  @retval EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuSetVariable (

-  IN CHAR16                  *VariableName,

-  IN EFI_GUID                *VendorGuid,

-  IN UINT32                  Attributes,

-  IN UINTN                   DataSize,

-  IN VOID                    *Data,

-  IN VARIABLE_GLOBAL         *Global,

-  IN UINTN                   *VolatileOffset,

-  IN UINTN                   *NonVolatileOffset

-  );

-

-/**

-

-  This code returns information about the EFI variables.

-

-  @param  Attributes                   Attributes bitmask to specify the type of variables

-                                       on which to return information.

-  @param  MaximumVariableStorageSize   On output the maximum size of the storage space available for 

-                                       the EFI variables associated with the attributes specified.  

-  @param  RemainingVariableStorageSize Returns the remaining size of the storage space available for EFI 

-                                       variables associated with the attributes specified.

-  @param  MaximumVariableSize          Returns the maximum size of an individual EFI variable 

-                                       associated with the attributes specified.

-  @param  Global                       Pointer to VARIABLE_GLOBAL structure.

-

-  @retval EFI_SUCCESS                  Valid answer returned.

-  @retval EFI_INVALID_PARAMETER        An invalid combination of attribute bits was supplied

-  @retval EFI_UNSUPPORTED              The attribute is not supported on this platform, and the 

-                                       MaximumVariableStorageSize, RemainingVariableStorageSize, 

-                                       MaximumVariableSize are undefined.

-

-**/

-EFI_STATUS

-EFIAPI

-EmuQueryVariableInfo (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize,

-  IN  VARIABLE_GLOBAL        *Global

-  );

-

-#endif

diff --git a/MdeModulePkg/Universal/Variable/Pei/PeiVariable.uni b/MdeModulePkg/Universal/Variable/Pei/PeiVariable.uni
deleted file mode 100644
index 65ca7d02db..0000000000
--- a/MdeModulePkg/Universal/Variable/Pei/PeiVariable.uni
+++ /dev/null
@@ -1,22 +0,0 @@
-// /** @file

-// Implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI.

-//

-// This module implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI.

-//

-// Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// 

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-

-#string STR_MODULE_ABSTRACT             #language en-US "Implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI"

-

-#string STR_MODULE_DESCRIPTION          #language en-US "This module implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI."

-

diff --git a/MdeModulePkg/Universal/Variable/Pei/PeiVariableExtra.uni b/MdeModulePkg/Universal/Variable/Pei/PeiVariableExtra.uni
deleted file mode 100644
index 8b967d4e8f..0000000000
--- a/MdeModulePkg/Universal/Variable/Pei/PeiVariableExtra.uni
+++ /dev/null
@@ -1,20 +0,0 @@
-// /** @file

-// PeiVariable Localized Strings and Content

-//

-// Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-//

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-#string STR_PROPERTIES_MODULE_NAME 

-#language en-US 

-"Variable Access PEI Module"

-

-

diff --git a/MdeModulePkg/Universal/Variable/Pei/Variable.c b/MdeModulePkg/Universal/Variable/Pei/Variable.c
deleted file mode 100644
index a072c31e60..0000000000
--- a/MdeModulePkg/Universal/Variable/Pei/Variable.c
+++ /dev/null
@@ -1,1186 +0,0 @@
-/** @file

-  Implement ReadOnly Variable Services required by PEIM and install

-  PEI ReadOnly Varaiable2 PPI. These services operates the non volatile storage space.

-

-Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-

-#include "Variable.h"

-

-//

-// Module globals

-//

-EFI_PEI_READ_ONLY_VARIABLE2_PPI mVariablePpi = {

-  PeiGetVariable,

-  PeiGetNextVariableName

-};

-

-EFI_PEI_PPI_DESCRIPTOR     mPpiListVariable = {

-  (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),

-  &gEfiPeiReadOnlyVariable2PpiGuid,

-  &mVariablePpi

-};

-

-

-/**

-  Provide the functionality of the variable services.

-

-  @param  FileHandle   Handle of the file being invoked.

-                       Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().

-  @param  PeiServices  General purpose services available to every PEIM.

-

-  @retval EFI_SUCCESS  If the interface could be successfully installed

-  @retval Others       Returned from PeiServicesInstallPpi()

-**/

-EFI_STATUS

-EFIAPI

-PeimInitializeVariableServices (

-  IN       EFI_PEI_FILE_HANDLE       FileHandle,

-  IN CONST EFI_PEI_SERVICES          **PeiServices

-  )

-{

-  return PeiServicesInstallPpi (&mPpiListVariable);

-}

-

-/**

-

-  Gets the pointer to the first variable header in given variable store area.

-

-  @param VarStoreHeader  Pointer to the Variable Store Header.

-

-  @return Pointer to the first variable header

-

-**/

-VARIABLE_HEADER *

-GetStartPointer (

-  IN VARIABLE_STORE_HEADER       *VarStoreHeader

-  )

-{

-  //

-  // The end of variable store

-  //

-  return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);

-}

-

-

-/**

-  This code gets the pointer to the last variable memory pointer byte.

-

-  @param  VarStoreHeader  Pointer to the Variable Store Header.

-

-  @return VARIABLE_HEADER* pointer to last unavailable Variable Header.

-

-**/

-VARIABLE_HEADER *

-GetEndPointer (

-  IN VARIABLE_STORE_HEADER       *VarStoreHeader

-  )

-{

-  //

-  // The end of variable store

-  //

-  return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);

-}

-

-

-/**

-  This code checks if variable header is valid or not.

-

-  @param  Variable  Pointer to the Variable Header.

-

-  @retval TRUE      Variable header is valid.

-  @retval FALSE     Variable header is not valid.

-

-**/

-BOOLEAN

-IsValidVariableHeader (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  if (Variable == NULL || Variable->StartId != VARIABLE_DATA ) {

-    return FALSE;

-  }

-

-  return TRUE;

-}

-

-/**

-  This code gets the size of variable header.

-

-  @param AuthFlag   Authenticated variable flag.

-

-  @return Size of variable header in bytes in type UINTN.

-

-**/

-UINTN

-GetVariableHeaderSize (

-  IN  BOOLEAN       AuthFlag

-  )

-{

-  UINTN Value;

-

-  if (AuthFlag) {

-    Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);

-  } else {

-    Value = sizeof (VARIABLE_HEADER);

-  }

-

-  return Value;

-}

-

-/**

-  This code gets the size of name of variable.

-

-  @param  Variable  Pointer to the Variable Header.

-  @param  AuthFlag  Authenticated variable flag.

-

-  @return Size of variable in bytes in type UINTN.

-

-**/

-UINTN

-NameSizeOfVariable (

-  IN  VARIABLE_HEADER   *Variable,

-  IN  BOOLEAN           AuthFlag

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (AuthFlag) {

-    if (AuthVariable->State == (UINT8) (-1) ||

-       AuthVariable->DataSize == (UINT32) (-1) ||

-       AuthVariable->NameSize == (UINT32) (-1) ||

-       AuthVariable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) AuthVariable->NameSize;

-  } else {

-    if (Variable->State == (UINT8) (-1) ||

-       Variable->DataSize == (UINT32) (-1) ||

-       Variable->NameSize == (UINT32) (-1) ||

-       Variable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) Variable->NameSize;

-  }

-}

-

-

-/**

-  This code gets the size of data of variable.

-

-  @param  Variable  Pointer to the Variable Header.

-  @param  AuthFlag  Authenticated variable flag.

-

-  @return Size of variable in bytes in type UINTN.

-

-**/

-UINTN

-DataSizeOfVariable (

-  IN  VARIABLE_HEADER   *Variable,

-  IN  BOOLEAN           AuthFlag

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (AuthFlag) {

-    if (AuthVariable->State == (UINT8) (-1) ||

-       AuthVariable->DataSize == (UINT32) (-1) ||

-       AuthVariable->NameSize == (UINT32) (-1) ||

-       AuthVariable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) AuthVariable->DataSize;

-  } else {

-    if (Variable->State == (UINT8) (-1) ||

-       Variable->DataSize == (UINT32) (-1) ||

-       Variable->NameSize == (UINT32) (-1) ||

-       Variable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) Variable->DataSize;

-  }

-}

-

-/**

-  This code gets the pointer to the variable name.

-

-  @param   Variable  Pointer to the Variable Header.

-  @param   AuthFlag  Authenticated variable flag.

-

-  @return  A CHAR16* pointer to Variable Name.

-

-**/

-CHAR16 *

-GetVariableNamePtr (

-  IN VARIABLE_HEADER    *Variable,

-  IN BOOLEAN            AuthFlag

-  )

-{

-  return (CHAR16 *) ((UINTN) Variable + GetVariableHeaderSize (AuthFlag));

-}

-

-/**

-  This code gets the pointer to the variable guid.

-

-  @param Variable   Pointer to the Variable Header.

-  @param AuthFlag   Authenticated variable flag.

-

-  @return A EFI_GUID* pointer to Vendor Guid.

-

-**/

-EFI_GUID *

-GetVendorGuidPtr (

-  IN VARIABLE_HEADER    *Variable,

-  IN BOOLEAN            AuthFlag

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (AuthFlag) {

-    return &AuthVariable->VendorGuid;

-  } else {

-    return &Variable->VendorGuid;

-  }

-}

-

-/**

-  This code gets the pointer to the variable data.

-

-  @param   Variable         Pointer to the Variable Header.

-  @param   VariableHeader   Pointer to the Variable Header that has consecutive content.

-  @param   AuthFlag         Authenticated variable flag.

-

-  @return  A UINT8* pointer to Variable Data.

-

-**/

-UINT8 *

-GetVariableDataPtr (

-  IN  VARIABLE_HEADER   *Variable,

-  IN  VARIABLE_HEADER   *VariableHeader,

-  IN  BOOLEAN           AuthFlag

-  )

-{

-  UINTN Value;

-

-  //

-  // Be careful about pad size for alignment

-  //

-  Value =  (UINTN) GetVariableNamePtr (Variable, AuthFlag);

-  Value += NameSizeOfVariable (VariableHeader, AuthFlag);

-  Value += GET_PAD_SIZE (NameSizeOfVariable (VariableHeader, AuthFlag));

-

-  return (UINT8 *) Value;

-}

-

-

-/**

-  This code gets the pointer to the next variable header.

-

-  @param  StoreInfo         Pointer to variable store info structure.

-  @param  Variable          Pointer to the Variable Header.

-  @param  VariableHeader    Pointer to the Variable Header that has consecutive content.

-

-  @return  A VARIABLE_HEADER* pointer to next variable header.

-

-**/

-VARIABLE_HEADER *

-GetNextVariablePtr (

-  IN  VARIABLE_STORE_INFO   *StoreInfo,

-  IN  VARIABLE_HEADER       *Variable,

-  IN  VARIABLE_HEADER       *VariableHeader

-  )

-{

-  EFI_PHYSICAL_ADDRESS  TargetAddress;

-  EFI_PHYSICAL_ADDRESS  SpareAddress;

-  UINTN                 Value;

-

-  Value =  (UINTN) GetVariableDataPtr (Variable, VariableHeader, StoreInfo->AuthFlag);

-  Value += DataSizeOfVariable (VariableHeader, StoreInfo->AuthFlag);

-  Value += GET_PAD_SIZE (DataSizeOfVariable (VariableHeader, StoreInfo->AuthFlag));

-  //

-  // Be careful about pad size for alignment

-  //

-  Value = HEADER_ALIGN (Value);

-

-  if (StoreInfo->FtwLastWriteData != NULL) {

-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;

-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;

-    if (((UINTN) Variable < (UINTN) TargetAddress) && (Value >= (UINTN) TargetAddress)) {

-      //

-      // Next variable is in spare block.

-      //

-      Value = (UINTN) SpareAddress + (Value - (UINTN) TargetAddress);

-    }

-  }

-

-  return (VARIABLE_HEADER *) Value;

-}

-

-/**

-  Get variable store status.

-

-  @param  VarStoreHeader  Pointer to the Variable Store Header.

-

-  @retval  EfiRaw      Variable store is raw

-  @retval  EfiValid    Variable store is valid

-  @retval  EfiInvalid  Variable store is invalid

-

-**/

-VARIABLE_STORE_STATUS

-GetVariableStoreStatus (

-  IN VARIABLE_STORE_HEADER *VarStoreHeader

-  )

-{

-  if ((CompareGuid (&VarStoreHeader->Signature, &gEfiAuthenticatedVariableGuid) ||

-       CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid)) &&

-      VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&

-      VarStoreHeader->State == VARIABLE_STORE_HEALTHY

-      ) {

-

-    return EfiValid;

-  }

-

-  if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&

-      ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&

-      ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&

-      ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&

-      VarStoreHeader->Size == 0xffffffff &&

-      VarStoreHeader->Format == 0xff &&

-      VarStoreHeader->State == 0xff

-      ) {

-

-    return EfiRaw;

-  } else {

-    return EfiInvalid;

-  }

-}

-

-/**

-  Compare two variable names, one of them may be inconsecutive.

-

-  @param StoreInfo      Pointer to variable store info structure.

-  @param Name1          Pointer to one variable name.

-  @param Name2          Pointer to another variable name.

-  @param NameSize       Variable name size.

-

-  @retval TRUE          Name1 and Name2 are identical.

-  @retval FALSE         Name1 and Name2 are not identical.

-

-**/

-BOOLEAN

-CompareVariableName (

-  IN VARIABLE_STORE_INFO    *StoreInfo,

-  IN CONST CHAR16           *Name1,

-  IN CONST CHAR16           *Name2,

-  IN UINTN                  NameSize

-  )

-{

-  EFI_PHYSICAL_ADDRESS  TargetAddress;

-  EFI_PHYSICAL_ADDRESS  SpareAddress;

-  UINTN                 PartialNameSize;

-

-  if (StoreInfo->FtwLastWriteData != NULL) {

-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;

-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;

-    if (((UINTN) Name1 < (UINTN) TargetAddress) && (((UINTN) Name1 + NameSize) > (UINTN) TargetAddress)) {

-      //

-      // Name1 is inconsecutive.

-      //

-      PartialNameSize = (UINTN) TargetAddress - (UINTN) Name1;

-      //

-      // Partial content is in NV storage.

-      //

-      if (CompareMem ((UINT8 *) Name1, (UINT8 *) Name2, PartialNameSize) == 0) {

-        //

-        // Another partial content is in spare block.

-        //

-        if (CompareMem ((UINT8 *) (UINTN) SpareAddress, (UINT8 *) Name2 + PartialNameSize, NameSize - PartialNameSize) == 0) {

-          return TRUE;

-        }

-      }

-      return FALSE;

-    } else if (((UINTN) Name2 < (UINTN) TargetAddress) && (((UINTN) Name2 + NameSize) > (UINTN) TargetAddress)) {

-      //

-      // Name2 is inconsecutive.

-      //

-      PartialNameSize = (UINTN) TargetAddress - (UINTN) Name2;

-      //

-      // Partial content is in NV storage.

-      //

-      if (CompareMem ((UINT8 *) Name2, (UINT8 *) Name1, PartialNameSize) == 0) {

-        //

-        // Another partial content is in spare block.

-        //

-        if (CompareMem ((UINT8 *) (UINTN) SpareAddress, (UINT8 *) Name1 + PartialNameSize, NameSize - PartialNameSize) == 0) {

-          return TRUE;

-        }

-      }

-      return FALSE;

-    }

-  }

-

-  //

-  // Both Name1 and Name2 are consecutive.

-  //

-  if (CompareMem ((UINT8 *) Name1, (UINT8 *) Name2, NameSize) == 0) {

-    return TRUE;

-  }

-  return FALSE;

-}

-

-/**

-  This function compares a variable with variable entries in database.

-

-  @param  StoreInfo     Pointer to variable store info structure.

-  @param  Variable      Pointer to the variable in our database

-  @param  VariableHeader Pointer to the Variable Header that has consecutive content.

-  @param  VariableName  Name of the variable to compare to 'Variable'

-  @param  VendorGuid    GUID of the variable to compare to 'Variable'

-  @param  PtrTrack      Variable Track Pointer structure that contains Variable Information.

-

-  @retval EFI_SUCCESS    Found match variable

-  @retval EFI_NOT_FOUND  Variable not found

-

-**/

-EFI_STATUS

-CompareWithValidVariable (

-  IN  VARIABLE_STORE_INFO           *StoreInfo,

-  IN  VARIABLE_HEADER               *Variable,

-  IN  VARIABLE_HEADER               *VariableHeader,

-  IN  CONST CHAR16                  *VariableName,

-  IN  CONST EFI_GUID                *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK        *PtrTrack

-  )

-{

-  VOID      *Point;

-  EFI_GUID  *TempVendorGuid;

-

-  TempVendorGuid = GetVendorGuidPtr (VariableHeader, StoreInfo->AuthFlag);

-

-  if (VariableName[0] == 0) {

-    PtrTrack->CurrPtr = Variable;

-    return EFI_SUCCESS;

-  } else {

-    //

-    // Don't use CompareGuid function here for performance reasons.

-    // Instead we compare the GUID a UINT32 at a time and branch

-    // on the first failed comparison.

-    //

-    if ((((INT32 *) VendorGuid)[0] == ((INT32 *) TempVendorGuid)[0]) &&

-        (((INT32 *) VendorGuid)[1] == ((INT32 *) TempVendorGuid)[1]) &&

-        (((INT32 *) VendorGuid)[2] == ((INT32 *) TempVendorGuid)[2]) &&

-        (((INT32 *) VendorGuid)[3] == ((INT32 *) TempVendorGuid)[3])

-        ) {

-      ASSERT (NameSizeOfVariable (VariableHeader, StoreInfo->AuthFlag) != 0);

-      Point = (VOID *) GetVariableNamePtr (Variable, StoreInfo->AuthFlag);

-      if (CompareVariableName (StoreInfo, VariableName, Point, NameSizeOfVariable (VariableHeader, StoreInfo->AuthFlag))) {

-        PtrTrack->CurrPtr = Variable;

-        return EFI_SUCCESS;

-      }

-    }

-  }

-

-  return EFI_NOT_FOUND;

-}

-

-/**

-  Return the variable store header and the store info based on the Index.

-

-  @param Type       The type of the variable store.

-  @param StoreInfo  Return the store info.

-

-  @return  Pointer to the variable store header.

-**/

-VARIABLE_STORE_HEADER *

-GetVariableStore (

-  IN VARIABLE_STORE_TYPE         Type,

-  OUT VARIABLE_STORE_INFO        *StoreInfo

-  )

-{

-  EFI_HOB_GUID_TYPE                     *GuidHob;

-  EFI_FIRMWARE_VOLUME_HEADER            *FvHeader;

-  VARIABLE_STORE_HEADER                 *VariableStoreHeader;

-  EFI_PHYSICAL_ADDRESS                  NvStorageBase;

-  UINT32                                NvStorageSize;

-  FAULT_TOLERANT_WRITE_LAST_WRITE_DATA  *FtwLastWriteData;

-  UINT32                                BackUpOffset;

-

-  StoreInfo->IndexTable = NULL;

-  StoreInfo->FtwLastWriteData = NULL;

-  StoreInfo->AuthFlag = FALSE;

-  VariableStoreHeader = NULL;

-  switch (Type) {

-    case VariableStoreTypeHob:

-      GuidHob = GetFirstGuidHob (&gEfiAuthenticatedVariableGuid);

-      if (GuidHob != NULL) {

-        VariableStoreHeader = (VARIABLE_STORE_HEADER *) GET_GUID_HOB_DATA (GuidHob);

-        StoreInfo->AuthFlag = TRUE;

-      } else {

-        GuidHob = GetFirstGuidHob (&gEfiVariableGuid);

-        if (GuidHob != NULL) {

-          VariableStoreHeader = (VARIABLE_STORE_HEADER *) GET_GUID_HOB_DATA (GuidHob);

-          StoreInfo->AuthFlag = FALSE;

-        }

-      }

-      break;

-

-    case VariableStoreTypeNv:

-      if (GetBootModeHob () != BOOT_IN_RECOVERY_MODE) {

-        //

-        // The content of NV storage for variable is not reliable in recovery boot mode.

-        //

-

-        NvStorageSize = PcdGet32 (PcdFlashNvStorageVariableSize);

-        NvStorageBase = (EFI_PHYSICAL_ADDRESS) (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0 ?

-                                                PcdGet64 (PcdFlashNvStorageVariableBase64) :

-                                                PcdGet32 (PcdFlashNvStorageVariableBase)

-                                               );

-        //

-        // First let FvHeader point to NV storage base.

-        //

-        FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) NvStorageBase;

-

-        //

-        // Check the FTW last write data hob.

-        //

-        BackUpOffset = 0;

-        GuidHob = GetFirstGuidHob (&gEdkiiFaultTolerantWriteGuid);

-        if (GuidHob != NULL) {

-          FtwLastWriteData = (FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *) GET_GUID_HOB_DATA (GuidHob);

-          if (FtwLastWriteData->TargetAddress == NvStorageBase) {

-            //

-            // Let FvHeader point to spare block.

-            //

-            FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) FtwLastWriteData->SpareAddress;

-            DEBUG ((EFI_D_INFO, "PeiVariable: NV storage is backed up in spare block: 0x%x\n", (UINTN) FtwLastWriteData->SpareAddress));

-          } else if ((FtwLastWriteData->TargetAddress > NvStorageBase) && (FtwLastWriteData->TargetAddress < (NvStorageBase + NvStorageSize))) {

-            StoreInfo->FtwLastWriteData = FtwLastWriteData;

-            //

-            // Flash NV storage from the offset is backed up in spare block.

-            //

-            BackUpOffset = (UINT32) (FtwLastWriteData->TargetAddress - NvStorageBase);

-            DEBUG ((EFI_D_INFO, "PeiVariable: High partial NV storage from offset: %x is backed up in spare block: 0x%x\n", BackUpOffset, (UINTN) FtwLastWriteData->SpareAddress));

-            //

-            // At least one block data in flash NV storage is still valid, so still leave FvHeader point to NV storage base.

-            //

-          }

-        }

-

-        //

-        // Check if the Firmware Volume is not corrupted

-        //

-        if ((FvHeader->Signature != EFI_FVH_SIGNATURE) || (!CompareGuid (&gEfiSystemNvDataFvGuid, &FvHeader->FileSystemGuid))) {

-          DEBUG ((EFI_D_ERROR, "Firmware Volume for Variable Store is corrupted\n"));

-          break;

-        }

-

-        VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINT8 *) FvHeader + FvHeader->HeaderLength);

-

-        StoreInfo->AuthFlag = (BOOLEAN) (CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid));

-

-        GuidHob = GetFirstGuidHob (&gEfiVariableIndexTableGuid);

-        if (GuidHob != NULL) {

-          StoreInfo->IndexTable = GET_GUID_HOB_DATA (GuidHob);

-        } else {

-          //

-          // If it's the first time to access variable region in flash, create a guid hob to record

-          // VAR_ADDED type variable info.

-          // Note that as the resource of PEI phase is limited, only store the limited number of

-          // VAR_ADDED type variables to reduce access time.

-          //

-          StoreInfo->IndexTable = (VARIABLE_INDEX_TABLE *) BuildGuidHob (&gEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));

-          StoreInfo->IndexTable->Length      = 0;

-          StoreInfo->IndexTable->StartPtr    = GetStartPointer (VariableStoreHeader);

-          StoreInfo->IndexTable->EndPtr      = GetEndPointer   (VariableStoreHeader);

-          StoreInfo->IndexTable->GoneThrough = 0;

-        }

-      }

-      break;

-

-    default:

-      ASSERT (FALSE);

-      break;

-  }

-

-  StoreInfo->VariableStoreHeader = VariableStoreHeader;

-  return VariableStoreHeader;

-}

-

-/**

-  Get variable header that has consecutive content.

-

-  @param StoreInfo      Pointer to variable store info structure.

-  @param Variable       Pointer to the Variable Header.

-  @param VariableHeader Pointer to Pointer to the Variable Header that has consecutive content.

-

-  @retval TRUE          Variable header is valid.

-  @retval FALSE         Variable header is not valid.

-

-**/

-BOOLEAN

-GetVariableHeader (

-  IN VARIABLE_STORE_INFO    *StoreInfo,

-  IN VARIABLE_HEADER        *Variable,

-  OUT VARIABLE_HEADER       **VariableHeader

-  )

-{

-  EFI_PHYSICAL_ADDRESS  TargetAddress;

-  EFI_PHYSICAL_ADDRESS  SpareAddress;

-  EFI_HOB_GUID_TYPE     *GuidHob;

-  UINTN                 PartialHeaderSize;

-

-  if (Variable == NULL) {

-    return FALSE;

-  }

-

-  //

-  // First assume variable header pointed by Variable is consecutive.

-  //

-  *VariableHeader = Variable;

-

-  if (StoreInfo->FtwLastWriteData != NULL) {

-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;

-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;

-    if (((UINTN) Variable > (UINTN) SpareAddress) &&

-        (((UINTN) Variable - (UINTN) SpareAddress + (UINTN) TargetAddress) >= (UINTN) GetEndPointer (StoreInfo->VariableStoreHeader))) {

-      //

-      // Reach the end of variable store.

-      //

-      return FALSE;

-    }

-    if (((UINTN) Variable < (UINTN) TargetAddress) && (((UINTN) Variable + GetVariableHeaderSize (StoreInfo->AuthFlag)) > (UINTN) TargetAddress)) {

-      //

-      // Variable header pointed by Variable is inconsecutive,

-      // create a guid hob to combine the two partial variable header content together.

-      //

-      GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);

-      if (GuidHob != NULL) {

-        *VariableHeader = (VARIABLE_HEADER *) GET_GUID_HOB_DATA (GuidHob);

-      } else {

-        *VariableHeader = (VARIABLE_HEADER *) BuildGuidHob (&gEfiCallerIdGuid, GetVariableHeaderSize (StoreInfo->AuthFlag));

-        PartialHeaderSize = (UINTN) TargetAddress - (UINTN) Variable;

-        //

-        // Partial content is in NV storage.

-        //

-        CopyMem ((UINT8 *) *VariableHeader, (UINT8 *) Variable, PartialHeaderSize);

-        //

-        // Another partial content is in spare block.

-        //

-        CopyMem ((UINT8 *) *VariableHeader + PartialHeaderSize, (UINT8 *) (UINTN) SpareAddress, GetVariableHeaderSize (StoreInfo->AuthFlag) - PartialHeaderSize);

-      }

-    }

-  } else {

-    if (Variable >= GetEndPointer (StoreInfo->VariableStoreHeader)) {

-      //

-      // Reach the end of variable store.

-      //

-      return FALSE;

-    }

-  }

-

-  return IsValidVariableHeader (*VariableHeader);

-}

-

-/**

-  Get variable name or data to output buffer.

-

-  @param  StoreInfo     Pointer to variable store info structure.

-  @param  NameOrData    Pointer to the variable name/data that may be inconsecutive.

-  @param  Size          Variable name/data size.

-  @param  Buffer        Pointer to output buffer to hold the variable name/data.

-

-**/

-VOID

-GetVariableNameOrData (

-  IN VARIABLE_STORE_INFO    *StoreInfo,

-  IN UINT8                  *NameOrData,

-  IN UINTN                  Size,

-  OUT UINT8                 *Buffer

-  )

-{

-  EFI_PHYSICAL_ADDRESS  TargetAddress;

-  EFI_PHYSICAL_ADDRESS  SpareAddress;

-  UINTN                 PartialSize;

-

-  if (StoreInfo->FtwLastWriteData != NULL) {

-    TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;

-    SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;

-    if (((UINTN) NameOrData < (UINTN) TargetAddress) && (((UINTN) NameOrData + Size) > (UINTN) TargetAddress)) {

-      //

-      // Variable name/data is inconsecutive.

-      //

-      PartialSize = (UINTN) TargetAddress - (UINTN) NameOrData;

-      //

-      // Partial content is in NV storage.

-      //

-      CopyMem (Buffer, NameOrData, PartialSize);

-      //

-      // Another partial content is in spare block.

-      //

-      CopyMem (Buffer + PartialSize, (UINT8 *) (UINTN) SpareAddress, Size - PartialSize);

-      return;

-    }

-  }

-

-  //

-  // Variable name/data is consecutive.

-  //

-  CopyMem (Buffer, NameOrData, Size);

-}

-

-/**

-  Find the variable in the specified variable store.

-

-  @param  StoreInfo           Pointer to the store info structure.

-  @param  VariableName        Name of the variable to be found

-  @param  VendorGuid          Vendor GUID to be found.

-  @param  PtrTrack            Variable Track Pointer structure that contains Variable Information.

-

-  @retval  EFI_SUCCESS            Variable found successfully

-  @retval  EFI_NOT_FOUND          Variable not found

-  @retval  EFI_INVALID_PARAMETER  Invalid variable name

-

-**/

-EFI_STATUS

-FindVariableEx (

-  IN VARIABLE_STORE_INFO         *StoreInfo,

-  IN CONST CHAR16                *VariableName,

-  IN CONST EFI_GUID              *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK     *PtrTrack

-  )

-{

-  VARIABLE_HEADER         *Variable;

-  VARIABLE_HEADER         *LastVariable;

-  VARIABLE_HEADER         *MaxIndex;

-  UINTN                   Index;

-  UINTN                   Offset;

-  BOOLEAN                 StopRecord;

-  VARIABLE_HEADER         *InDeletedVariable;

-  VARIABLE_STORE_HEADER   *VariableStoreHeader;

-  VARIABLE_INDEX_TABLE    *IndexTable;

-  VARIABLE_HEADER         *VariableHeader;

-

-  VariableStoreHeader = StoreInfo->VariableStoreHeader;

-

-  if (VariableStoreHeader == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {

-    return EFI_UNSUPPORTED;

-  }

-

-  if (~VariableStoreHeader->Size == 0) {

-    return EFI_NOT_FOUND;

-  }

-

-  IndexTable = StoreInfo->IndexTable;

-  PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader);

-  PtrTrack->EndPtr   = GetEndPointer   (VariableStoreHeader);

-

-  InDeletedVariable = NULL;

-

-  //

-  // No Variable Address equals zero, so 0 as initial value is safe.

-  //

-  MaxIndex   = NULL;

-  VariableHeader = NULL;

-

-  if (IndexTable != NULL) {

-    //

-    // traverse the variable index table to look for varible.

-    // The IndexTable->Index[Index] records the distance of two neighbouring VAR_ADDED type variables.

-    //

-    for (Offset = 0, Index = 0; Index < IndexTable->Length; Index++) {

-      ASSERT (Index < sizeof (IndexTable->Index) / sizeof (IndexTable->Index[0]));

-      Offset   += IndexTable->Index[Index];

-      MaxIndex  = (VARIABLE_HEADER *) ((UINT8 *) IndexTable->StartPtr + Offset);

-      GetVariableHeader (StoreInfo, MaxIndex, &VariableHeader);

-      if (CompareWithValidVariable (StoreInfo, MaxIndex, VariableHeader, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {

-        if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-          InDeletedVariable = PtrTrack->CurrPtr;

-        } else {

-          return EFI_SUCCESS;

-        }

-      }

-    }

-

-    if (IndexTable->GoneThrough != 0) {

-      //

-      // If the table has all the existing variables indexed, return.

-      //

-      PtrTrack->CurrPtr = InDeletedVariable;

-      return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

-    }

-  }

-

-  if (MaxIndex != NULL) {

-    //

-    // HOB exists but the variable cannot be found in HOB

-    // If not found in HOB, then let's start from the MaxIndex we've found.

-    //

-    Variable     = GetNextVariablePtr (StoreInfo, MaxIndex, VariableHeader);

-    LastVariable = MaxIndex;

-  } else {

-    //

-    // Start Pointers for the variable.

-    // Actual Data Pointer where data can be written.

-    //

-    Variable     = PtrTrack->StartPtr;

-    LastVariable = PtrTrack->StartPtr;

-  }

-

-  //

-  // Find the variable by walk through variable store

-  //

-  StopRecord = FALSE;

-  while (GetVariableHeader (StoreInfo, Variable, &VariableHeader)) {

-    if (VariableHeader->State == VAR_ADDED || VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-      //

-      // Record Variable in VariableIndex HOB

-      //

-      if ((IndexTable != NULL) && !StopRecord) {

-        Offset = (UINTN) Variable - (UINTN) LastVariable;

-        if ((Offset > 0x0FFFF) || (IndexTable->Length == sizeof (IndexTable->Index) / sizeof (IndexTable->Index[0]))) {

-          //

-          // Stop to record if the distance of two neighbouring VAR_ADDED variable is larger than the allowable scope(UINT16),

-          // or the record buffer is full.

-          //

-          StopRecord = TRUE;

-        } else {

-          IndexTable->Index[IndexTable->Length++] = (UINT16) Offset;

-          LastVariable = Variable;

-        }

-      }

-

-      if (CompareWithValidVariable (StoreInfo, Variable, VariableHeader, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {

-        if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-          InDeletedVariable = PtrTrack->CurrPtr;

-        } else {

-          return EFI_SUCCESS;

-        }

-      }

-    }

-

-    Variable = GetNextVariablePtr (StoreInfo, Variable, VariableHeader);

-  }

-  //

-  // If gone through the VariableStore, that means we never find in Firmware any more.

-  //

-  if ((IndexTable != NULL) && !StopRecord) {

-    IndexTable->GoneThrough = 1;

-  }

-

-  PtrTrack->CurrPtr = InDeletedVariable;

-

-  return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

-}

-

-/**

-  Find the variable in HOB and Non-Volatile variable storages.

-

-  @param  VariableName  Name of the variable to be found

-  @param  VendorGuid    Vendor GUID to be found.

-  @param  PtrTrack      Variable Track Pointer structure that contains Variable Information.

-  @param  StoreInfo     Return the store info.

-

-  @retval  EFI_SUCCESS            Variable found successfully

-  @retval  EFI_NOT_FOUND          Variable not found

-  @retval  EFI_INVALID_PARAMETER  Invalid variable name

-**/

-EFI_STATUS

-FindVariable (

-  IN CONST  CHAR16            *VariableName,

-  IN CONST  EFI_GUID          *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK  *PtrTrack,

-  OUT VARIABLE_STORE_INFO     *StoreInfo

-  )

-{

-  EFI_STATUS                  Status;

-  VARIABLE_STORE_TYPE         Type;

-

-  if (VariableName[0] != 0 && VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {

-    GetVariableStore (Type, StoreInfo);

-    Status = FindVariableEx (

-               StoreInfo,

-               VariableName,

-               VendorGuid,

-               PtrTrack

-               );

-    if (!EFI_ERROR (Status)) {

-      return Status;

-    }

-  }

-

-  return EFI_NOT_FOUND;

-}

-

-/**

-  This service retrieves a variable's value using its name and GUID.

-

-  Read the specified variable from the UEFI variable store. If the Data

-  buffer is too small to hold the contents of the variable, the error

-  EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer

-  size to obtain the data.

-

-  @param  This                  A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.

-  @param  VariableName          A pointer to a null-terminated string that is the variable's name.

-  @param  VariableGuid          A pointer to an EFI_GUID that is the variable's GUID. The combination of

-                                VariableGuid and VariableName must be unique.

-  @param  Attributes            If non-NULL, on return, points to the variable's attributes.

-  @param  DataSize              On entry, points to the size in bytes of the Data buffer.

-                                On return, points to the size of the data returned in Data.

-  @param  Data                  Points to the buffer which will hold the returned variable value.

-

-  @retval EFI_SUCCESS           The variable was read successfully.

-  @retval EFI_NOT_FOUND         The variable could not be found.

-  @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the resulting data.

-                                DataSize is updated with the size required for

-                                the specified variable.

-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.

-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.

-

-**/

-EFI_STATUS

-EFIAPI

-PeiGetVariable (

-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,

-  IN CONST  CHAR16                          *VariableName,

-  IN CONST  EFI_GUID                        *VariableGuid,

-  OUT       UINT32                          *Attributes,

-  IN OUT    UINTN                           *DataSize,

-  OUT       VOID                            *Data

-  )

-{

-  VARIABLE_POINTER_TRACK  Variable;

-  UINTN                   VarDataSize;

-  EFI_STATUS              Status;

-  VARIABLE_STORE_INFO     StoreInfo;

-  VARIABLE_HEADER         *VariableHeader;

-

-  if (VariableName == NULL || VariableGuid == NULL || DataSize == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (VariableName[0] == 0) {

-    return EFI_NOT_FOUND;

-  }

-

-  VariableHeader = NULL;

-

-  //

-  // Find existing variable

-  //

-  Status = FindVariable (VariableName, VariableGuid, &Variable, &StoreInfo);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-  GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader);

-

-  //

-  // Get data size

-  //

-  VarDataSize = DataSizeOfVariable (VariableHeader, StoreInfo.AuthFlag);

-  if (*DataSize >= VarDataSize) {

-    if (Data == NULL) {

-      return EFI_INVALID_PARAMETER;

-    }

-

-    GetVariableNameOrData (&StoreInfo, GetVariableDataPtr (Variable.CurrPtr, VariableHeader, StoreInfo.AuthFlag), VarDataSize, Data);

-

-    if (Attributes != NULL) {

-      *Attributes = VariableHeader->Attributes;

-    }

-

-    *DataSize = VarDataSize;

-    return EFI_SUCCESS;

-  } else {

-    *DataSize = VarDataSize;

-    return EFI_BUFFER_TOO_SMALL;

-  }

-}

-

-/**

-  Return the next variable name and GUID.

-

-  This function is called multiple times to retrieve the VariableName

-  and VariableGuid of all variables currently available in the system.

-  On each call, the previous results are passed into the interface,

-  and, on return, the interface returns the data for the next

-  interface. When the entire variable list has been returned,

-  EFI_NOT_FOUND is returned.

-

-  @param  This              A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.

-

-  @param  VariableNameSize  On entry, points to the size of the buffer pointed to by VariableName.

-                            On return, the size of the variable name buffer.

-  @param  VariableName      On entry, a pointer to a null-terminated string that is the variable's name.

-                            On return, points to the next variable's null-terminated name string.

-  @param  VariableGuid      On entry, a pointer to an EFI_GUID that is the variable's GUID.

-                            On return, a pointer to the next variable's GUID.

-

-  @retval EFI_SUCCESS           The variable was read successfully.

-  @retval EFI_NOT_FOUND         The variable could not be found.

-  @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the resulting

-                                data. VariableNameSize is updated with the size

-                                required for the specified variable.

-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or

-                                VariableNameSize is NULL.

-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.

-

-**/

-EFI_STATUS

-EFIAPI

-PeiGetNextVariableName (

-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,

-  IN OUT UINTN                              *VariableNameSize,

-  IN OUT CHAR16                             *VariableName,

-  IN OUT EFI_GUID                           *VariableGuid

-  )

-{

-  VARIABLE_STORE_TYPE     Type;

-  VARIABLE_POINTER_TRACK  Variable;

-  VARIABLE_POINTER_TRACK  VariableInHob;

-  VARIABLE_POINTER_TRACK  VariablePtrTrack;

-  UINTN                   VarNameSize;

-  EFI_STATUS              Status;

-  VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

-  VARIABLE_HEADER         *VariableHeader;

-  VARIABLE_STORE_INFO     StoreInfo;

-  VARIABLE_STORE_INFO     StoreInfoForNv;

-  VARIABLE_STORE_INFO     StoreInfoForHob;

-

-  if (VariableName == NULL || VariableGuid == NULL || VariableNameSize == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  VariableHeader = NULL;

-

-  Status = FindVariable (VariableName, VariableGuid, &Variable, &StoreInfo);

-  if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {

-    return Status;

-  }

-

-  if (VariableName[0] != 0) {

-    //

-    // If variable name is not NULL, get next variable

-    //

-    GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader);

-    Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);

-  }

-

-  VariableStoreHeader[VariableStoreTypeHob] = GetVariableStore (VariableStoreTypeHob, &StoreInfoForHob);

-  VariableStoreHeader[VariableStoreTypeNv]  = GetVariableStore (VariableStoreTypeNv, &StoreInfoForNv);

-

-  while (TRUE) {

-    //

-    // Switch from HOB to Non-Volatile.

-    //

-    while (!GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader)) {

-      //

-      // Find current storage index

-      //

-      for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {

-        if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {

-          break;

-        }

-      }

-      ASSERT (Type < VariableStoreTypeMax);

-      //

-      // Switch to next storage

-      //

-      for (Type++; Type < VariableStoreTypeMax; Type++) {

-        if (VariableStoreHeader[Type] != NULL) {

-          break;

-        }

-      }

-      //

-      // Capture the case that

-      // 1. current storage is the last one, or

-      // 2. no further storage

-      //

-      if (Type == VariableStoreTypeMax) {

-        return EFI_NOT_FOUND;

-      }

-      Variable.StartPtr = GetStartPointer (VariableStoreHeader[Type]);

-      Variable.EndPtr   = GetEndPointer   (VariableStoreHeader[Type]);

-      Variable.CurrPtr  = Variable.StartPtr;

-      GetVariableStore (Type, &StoreInfo);

-    }

-

-    if (VariableHeader->State == VAR_ADDED || VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-      if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-        //

-        // If it is a IN_DELETED_TRANSITION variable,

-        // and there is also a same ADDED one at the same time,

-        // don't return it.

-        //

-        Status = FindVariableEx (

-                   &StoreInfo,

-                   GetVariableNamePtr (Variable.CurrPtr, StoreInfo.AuthFlag),

-                   GetVendorGuidPtr (VariableHeader, StoreInfo.AuthFlag),

-                   &VariablePtrTrack

-                   );

-        if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr != Variable.CurrPtr) {

-          Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);

-          continue;

-        }

-      }

-

-      //

-      // Don't return NV variable when HOB overrides it

-      //

-      if ((VariableStoreHeader[VariableStoreTypeHob] != NULL) && (VariableStoreHeader[VariableStoreTypeNv] != NULL) &&

-          (Variable.StartPtr == GetStartPointer (VariableStoreHeader[VariableStoreTypeNv]))

-         ) {

-        Status = FindVariableEx (

-                   &StoreInfoForHob,

-                   GetVariableNamePtr (Variable.CurrPtr, StoreInfo.AuthFlag),

-                   GetVendorGuidPtr (VariableHeader, StoreInfo.AuthFlag),

-                   &VariableInHob

-                   );

-        if (!EFI_ERROR (Status)) {

-          Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);

-          continue;

-        }

-      }

-

-      VarNameSize = NameSizeOfVariable (VariableHeader, StoreInfo.AuthFlag);

-      ASSERT (VarNameSize != 0);

-

-      if (VarNameSize <= *VariableNameSize) {

-        GetVariableNameOrData (&StoreInfo, (UINT8 *) GetVariableNamePtr (Variable.CurrPtr, StoreInfo.AuthFlag), VarNameSize, (UINT8 *) VariableName);

-

-        CopyMem (VariableGuid, GetVendorGuidPtr (VariableHeader, StoreInfo.AuthFlag), sizeof (EFI_GUID));

-

-        Status = EFI_SUCCESS;

-      } else {

-        Status = EFI_BUFFER_TOO_SMALL;

-      }

-

-      *VariableNameSize = VarNameSize;

-      //

-      // Variable is found

-      //

-      return Status;

-    } else {

-      Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);

-    }

-  }

-}

diff --git a/MdeModulePkg/Universal/Variable/Pei/Variable.h b/MdeModulePkg/Universal/Variable/Pei/Variable.h
deleted file mode 100644
index 580d69fb42..0000000000
--- a/MdeModulePkg/Universal/Variable/Pei/Variable.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/** @file

-  The internal header file includes the common header files, defines

-  internal structure and functions used by PeiVariable module.

-

-Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#ifndef _PEI_VARIABLE_H_

-#define _PEI_VARIABLE_H_

-

-#include <PiPei.h>

-#include <Ppi/ReadOnlyVariable2.h>

-

-#include <Library/DebugLib.h>

-#include <Library/PeimEntryPoint.h>

-#include <Library/HobLib.h>

-#include <Library/PcdLib.h>

-#include <Library/BaseMemoryLib.h>

-#include <Library/PeiServicesTablePointerLib.h>

-#include <Library/PeiServicesLib.h>

-

-#include <Guid/VariableFormat.h>

-#include <Guid/VariableIndexTable.h>

-#include <Guid/SystemNvDataGuid.h>

-#include <Guid/FaultTolerantWrite.h>

-

-typedef enum {

-  VariableStoreTypeHob,

-  VariableStoreTypeNv,

-  VariableStoreTypeMax

-} VARIABLE_STORE_TYPE;

-

-typedef struct {

-  VARIABLE_STORE_HEADER                   *VariableStoreHeader;

-  VARIABLE_INDEX_TABLE                    *IndexTable;

-  //

-  // If it is not NULL, it means there may be an inconsecutive variable whose

-  // partial content is still in NV storage, but another partial content is backed up

-  // in spare block.

-  //

-  FAULT_TOLERANT_WRITE_LAST_WRITE_DATA    *FtwLastWriteData;

-  BOOLEAN                                 AuthFlag;

-} VARIABLE_STORE_INFO;

-

-//

-// Functions

-//

-/**

-  Provide the functionality of the variable services.

-

-  @param  FileHandle  Handle of the file being invoked.

-                      Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().

-  @param  PeiServices  General purpose services available to every PEIM.

-

-  @retval EFI_SUCCESS  If the interface could be successfully installed

-  @retval Others       Returned from PeiServicesInstallPpi()

-

-**/

-EFI_STATUS

-EFIAPI

-PeimInitializeVariableServices (

-  IN       EFI_PEI_FILE_HANDLE       FileHandle,

-  IN CONST EFI_PEI_SERVICES          **PeiServices

-  );

-

-/**

-  This service retrieves a variable's value using its name and GUID.

-

-  Read the specified variable from the UEFI variable store. If the Data

-  buffer is too small to hold the contents of the variable, the error

-  EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer

-  size to obtain the data.

-

-  @param  This                  A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.

-  @param  VariableName          A pointer to a null-terminated string that is the variable's name.

-  @param  VariableGuid          A pointer to an EFI_GUID that is the variable's GUID. The combination of

-                                VariableGuid and VariableName must be unique.

-  @param  Attributes            If non-NULL, on return, points to the variable's attributes.

-  @param  DataSize              On entry, points to the size in bytes of the Data buffer.

-                                On return, points to the size of the data returned in Data.

-  @param  Data                  Points to the buffer which will hold the returned variable value.

-

-  @retval EFI_SUCCESS           The variable was read successfully.

-  @retval EFI_NOT_FOUND         The variable could not be found.

-  @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the resulting data.

-                                DataSize is updated with the size required for

-                                the specified variable.

-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.

-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.

-

-**/

-EFI_STATUS

-EFIAPI

-PeiGetVariable (

-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,

-  IN CONST  CHAR16                          *VariableName,

-  IN CONST  EFI_GUID                        *VariableGuid,

-  OUT       UINT32                          *Attributes,

-  IN OUT    UINTN                           *DataSize,

-  OUT       VOID                            *Data

-  );

-

-/**

-  Return the next variable name and GUID.

-

-  This function is called multiple times to retrieve the VariableName

-  and VariableGuid of all variables currently available in the system.

-  On each call, the previous results are passed into the interface,

-  and, on return, the interface returns the data for the next

-  interface. When the entire variable list has been returned,

-  EFI_NOT_FOUND is returned.

-

-  @param  This              A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.

-

-  @param  VariableNameSize  On entry, points to the size of the buffer pointed to by VariableName.

-  @param  VariableName      On entry, a pointer to a null-terminated string that is the variable's name.

-                            On return, points to the next variable's null-terminated name string.

-

-  @param  VariableGuid      On entry, a pointer to an UEFI _GUID that is the variable's GUID.

-                            On return, a pointer to the next variable's GUID.

-

-  @retval EFI_SUCCESS           The variable was read successfully.

-  @retval EFI_NOT_FOUND         The variable could not be found.

-  @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the resulting

-                                data. VariableNameSize is updated with the size

-                                required for the specified variable.

-  @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or

-                                VariableNameSize is NULL.

-  @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.

-

-**/

-EFI_STATUS

-EFIAPI

-PeiGetNextVariableName (

-  IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,

-  IN OUT UINTN                              *VariableNameSize,

-  IN OUT CHAR16                             *VariableName,

-  IN OUT EFI_GUID                           *VariableGuid

-  );

-

-#endif

diff --git a/MdeModulePkg/Universal/Variable/Pei/VariablePei.inf b/MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
deleted file mode 100644
index 72a440dcd1..0000000000
--- a/MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
+++ /dev/null
@@ -1,79 +0,0 @@
-## @file

-#  Implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI.

-#

-#  This module implements ReadOnly Variable Services required by PEIM and installs PEI ReadOnly Varaiable2 PPI.

-#

-#  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>

-#  This program and the accompanying materials

-#  are licensed and made available under the terms and conditions of the BSD License

-#  which accompanies this distribution. The full text of the license may be found at

-#  http://opensource.org/licenses/bsd-license.php

-#

-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-#

-##

-

-[Defines]

-  INF_VERSION                    = 0x00010005

-  BASE_NAME                      = PeiVariable

-  MODULE_UNI_FILE                = PeiVariable.uni

-  FILE_GUID                      = 34C8C28F-B61C-45a2-8F2E-89E46BECC63B

-  MODULE_TYPE                    = PEIM

-  VERSION_STRING                 = 1.0

-  ENTRY_POINT                    = PeimInitializeVariableServices

-

-#

-# The following information is for reference only and not required by the build tools.

-#

-#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

-#

-

-[Sources]

-  Variable.c

-  Variable.h

-

-[Packages]

-  MdePkg/MdePkg.dec

-  MdeModulePkg/MdeModulePkg.dec

-

-[LibraryClasses]

-  BaseMemoryLib

-  PcdLib

-  HobLib

-  PeimEntryPoint

-  DebugLib

-  PeiServicesTablePointerLib

-  PeiServicesLib

-

-[Guids]

-  ## CONSUMES             ## GUID # Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  gEfiAuthenticatedVariableGuid

-  ## SOMETIMES_CONSUMES   ## GUID # Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  gEfiVariableGuid

-  ## SOMETIMES_PRODUCES   ## HOB

-  ## SOMETIMES_CONSUMES   ## HOB

-  gEfiVariableIndexTableGuid

-  gEfiSystemNvDataFvGuid            ## SOMETIMES_CONSUMES   ## GUID

-  ## SOMETIMES_CONSUMES   ## HOB

-  ## CONSUMES             ## GUID # Dependence

-  gEdkiiFaultTolerantWriteGuid

-

-[Ppis]

-  gEfiPeiReadOnlyVariable2PpiGuid   ## PRODUCES

-

-[Pcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase      ## SOMETIMES_CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64    ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize      ## CONSUMES

-

-[Depex]

-  gEdkiiFaultTolerantWriteGuid

-

-# [BootMode]

-# RECOVERY_FULL             ## SOMETIMES_CONSUMES

-

-[UserExtensions.TianoCore."ExtraFiles"]

-  PeiVariableExtra.uni

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/Measurement.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/Measurement.c
deleted file mode 100644
index 936b5b00a3..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/Measurement.c
+++ /dev/null
@@ -1,343 +0,0 @@
-/** @file

-  Measure TCG required variable.

-

-Copyright (c) 2013 - 2017, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include <PiDxe.h>

-#include <Guid/ImageAuthentication.h>

-#include <IndustryStandard/UefiTcgPlatform.h>

-

-#include <Library/UefiBootServicesTableLib.h>

-#include <Library/UefiRuntimeServicesTableLib.h>

-#include <Library/MemoryAllocationLib.h>

-#include <Library/BaseMemoryLib.h>

-#include <Library/DebugLib.h>

-#include <Library/BaseLib.h>

-#include <Library/TpmMeasurementLib.h>

-

-typedef struct {

-  CHAR16                                 *VariableName;

-  EFI_GUID                               *VendorGuid;

-} VARIABLE_TYPE;

-

-VARIABLE_TYPE  mVariableType[] = {

-  {EFI_SECURE_BOOT_MODE_NAME,    &gEfiGlobalVariableGuid},

-  {EFI_PLATFORM_KEY_NAME,        &gEfiGlobalVariableGuid},

-  {EFI_KEY_EXCHANGE_KEY_NAME,    &gEfiGlobalVariableGuid},

-  {EFI_IMAGE_SECURITY_DATABASE,  &gEfiImageSecurityDatabaseGuid},

-  {EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid},

-  {EFI_IMAGE_SECURITY_DATABASE2, &gEfiImageSecurityDatabaseGuid},

-};

-

-//

-// "SecureBoot" may update following PK Del/Add

-//  Cache its value to detect value update

-//

-UINT8       *mSecureBootVarData    = NULL;

-UINTN       mSecureBootVarDataSize = 0;

-

-/**

-  This function will return if this variable is SecureBootPolicy Variable.

-

-  @param[in]  VariableName      A Null-terminated string that is the name of the vendor's variable.

-  @param[in]  VendorGuid        A unique identifier for the vendor.

-

-  @retval TRUE  This is SecureBootPolicy Variable

-  @retval FALSE This is not SecureBootPolicy Variable

-**/

-BOOLEAN

-IsSecureBootPolicyVariable (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  )

-{

-  UINTN   Index;

-

-  for (Index = 0; Index < sizeof(mVariableType)/sizeof(mVariableType[0]); Index++) {

-    if ((StrCmp (VariableName, mVariableType[Index].VariableName) == 0) &&

-        (CompareGuid (VendorGuid, mVariableType[Index].VendorGuid))) {

-      return TRUE;

-    }

-  }

-  return FALSE;

-}

-

-/**

-  Measure and log an EFI variable, and extend the measurement result into a specific PCR.

-

-  @param[in]  VarName           A Null-terminated string that is the name of the vendor's variable.

-  @param[in]  VendorGuid        A unique identifier for the vendor.

-  @param[in]  VarData           The content of the variable data.

-  @param[in]  VarSize           The size of the variable data.

-

-  @retval EFI_SUCCESS           Operation completed successfully.

-  @retval EFI_OUT_OF_RESOURCES  Out of memory.

-  @retval EFI_DEVICE_ERROR      The operation was unsuccessful.

-

-**/

-EFI_STATUS

-EFIAPI

-MeasureVariable (

-  IN      CHAR16                    *VarName,

-  IN      EFI_GUID                  *VendorGuid,

-  IN      VOID                      *VarData,

-  IN      UINTN                     VarSize

-  )

-{

-  EFI_STATUS                        Status;

-  UINTN                             VarNameLength;

-  UEFI_VARIABLE_DATA                *VarLog;

-  UINT32                            VarLogSize;

-

-  ASSERT ((VarSize == 0 && VarData == NULL) || (VarSize != 0 && VarData != NULL));

-

-  VarNameLength      = StrLen (VarName);

-  VarLogSize = (UINT32)(sizeof (*VarLog) + VarNameLength * sizeof (*VarName) + VarSize

-                        - sizeof (VarLog->UnicodeName) - sizeof (VarLog->VariableData));

-

-  VarLog = (UEFI_VARIABLE_DATA *) AllocateZeroPool (VarLogSize);

-  if (VarLog == NULL) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  CopyMem (&VarLog->VariableName, VendorGuid, sizeof(VarLog->VariableName));

-  VarLog->UnicodeNameLength  = VarNameLength;

-  VarLog->VariableDataLength = VarSize;

-  CopyMem (

-     VarLog->UnicodeName,

-     VarName,

-     VarNameLength * sizeof (*VarName)

-     );

-  if (VarSize != 0) {

-    CopyMem (

-       (CHAR16 *)VarLog->UnicodeName + VarNameLength,

-       VarData,

-       VarSize

-       );

-  }

-

-  DEBUG ((EFI_D_INFO, "AuthVariableDxe: MeasureVariable (Pcr - %x, EventType - %x, ", (UINTN)7, (UINTN)EV_EFI_VARIABLE_AUTHORITY));

-  DEBUG ((EFI_D_INFO, "VariableName - %s, VendorGuid - %g)\n", VarName, VendorGuid));

-

-  Status = TpmMeasureAndLogData (

-             7,

-             EV_EFI_VARIABLE_DRIVER_CONFIG,

-             VarLog,

-             VarLogSize,

-             VarLog,

-             VarLogSize

-             );

-  FreePool (VarLog);

-  return Status;

-}

-

-/**

-  Returns the status whether get the variable success. The function retrieves

-  variable  through the UEFI Runtime Service GetVariable().  The

-  returned buffer is allocated using AllocatePool().  The caller is responsible

-  for freeing this buffer with FreePool().

-

-  This API is only invoked in boot time. It may NOT be invoked at runtime.

-

-  @param[in]  Name  The pointer to a Null-terminated Unicode string.

-  @param[in]  Guid  The pointer to an EFI_GUID structure

-  @param[out] Value The buffer point saved the variable info.

-  @param[out] Size  The buffer size of the variable.

-

-  @return EFI_OUT_OF_RESOURCES      Allocate buffer failed.

-  @return EFI_SUCCESS               Find the specified variable.

-  @return Others Errors             Return errors from call to gRT->GetVariable.

-

-**/

-EFI_STATUS

-InternalGetVariable (

-  IN CONST CHAR16    *Name,

-  IN CONST EFI_GUID  *Guid,

-  OUT VOID           **Value,

-  OUT UINTN          *Size

-  )

-{

-  EFI_STATUS  Status;

-  UINTN       BufferSize;

-

-  //

-  // Try to get the variable size.

-  //

-  BufferSize = 0;

-  *Value     = NULL;

-  if (Size != NULL) {

-    *Size  = 0;

-  }

-

-  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &BufferSize, *Value);

-  if (Status != EFI_BUFFER_TOO_SMALL) {

-    return Status;

-  }

-

-  //

-  // Allocate buffer to get the variable.

-  //

-  *Value = AllocatePool (BufferSize);

-  ASSERT (*Value != NULL);

-  if (*Value == NULL) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  //

-  // Get the variable data.

-  //

-  Status = gRT->GetVariable ((CHAR16 *) Name, (EFI_GUID *) Guid, NULL, &BufferSize, *Value);

-  if (EFI_ERROR (Status)) {

-    FreePool(*Value);

-    *Value = NULL;

-  }

-

-  if (Size != NULL) {

-    *Size = BufferSize;

-  }

-

-  return Status;

-}

-

-/**

-  SecureBoot Hook for SetVariable.

-

-  @param[in] VariableName                 Name of Variable to be found.

-  @param[in] VendorGuid                   Variable vendor GUID.

-

-**/

-VOID

-EFIAPI

-SecureBootHook (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  )

-{

-  EFI_STATUS                        Status;

-  UINTN                             VariableDataSize;

-  VOID                              *VariableData;

-

-  if (!IsSecureBootPolicyVariable (VariableName, VendorGuid)) {

-    return ;

-  }

-

-  //

-  // We should NOT use Data and DataSize here,because it may include signature,

-  // or is just partial with append attributes, or is deleted.

-  // We should GetVariable again, to get full variable content.

-  //

-  Status = InternalGetVariable (

-             VariableName,

-             VendorGuid,

-             &VariableData,

-             &VariableDataSize

-             );

-  if (EFI_ERROR (Status)) {

-    //

-    // Measure DBT only if present and not empty

-    //

-    if (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0 &&

-        CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid)) {

-      DEBUG((DEBUG_INFO, "Skip measuring variable %s since it's deleted\n", EFI_IMAGE_SECURITY_DATABASE2));

-      return;

-    } else {

-      VariableData     = NULL;

-      VariableDataSize = 0;

-    }

-  }

-

-  Status = MeasureVariable (

-             VariableName,

-             VendorGuid,

-             VariableData,

-             VariableDataSize

-             );

-  DEBUG ((EFI_D_INFO, "MeasureBootPolicyVariable - %r\n", Status));

-

-  if (VariableData != NULL) {

-    FreePool (VariableData);

-  }

-

-  //

-  // "SecureBoot" is 8bit & read-only. It can only be changed according to PK update

-  //

-  if ((StrCmp (VariableName, EFI_PLATFORM_KEY_NAME) == 0) &&

-       CompareGuid (VendorGuid, &gEfiGlobalVariableGuid)) {

-     Status = InternalGetVariable (

-                EFI_SECURE_BOOT_MODE_NAME,

-                &gEfiGlobalVariableGuid,

-                &VariableData,

-                &VariableDataSize

-                );

-     if (EFI_ERROR (Status)) {

-       return;

-     }

-

-     //

-     // If PK update is successful. "SecureBoot" shall always exist ever since variable write service is ready

-     //

-     ASSERT(mSecureBootVarData != NULL);

-

-     if (CompareMem(mSecureBootVarData, VariableData, VariableDataSize) != 0) {

-       FreePool(mSecureBootVarData);

-       mSecureBootVarData     = VariableData;

-       mSecureBootVarDataSize = VariableDataSize;

-

-       DEBUG((DEBUG_INFO, "%s variable updated according to PK change. Remeasure the value!\n", EFI_SECURE_BOOT_MODE_NAME));

-       Status = MeasureVariable (

-                  EFI_SECURE_BOOT_MODE_NAME,

-                  &gEfiGlobalVariableGuid,

-                  mSecureBootVarData,

-                  mSecureBootVarDataSize

-                  );

-       DEBUG ((DEBUG_INFO, "MeasureBootPolicyVariable - %r\n", Status));

-     } else {

-       //

-       // "SecureBoot" variable is not changed

-       //

-       FreePool(VariableData);

-     }

-  }

-

-  return ;

-}

-

-/**

-  Some Secure Boot Policy Variable may update following other variable changes(SecureBoot follows PK change, etc).

-  Record their initial State when variable write service is ready.

-

-**/

-VOID

-EFIAPI

-RecordSecureBootPolicyVarData(

-  VOID

-  )

-{

-  EFI_STATUS Status;

-

-  //

-  // Record initial "SecureBoot" variable value.

-  // It is used to detect SecureBoot variable change in SecureBootHook.

-  //

-  Status = InternalGetVariable (

-             EFI_SECURE_BOOT_MODE_NAME,

-             &gEfiGlobalVariableGuid,

-             (VOID **)&mSecureBootVarData,

-             &mSecureBootVarDataSize

-             );

-  if (EFI_ERROR(Status)) {

-    //

-    // Read could fail when Auth Variable solution is not supported

-    //

-    DEBUG((DEBUG_INFO, "RecordSecureBootPolicyVarData GetVariable %s Status %x\n", EFI_SECURE_BOOT_MODE_NAME, Status));

-  }

-}

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/Reclaim.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/Reclaim.c
deleted file mode 100644
index 616812ccd8..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/Reclaim.c
+++ /dev/null
@@ -1,161 +0,0 @@
-/** @file

-  Handles non-volatile variable store garbage collection, using FTW

-  (Fault Tolerant Write) protocol.

-

-Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-/**

-  Gets LBA of block and offset by given address.

-

-  This function gets the Logical Block Address (LBA) of a firmware

-  volume block containing the given address, and the offset of the

-  address on the block.

-

-  @param  Address        Address which should be contained

-                         by returned FVB handle.

-  @param  Lba            Pointer to LBA for output.

-  @param  Offset         Pointer to offset for output.

-

-  @retval EFI_SUCCESS    LBA and offset successfully returned.

-  @retval EFI_NOT_FOUND  Fail to find FVB handle by address.

-  @retval EFI_ABORTED    Fail to find valid LBA and offset.

-

-**/

-EFI_STATUS

-GetLbaAndOffsetByAddress (

-  IN  EFI_PHYSICAL_ADDRESS   Address,

-  OUT EFI_LBA                *Lba,

-  OUT UINTN                  *Offset

-  )

-{

-  EFI_STATUS                          Status;

-  EFI_PHYSICAL_ADDRESS                FvbBaseAddress;

-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;

-  EFI_FIRMWARE_VOLUME_HEADER          *FwVolHeader;

-  EFI_FV_BLOCK_MAP_ENTRY              *FvbMapEntry;

-  UINT32                              LbaIndex;

-

-  Fvb     = NULL;

-  *Lba    = (EFI_LBA) (-1);

-  *Offset = 0;

-

-  //

-  // Get the proper FVB protocol.

-  //

-  Status = GetFvbInfoByAddress (Address, NULL, &Fvb);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  //

-  // Get the Base Address of FV.

-  //

-  Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);

-

-  //

-  // Get the (LBA, Offset) of Address.

-  //

-  if ((FwVolHeader->FvLength) > (FwVolHeader->HeaderLength)) {

-    //

-    // BUGBUG: Assume one FV has one type of BlockLength.

-    //

-    FvbMapEntry = &FwVolHeader->BlockMap[0];

-    for (LbaIndex = 1; LbaIndex <= FvbMapEntry->NumBlocks; LbaIndex += 1) {

-      if (Address < (FvbBaseAddress + FvbMapEntry->Length * LbaIndex)) {

-        //

-        // Found the (Lba, Offset).

-        //

-        *Lba    = LbaIndex - 1;

-        *Offset = (UINTN) (Address - (FvbBaseAddress + FvbMapEntry->Length * (LbaIndex - 1)));

-        return EFI_SUCCESS;

-     }

-    }

-  }

-

-  return EFI_ABORTED;

-}

-

-/**

-  Writes a buffer to variable storage space, in the working block.

-

-  This function writes a buffer to variable storage space into a firmware

-  volume block device. The destination is specified by parameter

-  VariableBase. Fault Tolerant Write protocol is used for writing.

-

-  @param  VariableBase   Base address of variable to write

-  @param  VariableBuffer Point to the variable data buffer.

-

-  @retval EFI_SUCCESS    The function completed successfully.

-  @retval EFI_NOT_FOUND  Fail to locate Fault Tolerant Write protocol.

-  @retval EFI_ABORTED    The function could not complete successfully.

-

-**/

-EFI_STATUS

-FtwVariableSpace (

-  IN EFI_PHYSICAL_ADDRESS   VariableBase,

-  IN VARIABLE_STORE_HEADER  *VariableBuffer

-  )

-{

-  EFI_STATUS                         Status;

-  EFI_HANDLE                         FvbHandle;

-  EFI_LBA                            VarLba;

-  UINTN                              VarOffset;

-  UINTN                              FtwBufferSize;

-  EFI_FAULT_TOLERANT_WRITE_PROTOCOL  *FtwProtocol;

-

-  //

-  // Locate fault tolerant write protocol.

-  //

-  Status = GetFtwProtocol((VOID **) &FtwProtocol);

-  if (EFI_ERROR (Status)) {

-    return EFI_NOT_FOUND;

-  }

-  //

-  // Locate Fvb handle by address.

-  //

-  Status = GetFvbInfoByAddress (VariableBase, &FvbHandle, NULL);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-  //

-  // Get LBA and Offset by address.

-  //

-  Status = GetLbaAndOffsetByAddress (VariableBase, &VarLba, &VarOffset);

-  if (EFI_ERROR (Status)) {

-    return EFI_ABORTED;

-  }

-

-  FtwBufferSize = ((VARIABLE_STORE_HEADER *) ((UINTN) VariableBase))->Size;

-  ASSERT (FtwBufferSize == VariableBuffer->Size);

-

-  //

-  // FTW write record.

-  //

-  Status = FtwProtocol->Write (

-                          FtwProtocol,

-                          VarLba,         // LBA

-                          VarOffset,      // Offset

-                          FtwBufferSize,  // NumBytes

-                          NULL,           // PrivateData NULL

-                          FvbHandle,      // Fvb Handle

-                          (VOID *) VariableBuffer // write buffer

-                          );

-

-  return Status;

-}

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/TcgMorLockDxe.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/TcgMorLockDxe.c
deleted file mode 100644
index c32eb3b1ac..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/TcgMorLockDxe.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/** @file

-  TCG MOR (Memory Overwrite Request) Lock Control support (DXE version).

-

-  This module clears MemoryOverwriteRequestControlLock variable to indicate

-  MOR lock control unsupported.

-

-Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include <PiDxe.h>

-#include <Guid/MemoryOverwriteControl.h>

-#include <IndustryStandard/MemoryOverwriteRequestControlLock.h>

-#include <Library/DebugLib.h>

-#include <Library/BaseLib.h>

-#include <Library/BaseMemoryLib.h>

-#include "Variable.h"

-

-extern EDKII_VARIABLE_LOCK_PROTOCOL     mVariableLock;

-

-/**

-  This service is an MOR/MorLock checker handler for the SetVariable().

-

-  @param  VariableName the name of the vendor's variable, as a

-                       Null-Terminated Unicode String

-  @param  VendorGuid   Unify identifier for vendor.

-  @param  Attributes   Point to memory location to return the attributes of variable. If the point

-                       is NULL, the parameter would be ignored.

-  @param  DataSize     The size in bytes of Data-Buffer.

-  @param  Data         Point to the content of the variable.

-

-  @retval  EFI_SUCCESS            The MOR/MorLock check pass, and Variable driver can store the variable data.

-  @retval  EFI_INVALID_PARAMETER  The MOR/MorLock data or data size or attributes is not allowed for MOR variable.

-  @retval  EFI_ACCESS_DENIED      The MOR/MorLock is locked.

-  @retval  EFI_ALREADY_STARTED    The MorLock variable is handled inside this function.

-                                  Variable driver can just return EFI_SUCCESS.

-**/

-EFI_STATUS

-SetVariableCheckHandlerMor (

-  IN CHAR16     *VariableName,

-  IN EFI_GUID   *VendorGuid,

-  IN UINT32     Attributes,

-  IN UINTN      DataSize,

-  IN VOID       *Data

-  )

-{

-  //

-  // Just let it pass. No need provide protection for DXE version.

-  //

-  return EFI_SUCCESS;

-}

-

-/**

-  Initialization for MOR Lock Control.

-

-  @retval EFI_SUCEESS     MorLock initialization success.

-  @return Others          Some error occurs.

-**/

-EFI_STATUS

-MorLockInit (

-  VOID

-  )

-{

-  //

-  // Always clear variable to report unsupported to OS.

-  // The reason is that the DXE version is not proper to provide *protection*.

-  // BIOS should use SMM version variable driver to provide such capability.

-  //

-  VariableServiceSetVariable (

-    MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_NAME,

-    &gEfiMemoryOverwriteRequestControlLockGuid,

-    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-    0,

-    NULL

-    );

-

-  //

-  // Need set this variable to be read-only to prevent other module set it.

-  //

-  VariableLockRequestToLock (&mVariableLock, MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_NAME, &gEfiMemoryOverwriteRequestControlLockGuid);

-  return EFI_SUCCESS;

-}

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/TcgMorLockSmm.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/TcgMorLockSmm.c
deleted file mode 100644
index d06317ca9c..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/TcgMorLockSmm.c
+++ /dev/null
@@ -1,394 +0,0 @@
-/** @file

-  TCG MOR (Memory Overwrite Request) Lock Control support (SMM version).

-

-  This module initilizes MemoryOverwriteRequestControlLock variable.

-  This module adds Variable Hook and check MemoryOverwriteRequestControlLock.

-

-Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include <PiDxe.h>

-#include <Guid/MemoryOverwriteControl.h>

-#include <IndustryStandard/MemoryOverwriteRequestControlLock.h>

-#include <Library/DebugLib.h>

-#include <Library/BaseLib.h>

-#include <Library/BaseMemoryLib.h>

-#include "Variable.h"

-

-typedef struct {

-  CHAR16                                 *VariableName;

-  EFI_GUID                               *VendorGuid;

-} VARIABLE_TYPE;

-

-VARIABLE_TYPE  mMorVariableType[] = {

-  {MEMORY_OVERWRITE_REQUEST_VARIABLE_NAME,      &gEfiMemoryOverwriteControlDataGuid},

-  {MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_NAME,  &gEfiMemoryOverwriteRequestControlLockGuid},

-};

-

-#define MOR_LOCK_DATA_UNLOCKED           0x0

-#define MOR_LOCK_DATA_LOCKED_WITHOUT_KEY 0x1

-#define MOR_LOCK_DATA_LOCKED_WITH_KEY    0x2

-

-#define MOR_LOCK_V1_SIZE      1

-#define MOR_LOCK_V2_KEY_SIZE  8

-

-typedef enum {

-  MorLockStateUnlocked = 0,

-  MorLockStateLocked = 1,

-} MOR_LOCK_STATE;

-

-UINT8           mMorLockKey[MOR_LOCK_V2_KEY_SIZE];

-BOOLEAN         mMorLockKeyEmpty = TRUE;

-BOOLEAN         mMorLockPassThru = FALSE;

-MOR_LOCK_STATE  mMorLockState = MorLockStateUnlocked;

-

-/**

-  Returns if this is MOR related variable.

-

-  @param  VariableName the name of the vendor's variable, it's a Null-Terminated Unicode String

-  @param  VendorGuid   Unify identifier for vendor.

-

-  @retval  TRUE            The variable is MOR related.

-  @retval  FALSE           The variable is NOT MOR related.

-**/

-BOOLEAN

-IsAnyMorVariable (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  )

-{

-  UINTN   Index;

-

-  for (Index = 0; Index < sizeof(mMorVariableType)/sizeof(mMorVariableType[0]); Index++) {

-    if ((StrCmp (VariableName, mMorVariableType[Index].VariableName) == 0) &&

-        (CompareGuid (VendorGuid, mMorVariableType[Index].VendorGuid))) {

-      return TRUE;

-    }

-  }

-  return FALSE;

-}

-

-/**

-  Returns if this is MOR lock variable.

-

-  @param  VariableName the name of the vendor's variable, it's a Null-Terminated Unicode String

-  @param  VendorGuid   Unify identifier for vendor.

-

-  @retval  TRUE            The variable is MOR lock variable.

-  @retval  FALSE           The variable is NOT MOR lock variable.

-**/

-BOOLEAN

-IsMorLockVariable (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  )

-{

-  if ((StrCmp (VariableName, MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_NAME) == 0) &&

-      (CompareGuid (VendorGuid, &gEfiMemoryOverwriteRequestControlLockGuid))) {

-    return TRUE;

-  }

-  return FALSE;

-}

-

-/**

-  Set MOR lock variable.

-

-  @param  Data         MOR Lock variable data.

-

-  @retval  EFI_SUCCESS            The firmware has successfully stored the variable and its data as

-                                  defined by the Attributes.

-  @retval  EFI_INVALID_PARAMETER  An invalid combination of attribute bits was supplied, or the

-                                  DataSize exceeds the maximum allowed.

-  @retval  EFI_INVALID_PARAMETER  VariableName is an empty Unicode string.

-  @retval  EFI_OUT_OF_RESOURCES   Not enough storage is available to hold the variable and its data.

-  @retval  EFI_DEVICE_ERROR       The variable could not be saved due to a hardware failure.

-  @retval  EFI_WRITE_PROTECTED    The variable in question is read-only.

-  @retval  EFI_WRITE_PROTECTED    The variable in question cannot be deleted.

-  @retval  EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS

-                                  set but the AuthInfo does NOT pass the validation check carried

-                                  out by the firmware.

-  @retval  EFI_NOT_FOUND          The variable trying to be updated or deleted was not found.

-**/

-EFI_STATUS

-SetMorLockVariable (

-  IN UINT8  Data

-  )

-{

-  EFI_STATUS  Status;

-

-  mMorLockPassThru = TRUE;

-  Status = VariableServiceSetVariable (

-             MEMORY_OVERWRITE_REQUEST_CONTROL_LOCK_NAME,

-             &gEfiMemoryOverwriteRequestControlLockGuid,

-             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-             sizeof(Data),

-             &Data

-             );

-  mMorLockPassThru = FALSE;

-  return Status;

-}

-

-/**

-  This service is an MorLock checker handler for the SetVariable().

-

-  @param  VariableName the name of the vendor's variable, as a

-                       Null-Terminated Unicode String

-  @param  VendorGuid   Unify identifier for vendor.

-  @param  Attributes   Point to memory location to return the attributes of variable. If the point

-                       is NULL, the parameter would be ignored.

-  @param  DataSize     The size in bytes of Data-Buffer.

-  @param  Data         Point to the content of the variable.

-

-  @retval  EFI_SUCCESS            The MorLock check pass, and Variable driver can store the variable data.

-  @retval  EFI_INVALID_PARAMETER  The MorLock data or data size or attributes is not allowed.

-  @retval  EFI_ACCESS_DENIED      The MorLock is locked.

-  @retval  EFI_WRITE_PROTECTED    The MorLock deletion is not allowed.

-  @retval  EFI_ALREADY_STARTED    The MorLock variable is handled inside this function.

-                                  Variable driver can just return EFI_SUCCESS.

-**/

-EFI_STATUS

-SetVariableCheckHandlerMorLock (

-  IN CHAR16     *VariableName,

-  IN EFI_GUID   *VendorGuid,

-  IN UINT32     Attributes,

-  IN UINTN      DataSize,

-  IN VOID       *Data

-  )

-{

-  EFI_STATUS  Status;

-

-  //

-  // Basic Check

-  //

-  if (Attributes == 0 || DataSize == 0 || Data == NULL) {

-    return EFI_WRITE_PROTECTED;

-  }

-

-  if ((Attributes != (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)) ||

-      ((DataSize != MOR_LOCK_V1_SIZE) && (DataSize != MOR_LOCK_V2_KEY_SIZE))) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  // Do not check if the request is passthru.

-  //

-  if (mMorLockPassThru) {

-    return EFI_SUCCESS;

-  }

-

-  if (mMorLockState == MorLockStateUnlocked) {

-    //

-    // In Unlocked State

-    //

-    if (DataSize == MOR_LOCK_V1_SIZE) {

-      //

-      // V1 - lock permanently

-      //

-      if (*(UINT8 *)Data == MOR_LOCK_DATA_UNLOCKED) {

-        //

-        // Unlock

-        //

-        Status = SetMorLockVariable (MOR_LOCK_DATA_UNLOCKED);

-        if (!EFI_ERROR (Status)) {

-          //

-          // return EFI_ALREADY_STARTED to skip variable set.

-          //

-          return EFI_ALREADY_STARTED;

-        } else {

-          //

-          // SetVar fail

-          //

-          return Status;

-        }

-      } else if (*(UINT8 *)Data == MOR_LOCK_DATA_LOCKED_WITHOUT_KEY) {

-        //

-        // Lock without key

-        //

-        Status = SetMorLockVariable (MOR_LOCK_DATA_LOCKED_WITHOUT_KEY);

-        if (!EFI_ERROR (Status)) {

-          //

-          // Lock success

-          //

-          mMorLockState = MorLockStateLocked;

-          //

-          // return EFI_ALREADY_STARTED to skip variable set.

-          //

-          return EFI_ALREADY_STARTED;

-        } else {

-          //

-          // SetVar fail

-          //

-          return Status;

-        }

-      } else {

-        return EFI_INVALID_PARAMETER;

-      }

-    } else if (DataSize == MOR_LOCK_V2_KEY_SIZE) {

-      //

-      // V2 lock and provision the key

-      //

-

-      //

-      // Need set here because the data value on flash is different

-      //

-      Status = SetMorLockVariable (MOR_LOCK_DATA_LOCKED_WITH_KEY);

-      if (EFI_ERROR(Status)) {

-        //

-        // SetVar fail, do not provision the key

-        //

-        return Status;

-      } else {

-        //

-        // Lock success, provision the key

-        //

-        mMorLockKeyEmpty = FALSE;

-        CopyMem (mMorLockKey, Data, MOR_LOCK_V2_KEY_SIZE);

-        mMorLockState = MorLockStateLocked;

-        //

-        // return EFI_ALREADY_STARTED to skip variable set.

-        //

-        return EFI_ALREADY_STARTED;

-      }

-    } else {

-      ASSERT (FALSE);

-      return EFI_OUT_OF_RESOURCES;

-    }

-  } else {

-    //

-    // In Locked State

-    //

-    if (mMorLockKeyEmpty || (DataSize != MOR_LOCK_V2_KEY_SIZE)) {

-      return EFI_ACCESS_DENIED;

-    }

-    if ((CompareMem (Data, mMorLockKey, MOR_LOCK_V2_KEY_SIZE) == 0)) {

-      //

-      // Key match - unlock

-      //

-

-      //

-      // Need set here because the data value on flash is different

-      //

-      Status = SetMorLockVariable (MOR_LOCK_DATA_UNLOCKED);

-      if (EFI_ERROR (Status)) {

-        //

-        // SetVar fail

-        //

-        return Status;

-      } else {

-        //

-        // Unlock Success

-        //

-        mMorLockState = MorLockStateUnlocked;

-        mMorLockKeyEmpty = TRUE;

-        ZeroMem (mMorLockKey, sizeof(mMorLockKey));

-        //

-        // return EFI_ALREADY_STARTED to skip variable set.

-        //

-        return EFI_ALREADY_STARTED;

-      }

-    } else {

-      //

-      // Key mismatch - Prevent Dictionary Attack

-      //

-      mMorLockState = MorLockStateLocked;

-      mMorLockKeyEmpty = TRUE;

-      ZeroMem (mMorLockKey, sizeof(mMorLockKey));

-      return EFI_ACCESS_DENIED;

-    }

-  }

-}

-

-/**

-  This service is an MOR/MorLock checker handler for the SetVariable().

-

-  @param  VariableName the name of the vendor's variable, as a

-                       Null-Terminated Unicode String

-  @param  VendorGuid   Unify identifier for vendor.

-  @param  Attributes   Point to memory location to return the attributes of variable. If the point

-                       is NULL, the parameter would be ignored.

-  @param  DataSize     The size in bytes of Data-Buffer.

-  @param  Data         Point to the content of the variable.

-

-  @retval  EFI_SUCCESS            The MOR/MorLock check pass, and Variable driver can store the variable data.

-  @retval  EFI_INVALID_PARAMETER  The MOR/MorLock data or data size or attributes is not allowed for MOR variable.

-  @retval  EFI_ACCESS_DENIED      The MOR/MorLock is locked.

-  @retval  EFI_ALREADY_STARTED    The MorLock variable is handled inside this function.

-                                  Variable driver can just return EFI_SUCCESS.

-**/

-EFI_STATUS

-SetVariableCheckHandlerMor (

-  IN CHAR16     *VariableName,

-  IN EFI_GUID   *VendorGuid,

-  IN UINT32     Attributes,

-  IN UINTN      DataSize,

-  IN VOID       *Data

-  )

-{

-  //

-  // do not handle non-MOR variable

-  //

-  if (!IsAnyMorVariable (VariableName, VendorGuid)) {

-    return EFI_SUCCESS;

-  }

-

-  //

-  // MorLock variable

-  //

-  if (IsMorLockVariable (VariableName, VendorGuid)) {

-    return SetVariableCheckHandlerMorLock (

-             VariableName,

-             VendorGuid,

-             Attributes,

-             DataSize,

-             Data

-             );

-  }

-

-  //

-  // Mor Variable

-  //

-

-  //

-  // Basic Check

-  //

-  if ((Attributes != (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)) ||

-      (DataSize != sizeof(UINT8)) ||

-      (Data == NULL)) {

-    return EFI_INVALID_PARAMETER;

-  }

-  if (mMorLockState == MorLockStateLocked) {

-    //

-    // If lock, deny access

-    //

-    return EFI_ACCESS_DENIED;

-  }

-  //

-  // grant access

-  //

-  return EFI_SUCCESS;

-}

-

-/**

-  Initialization for MOR Lock Control.

-

-  @retval EFI_SUCEESS     MorLock initialization success.

-  @return Others          Some error occurs.

-**/

-EFI_STATUS

-MorLockInit (

-  VOID

-  )

-{

-  //

-  // Set variable to report capability to OS

-  //

-  return SetMorLockVariable (0);

-}

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c
deleted file mode 100644
index ad56a9f5be..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c
+++ /dev/null
@@ -1,155 +0,0 @@
-/** @file

-  Implementation functions and structures for var check protocol

-  and variable lock protocol based on VarCheckLib.

-

-Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-/**

-  Mark a variable that will become read-only after leaving the DXE phase of execution.

-  Write request coming from SMM environment through EFI_SMM_VARIABLE_PROTOCOL is allowed.

-

-  @param[in] This          The VARIABLE_LOCK_PROTOCOL instance.

-  @param[in] VariableName  A pointer to the variable name that will be made read-only subsequently.

-  @param[in] VendorGuid    A pointer to the vendor GUID that will be made read-only subsequently.

-

-  @retval EFI_SUCCESS           The variable specified by the VariableName and the VendorGuid was marked

-                                as pending to be read-only.

-  @retval EFI_INVALID_PARAMETER VariableName or VendorGuid is NULL.

-                                Or VariableName is an empty string.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource to hold the lock request.

-**/

-EFI_STATUS

-EFIAPI

-VariableLockRequestToLock (

-  IN CONST EDKII_VARIABLE_LOCK_PROTOCOL *This,

-  IN       CHAR16                       *VariableName,

-  IN       EFI_GUID                     *VendorGuid

-  )

-{

-  EFI_STATUS                    Status;

-  VAR_CHECK_VARIABLE_PROPERTY   Property;

-

-  AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  Status = VarCheckLibVariablePropertyGet (VariableName, VendorGuid, &Property);

-  if (!EFI_ERROR (Status)) {

-    Property.Property |= VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY;

-  } else {

-    Property.Revision = VAR_CHECK_VARIABLE_PROPERTY_REVISION;

-    Property.Property = VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY;

-    Property.Attributes = 0;

-    Property.MinSize = 1;

-    Property.MaxSize = MAX_UINTN;

-  }

-  Status = VarCheckLibVariablePropertySet (VariableName, VendorGuid, &Property);

-

-  DEBUG ((EFI_D_INFO, "[Variable] Lock: %g:%s %r\n", VendorGuid, VariableName, Status));

-

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  return Status;

-}

-

-/**

-  Register SetVariable check handler.

-

-  @param[in] Handler            Pointer to check handler.

-

-  @retval EFI_SUCCESS           The SetVariable check handler was registered successfully.

-  @retval EFI_INVALID_PARAMETER Handler is NULL.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource for the SetVariable check handler register request.

-  @retval EFI_UNSUPPORTED       This interface is not implemented.

-                                For example, it is unsupported in VarCheck protocol if both VarCheck and SmmVarCheck protocols are present.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckRegisterSetVariableCheckHandler (

-  IN VAR_CHECK_SET_VARIABLE_CHECK_HANDLER   Handler

-  )

-{

-  EFI_STATUS    Status;

-

-  AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-  Status = VarCheckLibRegisterSetVariableCheckHandler (Handler);

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  return Status;

-}

-

-/**

-  Variable property set.

-

-  @param[in] Name               Pointer to the variable name.

-  @param[in] Guid               Pointer to the vendor GUID.

-  @param[in] VariableProperty   Pointer to the input variable property.

-

-  @retval EFI_SUCCESS           The property of variable specified by the Name and Guid was set successfully.

-  @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string,

-                                or the fields of VariableProperty are not valid.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource for the variable property set request.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckVariablePropertySet (

-  IN CHAR16                         *Name,

-  IN EFI_GUID                       *Guid,

-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariableProperty

-  )

-{

-  EFI_STATUS    Status;

-

-  AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-  Status = VarCheckLibVariablePropertySet (Name, Guid, VariableProperty);

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  return Status;

-}

-

-/**

-  Variable property get.

-

-  @param[in]  Name              Pointer to the variable name.

-  @param[in]  Guid              Pointer to the vendor GUID.

-  @param[out] VariableProperty  Pointer to the output variable property.

-

-  @retval EFI_SUCCESS           The property of variable specified by the Name and Guid was got successfully.

-  @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string.

-  @retval EFI_NOT_FOUND         The property of variable specified by the Name and Guid was not found.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckVariablePropertyGet (

-  IN CHAR16                         *Name,

-  IN EFI_GUID                       *Guid,

-  OUT VAR_CHECK_VARIABLE_PROPERTY   *VariableProperty

-  )

-{

-  EFI_STATUS    Status;

-

-  AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-  Status = VarCheckLibVariablePropertyGet (Name, Guid, VariableProperty);

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  return Status;

-}

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
deleted file mode 100644
index 0a325de165..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
+++ /dev/null
@@ -1,4237 +0,0 @@
-/** @file

-  The common variable operation routines shared by DXE_RUNTIME variable

-  module and DXE_SMM variable module.

-

-  Caution: This module requires additional review when modified.

-  This driver will have external input - variable data. They may be input in SMM mode.

-  This external input must be validated carefully to avoid security issue like

-  buffer overflow, integer overflow.

-

-  VariableServiceGetNextVariableName () and VariableServiceQueryVariableInfo() are external API.

-  They need check input parameter.

-

-  VariableServiceGetVariable() and VariableServiceSetVariable() are external API

-  to receive datasize and data buffer. The size should be checked carefully.

-

-  VariableServiceSetVariable() should also check authenticate data to avoid buffer overflow,

-  integer overflow. It should also check attribute to avoid authentication bypass.

-

-Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>

-(C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-VARIABLE_MODULE_GLOBAL  *mVariableModuleGlobal;

-

-///

-/// Define a memory cache that improves the search performance for a variable.

-///

-VARIABLE_STORE_HEADER  *mNvVariableCache      = NULL;

-

-///

-/// Memory cache of Fv Header.

-///

-EFI_FIRMWARE_VOLUME_HEADER *mNvFvHeaderCache  = NULL;

-

-///

-/// The memory entry used for variable statistics data.

-///

-VARIABLE_INFO_ENTRY    *gVariableInfo         = NULL;

-

-///

-/// The flag to indicate whether the platform has left the DXE phase of execution.

-///

-BOOLEAN                mEndOfDxe              = FALSE;

-

-///

-/// It indicates the var check request source.

-/// In the implementation, DXE is regarded as untrusted, and SMM is trusted.

-///

-VAR_CHECK_REQUEST_SOURCE mRequestSource       = VarCheckFromUntrusted;

-

-//

-// It will record the current boot error flag before EndOfDxe.

-//

-VAR_ERROR_FLAG         mCurrentBootVarErrFlag = VAR_ERROR_FLAG_NO_ERROR;

-

-VARIABLE_ENTRY_PROPERTY mVariableEntryProperty[] = {

-  {

-    &gEdkiiVarErrorFlagGuid,

-    VAR_ERROR_FLAG_NAME,

-    {

-      VAR_CHECK_VARIABLE_PROPERTY_REVISION,

-      VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,

-      VARIABLE_ATTRIBUTE_NV_BS_RT,

-      sizeof (VAR_ERROR_FLAG),

-      sizeof (VAR_ERROR_FLAG)

-    }

-  },

-};

-

-AUTH_VAR_LIB_CONTEXT_IN mAuthContextIn = {

-  AUTH_VAR_LIB_CONTEXT_IN_STRUCT_VERSION,

-  //

-  // StructSize, TO BE FILLED

-  //

-  0,

-  //

-  // MaxAuthVariableSize, TO BE FILLED

-  //

-  0,

-  VariableExLibFindVariable,

-  VariableExLibFindNextVariable,

-  VariableExLibUpdateVariable,

-  VariableExLibGetScratchBuffer,

-  VariableExLibCheckRemainingSpaceForConsistency,

-  VariableExLibAtRuntime,

-};

-

-AUTH_VAR_LIB_CONTEXT_OUT mAuthContextOut;

-

-/**

-

-  SecureBoot Hook for auth variable update.

-

-  @param[in] VariableName                 Name of Variable to be found.

-  @param[in] VendorGuid                   Variable vendor GUID.

-**/

-VOID

-EFIAPI

-SecureBootHook (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  );

-

-/**

-  Initialization for MOR Lock Control.

-

-  @retval EFI_SUCEESS     MorLock initialization success.

-  @return Others          Some error occurs.

-**/

-EFI_STATUS

-MorLockInit (

-  VOID

-  );

-

-/**

-  This service is an MOR/MorLock checker handler for the SetVariable().

-

-  @param  VariableName the name of the vendor's variable, as a

-                       Null-Terminated Unicode String

-  @param  VendorGuid   Unify identifier for vendor.

-  @param  Attributes   Point to memory location to return the attributes of variable. If the point

-                       is NULL, the parameter would be ignored.

-  @param  DataSize     The size in bytes of Data-Buffer.

-  @param  Data         Point to the content of the variable.

-

-  @retval  EFI_SUCCESS            The MOR/MorLock check pass, and Variable driver can store the variable data.

-  @retval  EFI_INVALID_PARAMETER  The MOR/MorLock data or data size or attributes is not allowed for MOR variable.

-  @retval  EFI_ACCESS_DENIED      The MOR/MorLock is locked.

-  @retval  EFI_ALREADY_STARTED    The MorLock variable is handled inside this function.

-                                  Variable driver can just return EFI_SUCCESS.

-**/

-EFI_STATUS

-SetVariableCheckHandlerMor (

-  IN CHAR16     *VariableName,

-  IN EFI_GUID   *VendorGuid,

-  IN UINT32     Attributes,

-  IN UINTN      DataSize,

-  IN VOID       *Data

-  );

-

-/**

-  Routine used to track statistical information about variable usage.

-  The data is stored in the EFI system table so it can be accessed later.

-  VariableInfo.efi can dump out the table. Only Boot Services variable

-  accesses are tracked by this code. The PcdVariableCollectStatistics

-  build flag controls if this feature is enabled.

-

-  A read that hits in the cache will have Read and Cache true for

-  the transaction. Data is allocated by this routine, but never

-  freed.

-

-  @param[in] VariableName   Name of the Variable to track.

-  @param[in] VendorGuid     Guid of the Variable to track.

-  @param[in] Volatile       TRUE if volatile FALSE if non-volatile.

-  @param[in] Read           TRUE if GetVariable() was called.

-  @param[in] Write          TRUE if SetVariable() was called.

-  @param[in] Delete         TRUE if deleted via SetVariable().

-  @param[in] Cache          TRUE for a cache hit.

-

-**/

-VOID

-UpdateVariableInfo (

-  IN  CHAR16                  *VariableName,

-  IN  EFI_GUID                *VendorGuid,

-  IN  BOOLEAN                 Volatile,

-  IN  BOOLEAN                 Read,

-  IN  BOOLEAN                 Write,

-  IN  BOOLEAN                 Delete,

-  IN  BOOLEAN                 Cache

-  )

-{

-  VARIABLE_INFO_ENTRY   *Entry;

-

-  if (FeaturePcdGet (PcdVariableCollectStatistics)) {

-

-    if (AtRuntime ()) {

-      // Don't collect statistics at runtime.

-      return;

-    }

-

-    if (gVariableInfo == NULL) {

-      //

-      // On the first call allocate a entry and place a pointer to it in

-      // the EFI System Table.

-      //

-      gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));

-      ASSERT (gVariableInfo != NULL);

-

-      CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);

-      gVariableInfo->Name = AllocateZeroPool (StrSize (VariableName));

-      ASSERT (gVariableInfo->Name != NULL);

-      StrCpyS (gVariableInfo->Name, StrSize(VariableName)/sizeof(CHAR16), VariableName);

-      gVariableInfo->Volatile = Volatile;

-    }

-

-

-    for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) {

-      if (CompareGuid (VendorGuid, &Entry->VendorGuid)) {

-        if (StrCmp (VariableName, Entry->Name) == 0) {

-          if (Read) {

-            Entry->ReadCount++;

-          }

-          if (Write) {

-            Entry->WriteCount++;

-          }

-          if (Delete) {

-            Entry->DeleteCount++;

-          }

-          if (Cache) {

-            Entry->CacheCount++;

-          }

-

-          return;

-        }

-      }

-

-      if (Entry->Next == NULL) {

-        //

-        // If the entry is not in the table add it.

-        // Next iteration of the loop will fill in the data.

-        //

-        Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));

-        ASSERT (Entry->Next != NULL);

-

-        CopyGuid (&Entry->Next->VendorGuid, VendorGuid);

-        Entry->Next->Name = AllocateZeroPool (StrSize (VariableName));

-        ASSERT (Entry->Next->Name != NULL);

-        StrCpyS (Entry->Next->Name, StrSize(VariableName)/sizeof(CHAR16), VariableName);

-        Entry->Next->Volatile = Volatile;

-      }

-

-    }

-  }

-}

-

-

-/**

-

-  This code checks if variable header is valid or not.

-

-  @param Variable           Pointer to the Variable Header.

-  @param VariableStoreEnd   Pointer to the Variable Store End.

-

-  @retval TRUE              Variable header is valid.

-  @retval FALSE             Variable header is not valid.

-

-**/

-BOOLEAN

-IsValidVariableHeader (

-  IN  VARIABLE_HEADER       *Variable,

-  IN  VARIABLE_HEADER       *VariableStoreEnd

-  )

-{

-  if ((Variable == NULL) || (Variable >= VariableStoreEnd) || (Variable->StartId != VARIABLE_DATA)) {

-    //

-    // Variable is NULL or has reached the end of variable store,

-    // or the StartId is not correct.

-    //

-    return FALSE;

-  }

-

-  return TRUE;

-}

-

-

-/**

-

-  This function writes data to the FWH at the correct LBA even if the LBAs

-  are fragmented.

-

-  @param Global                  Pointer to VARAIBLE_GLOBAL structure.

-  @param Volatile                Point out the Variable is Volatile or Non-Volatile.

-  @param SetByIndex              TRUE if target pointer is given as index.

-                                 FALSE if target pointer is absolute.

-  @param Fvb                     Pointer to the writable FVB protocol.

-  @param DataPtrIndex            Pointer to the Data from the end of VARIABLE_STORE_HEADER

-                                 structure.

-  @param DataSize                Size of data to be written.

-  @param Buffer                  Pointer to the buffer from which data is written.

-

-  @retval EFI_INVALID_PARAMETER  Parameters not valid.

-  @retval EFI_SUCCESS            Variable store successfully updated.

-

-**/

-EFI_STATUS

-UpdateVariableStore (

-  IN  VARIABLE_GLOBAL                     *Global,

-  IN  BOOLEAN                             Volatile,

-  IN  BOOLEAN                             SetByIndex,

-  IN  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb,

-  IN  UINTN                               DataPtrIndex,

-  IN  UINT32                              DataSize,

-  IN  UINT8                               *Buffer

-  )

-{

-  EFI_FV_BLOCK_MAP_ENTRY      *PtrBlockMapEntry;

-  UINTN                       BlockIndex2;

-  UINTN                       LinearOffset;

-  UINTN                       CurrWriteSize;

-  UINTN                       CurrWritePtr;

-  UINT8                       *CurrBuffer;

-  EFI_LBA                     LbaNumber;

-  UINTN                       Size;

-  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;

-  VARIABLE_STORE_HEADER       *VolatileBase;

-  EFI_PHYSICAL_ADDRESS        FvVolHdr;

-  EFI_PHYSICAL_ADDRESS        DataPtr;

-  EFI_STATUS                  Status;

-

-  FwVolHeader = NULL;

-  DataPtr     = DataPtrIndex;

-

-  //

-  // Check if the Data is Volatile.

-  //

-  if (!Volatile) {

-    if (Fvb == NULL) {

-      return EFI_INVALID_PARAMETER;

-    }

-    Status = Fvb->GetPhysicalAddress(Fvb, &FvVolHdr);

-    ASSERT_EFI_ERROR (Status);

-

-    FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);

-    //

-    // Data Pointer should point to the actual Address where data is to be

-    // written.

-    //

-    if (SetByIndex) {

-      DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;

-    }

-

-    if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {

-      return EFI_INVALID_PARAMETER;

-    }

-  } else {

-    //

-    // Data Pointer should point to the actual Address where data is to be

-    // written.

-    //

-    VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);

-    if (SetByIndex) {

-      DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;

-    }

-

-    if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {

-      return EFI_INVALID_PARAMETER;

-    }

-

-    //

-    // If Volatile Variable just do a simple mem copy.

-    //

-    CopyMem ((UINT8 *)(UINTN)DataPtr, Buffer, DataSize);

-    return EFI_SUCCESS;

-  }

-

-  //

-  // If we are here we are dealing with Non-Volatile Variables.

-  //

-  LinearOffset  = (UINTN) FwVolHeader;

-  CurrWritePtr  = (UINTN) DataPtr;

-  CurrWriteSize = DataSize;

-  CurrBuffer    = Buffer;

-  LbaNumber     = 0;

-

-  if (CurrWritePtr < LinearOffset) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  for (PtrBlockMapEntry = mNvFvHeaderCache->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {

-    for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {

-      //

-      // Check to see if the Variable Writes are spanning through multiple

-      // blocks.

-      //

-      if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->Length)) {

-        if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->Length)) {

-          Status = Fvb->Write (

-                    Fvb,

-                    LbaNumber,

-                    (UINTN) (CurrWritePtr - LinearOffset),

-                    &CurrWriteSize,

-                    CurrBuffer

-                    );

-          return Status;

-        } else {

-          Size = (UINT32) (LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);

-          Status = Fvb->Write (

-                    Fvb,

-                    LbaNumber,

-                    (UINTN) (CurrWritePtr - LinearOffset),

-                    &Size,

-                    CurrBuffer

-                    );

-          if (EFI_ERROR (Status)) {

-            return Status;

-          }

-

-          CurrWritePtr  = LinearOffset + PtrBlockMapEntry->Length;

-          CurrBuffer    = CurrBuffer + Size;

-          CurrWriteSize = CurrWriteSize - Size;

-        }

-      }

-

-      LinearOffset += PtrBlockMapEntry->Length;

-      LbaNumber++;

-    }

-  }

-

-  return EFI_SUCCESS;

-}

-

-

-/**

-

-  This code gets the current status of Variable Store.

-

-  @param VarStoreHeader  Pointer to the Variable Store Header.

-

-  @retval EfiRaw         Variable store status is raw.

-  @retval EfiValid       Variable store status is valid.

-  @retval EfiInvalid     Variable store status is invalid.

-

-**/

-VARIABLE_STORE_STATUS

-GetVariableStoreStatus (

-  IN VARIABLE_STORE_HEADER *VarStoreHeader

-  )

-{

-  if ((CompareGuid (&VarStoreHeader->Signature, &gEfiAuthenticatedVariableGuid) ||

-       CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid)) &&

-      VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&

-      VarStoreHeader->State == VARIABLE_STORE_HEALTHY

-      ) {

-

-    return EfiValid;

-  } else if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&

-             ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&

-             ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&

-             ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&

-             VarStoreHeader->Size == 0xffffffff &&

-             VarStoreHeader->Format == 0xff &&

-             VarStoreHeader->State == 0xff

-          ) {

-

-    return EfiRaw;

-  } else {

-    return EfiInvalid;

-  }

-}

-

-/**

-  This code gets the size of variable header.

-

-  @return Size of variable header in bytes in type UINTN.

-

-**/

-UINTN

-GetVariableHeaderSize (

-  VOID

-  )

-{

-  UINTN Value;

-

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);

-  } else {

-    Value = sizeof (VARIABLE_HEADER);

-  }

-

-  return Value;

-}

-

-/**

-

-  This code gets the size of name of variable.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return UINTN          Size of variable in bytes.

-

-**/

-UINTN

-NameSizeOfVariable (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    if (AuthVariable->State == (UINT8) (-1) ||

-       AuthVariable->DataSize == (UINT32) (-1) ||

-       AuthVariable->NameSize == (UINT32) (-1) ||

-       AuthVariable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) AuthVariable->NameSize;

-  } else {

-    if (Variable->State == (UINT8) (-1) ||

-        Variable->DataSize == (UINT32) (-1) ||

-        Variable->NameSize == (UINT32) (-1) ||

-        Variable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) Variable->NameSize;

-  }

-}

-

-/**

-  This code sets the size of name of variable.

-

-  @param[in] Variable   Pointer to the Variable Header.

-  @param[in] NameSize   Name size to set.

-

-**/

-VOID

-SetNameSizeOfVariable (

-  IN VARIABLE_HEADER    *Variable,

-  IN UINTN              NameSize

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    AuthVariable->NameSize = (UINT32) NameSize;

-  } else {

-    Variable->NameSize = (UINT32) NameSize;

-  }

-}

-

-/**

-

-  This code gets the size of variable data.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Size of variable in bytes.

-

-**/

-UINTN

-DataSizeOfVariable (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    if (AuthVariable->State == (UINT8) (-1) ||

-       AuthVariable->DataSize == (UINT32) (-1) ||

-       AuthVariable->NameSize == (UINT32) (-1) ||

-       AuthVariable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) AuthVariable->DataSize;

-  } else {

-    if (Variable->State == (UINT8) (-1) ||

-        Variable->DataSize == (UINT32) (-1) ||

-        Variable->NameSize == (UINT32) (-1) ||

-        Variable->Attributes == (UINT32) (-1)) {

-      return 0;

-    }

-    return (UINTN) Variable->DataSize;

-  }

-}

-

-/**

-  This code sets the size of variable data.

-

-  @param[in] Variable   Pointer to the Variable Header.

-  @param[in] DataSize   Data size to set.

-

-**/

-VOID

-SetDataSizeOfVariable (

-  IN VARIABLE_HEADER    *Variable,

-  IN UINTN              DataSize

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    AuthVariable->DataSize = (UINT32) DataSize;

-  } else {

-    Variable->DataSize = (UINT32) DataSize;

-  }

-}

-

-/**

-

-  This code gets the pointer to the variable name.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Pointer to Variable Name which is Unicode encoding.

-

-**/

-CHAR16 *

-GetVariableNamePtr (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  return (CHAR16 *) ((UINTN) Variable + GetVariableHeaderSize ());

-}

-

-/**

-  This code gets the pointer to the variable guid.

-

-  @param Variable   Pointer to the Variable Header.

-

-  @return A EFI_GUID* pointer to Vendor Guid.

-

-**/

-EFI_GUID *

-GetVendorGuidPtr (

-  IN VARIABLE_HEADER    *Variable

-  )

-{

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    return &AuthVariable->VendorGuid;

-  } else {

-    return &Variable->VendorGuid;

-  }

-}

-

-/**

-

-  This code gets the pointer to the variable data.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Pointer to Variable Data.

-

-**/

-UINT8 *

-GetVariableDataPtr (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  UINTN Value;

-

-  //

-  // Be careful about pad size for alignment.

-  //

-  Value =  (UINTN) GetVariableNamePtr (Variable);

-  Value += NameSizeOfVariable (Variable);

-  Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));

-

-  return (UINT8 *) Value;

-}

-

-/**

-  This code gets the variable data offset related to variable header.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Variable Data offset.

-

-**/

-UINTN

-GetVariableDataOffset (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  UINTN Value;

-

-  //

-  // Be careful about pad size for alignment

-  //

-  Value = GetVariableHeaderSize ();

-  Value += NameSizeOfVariable (Variable);

-  Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));

-

-  return Value;

-}

-

-/**

-

-  This code gets the pointer to the next variable header.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Pointer to next variable header.

-

-**/

-VARIABLE_HEADER *

-GetNextVariablePtr (

-  IN  VARIABLE_HEADER   *Variable

-  )

-{

-  UINTN Value;

-

-  Value =  (UINTN) GetVariableDataPtr (Variable);

-  Value += DataSizeOfVariable (Variable);

-  Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));

-

-  //

-  // Be careful about pad size for alignment.

-  //

-  return (VARIABLE_HEADER *) HEADER_ALIGN (Value);

-}

-

-/**

-

-  Gets the pointer to the first variable header in given variable store area.

-

-  @param VarStoreHeader  Pointer to the Variable Store Header.

-

-  @return Pointer to the first variable header.

-

-**/

-VARIABLE_HEADER *

-GetStartPointer (

-  IN VARIABLE_STORE_HEADER       *VarStoreHeader

-  )

-{

-  //

-  // The end of variable store.

-  //

-  return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);

-}

-

-/**

-

-  Gets the pointer to the end of the variable storage area.

-

-  This function gets pointer to the end of the variable storage

-  area, according to the input variable store header.

-

-  @param VarStoreHeader  Pointer to the Variable Store Header.

-

-  @return Pointer to the end of the variable storage area.

-

-**/

-VARIABLE_HEADER *

-GetEndPointer (

-  IN VARIABLE_STORE_HEADER       *VarStoreHeader

-  )

-{

-  //

-  // The end of variable store

-  //

-  return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);

-}

-

-/**

-  Record variable error flag.

-

-  @param[in] Flag               Variable error flag to record.

-  @param[in] VariableName       Name of variable.

-  @param[in] VendorGuid         Guid of variable.

-  @param[in] Attributes         Attributes of the variable.

-  @param[in] VariableSize       Size of the variable.

-

-**/

-VOID

-RecordVarErrorFlag (

-  IN VAR_ERROR_FLAG         Flag,

-  IN CHAR16                 *VariableName,

-  IN EFI_GUID               *VendorGuid,

-  IN UINT32                 Attributes,

-  IN UINTN                  VariableSize

-  )

-{

-  EFI_STATUS                Status;

-  VARIABLE_POINTER_TRACK    Variable;

-  VAR_ERROR_FLAG            *VarErrFlag;

-  VAR_ERROR_FLAG            TempFlag;

-

-  DEBUG_CODE (

-    DEBUG ((EFI_D_ERROR, "RecordVarErrorFlag (0x%02x) %s:%g - 0x%08x - 0x%x\n", Flag, VariableName, VendorGuid, Attributes, VariableSize));

-    if (Flag == VAR_ERROR_FLAG_SYSTEM_ERROR) {

-      if (AtRuntime ()) {

-        DEBUG ((EFI_D_ERROR, "CommonRuntimeVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonRuntimeVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));

-      } else {

-        DEBUG ((EFI_D_ERROR, "CommonVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));

-      }

-    } else {

-      DEBUG ((EFI_D_ERROR, "CommonMaxUserVariableSpace = 0x%x - CommonUserVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonUserVariableTotalSize));

-    }

-  );

-

-  if (!mEndOfDxe) {

-    //

-    // Before EndOfDxe, just record the current boot variable error flag to local variable,

-    // and leave the variable error flag in NV flash as the last boot variable error flag.

-    // After EndOfDxe in InitializeVarErrorFlag (), the variable error flag in NV flash

-    // will be initialized to this local current boot variable error flag.

-    //

-    mCurrentBootVarErrFlag &= Flag;

-    return;

-  }

-

-  //

-  // Record error flag (it should have be initialized).

-  //

-  Status = FindVariable (

-             VAR_ERROR_FLAG_NAME,

-             &gEdkiiVarErrorFlagGuid,

-             &Variable,

-             &mVariableModuleGlobal->VariableGlobal,

-             FALSE

-             );

-  if (!EFI_ERROR (Status)) {

-    VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr);

-    TempFlag = *VarErrFlag;

-    TempFlag &= Flag;

-    if (TempFlag == *VarErrFlag) {

-      return;

-    }

-    Status = UpdateVariableStore (

-               &mVariableModuleGlobal->VariableGlobal,

-               FALSE,

-               FALSE,

-               mVariableModuleGlobal->FvbInstance,

-               (UINTN) VarErrFlag - (UINTN) mNvVariableCache + (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

-               sizeof (TempFlag),

-               &TempFlag

-               );

-    if (!EFI_ERROR (Status)) {

-      //

-      // Update the data in NV cache.

-      //

-      *VarErrFlag = TempFlag;

-    }

-  }

-}

-

-/**

-  Initialize variable error flag.

-

-  Before EndOfDxe, the variable indicates the last boot variable error flag,

-  then it means the last boot variable error flag must be got before EndOfDxe.

-  After EndOfDxe, the variable indicates the current boot variable error flag,

-  then it means the current boot variable error flag must be got after EndOfDxe.

-

-**/

-VOID

-InitializeVarErrorFlag (

-  VOID

-  )

-{

-  EFI_STATUS                Status;

-  VARIABLE_POINTER_TRACK    Variable;

-  VAR_ERROR_FLAG            Flag;

-  VAR_ERROR_FLAG            VarErrFlag;

-

-  if (!mEndOfDxe) {

-    return;

-  }

-

-  Flag = mCurrentBootVarErrFlag;

-  DEBUG ((EFI_D_INFO, "Initialize variable error flag (%02x)\n", Flag));

-

-  Status = FindVariable (

-             VAR_ERROR_FLAG_NAME,

-             &gEdkiiVarErrorFlagGuid,

-             &Variable,

-             &mVariableModuleGlobal->VariableGlobal,

-             FALSE

-             );

-  if (!EFI_ERROR (Status)) {

-    VarErrFlag = *((VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr));

-    if (VarErrFlag == Flag) {

-      return;

-    }

-  }

-

-  UpdateVariable (

-    VAR_ERROR_FLAG_NAME,

-    &gEdkiiVarErrorFlagGuid,

-    &Flag,

-    sizeof (Flag),

-    VARIABLE_ATTRIBUTE_NV_BS_RT,

-    0,

-    0,

-    &Variable,

-    NULL

-    );

-}

-

-/**

-  Is user variable?

-

-  @param[in] Variable   Pointer to variable header.

-

-  @retval TRUE          User variable.

-  @retval FALSE         System variable.

-

-**/

-BOOLEAN

-IsUserVariable (

-  IN VARIABLE_HEADER    *Variable

-  )

-{

-  VAR_CHECK_VARIABLE_PROPERTY   Property;

-

-  //

-  // Only after End Of Dxe, the variables belong to system variable are fixed.

-  // If PcdMaxUserNvStorageVariableSize is 0, it means user variable share the same NV storage with system variable,

-  // then no need to check if the variable is user variable or not specially.

-  //

-  if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {

-    if (VarCheckLibVariablePropertyGet (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &Property) == EFI_NOT_FOUND) {

-      return TRUE;

-    }

-  }

-  return FALSE;

-}

-

-/**

-  Calculate common user variable total size.

-

-**/

-VOID

-CalculateCommonUserVariableTotalSize (

-  VOID

-  )

-{

-  VARIABLE_HEADER               *Variable;

-  VARIABLE_HEADER               *NextVariable;

-  UINTN                         VariableSize;

-  VAR_CHECK_VARIABLE_PROPERTY   Property;

-

-  //

-  // Only after End Of Dxe, the variables belong to system variable are fixed.

-  // If PcdMaxUserNvStorageVariableSize is 0, it means user variable share the same NV storage with system variable,

-  // then no need to calculate the common user variable total size specially.

-  //

-  if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {

-    Variable = GetStartPointer (mNvVariableCache);

-    while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache))) {

-      NextVariable = GetNextVariablePtr (Variable);

-      VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-      if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-        if (VarCheckLibVariablePropertyGet (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &Property) == EFI_NOT_FOUND) {

-          //

-          // No property, it is user variable.

-          //

-          mVariableModuleGlobal->CommonUserVariableTotalSize += VariableSize;

-        }

-      }

-

-      Variable = NextVariable;

-    }

-  }

-}

-

-/**

-  Initialize variable quota.

-

-**/

-VOID

-InitializeVariableQuota (

-  VOID

-  )

-{

-  if (!mEndOfDxe) {

-    return;

-  }

-

-  InitializeVarErrorFlag ();

-  CalculateCommonUserVariableTotalSize ();

-}

-

-/**

-

-  Variable store garbage collection and reclaim operation.

-

-  @param[in]      VariableBase            Base address of variable store.

-  @param[out]     LastVariableOffset      Offset of last variable.

-  @param[in]      IsVolatile              The variable store is volatile or not;

-                                          if it is non-volatile, need FTW.

-  @param[in, out] UpdatingPtrTrack        Pointer to updating variable pointer track structure.

-  @param[in]      NewVariable             Pointer to new variable.

-  @param[in]      NewVariableSize         New variable size.

-

-  @return EFI_SUCCESS                  Reclaim operation has finished successfully.

-  @return EFI_OUT_OF_RESOURCES         No enough memory resources or variable space.

-  @return Others                       Unexpect error happened during reclaim operation.

-

-**/

-EFI_STATUS

-Reclaim (

-  IN     EFI_PHYSICAL_ADDRESS         VariableBase,

-  OUT    UINTN                        *LastVariableOffset,

-  IN     BOOLEAN                      IsVolatile,

-  IN OUT VARIABLE_POINTER_TRACK       *UpdatingPtrTrack,

-  IN     VARIABLE_HEADER              *NewVariable,

-  IN     UINTN                        NewVariableSize

-  )

-{

-  VARIABLE_HEADER       *Variable;

-  VARIABLE_HEADER       *AddedVariable;

-  VARIABLE_HEADER       *NextVariable;

-  VARIABLE_HEADER       *NextAddedVariable;

-  VARIABLE_STORE_HEADER *VariableStoreHeader;

-  UINT8                 *ValidBuffer;

-  UINTN                 MaximumBufferSize;

-  UINTN                 VariableSize;

-  UINTN                 NameSize;

-  UINT8                 *CurrPtr;

-  VOID                  *Point0;

-  VOID                  *Point1;

-  BOOLEAN               FoundAdded;

-  EFI_STATUS            Status;

-  UINTN                 CommonVariableTotalSize;

-  UINTN                 CommonUserVariableTotalSize;

-  UINTN                 HwErrVariableTotalSize;

-  VARIABLE_HEADER       *UpdatingVariable;

-  VARIABLE_HEADER       *UpdatingInDeletedTransition;

-

-  UpdatingVariable = NULL;

-  UpdatingInDeletedTransition = NULL;

-  if (UpdatingPtrTrack != NULL) {

-    UpdatingVariable = UpdatingPtrTrack->CurrPtr;

-    UpdatingInDeletedTransition = UpdatingPtrTrack->InDeletedTransitionPtr;

-  }

-

-  VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);

-

-  CommonVariableTotalSize = 0;

-  CommonUserVariableTotalSize = 0;

-  HwErrVariableTotalSize  = 0;

-

-  if (IsVolatile) {

-    //

-    // Start Pointers for the variable.

-    //

-    Variable          = GetStartPointer (VariableStoreHeader);

-    MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);

-

-    while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {

-      NextVariable = GetNextVariablePtr (Variable);

-      if ((Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) &&

-          Variable != UpdatingVariable &&

-          Variable != UpdatingInDeletedTransition

-         ) {

-        VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-        MaximumBufferSize += VariableSize;

-      }

-

-      Variable = NextVariable;

-    }

-

-    if (NewVariable != NULL) {

-      //

-      // Add the new variable size.

-      //

-      MaximumBufferSize += NewVariableSize;

-    }

-

-    //

-    // Reserve the 1 Bytes with Oxff to identify the

-    // end of the variable buffer.

-    //

-    MaximumBufferSize += 1;

-    ValidBuffer = AllocatePool (MaximumBufferSize);

-    if (ValidBuffer == NULL) {

-      return EFI_OUT_OF_RESOURCES;

-    }

-  } else {

-    //

-    // For NV variable reclaim, don't allocate pool here and just use mNvVariableCache

-    // as the buffer to reduce SMRAM consumption for SMM variable driver.

-    //

-    MaximumBufferSize = mNvVariableCache->Size;

-    ValidBuffer = (UINT8 *) mNvVariableCache;

-  }

-

-  SetMem (ValidBuffer, MaximumBufferSize, 0xff);

-

-  //

-  // Copy variable store header.

-  //

-  CopyMem (ValidBuffer, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));

-  CurrPtr = (UINT8 *) GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);

-

-  //

-  // Reinstall all ADDED variables as long as they are not identical to Updating Variable.

-  //

-  Variable = GetStartPointer (VariableStoreHeader);

-  while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {

-    NextVariable = GetNextVariablePtr (Variable);

-    if (Variable != UpdatingVariable && Variable->State == VAR_ADDED) {

-      VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-      CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);

-      CurrPtr += VariableSize;

-      if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-        HwErrVariableTotalSize += VariableSize;

-      } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-        CommonVariableTotalSize += VariableSize;

-        if (IsUserVariable (Variable)) {

-          CommonUserVariableTotalSize += VariableSize;

-        }

-      }

-    }

-    Variable = NextVariable;

-  }

-

-  //

-  // Reinstall all in delete transition variables.

-  //

-  Variable = GetStartPointer (VariableStoreHeader);

-  while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {

-    NextVariable = GetNextVariablePtr (Variable);

-    if (Variable != UpdatingVariable && Variable != UpdatingInDeletedTransition && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-

-      //

-      // Buffer has cached all ADDED variable.

-      // Per IN_DELETED variable, we have to guarantee that

-      // no ADDED one in previous buffer.

-      //

-

-      FoundAdded = FALSE;

-      AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);

-      while (IsValidVariableHeader (AddedVariable, GetEndPointer ((VARIABLE_STORE_HEADER *) ValidBuffer))) {

-        NextAddedVariable = GetNextVariablePtr (AddedVariable);

-        NameSize = NameSizeOfVariable (AddedVariable);

-        if (CompareGuid (GetVendorGuidPtr (AddedVariable), GetVendorGuidPtr (Variable)) &&

-            NameSize == NameSizeOfVariable (Variable)

-           ) {

-          Point0 = (VOID *) GetVariableNamePtr (AddedVariable);

-          Point1 = (VOID *) GetVariableNamePtr (Variable);

-          if (CompareMem (Point0, Point1, NameSize) == 0) {

-            FoundAdded = TRUE;

-            break;

-          }

-        }

-        AddedVariable = NextAddedVariable;

-      }

-      if (!FoundAdded) {

-        //

-        // Promote VAR_IN_DELETED_TRANSITION to VAR_ADDED.

-        //

-        VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-        CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);

-        ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;

-        CurrPtr += VariableSize;

-        if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-          HwErrVariableTotalSize += VariableSize;

-        } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-          CommonVariableTotalSize += VariableSize;

-          if (IsUserVariable (Variable)) {

-            CommonUserVariableTotalSize += VariableSize;

-          }

-        }

-      }

-    }

-

-    Variable = NextVariable;

-  }

-

-  //

-  // Install the new variable if it is not NULL.

-  //

-  if (NewVariable != NULL) {

-    if (((UINTN) CurrPtr - (UINTN) ValidBuffer) + NewVariableSize > VariableStoreHeader->Size) {

-      //

-      // No enough space to store the new variable.

-      //

-      Status = EFI_OUT_OF_RESOURCES;

-      goto Done;

-    }

-    if (!IsVolatile) {

-      if ((NewVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-        HwErrVariableTotalSize += NewVariableSize;

-      } else if ((NewVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-        CommonVariableTotalSize += NewVariableSize;

-        if (IsUserVariable (NewVariable)) {

-          CommonUserVariableTotalSize += NewVariableSize;

-        }

-      }

-      if ((HwErrVariableTotalSize > PcdGet32 (PcdHwErrStorageSize)) ||

-          (CommonVariableTotalSize > mVariableModuleGlobal->CommonVariableSpace) ||

-          (CommonUserVariableTotalSize > mVariableModuleGlobal->CommonMaxUserVariableSpace)) {

-        //

-        // No enough space to store the new variable by NV or NV+HR attribute.

-        //

-        Status = EFI_OUT_OF_RESOURCES;

-        goto Done;

-      }

-    }

-

-    CopyMem (CurrPtr, (UINT8 *) NewVariable, NewVariableSize);

-    ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;

-    if (UpdatingVariable != NULL) {

-      UpdatingPtrTrack->CurrPtr = (VARIABLE_HEADER *)((UINTN)UpdatingPtrTrack->StartPtr + ((UINTN)CurrPtr - (UINTN)GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer)));

-      UpdatingPtrTrack->InDeletedTransitionPtr = NULL;

-    }

-    CurrPtr += NewVariableSize;

-  }

-

-  if (IsVolatile) {

-    //

-    // If volatile variable store, just copy valid buffer.

-    //

-    SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);

-    CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, (UINTN) CurrPtr - (UINTN) ValidBuffer);

-    *LastVariableOffset = (UINTN) CurrPtr - (UINTN) ValidBuffer;

-    Status  = EFI_SUCCESS;

-  } else {

-    //

-    // If non-volatile variable store, perform FTW here.

-    //

-    Status = FtwVariableSpace (

-              VariableBase,

-              (VARIABLE_STORE_HEADER *) ValidBuffer

-              );

-    if (!EFI_ERROR (Status)) {

-      *LastVariableOffset = (UINTN) CurrPtr - (UINTN) ValidBuffer;

-      mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;

-      mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;

-      mVariableModuleGlobal->CommonUserVariableTotalSize = CommonUserVariableTotalSize;

-    } else {

-      mVariableModuleGlobal->HwErrVariableTotalSize = 0;

-      mVariableModuleGlobal->CommonVariableTotalSize = 0;

-      mVariableModuleGlobal->CommonUserVariableTotalSize = 0;

-      Variable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase);

-      while (IsValidVariableHeader (Variable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase))) {

-        NextVariable = GetNextVariablePtr (Variable);

-        VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-        if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-          mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;

-        } else if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-          mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;

-          if (IsUserVariable (Variable)) {

-            mVariableModuleGlobal->CommonUserVariableTotalSize += VariableSize;

-          }

-        }

-

-        Variable = NextVariable;

-      }

-      *LastVariableOffset = (UINTN) Variable - (UINTN) VariableBase;

-    }

-  }

-

-Done:

-  if (IsVolatile) {

-    FreePool (ValidBuffer);

-  } else {

-    //

-    // For NV variable reclaim, we use mNvVariableCache as the buffer, so copy the data back.

-    //

-    CopyMem (mNvVariableCache, (UINT8 *)(UINTN)VariableBase, VariableStoreHeader->Size);

-  }

-

-  return Status;

-}

-

-/**

-  Find the variable in the specified variable store.

-

-  @param[in]       VariableName        Name of the variable to be found

-  @param[in]       VendorGuid          Vendor GUID to be found.

-  @param[in]       IgnoreRtCheck       Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute

-                                       check at runtime when searching variable.

-  @param[in, out]  PtrTrack            Variable Track Pointer structure that contains Variable Information.

-

-  @retval          EFI_SUCCESS         Variable found successfully

-  @retval          EFI_NOT_FOUND       Variable not found

-**/

-EFI_STATUS

-FindVariableEx (

-  IN     CHAR16                  *VariableName,

-  IN     EFI_GUID                *VendorGuid,

-  IN     BOOLEAN                 IgnoreRtCheck,

-  IN OUT VARIABLE_POINTER_TRACK  *PtrTrack

-  )

-{

-  VARIABLE_HEADER                *InDeletedVariable;

-  VOID                           *Point;

-

-  PtrTrack->InDeletedTransitionPtr = NULL;

-

-  //

-  // Find the variable by walk through HOB, volatile and non-volatile variable store.

-  //

-  InDeletedVariable  = NULL;

-

-  for ( PtrTrack->CurrPtr = PtrTrack->StartPtr

-      ; IsValidVariableHeader (PtrTrack->CurrPtr, PtrTrack->EndPtr)

-      ; PtrTrack->CurrPtr = GetNextVariablePtr (PtrTrack->CurrPtr)

-      ) {

-    if (PtrTrack->CurrPtr->State == VAR_ADDED ||

-        PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)

-       ) {

-      if (IgnoreRtCheck || !AtRuntime () || ((PtrTrack->CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {

-        if (VariableName[0] == 0) {

-          if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-            InDeletedVariable   = PtrTrack->CurrPtr;

-          } else {

-            PtrTrack->InDeletedTransitionPtr = InDeletedVariable;

-            return EFI_SUCCESS;

-          }

-        } else {

-          if (CompareGuid (VendorGuid, GetVendorGuidPtr (PtrTrack->CurrPtr))) {

-            Point = (VOID *) GetVariableNamePtr (PtrTrack->CurrPtr);

-

-            ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr) != 0);

-            if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr)) == 0) {

-              if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-                InDeletedVariable     = PtrTrack->CurrPtr;

-              } else {

-                PtrTrack->InDeletedTransitionPtr = InDeletedVariable;

-                return EFI_SUCCESS;

-              }

-            }

-          }

-        }

-      }

-    }

-  }

-

-  PtrTrack->CurrPtr = InDeletedVariable;

-  return (PtrTrack->CurrPtr  == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

-}

-

-

-/**

-  Finds variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-  If IgnoreRtCheck is TRUE, then we ignore the EFI_VARIABLE_RUNTIME_ACCESS attribute check

-  at runtime when searching existing variable, only VariableName and VendorGuid are compared.

-  Otherwise, variables without EFI_VARIABLE_RUNTIME_ACCESS are not visible at runtime.

-

-  @param[in]   VariableName           Name of the variable to be found.

-  @param[in]   VendorGuid             Vendor GUID to be found.

-  @param[out]  PtrTrack               VARIABLE_POINTER_TRACK structure for output,

-                                      including the range searched and the target position.

-  @param[in]   Global                 Pointer to VARIABLE_GLOBAL structure, including

-                                      base of volatile variable storage area, base of

-                                      NV variable storage area, and a lock.

-  @param[in]   IgnoreRtCheck          Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute

-                                      check at runtime when searching variable.

-

-  @retval EFI_INVALID_PARAMETER       If VariableName is not an empty string, while

-                                      VendorGuid is NULL.

-  @retval EFI_SUCCESS                 Variable successfully found.

-  @retval EFI_NOT_FOUND               Variable not found

-

-**/

-EFI_STATUS

-FindVariable (

-  IN  CHAR16                  *VariableName,

-  IN  EFI_GUID                *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK  *PtrTrack,

-  IN  VARIABLE_GLOBAL         *Global,

-  IN  BOOLEAN                 IgnoreRtCheck

-  )

-{

-  EFI_STATUS              Status;

-  VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

-  VARIABLE_STORE_TYPE     Type;

-

-  if (VariableName[0] != 0 && VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  // 0: Volatile, 1: HOB, 2: Non-Volatile.

-  // The index and attributes mapping must be kept in this order as RuntimeServiceGetNextVariableName

-  // make use of this mapping to implement search algorithm.

-  //

-  VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) Global->VolatileVariableBase;

-  VariableStoreHeader[VariableStoreTypeHob]      = (VARIABLE_STORE_HEADER *) (UINTN) Global->HobVariableBase;

-  VariableStoreHeader[VariableStoreTypeNv]       = mNvVariableCache;

-

-  //

-  // Find the variable by walk through HOB, volatile and non-volatile variable store.

-  //

-  for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {

-    if (VariableStoreHeader[Type] == NULL) {

-      continue;

-    }

-

-    PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Type]);

-    PtrTrack->EndPtr   = GetEndPointer   (VariableStoreHeader[Type]);

-    PtrTrack->Volatile = (BOOLEAN) (Type == VariableStoreTypeVolatile);

-

-    Status = FindVariableEx (VariableName, VendorGuid, IgnoreRtCheck, PtrTrack);

-    if (!EFI_ERROR (Status)) {

-      return Status;

-    }

-  }

-  return EFI_NOT_FOUND;

-}

-

-/**

-  Get index from supported language codes according to language string.

-

-  This code is used to get corresponding index in supported language codes. It can handle

-  RFC4646 and ISO639 language tags.

-  In ISO639 language tags, take 3-characters as a delimitation to find matched string and calculate the index.

-  In RFC4646 language tags, take semicolon as a delimitation to find matched string and calculate the index.

-

-  For example:

-    SupportedLang  = "engfraengfra"

-    Lang           = "eng"

-    Iso639Language = TRUE

-  The return value is "0".

-  Another example:

-    SupportedLang  = "en;fr;en-US;fr-FR"

-    Lang           = "fr-FR"

-    Iso639Language = FALSE

-  The return value is "3".

-

-  @param  SupportedLang               Platform supported language codes.

-  @param  Lang                        Configured language.

-  @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.

-

-  @retval The index of language in the language codes.

-

-**/

-UINTN

-GetIndexFromSupportedLangCodes(

-  IN  CHAR8            *SupportedLang,

-  IN  CHAR8            *Lang,

-  IN  BOOLEAN          Iso639Language

-  )

-{

-  UINTN    Index;

-  UINTN    CompareLength;

-  UINTN    LanguageLength;

-

-  if (Iso639Language) {

-    CompareLength = ISO_639_2_ENTRY_SIZE;

-    for (Index = 0; Index < AsciiStrLen (SupportedLang); Index += CompareLength) {

-      if (AsciiStrnCmp (Lang, SupportedLang + Index, CompareLength) == 0) {

-        //

-        // Successfully find the index of Lang string in SupportedLang string.

-        //

-        Index = Index / CompareLength;

-        return Index;

-      }

-    }

-    ASSERT (FALSE);

-    return 0;

-  } else {

-    //

-    // Compare RFC4646 language code

-    //

-    Index = 0;

-    for (LanguageLength = 0; Lang[LanguageLength] != '\0'; LanguageLength++);

-

-    for (Index = 0; *SupportedLang != '\0'; Index++, SupportedLang += CompareLength) {

-      //

-      // Skip ';' characters in SupportedLang

-      //

-      for (; *SupportedLang != '\0' && *SupportedLang == ';'; SupportedLang++);

-      //

-      // Determine the length of the next language code in SupportedLang

-      //

-      for (CompareLength = 0; SupportedLang[CompareLength] != '\0' && SupportedLang[CompareLength] != ';'; CompareLength++);

-

-      if ((CompareLength == LanguageLength) &&

-          (AsciiStrnCmp (Lang, SupportedLang, CompareLength) == 0)) {

-        //

-        // Successfully find the index of Lang string in SupportedLang string.

-        //

-        return Index;

-      }

-    }

-    ASSERT (FALSE);

-    return 0;

-  }

-}

-

-/**

-  Get language string from supported language codes according to index.

-

-  This code is used to get corresponding language strings in supported language codes. It can handle

-  RFC4646 and ISO639 language tags.

-  In ISO639 language tags, take 3-characters as a delimitation. Find language string according to the index.

-  In RFC4646 language tags, take semicolon as a delimitation. Find language string according to the index.

-

-  For example:

-    SupportedLang  = "engfraengfra"

-    Index          = "1"

-    Iso639Language = TRUE

-  The return value is "fra".

-  Another example:

-    SupportedLang  = "en;fr;en-US;fr-FR"

-    Index          = "1"

-    Iso639Language = FALSE

-  The return value is "fr".

-

-  @param  SupportedLang               Platform supported language codes.

-  @param  Index                       The index in supported language codes.

-  @param  Iso639Language              A bool value to signify if the handler is operated on ISO639 or RFC4646.

-

-  @retval The language string in the language codes.

-

-**/

-CHAR8 *

-GetLangFromSupportedLangCodes (

-  IN  CHAR8            *SupportedLang,

-  IN  UINTN            Index,

-  IN  BOOLEAN          Iso639Language

-)

-{

-  UINTN    SubIndex;

-  UINTN    CompareLength;

-  CHAR8    *Supported;

-

-  SubIndex  = 0;

-  Supported = SupportedLang;

-  if (Iso639Language) {

-    //

-    // According to the index of Lang string in SupportedLang string to get the language.

-    // This code will be invoked in RUNTIME, therefore there is not a memory allocate/free operation.

-    // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.

-    //

-    CompareLength = ISO_639_2_ENTRY_SIZE;

-    mVariableModuleGlobal->Lang[CompareLength] = '\0';

-    return CopyMem (mVariableModuleGlobal->Lang, SupportedLang + Index * CompareLength, CompareLength);

-

-  } else {

-    while (TRUE) {

-      //

-      // Take semicolon as delimitation, sequentially traverse supported language codes.

-      //

-      for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {

-        Supported++;

-      }

-      if ((*Supported == '\0') && (SubIndex != Index)) {

-        //

-        // Have completed the traverse, but not find corrsponding string.

-        // This case is not allowed to happen.

-        //

-        ASSERT(FALSE);

-        return NULL;

-      }

-      if (SubIndex == Index) {

-        //

-        // According to the index of Lang string in SupportedLang string to get the language.

-        // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.

-        // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.

-        //

-        mVariableModuleGlobal->PlatformLang[CompareLength] = '\0';

-        return CopyMem (mVariableModuleGlobal->PlatformLang, Supported - CompareLength, CompareLength);

-      }

-      SubIndex++;

-

-      //

-      // Skip ';' characters in Supported

-      //

-      for (; *Supported != '\0' && *Supported == ';'; Supported++);

-    }

-  }

-}

-

-/**

-  Returns a pointer to an allocated buffer that contains the best matching language

-  from a set of supported languages.

-

-  This function supports both ISO 639-2 and RFC 4646 language codes, but language

-  code types may not be mixed in a single call to this function. This function

-  supports a variable argument list that allows the caller to pass in a prioritized

-  list of language codes to test against all the language codes in SupportedLanguages.

-

-  If SupportedLanguages is NULL, then ASSERT().

-

-  @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string that

-                                  contains a set of language codes in the format

-                                  specified by Iso639Language.

-  @param[in]  Iso639Language      If TRUE, then all language codes are assumed to be

-                                  in ISO 639-2 format.  If FALSE, then all language

-                                  codes are assumed to be in RFC 4646 language format

-  @param[in]  ...                 A variable argument list that contains pointers to

-                                  Null-terminated ASCII strings that contain one or more

-                                  language codes in the format specified by Iso639Language.

-                                  The first language code from each of these language

-                                  code lists is used to determine if it is an exact or

-                                  close match to any of the language codes in

-                                  SupportedLanguages.  Close matches only apply to RFC 4646

-                                  language codes, and the matching algorithm from RFC 4647

-                                  is used to determine if a close match is present.  If

-                                  an exact or close match is found, then the matching

-                                  language code from SupportedLanguages is returned.  If

-                                  no matches are found, then the next variable argument

-                                  parameter is evaluated.  The variable argument list

-                                  is terminated by a NULL.

-

-  @retval NULL   The best matching language could not be found in SupportedLanguages.

-  @retval NULL   There are not enough resources available to return the best matching

-                 language.

-  @retval Other  A pointer to a Null-terminated ASCII string that is the best matching

-                 language in SupportedLanguages.

-

-**/

-CHAR8 *

-EFIAPI

-VariableGetBestLanguage (

-  IN CONST CHAR8  *SupportedLanguages,

-  IN BOOLEAN      Iso639Language,

-  ...

-  )

-{

-  VA_LIST      Args;

-  CHAR8        *Language;

-  UINTN        CompareLength;

-  UINTN        LanguageLength;

-  CONST CHAR8  *Supported;

-  CHAR8        *Buffer;

-

-  if (SupportedLanguages == NULL) {

-    return NULL;

-  }

-

-  VA_START (Args, Iso639Language);

-  while ((Language = VA_ARG (Args, CHAR8 *)) != NULL) {

-    //

-    // Default to ISO 639-2 mode

-    //

-    CompareLength  = 3;

-    LanguageLength = MIN (3, AsciiStrLen (Language));

-

-    //

-    // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language

-    //

-    if (!Iso639Language) {

-      for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);

-    }

-

-    //

-    // Trim back the length of Language used until it is empty

-    //

-    while (LanguageLength > 0) {

-      //

-      // Loop through all language codes in SupportedLanguages

-      //

-      for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {

-        //

-        // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages

-        //

-        if (!Iso639Language) {

-          //

-          // Skip ';' characters in Supported

-          //

-          for (; *Supported != '\0' && *Supported == ';'; Supported++);

-          //

-          // Determine the length of the next language code in Supported

-          //

-          for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);

-          //

-          // If Language is longer than the Supported, then skip to the next language

-          //

-          if (LanguageLength > CompareLength) {

-            continue;

-          }

-        }

-        //

-        // See if the first LanguageLength characters in Supported match Language

-        //

-        if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {

-          VA_END (Args);

-

-          Buffer = Iso639Language ? mVariableModuleGlobal->Lang : mVariableModuleGlobal->PlatformLang;

-          Buffer[CompareLength] = '\0';

-          return CopyMem (Buffer, Supported, CompareLength);

-        }

-      }

-

-      if (Iso639Language) {

-        //

-        // If ISO 639 mode, then each language can only be tested once

-        //

-        LanguageLength = 0;

-      } else {

-        //

-        // If RFC 4646 mode, then trim Language from the right to the next '-' character

-        //

-        for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);

-      }

-    }

-  }

-  VA_END (Args);

-

-  //

-  // No matches were found

-  //

-  return NULL;

-}

-

-/**

-  This function is to check if the remaining variable space is enough to set

-  all Variables from argument list successfully. The purpose of the check

-  is to keep the consistency of the Variables to be in variable storage.

-

-  Note: Variables are assumed to be in same storage.

-  The set sequence of Variables will be same with the sequence of VariableEntry from argument list,

-  so follow the argument sequence to check the Variables.

-

-  @param[in] Attributes         Variable attributes for Variable entries.

-  @param[in] Marker             VA_LIST style variable argument list.

-                                The variable argument list with type VARIABLE_ENTRY_CONSISTENCY *.

-                                A NULL terminates the list. The VariableSize of

-                                VARIABLE_ENTRY_CONSISTENCY is the variable data size as input.

-                                It will be changed to variable total size as output.

-

-  @retval TRUE                  Have enough variable space to set the Variables successfully.

-  @retval FALSE                 No enough variable space to set the Variables successfully.

-

-**/

-BOOLEAN

-EFIAPI

-CheckRemainingSpaceForConsistencyInternal (

-  IN UINT32                     Attributes,

-  IN VA_LIST                    Marker

-  )

-{

-  EFI_STATUS                    Status;

-  VA_LIST                       Args;

-  VARIABLE_ENTRY_CONSISTENCY    *VariableEntry;

-  UINT64                        MaximumVariableStorageSize;

-  UINT64                        RemainingVariableStorageSize;

-  UINT64                        MaximumVariableSize;

-  UINTN                         TotalNeededSize;

-  UINTN                         OriginalVarSize;

-  VARIABLE_STORE_HEADER         *VariableStoreHeader;

-  VARIABLE_POINTER_TRACK        VariablePtrTrack;

-  VARIABLE_HEADER               *NextVariable;

-  UINTN                         VarNameSize;

-  UINTN                         VarDataSize;

-

-  //

-  // Non-Volatile related.

-  //

-  VariableStoreHeader = mNvVariableCache;

-

-  Status = VariableServiceQueryVariableInfoInternal (

-             Attributes,

-             &MaximumVariableStorageSize,

-             &RemainingVariableStorageSize,

-             &MaximumVariableSize

-             );

-  ASSERT_EFI_ERROR (Status);

-

-  TotalNeededSize = 0;

-  VA_COPY (Args, Marker);

-  VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);

-  while (VariableEntry != NULL) {

-    //

-    // Calculate variable total size.

-    //

-    VarNameSize  = StrSize (VariableEntry->Name);

-    VarNameSize += GET_PAD_SIZE (VarNameSize);

-    VarDataSize  = VariableEntry->VariableSize;

-    VarDataSize += GET_PAD_SIZE (VarDataSize);

-    VariableEntry->VariableSize = HEADER_ALIGN (GetVariableHeaderSize () + VarNameSize + VarDataSize);

-

-    TotalNeededSize += VariableEntry->VariableSize;

-    VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);

-  }

-  VA_END  (Args);

-

-  if (RemainingVariableStorageSize >= TotalNeededSize) {

-    //

-    // Already have enough space.

-    //

-    return TRUE;

-  } else if (AtRuntime ()) {

-    //

-    // At runtime, no reclaim.

-    // The original variable space of Variables can't be reused.

-    //

-    return FALSE;

-  }

-

-  VA_COPY (Args, Marker);

-  VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);

-  while (VariableEntry != NULL) {

-    //

-    // Check if Variable[Index] has been present and get its size.

-    //

-    OriginalVarSize = 0;

-    VariablePtrTrack.StartPtr = GetStartPointer (VariableStoreHeader);

-    VariablePtrTrack.EndPtr   = GetEndPointer   (VariableStoreHeader);

-    Status = FindVariableEx (

-               VariableEntry->Name,

-               VariableEntry->Guid,

-               FALSE,

-               &VariablePtrTrack

-               );

-    if (!EFI_ERROR (Status)) {

-      //

-      // Get size of Variable[Index].

-      //

-      NextVariable = GetNextVariablePtr (VariablePtrTrack.CurrPtr);

-      OriginalVarSize = (UINTN) NextVariable - (UINTN) VariablePtrTrack.CurrPtr;

-      //

-      // Add the original size of Variable[Index] to remaining variable storage size.

-      //

-      RemainingVariableStorageSize += OriginalVarSize;

-    }

-    if (VariableEntry->VariableSize > RemainingVariableStorageSize) {

-      //

-      // No enough space for Variable[Index].

-      //

-      return FALSE;

-    }

-    //

-    // Sub the (new) size of Variable[Index] from remaining variable storage size.

-    //

-    RemainingVariableStorageSize -= VariableEntry->VariableSize;

-    VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);

-  }

-  VA_END  (Args);

-

-  return TRUE;

-}

-

-/**

-  This function is to check if the remaining variable space is enough to set

-  all Variables from argument list successfully. The purpose of the check

-  is to keep the consistency of the Variables to be in variable storage.

-

-  Note: Variables are assumed to be in same storage.

-  The set sequence of Variables will be same with the sequence of VariableEntry from argument list,

-  so follow the argument sequence to check the Variables.

-

-  @param[in] Attributes         Variable attributes for Variable entries.

-  @param ...                    The variable argument list with type VARIABLE_ENTRY_CONSISTENCY *.

-                                A NULL terminates the list. The VariableSize of

-                                VARIABLE_ENTRY_CONSISTENCY is the variable data size as input.

-                                It will be changed to variable total size as output.

-

-  @retval TRUE                  Have enough variable space to set the Variables successfully.

-  @retval FALSE                 No enough variable space to set the Variables successfully.

-

-**/

-BOOLEAN

-EFIAPI

-CheckRemainingSpaceForConsistency (

-  IN UINT32                     Attributes,

-  ...

-  )

-{

-  VA_LIST Marker;

-  BOOLEAN Return;

-

-  VA_START (Marker, Attributes);

-

-  Return = CheckRemainingSpaceForConsistencyInternal (Attributes, Marker);

-

-  VA_END (Marker);

-

-  return Return;

-}

-

-/**

-  Hook the operations in PlatformLangCodes, LangCodes, PlatformLang and Lang.

-

-  When setting Lang/LangCodes, simultaneously update PlatformLang/PlatformLangCodes.

-

-  According to UEFI spec, PlatformLangCodes/LangCodes are only set once in firmware initialization,

-  and are read-only. Therefore, in variable driver, only store the original value for other use.

-

-  @param[in] VariableName       Name of variable.

-

-  @param[in] Data               Variable data.

-

-  @param[in] DataSize           Size of data. 0 means delete.

-

-  @retval EFI_SUCCESS           The update operation is successful or ignored.

-  @retval EFI_WRITE_PROTECTED   Update PlatformLangCodes/LangCodes at runtime.

-  @retval EFI_OUT_OF_RESOURCES  No enough variable space to do the update operation.

-  @retval Others                Other errors happened during the update operation.

-

-**/

-EFI_STATUS

-AutoUpdateLangVariable (

-  IN  CHAR16             *VariableName,

-  IN  VOID               *Data,

-  IN  UINTN              DataSize

-  )

-{

-  EFI_STATUS             Status;

-  CHAR8                  *BestPlatformLang;

-  CHAR8                  *BestLang;

-  UINTN                  Index;

-  UINT32                 Attributes;

-  VARIABLE_POINTER_TRACK Variable;

-  BOOLEAN                SetLanguageCodes;

-  VARIABLE_ENTRY_CONSISTENCY VariableEntry[2];

-

-  //

-  // Don't do updates for delete operation

-  //

-  if (DataSize == 0) {

-    return EFI_SUCCESS;

-  }

-

-  SetLanguageCodes = FALSE;

-

-  if (StrCmp (VariableName, EFI_PLATFORM_LANG_CODES_VARIABLE_NAME) == 0) {

-    //

-    // PlatformLangCodes is a volatile variable, so it can not be updated at runtime.

-    //

-    if (AtRuntime ()) {

-      return EFI_WRITE_PROTECTED;

-    }

-

-    SetLanguageCodes = TRUE;

-

-    //

-    // According to UEFI spec, PlatformLangCodes is only set once in firmware initialization, and is read-only

-    // Therefore, in variable driver, only store the original value for other use.

-    //

-    if (mVariableModuleGlobal->PlatformLangCodes != NULL) {

-      FreePool (mVariableModuleGlobal->PlatformLangCodes);

-    }

-    mVariableModuleGlobal->PlatformLangCodes = AllocateRuntimeCopyPool (DataSize, Data);

-    ASSERT (mVariableModuleGlobal->PlatformLangCodes != NULL);

-

-    //

-    // PlatformLang holds a single language from PlatformLangCodes,

-    // so the size of PlatformLangCodes is enough for the PlatformLang.

-    //

-    if (mVariableModuleGlobal->PlatformLang != NULL) {

-      FreePool (mVariableModuleGlobal->PlatformLang);

-    }

-    mVariableModuleGlobal->PlatformLang = AllocateRuntimePool (DataSize);

-    ASSERT (mVariableModuleGlobal->PlatformLang != NULL);

-

-  } else if (StrCmp (VariableName, EFI_LANG_CODES_VARIABLE_NAME) == 0) {

-    //

-    // LangCodes is a volatile variable, so it can not be updated at runtime.

-    //

-    if (AtRuntime ()) {

-      return EFI_WRITE_PROTECTED;

-    }

-

-    SetLanguageCodes = TRUE;

-

-    //

-    // According to UEFI spec, LangCodes is only set once in firmware initialization, and is read-only

-    // Therefore, in variable driver, only store the original value for other use.

-    //

-    if (mVariableModuleGlobal->LangCodes != NULL) {

-      FreePool (mVariableModuleGlobal->LangCodes);

-    }

-    mVariableModuleGlobal->LangCodes = AllocateRuntimeCopyPool (DataSize, Data);

-    ASSERT (mVariableModuleGlobal->LangCodes != NULL);

-  }

-

-  if (SetLanguageCodes

-      && (mVariableModuleGlobal->PlatformLangCodes != NULL)

-      && (mVariableModuleGlobal->LangCodes != NULL)) {

-    //

-    // Update Lang if PlatformLang is already set

-    // Update PlatformLang if Lang is already set

-    //

-    Status = FindVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-    if (!EFI_ERROR (Status)) {

-      //

-      // Update Lang

-      //

-      VariableName = EFI_PLATFORM_LANG_VARIABLE_NAME;

-      Data         = GetVariableDataPtr (Variable.CurrPtr);

-      DataSize     = DataSizeOfVariable (Variable.CurrPtr);

-    } else {

-      Status = FindVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-      if (!EFI_ERROR (Status)) {

-        //

-        // Update PlatformLang

-        //

-        VariableName = EFI_LANG_VARIABLE_NAME;

-        Data         = GetVariableDataPtr (Variable.CurrPtr);

-        DataSize     = DataSizeOfVariable (Variable.CurrPtr);

-      } else {

-        //

-        // Neither PlatformLang nor Lang is set, directly return

-        //

-        return EFI_SUCCESS;

-      }

-    }

-  }

-

-  Status = EFI_SUCCESS;

-

-  //

-  // According to UEFI spec, "Lang" and "PlatformLang" is NV|BS|RT attributions.

-  //

-  Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;

-

-  if (StrCmp (VariableName, EFI_PLATFORM_LANG_VARIABLE_NAME) == 0) {

-    //

-    // Update Lang when PlatformLangCodes/LangCodes were set.

-    //

-    if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {

-      //

-      // When setting PlatformLang, firstly get most matched language string from supported language codes.

-      //

-      BestPlatformLang = VariableGetBestLanguage (mVariableModuleGlobal->PlatformLangCodes, FALSE, Data, NULL);

-      if (BestPlatformLang != NULL) {

-        //

-        // Get the corresponding index in language codes.

-        //

-        Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, BestPlatformLang, FALSE);

-

-        //

-        // Get the corresponding ISO639 language tag according to RFC4646 language tag.

-        //

-        BestLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, Index, TRUE);

-

-        //

-        // Check the variable space for both Lang and PlatformLang variable.

-        //

-        VariableEntry[0].VariableSize = ISO_639_2_ENTRY_SIZE + 1;

-        VariableEntry[0].Guid = &gEfiGlobalVariableGuid;

-        VariableEntry[0].Name = EFI_LANG_VARIABLE_NAME;

-

-        VariableEntry[1].VariableSize = AsciiStrSize (BestPlatformLang);

-        VariableEntry[1].Guid = &gEfiGlobalVariableGuid;

-        VariableEntry[1].Name = EFI_PLATFORM_LANG_VARIABLE_NAME;

-        if (!CheckRemainingSpaceForConsistency (VARIABLE_ATTRIBUTE_NV_BS_RT, &VariableEntry[0], &VariableEntry[1], NULL)) {

-          //

-          // No enough variable space to set both Lang and PlatformLang successfully.

-          //

-          Status = EFI_OUT_OF_RESOURCES;

-        } else {

-          //

-          // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.

-          //

-          FindVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-

-          Status = UpdateVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, BestLang,

-                                   ISO_639_2_ENTRY_SIZE + 1, Attributes, 0, 0, &Variable, NULL);

-        }

-

-        DEBUG ((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a Status: %r\n", BestPlatformLang, BestLang, Status));

-      }

-    }

-

-  } else if (StrCmp (VariableName, EFI_LANG_VARIABLE_NAME) == 0) {

-    //

-    // Update PlatformLang when PlatformLangCodes/LangCodes were set.

-    //

-    if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {

-      //

-      // When setting Lang, firstly get most matched language string from supported language codes.

-      //

-      BestLang = VariableGetBestLanguage (mVariableModuleGlobal->LangCodes, TRUE, Data, NULL);

-      if (BestLang != NULL) {

-        //

-        // Get the corresponding index in language codes.

-        //

-        Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, BestLang, TRUE);

-

-        //

-        // Get the corresponding RFC4646 language tag according to ISO639 language tag.

-        //

-        BestPlatformLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, Index, FALSE);

-

-        //

-        // Check the variable space for both PlatformLang and Lang variable.

-        //

-        VariableEntry[0].VariableSize = AsciiStrSize (BestPlatformLang);

-        VariableEntry[0].Guid = &gEfiGlobalVariableGuid;

-        VariableEntry[0].Name = EFI_PLATFORM_LANG_VARIABLE_NAME;

-

-        VariableEntry[1].VariableSize = ISO_639_2_ENTRY_SIZE + 1;

-        VariableEntry[1].Guid = &gEfiGlobalVariableGuid;

-        VariableEntry[1].Name = EFI_LANG_VARIABLE_NAME;

-        if (!CheckRemainingSpaceForConsistency (VARIABLE_ATTRIBUTE_NV_BS_RT, &VariableEntry[0], &VariableEntry[1], NULL)) {

-          //

-          // No enough variable space to set both PlatformLang and Lang successfully.

-          //

-          Status = EFI_OUT_OF_RESOURCES;

-        } else {

-          //

-          // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.

-          //

-          FindVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-

-          Status = UpdateVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, BestPlatformLang,

-                                   AsciiStrSize (BestPlatformLang), Attributes, 0, 0, &Variable, NULL);

-        }

-

-        DEBUG ((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a Status: %r\n", BestLang, BestPlatformLang, Status));

-      }

-    }

-  }

-

-  if (SetLanguageCodes) {

-    //

-    // Continue to set PlatformLangCodes or LangCodes.

-    //

-    return EFI_SUCCESS;

-  } else {

-    return Status;

-  }

-}

-

-/**

-  Compare two EFI_TIME data.

-

-

-  @param FirstTime           A pointer to the first EFI_TIME data.

-  @param SecondTime          A pointer to the second EFI_TIME data.

-

-  @retval  TRUE              The FirstTime is not later than the SecondTime.

-  @retval  FALSE             The FirstTime is later than the SecondTime.

-

-**/

-BOOLEAN

-VariableCompareTimeStampInternal (

-  IN EFI_TIME               *FirstTime,

-  IN EFI_TIME               *SecondTime

-  )

-{

-  if (FirstTime->Year != SecondTime->Year) {

-    return (BOOLEAN) (FirstTime->Year < SecondTime->Year);

-  } else if (FirstTime->Month != SecondTime->Month) {

-    return (BOOLEAN) (FirstTime->Month < SecondTime->Month);

-  } else if (FirstTime->Day != SecondTime->Day) {

-    return (BOOLEAN) (FirstTime->Day < SecondTime->Day);

-  } else if (FirstTime->Hour != SecondTime->Hour) {

-    return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);

-  } else if (FirstTime->Minute != SecondTime->Minute) {

-    return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);

-  }

-

-  return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);

-}

-

-/**

-  Update the variable region with Variable information. If EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS is set,

-  index of associated public key is needed.

-

-  @param[in] VariableName       Name of variable.

-  @param[in] VendorGuid         Guid of variable.

-  @param[in] Data               Variable data.

-  @param[in] DataSize           Size of data. 0 means delete.

-  @param[in] Attributes         Attributes of the variable.

-  @param[in] KeyIndex           Index of associated public key.

-  @param[in] MonotonicCount     Value of associated monotonic count.

-  @param[in, out] CacheVariable The variable information which is used to keep track of variable usage.

-  @param[in] TimeStamp          Value of associated TimeStamp.

-

-  @retval EFI_SUCCESS           The update operation is success.

-  @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.

-

-**/

-EFI_STATUS

-UpdateVariable (

-  IN      CHAR16                      *VariableName,

-  IN      EFI_GUID                    *VendorGuid,

-  IN      VOID                        *Data,

-  IN      UINTN                       DataSize,

-  IN      UINT32                      Attributes      OPTIONAL,

-  IN      UINT32                      KeyIndex        OPTIONAL,

-  IN      UINT64                      MonotonicCount  OPTIONAL,

-  IN OUT  VARIABLE_POINTER_TRACK      *CacheVariable,

-  IN      EFI_TIME                    *TimeStamp      OPTIONAL

-  )

-{

-  EFI_STATUS                          Status;

-  VARIABLE_HEADER                     *NextVariable;

-  UINTN                               ScratchSize;

-  UINTN                               MaxDataSize;

-  UINTN                               VarNameOffset;

-  UINTN                               VarDataOffset;

-  UINTN                               VarNameSize;

-  UINTN                               VarSize;

-  BOOLEAN                             Volatile;

-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;

-  UINT8                               State;

-  VARIABLE_POINTER_TRACK              *Variable;

-  VARIABLE_POINTER_TRACK              NvVariable;

-  VARIABLE_STORE_HEADER               *VariableStoreHeader;

-  UINTN                               CacheOffset;

-  UINT8                               *BufferForMerge;

-  UINTN                               MergedBufSize;

-  BOOLEAN                             DataReady;

-  UINTN                               DataOffset;

-  BOOLEAN                             IsCommonVariable;

-  BOOLEAN                             IsCommonUserVariable;

-  AUTHENTICATED_VARIABLE_HEADER       *AuthVariable;

-

-  if (mVariableModuleGlobal->FvbInstance == NULL) {

-    //

-    // The FVB protocol is not ready, so the EFI_VARIABLE_WRITE_ARCH_PROTOCOL is not installed.

-    //

-    if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {

-      //

-      // Trying to update NV variable prior to the installation of EFI_VARIABLE_WRITE_ARCH_PROTOCOL

-      //

-      DEBUG ((EFI_D_ERROR, "Update NV variable before EFI_VARIABLE_WRITE_ARCH_PROTOCOL ready - %r\n", EFI_NOT_AVAILABLE_YET));

-      return EFI_NOT_AVAILABLE_YET;

-    } else if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {

-      //

-      // Trying to update volatile authenticated variable prior to the installation of EFI_VARIABLE_WRITE_ARCH_PROTOCOL

-      // The authenticated variable perhaps is not initialized, just return here.

-      //

-      DEBUG ((EFI_D_ERROR, "Update AUTH variable before EFI_VARIABLE_WRITE_ARCH_PROTOCOL ready - %r\n", EFI_NOT_AVAILABLE_YET));

-      return EFI_NOT_AVAILABLE_YET;

-    }

-  }

-

-  //

-  // Check if CacheVariable points to the variable in variable HOB.

-  // If yes, let CacheVariable points to the variable in NV variable cache.

-  //

-  if ((CacheVariable->CurrPtr != NULL) &&

-      (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) &&

-      (CacheVariable->StartPtr == GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase))

-     ) {

-    CacheVariable->StartPtr = GetStartPointer (mNvVariableCache);

-    CacheVariable->EndPtr   = GetEndPointer   (mNvVariableCache);

-    CacheVariable->Volatile = FALSE;

-    Status = FindVariableEx (VariableName, VendorGuid, FALSE, CacheVariable);

-    if (CacheVariable->CurrPtr == NULL || EFI_ERROR (Status)) {

-      //

-      // There is no matched variable in NV variable cache.

-      //

-      if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0)) {

-        //

-        // It is to delete variable,

-        // go to delete this variable in variable HOB and

-        // try to flush other variables from HOB to flash.

-        //

-        UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, FALSE, TRUE, FALSE);

-        FlushHobVariableToFlash (VariableName, VendorGuid);

-        return EFI_SUCCESS;

-      }

-    }

-  }

-

-  if ((CacheVariable->CurrPtr == NULL) || CacheVariable->Volatile) {

-    Variable = CacheVariable;

-  } else {

-    //

-    // Update/Delete existing NV variable.

-    // CacheVariable points to the variable in the memory copy of Flash area

-    // Now let Variable points to the same variable in Flash area.

-    //

-    VariableStoreHeader  = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);

-    Variable = &NvVariable;

-    Variable->StartPtr = GetStartPointer (VariableStoreHeader);

-    Variable->EndPtr   = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->EndPtr - (UINTN)CacheVariable->StartPtr));

-

-    Variable->CurrPtr  = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));

-    if (CacheVariable->InDeletedTransitionPtr != NULL) {

-      Variable->InDeletedTransitionPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->InDeletedTransitionPtr - (UINTN)CacheVariable->StartPtr));

-    } else {

-      Variable->InDeletedTransitionPtr = NULL;

-    }

-    Variable->Volatile = FALSE;

-  }

-

-  Fvb       = mVariableModuleGlobal->FvbInstance;

-

-  //

-  // Tricky part: Use scratch data area at the end of volatile variable store

-  // as a temporary storage.

-  //

-  NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));

-  ScratchSize = mVariableModuleGlobal->ScratchBufferSize;

-  SetMem (NextVariable, ScratchSize, 0xff);

-  DataReady = FALSE;

-

-  if (Variable->CurrPtr != NULL) {

-    //

-    // Update/Delete existing variable.

-    //

-    if (AtRuntime ()) {

-      //

-      // If AtRuntime and the variable is Volatile and Runtime Access,

-      // the volatile is ReadOnly, and SetVariable should be aborted and

-      // return EFI_WRITE_PROTECTED.

-      //

-      if (Variable->Volatile) {

-        Status = EFI_WRITE_PROTECTED;

-        goto Done;

-      }

-      //

-      // Only variable that have NV attributes can be updated/deleted in Runtime.

-      //

-      if ((CacheVariable->CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {

-        Status = EFI_INVALID_PARAMETER;

-        goto Done;

-      }

-

-      //

-      // Only variable that have RT attributes can be updated/deleted in Runtime.

-      //

-      if ((CacheVariable->CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) {

-        Status = EFI_INVALID_PARAMETER;

-        goto Done;

-      }

-    }

-

-    //

-    // Setting a data variable with no access, or zero DataSize attributes

-    // causes it to be deleted.

-    // When the EFI_VARIABLE_APPEND_WRITE attribute is set, DataSize of zero will

-    // not delete the variable.

-    //

-    if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0))|| ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0)) {

-      if (Variable->InDeletedTransitionPtr != NULL) {

-        //

-        // Both ADDED and IN_DELETED_TRANSITION variable are present,

-        // set IN_DELETED_TRANSITION one to DELETED state first.

-        //

-        ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);

-        State = CacheVariable->InDeletedTransitionPtr->State;

-        State &= VAR_DELETED;

-        Status = UpdateVariableStore (

-                   &mVariableModuleGlobal->VariableGlobal,

-                   Variable->Volatile,

-                   FALSE,

-                   Fvb,

-                   (UINTN) &Variable->InDeletedTransitionPtr->State,

-                   sizeof (UINT8),

-                   &State

-                   );

-        if (!EFI_ERROR (Status)) {

-          if (!Variable->Volatile) {

-            CacheVariable->InDeletedTransitionPtr->State = State;

-          }

-        } else {

-          goto Done;

-        }

-      }

-

-      State = CacheVariable->CurrPtr->State;

-      State &= VAR_DELETED;

-

-      Status = UpdateVariableStore (

-                 &mVariableModuleGlobal->VariableGlobal,

-                 Variable->Volatile,

-                 FALSE,

-                 Fvb,

-                 (UINTN) &Variable->CurrPtr->State,

-                 sizeof (UINT8),

-                 &State

-                 );

-      if (!EFI_ERROR (Status)) {

-        UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, FALSE, TRUE, FALSE);

-        if (!Variable->Volatile) {

-          CacheVariable->CurrPtr->State = State;

-          FlushHobVariableToFlash (VariableName, VendorGuid);

-        }

-      }

-      goto Done;

-    }

-    //

-    // If the variable is marked valid, and the same data has been passed in,

-    // then return to the caller immediately.

-    //

-    if (DataSizeOfVariable (CacheVariable->CurrPtr) == DataSize &&

-        (CompareMem (Data, GetVariableDataPtr (CacheVariable->CurrPtr), DataSize) == 0) &&

-        ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) &&

-        (TimeStamp == NULL)) {

-      //

-      // Variable content unchanged and no need to update timestamp, just return.

-      //

-      UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, TRUE, FALSE, FALSE);

-      Status = EFI_SUCCESS;

-      goto Done;

-    } else if ((CacheVariable->CurrPtr->State == VAR_ADDED) ||

-               (CacheVariable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {

-

-      //

-      // EFI_VARIABLE_APPEND_WRITE attribute only effects for existing variable.

-      //

-      if ((Attributes & EFI_VARIABLE_APPEND_WRITE) != 0) {

-        //

-        // NOTE: From 0 to DataOffset of NextVariable is reserved for Variable Header and Name.

-        // From DataOffset of NextVariable is to save the existing variable data.

-        //

-        DataOffset = GetVariableDataOffset (CacheVariable->CurrPtr);

-        BufferForMerge = (UINT8 *) ((UINTN) NextVariable + DataOffset);

-        CopyMem (BufferForMerge, (UINT8 *) ((UINTN) CacheVariable->CurrPtr + DataOffset), DataSizeOfVariable (CacheVariable->CurrPtr));

-

-        //

-        // Set Max Common/Auth Variable Data Size as default MaxDataSize.

-        //

-        if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {

-          MaxDataSize = mVariableModuleGlobal->MaxAuthVariableSize - DataOffset;

-        } else {

-          MaxDataSize = mVariableModuleGlobal->MaxVariableSize - DataOffset;

-        }

-

-        //

-        // Append the new data to the end of existing data.

-        // Max Harware error record variable data size is different from common/auth variable.

-        //

-        if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-          MaxDataSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - DataOffset;

-        }

-

-        if (DataSizeOfVariable (CacheVariable->CurrPtr) + DataSize > MaxDataSize) {

-          //

-          // Existing data size + new data size exceed maximum variable size limitation.

-          //

-          Status = EFI_INVALID_PARAMETER;

-          goto Done;

-        }

-        CopyMem ((UINT8*) ((UINTN) BufferForMerge + DataSizeOfVariable (CacheVariable->CurrPtr)), Data, DataSize);

-        MergedBufSize = DataSizeOfVariable (CacheVariable->CurrPtr) + DataSize;

-

-        //

-        // BufferForMerge(from DataOffset of NextVariable) has included the merged existing and new data.

-        //

-        Data      = BufferForMerge;

-        DataSize  = MergedBufSize;

-        DataReady = TRUE;

-      }

-

-      //

-      // Mark the old variable as in delete transition.

-      //

-      State = CacheVariable->CurrPtr->State;

-      State &= VAR_IN_DELETED_TRANSITION;

-

-      Status = UpdateVariableStore (

-                 &mVariableModuleGlobal->VariableGlobal,

-                 Variable->Volatile,

-                 FALSE,

-                 Fvb,

-                 (UINTN) &Variable->CurrPtr->State,

-                 sizeof (UINT8),

-                 &State

-                 );

-      if (EFI_ERROR (Status)) {

-        goto Done;

-      }

-      if (!Variable->Volatile) {

-        CacheVariable->CurrPtr->State = State;

-      }

-    }

-  } else {

-    //

-    // Not found existing variable. Create a new variable.

-    //

-

-    if ((DataSize == 0) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) != 0)) {

-      Status = EFI_SUCCESS;

-      goto Done;

-    }

-

-    //

-    // Make sure we are trying to create a new variable.

-    // Setting a data variable with zero DataSize or no access attributes means to delete it.

-    //

-    if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {

-      Status = EFI_NOT_FOUND;

-      goto Done;

-    }

-

-    //

-    // Only variable have NV|RT attribute can be created in Runtime.

-    //

-    if (AtRuntime () &&

-        (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0))) {

-      Status = EFI_INVALID_PARAMETER;

-      goto Done;

-    }

-  }

-

-  //

-  // Function part - create a new variable and copy the data.

-  // Both update a variable and create a variable will come here.

-  //

-  NextVariable->StartId     = VARIABLE_DATA;

-  //

-  // NextVariable->State = VAR_ADDED;

-  //

-  NextVariable->Reserved        = 0;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) NextVariable;

-    AuthVariable->PubKeyIndex    = KeyIndex;

-    AuthVariable->MonotonicCount = MonotonicCount;

-    ZeroMem (&AuthVariable->TimeStamp, sizeof (EFI_TIME));

-

-    if (((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) &&

-        (TimeStamp != NULL)) {

-      if ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) {

-        CopyMem (&AuthVariable->TimeStamp, TimeStamp, sizeof (EFI_TIME));

-      } else {

-        //

-        // In the case when the EFI_VARIABLE_APPEND_WRITE attribute is set, only

-        // when the new TimeStamp value is later than the current timestamp associated

-        // with the variable, we need associate the new timestamp with the updated value.

-        //

-        if (Variable->CurrPtr != NULL) {

-          if (VariableCompareTimeStampInternal (&(((AUTHENTICATED_VARIABLE_HEADER *) CacheVariable->CurrPtr)->TimeStamp), TimeStamp)) {

-            CopyMem (&AuthVariable->TimeStamp, TimeStamp, sizeof (EFI_TIME));

-          }

-        }

-      }

-    }

-  }

-

-  //

-  // The EFI_VARIABLE_APPEND_WRITE attribute will never be set in the returned

-  // Attributes bitmask parameter of a GetVariable() call.

-  //

-  NextVariable->Attributes  = Attributes & (~EFI_VARIABLE_APPEND_WRITE);

-

-  VarNameOffset                 = GetVariableHeaderSize ();

-  VarNameSize                   = StrSize (VariableName);

-  CopyMem (

-    (UINT8 *) ((UINTN) NextVariable + VarNameOffset),

-    VariableName,

-    VarNameSize

-    );

-  VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);

-

-  //

-  // If DataReady is TRUE, it means the variable data has been saved into

-  // NextVariable during EFI_VARIABLE_APPEND_WRITE operation preparation.

-  //

-  if (!DataReady) {

-    CopyMem (

-      (UINT8 *) ((UINTN) NextVariable + VarDataOffset),

-      Data,

-      DataSize

-      );

-  }

-

-  CopyMem (GetVendorGuidPtr (NextVariable), VendorGuid, sizeof (EFI_GUID));

-  //

-  // There will be pad bytes after Data, the NextVariable->NameSize and

-  // NextVariable->DataSize should not include pad size so that variable

-  // service can get actual size in GetVariable.

-  //

-  SetNameSizeOfVariable (NextVariable, VarNameSize);

-  SetDataSizeOfVariable (NextVariable, DataSize);

-

-  //

-  // The actual size of the variable that stores in storage should

-  // include pad size.

-  //

-  VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);

-  if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {

-    //

-    // Create a nonvolatile variable.

-    //

-    Volatile = FALSE;

-

-    IsCommonVariable = FALSE;

-    IsCommonUserVariable = FALSE;

-    if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0) {

-      IsCommonVariable = TRUE;

-      IsCommonUserVariable = IsUserVariable (NextVariable);

-    }

-    if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0)

-      && ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))

-      || (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonVariableSpace))

-      || (IsCommonVariable && AtRuntime () && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonRuntimeVariableSpace))

-      || (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace))) {

-      if (AtRuntime ()) {

-        if (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace)) {

-          RecordVarErrorFlag (VAR_ERROR_FLAG_USER_ERROR, VariableName, VendorGuid, Attributes, VarSize);

-        }

-        if (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonRuntimeVariableSpace)) {

-          RecordVarErrorFlag (VAR_ERROR_FLAG_SYSTEM_ERROR, VariableName, VendorGuid, Attributes, VarSize);

-        }

-        Status = EFI_OUT_OF_RESOURCES;

-        goto Done;

-      }

-      //

-      // Perform garbage collection & reclaim operation, and integrate the new variable at the same time.

-      //

-      Status = Reclaim (

-                 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

-                 &mVariableModuleGlobal->NonVolatileLastVariableOffset,

-                 FALSE,

-                 Variable,

-                 NextVariable,

-                 HEADER_ALIGN (VarSize)

-                 );

-      if (!EFI_ERROR (Status)) {

-        //

-        // The new variable has been integrated successfully during reclaiming.

-        //

-        if (Variable->CurrPtr != NULL) {

-          CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));

-          CacheVariable->InDeletedTransitionPtr = NULL;

-        }

-        UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, TRUE, FALSE, FALSE);

-        FlushHobVariableToFlash (VariableName, VendorGuid);

-      } else {

-        if (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace)) {

-          RecordVarErrorFlag (VAR_ERROR_FLAG_USER_ERROR, VariableName, VendorGuid, Attributes, VarSize);

-        }

-        if (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonVariableSpace)) {

-          RecordVarErrorFlag (VAR_ERROR_FLAG_SYSTEM_ERROR, VariableName, VendorGuid, Attributes, VarSize);

-        }

-      }

-      goto Done;

-    }

-    //

-    // Four steps

-    // 1. Write variable header

-    // 2. Set variable state to header valid

-    // 3. Write variable data

-    // 4. Set variable state to valid

-    //

-    //

-    // Step 1:

-    //

-    CacheOffset = mVariableModuleGlobal->NonVolatileLastVariableOffset;

-    Status = UpdateVariableStore (

-               &mVariableModuleGlobal->VariableGlobal,

-               FALSE,

-               TRUE,

-               Fvb,

-               mVariableModuleGlobal->NonVolatileLastVariableOffset,

-               (UINT32) GetVariableHeaderSize (),

-               (UINT8 *) NextVariable

-               );

-

-    if (EFI_ERROR (Status)) {

-      goto Done;

-    }

-

-    //

-    // Step 2:

-    //

-    NextVariable->State = VAR_HEADER_VALID_ONLY;

-    Status = UpdateVariableStore (

-               &mVariableModuleGlobal->VariableGlobal,

-               FALSE,

-               TRUE,

-               Fvb,

-               mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),

-               sizeof (UINT8),

-               &NextVariable->State

-               );

-

-    if (EFI_ERROR (Status)) {

-      goto Done;

-    }

-    //

-    // Step 3:

-    //

-    Status = UpdateVariableStore (

-               &mVariableModuleGlobal->VariableGlobal,

-               FALSE,

-               TRUE,

-               Fvb,

-               mVariableModuleGlobal->NonVolatileLastVariableOffset + GetVariableHeaderSize (),

-               (UINT32) (VarSize - GetVariableHeaderSize ()),

-               (UINT8 *) NextVariable + GetVariableHeaderSize ()

-               );

-

-    if (EFI_ERROR (Status)) {

-      goto Done;

-    }

-    //

-    // Step 4:

-    //

-    NextVariable->State = VAR_ADDED;

-    Status = UpdateVariableStore (

-               &mVariableModuleGlobal->VariableGlobal,

-               FALSE,

-               TRUE,

-               Fvb,

-               mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),

-               sizeof (UINT8),

-               &NextVariable->State

-               );

-

-    if (EFI_ERROR (Status)) {

-      goto Done;

-    }

-

-    mVariableModuleGlobal->NonVolatileLastVariableOffset += HEADER_ALIGN (VarSize);

-

-    if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {

-      mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VarSize);

-    } else {

-      mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VarSize);

-      if (IsCommonUserVariable) {

-        mVariableModuleGlobal->CommonUserVariableTotalSize += HEADER_ALIGN (VarSize);

-      }

-    }

-    //

-    // update the memory copy of Flash region.

-    //

-    CopyMem ((UINT8 *)mNvVariableCache + CacheOffset, (UINT8 *)NextVariable, VarSize);

-  } else {

-    //

-    // Create a volatile variable.

-    //

-    Volatile = TRUE;

-

-    if ((UINT32) (VarSize + mVariableModuleGlobal->VolatileLastVariableOffset) >

-        ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {

-      //

-      // Perform garbage collection & reclaim operation, and integrate the new variable at the same time.

-      //

-      Status = Reclaim (

-                 mVariableModuleGlobal->VariableGlobal.VolatileVariableBase,

-                 &mVariableModuleGlobal->VolatileLastVariableOffset,

-                 TRUE,

-                 Variable,

-                 NextVariable,

-                 HEADER_ALIGN (VarSize)

-                 );

-      if (!EFI_ERROR (Status)) {

-        //

-        // The new variable has been integrated successfully during reclaiming.

-        //

-        if (Variable->CurrPtr != NULL) {

-          CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));

-          CacheVariable->InDeletedTransitionPtr = NULL;

-        }

-        UpdateVariableInfo (VariableName, VendorGuid, TRUE, FALSE, TRUE, FALSE, FALSE);

-      }

-      goto Done;

-    }

-

-    NextVariable->State = VAR_ADDED;

-    Status = UpdateVariableStore (

-               &mVariableModuleGlobal->VariableGlobal,

-               TRUE,

-               TRUE,

-               Fvb,

-               mVariableModuleGlobal->VolatileLastVariableOffset,

-               (UINT32) VarSize,

-               (UINT8 *) NextVariable

-               );

-

-    if (EFI_ERROR (Status)) {

-      goto Done;

-    }

-

-    mVariableModuleGlobal->VolatileLastVariableOffset += HEADER_ALIGN (VarSize);

-  }

-

-  //

-  // Mark the old variable as deleted.

-  //

-  if (!EFI_ERROR (Status) && Variable->CurrPtr != NULL) {

-    if (Variable->InDeletedTransitionPtr != NULL) {

-      //

-      // Both ADDED and IN_DELETED_TRANSITION old variable are present,

-      // set IN_DELETED_TRANSITION one to DELETED state first.

-      //

-      ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);

-      State = CacheVariable->InDeletedTransitionPtr->State;

-      State &= VAR_DELETED;

-      Status = UpdateVariableStore (

-                 &mVariableModuleGlobal->VariableGlobal,

-                 Variable->Volatile,

-                 FALSE,

-                 Fvb,

-                 (UINTN) &Variable->InDeletedTransitionPtr->State,

-                 sizeof (UINT8),

-                 &State

-                 );

-      if (!EFI_ERROR (Status)) {

-        if (!Variable->Volatile) {

-          CacheVariable->InDeletedTransitionPtr->State = State;

-        }

-      } else {

-        goto Done;

-      }

-    }

-

-    State = Variable->CurrPtr->State;

-    State &= VAR_DELETED;

-

-    Status = UpdateVariableStore (

-             &mVariableModuleGlobal->VariableGlobal,

-             Variable->Volatile,

-             FALSE,

-             Fvb,

-             (UINTN) &Variable->CurrPtr->State,

-             sizeof (UINT8),

-             &State

-             );

-    if (!EFI_ERROR (Status) && !Variable->Volatile) {

-      CacheVariable->CurrPtr->State = State;

-    }

-  }

-

-  if (!EFI_ERROR (Status)) {

-    UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);

-    if (!Volatile) {

-      FlushHobVariableToFlash (VariableName, VendorGuid);

-    }

-  }

-

-Done:

-  return Status;

-}

-

-/**

-

-  This code finds variable in storage blocks (Volatile or Non-Volatile).

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode, and datasize is external input.

-  This function will do basic validation, before parse the data.

-

-  @param VariableName               Name of Variable to be found.

-  @param VendorGuid                 Variable vendor GUID.

-  @param Attributes                 Attribute value of the variable found.

-  @param DataSize                   Size of Data found. If size is less than the

-                                    data, this value contains the required size.

-  @param Data                       The buffer to return the contents of the variable. May be NULL

-                                    with a zero DataSize in order to determine the size buffer needed.

-

-  @return EFI_INVALID_PARAMETER     Invalid parameter.

-  @return EFI_SUCCESS               Find the specified variable.

-  @return EFI_NOT_FOUND             Not found.

-  @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceGetVariable (

-  IN      CHAR16            *VariableName,

-  IN      EFI_GUID          *VendorGuid,

-  OUT     UINT32            *Attributes OPTIONAL,

-  IN OUT  UINTN             *DataSize,

-  OUT     VOID              *Data OPTIONAL

-  )

-{

-  EFI_STATUS              Status;

-  VARIABLE_POINTER_TRACK  Variable;

-  UINTN                   VarDataSize;

-

-  if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (VariableName[0] == 0) {

-    return EFI_NOT_FOUND;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-  if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  //

-  // Get data size

-  //

-  VarDataSize = DataSizeOfVariable (Variable.CurrPtr);

-  ASSERT (VarDataSize != 0);

-

-  if (*DataSize >= VarDataSize) {

-    if (Data == NULL) {

-      Status = EFI_INVALID_PARAMETER;

-      goto Done;

-    }

-

-    CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);

-    if (Attributes != NULL) {

-      *Attributes = Variable.CurrPtr->Attributes;

-    }

-

-    *DataSize = VarDataSize;

-    UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);

-

-    Status = EFI_SUCCESS;

-    goto Done;

-  } else {

-    *DataSize = VarDataSize;

-    Status = EFI_BUFFER_TOO_SMALL;

-    goto Done;

-  }

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-  return Status;

-}

-

-/**

-  This code Finds the Next available variable.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param[in]  VariableName  Pointer to variable name.

-  @param[in]  VendorGuid    Variable Vendor Guid.

-  @param[out] VariablePtr   Pointer to variable header address.

-

-  @return EFI_SUCCESS       Find the specified variable.

-  @return EFI_NOT_FOUND     Not found.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceGetNextVariableInternal (

-  IN  CHAR16                *VariableName,

-  IN  EFI_GUID              *VendorGuid,

-  OUT VARIABLE_HEADER       **VariablePtr

-  )

-{

-  VARIABLE_STORE_TYPE     Type;

-  VARIABLE_POINTER_TRACK  Variable;

-  VARIABLE_POINTER_TRACK  VariableInHob;

-  VARIABLE_POINTER_TRACK  VariablePtrTrack;

-  EFI_STATUS              Status;

-  VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

-

-  Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-  if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  if (VariableName[0] != 0) {

-    //

-    // If variable name is not NULL, get next variable.

-    //

-    Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

-  }

-

-  //

-  // 0: Volatile, 1: HOB, 2: Non-Volatile.

-  // The index and attributes mapping must be kept in this order as FindVariable

-  // makes use of this mapping to implement search algorithm.

-  //

-  VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;

-  VariableStoreHeader[VariableStoreTypeHob]      = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;

-  VariableStoreHeader[VariableStoreTypeNv]       = mNvVariableCache;

-

-  while (TRUE) {

-    //

-    // Switch from Volatile to HOB, to Non-Volatile.

-    //

-    while (!IsValidVariableHeader (Variable.CurrPtr, Variable.EndPtr)) {

-      //

-      // Find current storage index

-      //

-      for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {

-        if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {

-          break;

-        }

-      }

-      ASSERT (Type < VariableStoreTypeMax);

-      //

-      // Switch to next storage

-      //

-      for (Type++; Type < VariableStoreTypeMax; Type++) {

-        if (VariableStoreHeader[Type] != NULL) {

-          break;

-        }

-      }

-      //

-      // Capture the case that

-      // 1. current storage is the last one, or

-      // 2. no further storage

-      //

-      if (Type == VariableStoreTypeMax) {

-        Status = EFI_NOT_FOUND;

-        goto Done;

-      }

-      Variable.StartPtr = GetStartPointer (VariableStoreHeader[Type]);

-      Variable.EndPtr   = GetEndPointer   (VariableStoreHeader[Type]);

-      Variable.CurrPtr  = Variable.StartPtr;

-    }

-

-    //

-    // Variable is found

-    //

-    if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-      if (!AtRuntime () || ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {

-        if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-          //

-          // If it is a IN_DELETED_TRANSITION variable,

-          // and there is also a same ADDED one at the same time,

-          // don't return it.

-          //

-          VariablePtrTrack.StartPtr = Variable.StartPtr;

-          VariablePtrTrack.EndPtr = Variable.EndPtr;

-          Status = FindVariableEx (

-                     GetVariableNamePtr (Variable.CurrPtr),

-                     GetVendorGuidPtr (Variable.CurrPtr),

-                     FALSE,

-                     &VariablePtrTrack

-                     );

-          if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {

-            Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

-            continue;

-          }

-        }

-

-        //

-        // Don't return NV variable when HOB overrides it

-        //

-        if ((VariableStoreHeader[VariableStoreTypeHob] != NULL) && (VariableStoreHeader[VariableStoreTypeNv] != NULL) &&

-            (Variable.StartPtr == GetStartPointer (VariableStoreHeader[VariableStoreTypeNv]))

-           ) {

-          VariableInHob.StartPtr = GetStartPointer (VariableStoreHeader[VariableStoreTypeHob]);

-          VariableInHob.EndPtr   = GetEndPointer   (VariableStoreHeader[VariableStoreTypeHob]);

-          Status = FindVariableEx (

-                     GetVariableNamePtr (Variable.CurrPtr),

-                     GetVendorGuidPtr (Variable.CurrPtr),

-                     FALSE,

-                     &VariableInHob

-                     );

-          if (!EFI_ERROR (Status)) {

-            Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

-            continue;

-          }

-        }

-

-        *VariablePtr = Variable.CurrPtr;

-        Status = EFI_SUCCESS;

-        goto Done;

-      }

-    }

-

-    Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

-  }

-

-Done:

-  return Status;

-}

-

-/**

-

-  This code Finds the Next available variable.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param VariableNameSize           Size of the variable name.

-  @param VariableName               Pointer to variable name.

-  @param VendorGuid                 Variable Vendor Guid.

-

-  @return EFI_INVALID_PARAMETER     Invalid parameter.

-  @return EFI_SUCCESS               Find the specified variable.

-  @return EFI_NOT_FOUND             Not found.

-  @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceGetNextVariableName (

-  IN OUT  UINTN             *VariableNameSize,

-  IN OUT  CHAR16            *VariableName,

-  IN OUT  EFI_GUID          *VendorGuid

-  )

-{

-  EFI_STATUS              Status;

-  UINTN                   VarNameSize;

-  VARIABLE_HEADER         *VariablePtr;

-

-  if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  Status = VariableServiceGetNextVariableInternal (VariableName, VendorGuid, &VariablePtr);

-  if (!EFI_ERROR (Status)) {

-    VarNameSize = NameSizeOfVariable (VariablePtr);

-    ASSERT (VarNameSize != 0);

-    if (VarNameSize <= *VariableNameSize) {

-      CopyMem (VariableName, GetVariableNamePtr (VariablePtr), VarNameSize);

-      CopyMem (VendorGuid, GetVendorGuidPtr (VariablePtr), sizeof (EFI_GUID));

-      Status = EFI_SUCCESS;

-    } else {

-      Status = EFI_BUFFER_TOO_SMALL;

-    }

-

-    *VariableNameSize = VarNameSize;

-  }

-

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-  return Status;

-}

-

-/**

-

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode, and datasize and data are external input.

-  This function will do basic validation, before parse the data.

-  This function will parse the authentication carefully to avoid security issues, like

-  buffer overflow, integer overflow.

-  This function will check attribute carefully to avoid authentication bypass.

-

-  @param VariableName                     Name of Variable to be found.

-  @param VendorGuid                       Variable vendor GUID.

-  @param Attributes                       Attribute value of the variable found

-  @param DataSize                         Size of Data found. If size is less than the

-                                          data, this value contains the required size.

-  @param Data                             Data pointer.

-

-  @return EFI_INVALID_PARAMETER           Invalid parameter.

-  @return EFI_SUCCESS                     Set successfully.

-  @return EFI_OUT_OF_RESOURCES            Resource not enough to set variable.

-  @return EFI_NOT_FOUND                   Not found.

-  @return EFI_WRITE_PROTECTED             Variable is read-only.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceSetVariable (

-  IN CHAR16                  *VariableName,

-  IN EFI_GUID                *VendorGuid,

-  IN UINT32                  Attributes,

-  IN UINTN                   DataSize,

-  IN VOID                    *Data

-  )

-{

-  VARIABLE_POINTER_TRACK              Variable;

-  EFI_STATUS                          Status;

-  VARIABLE_HEADER                     *NextVariable;

-  EFI_PHYSICAL_ADDRESS                Point;

-  UINTN                               PayloadSize;

-

-  //

-  // Check input parameters.

-  //

-  if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (DataSize != 0 && Data == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  // Check for reserverd bit in variable attribute.

-  //

-  if ((Attributes & (~EFI_VARIABLE_ATTRIBUTES_MASK)) != 0) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  //  Make sure if runtime bit is set, boot service bit is set also.

-  //

-  if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {

-    return EFI_INVALID_PARAMETER;

-  } else if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {

-    if (!mVariableModuleGlobal->VariableGlobal.AuthSupport) {

-      //

-      // Not support authenticated variable write.

-      //

-      return EFI_INVALID_PARAMETER;

-    }

-  } else if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {

-    if (PcdGet32 (PcdHwErrStorageSize) == 0) {

-      //

-      // Not support harware error record variable variable.

-      //

-      return EFI_INVALID_PARAMETER;

-    }

-  }

-

-  //

-  // EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS and EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute

-  // cannot be set both.

-  //

-  if (((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)

-     && ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) {

-    if (DataSize < AUTHINFO_SIZE) {

-      //

-      // Try to write Authenticated Variable without AuthInfo.

-      //

-      return EFI_SECURITY_VIOLATION;

-    }

-    PayloadSize = DataSize - AUTHINFO_SIZE;

-  } else if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) {

-    //

-    // Sanity check for EFI_VARIABLE_AUTHENTICATION_2 descriptor.

-    //

-    if (DataSize < OFFSET_OF_AUTHINFO2_CERT_DATA ||

-      ((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->AuthInfo.Hdr.dwLength > DataSize - (OFFSET_OF (EFI_VARIABLE_AUTHENTICATION_2, AuthInfo)) ||

-      ((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->AuthInfo.Hdr.dwLength < OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)) {

-      return EFI_SECURITY_VIOLATION;

-    }

-    PayloadSize = DataSize - AUTHINFO2_SIZE (Data);

-  } else {

-    PayloadSize = DataSize;

-  }

-

-  if ((UINTN)(~0) - PayloadSize < StrSize(VariableName)){

-    //

-    // Prevent whole variable size overflow

-    //

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  //  The size of the VariableName, including the Unicode Null in bytes plus

-  //  the DataSize is limited to maximum size of PcdGet32 (PcdMaxHardwareErrorVariableSize)

-  //  bytes for HwErrRec#### variable.

-  //

-  if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-    if (StrSize (VariableName) + PayloadSize > PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize ()) {

-      return EFI_INVALID_PARAMETER;

-    }

-  } else {

-    //

-    //  The size of the VariableName, including the Unicode Null in bytes plus

-    //  the DataSize is limited to maximum size of Max(Auth)VariableSize bytes.

-    //

-    if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {

-      if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ()) {

-        return EFI_INVALID_PARAMETER;

-      }

-    } else {

-      if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize ()) {

-        return EFI_INVALID_PARAMETER;

-      }

-    }

-  }

-

-  //

-  // Special Handling for MOR Lock variable.

-  //

-  Status = SetVariableCheckHandlerMor (VariableName, VendorGuid, Attributes, PayloadSize, (VOID *) ((UINTN) Data + DataSize - PayloadSize));

-  if (Status == EFI_ALREADY_STARTED) {

-    //

-    // EFI_ALREADY_STARTED means the SetVariable() action is handled inside of SetVariableCheckHandlerMor().

-    // Variable driver can just return SUCCESS.

-    //

-    return EFI_SUCCESS;

-  }

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  Status = VarCheckLibSetVariableCheck (VariableName, VendorGuid, Attributes, PayloadSize, (VOID *) ((UINTN) Data + DataSize - PayloadSize), mRequestSource);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  //

-  // Consider reentrant in MCA/INIT/NMI. It needs be reupdated.

-  //

-  if (1 < InterlockedIncrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState)) {

-    Point = mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;

-    //

-    // Parse non-volatile variable data and get last variable offset.

-    //

-    NextVariable  = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point);

-    while (IsValidVariableHeader (NextVariable, GetEndPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point))) {

-      NextVariable = GetNextVariablePtr (NextVariable);

-    }

-    mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;

-  }

-

-  //

-  // Check whether the input variable is already existed.

-  //

-  Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, TRUE);

-  if (!EFI_ERROR (Status)) {

-    if (((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) && AtRuntime ()) {

-      Status = EFI_WRITE_PROTECTED;

-      goto Done;

-    }

-    if (Attributes != 0 && (Attributes & (~EFI_VARIABLE_APPEND_WRITE)) != Variable.CurrPtr->Attributes) {

-      //

-      // If a preexisting variable is rewritten with different attributes, SetVariable() shall not

-      // modify the variable and shall return EFI_INVALID_PARAMETER. Two exceptions to this rule:

-      // 1. No access attributes specified

-      // 2. The only attribute differing is EFI_VARIABLE_APPEND_WRITE

-      //

-      Status = EFI_INVALID_PARAMETER;

-      DEBUG ((EFI_D_INFO, "[Variable]: Rewritten a preexisting variable(0x%08x) with different attributes(0x%08x) - %g:%s\n", Variable.CurrPtr->Attributes, Attributes, VendorGuid, VariableName));

-      goto Done;

-    }

-  }

-

-  if (!FeaturePcdGet (PcdUefiVariableDefaultLangDeprecate)) {

-    //

-    // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang.

-    //

-    Status = AutoUpdateLangVariable (VariableName, Data, DataSize);

-    if (EFI_ERROR (Status)) {

-      //

-      // The auto update operation failed, directly return to avoid inconsistency between PlatformLang and Lang.

-      //

-      goto Done;

-    }

-  }

-

-  if (mVariableModuleGlobal->VariableGlobal.AuthSupport) {

-    Status = AuthVariableLibProcessVariable (VariableName, VendorGuid, Data, DataSize, Attributes);

-  } else {

-    Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, 0, 0, &Variable, NULL);

-  }

-

-Done:

-  InterlockedDecrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState);

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  if (!AtRuntime ()) {

-    if (!EFI_ERROR (Status)) {

-      SecureBootHook (

-        VariableName,

-        VendorGuid

-        );

-    }

-  }

-

-  return Status;

-}

-

-/**

-

-  This code returns information about the EFI variables.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param Attributes                     Attributes bitmask to specify the type of variables

-                                        on which to return information.

-  @param MaximumVariableStorageSize     Pointer to the maximum size of the storage space available

-                                        for the EFI variables associated with the attributes specified.

-  @param RemainingVariableStorageSize   Pointer to the remaining size of the storage space available

-                                        for EFI variables associated with the attributes specified.

-  @param MaximumVariableSize            Pointer to the maximum size of an individual EFI variables

-                                        associated with the attributes specified.

-

-  @return EFI_SUCCESS                   Query successfully.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceQueryVariableInfoInternal (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize

-  )

-{

-  VARIABLE_HEADER        *Variable;

-  VARIABLE_HEADER        *NextVariable;

-  UINT64                 VariableSize;

-  VARIABLE_STORE_HEADER  *VariableStoreHeader;

-  UINT64                 CommonVariableTotalSize;

-  UINT64                 HwErrVariableTotalSize;

-  EFI_STATUS             Status;

-  VARIABLE_POINTER_TRACK VariablePtrTrack;

-

-  CommonVariableTotalSize = 0;

-  HwErrVariableTotalSize = 0;

-

-  if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {

-    //

-    // Query is Volatile related.

-    //

-    VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);

-  } else {

-    //

-    // Query is Non-Volatile related.

-    //

-    VariableStoreHeader = mNvVariableCache;

-  }

-

-  //

-  // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize

-  // with the storage size (excluding the storage header size).

-  //

-  *MaximumVariableStorageSize   = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);

-

-  //

-  // Harware error record variable needs larger size.

-  //

-  if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-    *MaximumVariableStorageSize = PcdGet32 (PcdHwErrStorageSize);

-    *MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize ();

-  } else {

-    if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {

-      if (AtRuntime ()) {

-        *MaximumVariableStorageSize = mVariableModuleGlobal->CommonRuntimeVariableSpace;

-      } else {

-        *MaximumVariableStorageSize = mVariableModuleGlobal->CommonVariableSpace;

-      }

-    }

-

-    //

-    // Let *MaximumVariableSize be Max(Auth)VariableSize with the exception of the variable header size.

-    //

-    if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {

-      *MaximumVariableSize = mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ();

-    } else {

-      *MaximumVariableSize = mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize ();

-    }

-  }

-

-  //

-  // Point to the starting address of the variables.

-  //

-  Variable = GetStartPointer (VariableStoreHeader);

-

-  //

-  // Now walk through the related variable store.

-  //

-  while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {

-    NextVariable = GetNextVariablePtr (Variable);

-    VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;

-

-    if (AtRuntime ()) {

-      //

-      // We don't take the state of the variables in mind

-      // when calculating RemainingVariableStorageSize,

-      // since the space occupied by variables not marked with

-      // VAR_ADDED is not allowed to be reclaimed in Runtime.

-      //

-      if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-        HwErrVariableTotalSize += VariableSize;

-      } else {

-        CommonVariableTotalSize += VariableSize;

-      }

-    } else {

-      //

-      // Only care about Variables with State VAR_ADDED, because

-      // the space not marked as VAR_ADDED is reclaimable now.

-      //

-      if (Variable->State == VAR_ADDED) {

-        if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-          HwErrVariableTotalSize += VariableSize;

-        } else {

-          CommonVariableTotalSize += VariableSize;

-        }

-      } else if (Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

-        //

-        // If it is a IN_DELETED_TRANSITION variable,

-        // and there is not also a same ADDED one at the same time,

-        // this IN_DELETED_TRANSITION variable is valid.

-        //

-        VariablePtrTrack.StartPtr = GetStartPointer (VariableStoreHeader);

-        VariablePtrTrack.EndPtr   = GetEndPointer   (VariableStoreHeader);

-        Status = FindVariableEx (

-                   GetVariableNamePtr (Variable),

-                   GetVendorGuidPtr (Variable),

-                   FALSE,

-                   &VariablePtrTrack

-                   );

-        if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State != VAR_ADDED) {

-          if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-            HwErrVariableTotalSize += VariableSize;

-          } else {

-            CommonVariableTotalSize += VariableSize;

-          }

-        }

-      }

-    }

-

-    //

-    // Go to the next one.

-    //

-    Variable = NextVariable;

-  }

-

-  if ((Attributes  & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){

-    *RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;

-  } else {

-    if (*MaximumVariableStorageSize < CommonVariableTotalSize) {

-      *RemainingVariableStorageSize = 0;

-    } else {

-      *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;

-    }

-  }

-

-  if (*RemainingVariableStorageSize < GetVariableHeaderSize ()) {

-    *MaximumVariableSize = 0;

-  } else if ((*RemainingVariableStorageSize - GetVariableHeaderSize ()) < *MaximumVariableSize) {

-    *MaximumVariableSize = *RemainingVariableStorageSize - GetVariableHeaderSize ();

-  }

-

-  return EFI_SUCCESS;

-}

-

-/**

-

-  This code returns information about the EFI variables.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param Attributes                     Attributes bitmask to specify the type of variables

-                                        on which to return information.

-  @param MaximumVariableStorageSize     Pointer to the maximum size of the storage space available

-                                        for the EFI variables associated with the attributes specified.

-  @param RemainingVariableStorageSize   Pointer to the remaining size of the storage space available

-                                        for EFI variables associated with the attributes specified.

-  @param MaximumVariableSize            Pointer to the maximum size of an individual EFI variables

-                                        associated with the attributes specified.

-

-  @return EFI_INVALID_PARAMETER         An invalid combination of attribute bits was supplied.

-  @return EFI_SUCCESS                   Query successfully.

-  @return EFI_UNSUPPORTED               The attribute is not supported on this platform.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceQueryVariableInfo (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize

-  )

-{

-  EFI_STATUS             Status;

-

-  if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if ((Attributes & EFI_VARIABLE_ATTRIBUTES_MASK) == 0) {

-    //

-    // Make sure the Attributes combination is supported by the platform.

-    //

-    return EFI_UNSUPPORTED;

-  } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {

-    //

-    // Make sure if runtime bit is set, boot service bit is set also.

-    //

-    return EFI_INVALID_PARAMETER;

-  } else if (AtRuntime () && ((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) {

-    //

-    // Make sure RT Attribute is set if we are in Runtime phase.

-    //

-    return EFI_INVALID_PARAMETER;

-  } else if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {

-    //

-    // Make sure Hw Attribute is set with NV.

-    //

-    return EFI_INVALID_PARAMETER;

-  } else if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {

-    if (!mVariableModuleGlobal->VariableGlobal.AuthSupport) {

-      //

-      // Not support authenticated variable write.

-      //

-      return EFI_UNSUPPORTED;

-    }

-  } else if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {

-    if (PcdGet32 (PcdHwErrStorageSize) == 0) {

-      //

-      // Not support harware error record variable variable.

-      //

-      return EFI_UNSUPPORTED;

-    }

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  Status = VariableServiceQueryVariableInfoInternal (

-             Attributes,

-             MaximumVariableStorageSize,

-             RemainingVariableStorageSize,

-             MaximumVariableSize

-             );

-

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-  return Status;

-}

-

-/**

-  This function reclaims variable storage if free size is below the threshold.

-

-  Caution: This function may be invoked at SMM mode.

-  Care must be taken to make sure not security issue.

-

-**/

-VOID

-ReclaimForOS(

-  VOID

-  )

-{

-  EFI_STATUS                     Status;

-  UINTN                          RemainingCommonRuntimeVariableSpace;

-  UINTN                          RemainingHwErrVariableSpace;

-  STATIC BOOLEAN                 Reclaimed;

-

-  //

-  // This function will be called only once at EndOfDxe or ReadyToBoot event.

-  //

-  if (Reclaimed) {

-    return;

-  }

-  Reclaimed = TRUE;

-

-  Status  = EFI_SUCCESS;

-

-  if (mVariableModuleGlobal->CommonRuntimeVariableSpace < mVariableModuleGlobal->CommonVariableTotalSize) {

-    RemainingCommonRuntimeVariableSpace = 0;

-  } else {

-    RemainingCommonRuntimeVariableSpace = mVariableModuleGlobal->CommonRuntimeVariableSpace - mVariableModuleGlobal->CommonVariableTotalSize;

-  }

-

-  RemainingHwErrVariableSpace = PcdGet32 (PcdHwErrStorageSize) - mVariableModuleGlobal->HwErrVariableTotalSize;

-

-  //

-  // Check if the free area is below a threshold.

-  //

-  if (((RemainingCommonRuntimeVariableSpace < mVariableModuleGlobal->MaxVariableSize) ||

-       (RemainingCommonRuntimeVariableSpace < mVariableModuleGlobal->MaxAuthVariableSize)) ||

-      ((PcdGet32 (PcdHwErrStorageSize) != 0) &&

-       (RemainingHwErrVariableSpace < PcdGet32 (PcdMaxHardwareErrorVariableSize)))){

-    Status = Reclaim (

-            mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

-            &mVariableModuleGlobal->NonVolatileLastVariableOffset,

-            FALSE,

-            NULL,

-            NULL,

-            0

-            );

-    ASSERT_EFI_ERROR (Status);

-  }

-}

-

-/**

-  Get non-volatile maximum variable size.

-

-  @return Non-volatile maximum variable size.

-

-**/

-UINTN

-GetNonVolatileMaxVariableSize (

-  VOID

-  )

-{

-  if (PcdGet32 (PcdHwErrStorageSize) != 0) {

-    return MAX (MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxAuthVariableSize)),

-                PcdGet32 (PcdMaxHardwareErrorVariableSize));

-  } else {

-    return MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxAuthVariableSize));

-  }

-}

-

-/**

-  Init non-volatile variable store.

-

-  @param[out] NvFvHeader        Output pointer to non-volatile FV header address.

-

-  @retval EFI_SUCCESS           Function successfully executed.

-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.

-  @retval EFI_VOLUME_CORRUPTED  Variable Store or Firmware Volume for Variable Store is corrupted.

-

-**/

-EFI_STATUS

-InitNonVolatileVariableStore (

-  OUT EFI_FIRMWARE_VOLUME_HEADER    **NvFvHeader

-  )

-{

-  EFI_FIRMWARE_VOLUME_HEADER            *FvHeader;

-  VARIABLE_HEADER                       *Variable;

-  VARIABLE_HEADER                       *NextVariable;

-  EFI_PHYSICAL_ADDRESS                  VariableStoreBase;

-  UINT64                                VariableStoreLength;

-  UINTN                                 VariableSize;

-  EFI_HOB_GUID_TYPE                     *GuidHob;

-  EFI_PHYSICAL_ADDRESS                  NvStorageBase;

-  UINT8                                 *NvStorageData;

-  UINT32                                NvStorageSize;

-  FAULT_TOLERANT_WRITE_LAST_WRITE_DATA  *FtwLastWriteData;

-  UINT32                                BackUpOffset;

-  UINT32                                BackUpSize;

-  UINT32                                HwErrStorageSize;

-  UINT32                                MaxUserNvVariableSpaceSize;

-  UINT32                                BoottimeReservedNvVariableSpaceSize;

-  EFI_STATUS                            Status;

-  VOID                                  *FtwProtocol;

-

-  mVariableModuleGlobal->FvbInstance = NULL;

-

-  //

-  // Allocate runtime memory used for a memory copy of the FLASH region.

-  // Keep the memory and the FLASH in sync as updates occur.

-  //

-  NvStorageSize = PcdGet32 (PcdFlashNvStorageVariableSize);

-  NvStorageData = AllocateRuntimeZeroPool (NvStorageSize);

-  if (NvStorageData == NULL) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);

-  if (NvStorageBase == 0) {

-    NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);

-  }

-  //

-  // Copy NV storage data to the memory buffer.

-  //

-  CopyMem (NvStorageData, (UINT8 *) (UINTN) NvStorageBase, NvStorageSize);

-

-  Status = GetFtwProtocol ((VOID **)&FtwProtocol);

-  //

-  // If FTW protocol has been installed, no need to check FTW last write data hob.

-  //

-  if (EFI_ERROR (Status)) {

-    //

-    // Check the FTW last write data hob.

-    //

-    GuidHob = GetFirstGuidHob (&gEdkiiFaultTolerantWriteGuid);

-    if (GuidHob != NULL) {

-      FtwLastWriteData = (FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *) GET_GUID_HOB_DATA (GuidHob);

-      if (FtwLastWriteData->TargetAddress == NvStorageBase) {

-        DEBUG ((EFI_D_INFO, "Variable: NV storage is backed up in spare block: 0x%x\n", (UINTN) FtwLastWriteData->SpareAddress));

-        //

-        // Copy the backed up NV storage data to the memory buffer from spare block.

-        //

-        CopyMem (NvStorageData, (UINT8 *) (UINTN) (FtwLastWriteData->SpareAddress), NvStorageSize);

-      } else if ((FtwLastWriteData->TargetAddress > NvStorageBase) &&

-                 (FtwLastWriteData->TargetAddress < (NvStorageBase + NvStorageSize))) {

-        //

-        // Flash NV storage from the Offset is backed up in spare block.

-        //

-        BackUpOffset = (UINT32) (FtwLastWriteData->TargetAddress - NvStorageBase);

-        BackUpSize = NvStorageSize - BackUpOffset;

-        DEBUG ((EFI_D_INFO, "Variable: High partial NV storage from offset: %x is backed up in spare block: 0x%x\n", BackUpOffset, (UINTN) FtwLastWriteData->SpareAddress));

-        //

-        // Copy the partial backed up NV storage data to the memory buffer from spare block.

-        //

-        CopyMem (NvStorageData + BackUpOffset, (UINT8 *) (UINTN) FtwLastWriteData->SpareAddress, BackUpSize);

-      }

-    }

-  }

-

-  FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) NvStorageData;

-

-  //

-  // Check if the Firmware Volume is not corrupted

-  //

-  if ((FvHeader->Signature != EFI_FVH_SIGNATURE) || (!CompareGuid (&gEfiSystemNvDataFvGuid, &FvHeader->FileSystemGuid))) {

-    FreePool (NvStorageData);

-    DEBUG ((EFI_D_ERROR, "Firmware Volume for Variable Store is corrupted\n"));

-    return EFI_VOLUME_CORRUPTED;

-  }

-

-  VariableStoreBase = (UINTN) FvHeader + FvHeader->HeaderLength;

-  VariableStoreLength = NvStorageSize - FvHeader->HeaderLength;

-

-  mNvFvHeaderCache = FvHeader;

-  mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;

-  mNvVariableCache = (VARIABLE_STORE_HEADER *) (UINTN) VariableStoreBase;

-  if (GetVariableStoreStatus (mNvVariableCache) != EfiValid) {

-    FreePool (NvStorageData);

-    mNvFvHeaderCache = NULL;

-    mNvVariableCache = NULL;

-    DEBUG((EFI_D_ERROR, "Variable Store header is corrupted\n"));

-    return EFI_VOLUME_CORRUPTED;

-  }

-  ASSERT(mNvVariableCache->Size == VariableStoreLength);

-

-  ASSERT (sizeof (VARIABLE_STORE_HEADER) <= VariableStoreLength);

-

-  mVariableModuleGlobal->VariableGlobal.AuthFormat = (BOOLEAN)(CompareGuid (&mNvVariableCache->Signature, &gEfiAuthenticatedVariableGuid));

-

-  HwErrStorageSize = PcdGet32 (PcdHwErrStorageSize);

-  MaxUserNvVariableSpaceSize = PcdGet32 (PcdMaxUserNvVariableSpaceSize);

-  BoottimeReservedNvVariableSpaceSize = PcdGet32 (PcdBoottimeReservedNvVariableSpaceSize);

-

-  //

-  // Note that in EdkII variable driver implementation, Hardware Error Record type variable

-  // is stored with common variable in the same NV region. So the platform integrator should

-  // ensure that the value of PcdHwErrStorageSize is less than the value of

-  // (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)).

-  //

-  ASSERT (HwErrStorageSize < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)));

-  //

-  // Ensure that the value of PcdMaxUserNvVariableSpaceSize is less than the value of

-  // (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)) - PcdGet32 (PcdHwErrStorageSize).

-  //

-  ASSERT (MaxUserNvVariableSpaceSize < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize));

-  //

-  // Ensure that the value of PcdBoottimeReservedNvVariableSpaceSize is less than the value of

-  // (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)) - PcdGet32 (PcdHwErrStorageSize).

-  //

-  ASSERT (BoottimeReservedNvVariableSpaceSize < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize));

-

-  mVariableModuleGlobal->CommonVariableSpace = ((UINTN) VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize);

-  mVariableModuleGlobal->CommonMaxUserVariableSpace = ((MaxUserNvVariableSpaceSize != 0) ? MaxUserNvVariableSpaceSize : mVariableModuleGlobal->CommonVariableSpace);

-  mVariableModuleGlobal->CommonRuntimeVariableSpace = mVariableModuleGlobal->CommonVariableSpace - BoottimeReservedNvVariableSpaceSize;

-

-  DEBUG ((EFI_D_INFO, "Variable driver common space: 0x%x 0x%x 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonRuntimeVariableSpace));

-

-  //

-  // The max NV variable size should be < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)).

-  //

-  ASSERT (GetNonVolatileMaxVariableSize () < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)));

-

-  mVariableModuleGlobal->MaxVariableSize = PcdGet32 (PcdMaxVariableSize);

-  mVariableModuleGlobal->MaxAuthVariableSize = ((PcdGet32 (PcdMaxAuthVariableSize) != 0) ? PcdGet32 (PcdMaxAuthVariableSize) : mVariableModuleGlobal->MaxVariableSize);

-

-  //

-  // Parse non-volatile variable data and get last variable offset.

-  //

-  Variable  = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase);

-  while (IsValidVariableHeader (Variable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase))) {

-    NextVariable = GetNextVariablePtr (Variable);

-    VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-    if ((Variable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-      mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;

-    } else {

-      mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;

-    }

-

-    Variable = NextVariable;

-  }

-  mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) Variable - (UINTN) VariableStoreBase;

-

-  *NvFvHeader = FvHeader;

-  return EFI_SUCCESS;

-}

-

-/**

-  Flush the HOB variable to flash.

-

-  @param[in] VariableName       Name of variable has been updated or deleted.

-  @param[in] VendorGuid         Guid of variable has been updated or deleted.

-

-**/

-VOID

-FlushHobVariableToFlash (

-  IN CHAR16                     *VariableName,

-  IN EFI_GUID                   *VendorGuid

-  )

-{

-  EFI_STATUS                    Status;

-  VARIABLE_STORE_HEADER         *VariableStoreHeader;

-  VARIABLE_HEADER               *Variable;

-  VOID                          *VariableData;

-  VARIABLE_POINTER_TRACK        VariablePtrTrack;

-  BOOLEAN                       ErrorFlag;

-

-  ErrorFlag = FALSE;

-

-  //

-  // Flush the HOB variable to flash.

-  //

-  if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {

-    VariableStoreHeader = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;

-    //

-    // Set HobVariableBase to 0, it can avoid SetVariable to call back.

-    //

-    mVariableModuleGlobal->VariableGlobal.HobVariableBase = 0;

-    for ( Variable = GetStartPointer (VariableStoreHeader)

-        ; IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))

-        ; Variable = GetNextVariablePtr (Variable)

-        ) {

-      if (Variable->State != VAR_ADDED) {

-        //

-        // The HOB variable has been set to DELETED state in local.

-        //

-        continue;

-      }

-      ASSERT ((Variable->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0);

-      if (VendorGuid == NULL || VariableName == NULL ||

-          !CompareGuid (VendorGuid, GetVendorGuidPtr (Variable)) ||

-          StrCmp (VariableName, GetVariableNamePtr (Variable)) != 0) {

-        VariableData = GetVariableDataPtr (Variable);

-        FindVariable (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &VariablePtrTrack, &mVariableModuleGlobal->VariableGlobal, FALSE);

-        Status = UpdateVariable (

-                   GetVariableNamePtr (Variable),

-                   GetVendorGuidPtr (Variable),

-                   VariableData,

-                   DataSizeOfVariable (Variable),

-                   Variable->Attributes,

-                   0,

-                   0,

-                   &VariablePtrTrack,

-                   NULL

-                 );

-        DEBUG ((EFI_D_INFO, "Variable driver flush the HOB variable to flash: %g %s %r\n", GetVendorGuidPtr (Variable), GetVariableNamePtr (Variable), Status));

-      } else {

-        //

-        // The updated or deleted variable is matched with this HOB variable.

-        // Don't break here because we will try to set other HOB variables

-        // since this variable could be set successfully.

-        //

-        Status = EFI_SUCCESS;

-      }

-      if (!EFI_ERROR (Status)) {

-        //

-        // If set variable successful, or the updated or deleted variable is matched with the HOB variable,

-        // set the HOB variable to DELETED state in local.

-        //

-        DEBUG ((EFI_D_INFO, "Variable driver set the HOB variable to DELETED state in local: %g %s\n", GetVendorGuidPtr (Variable), GetVariableNamePtr (Variable)));

-        Variable->State &= VAR_DELETED;

-      } else {

-        ErrorFlag = TRUE;

-      }

-    }

-    if (ErrorFlag) {

-      //

-      // We still have HOB variable(s) not flushed in flash.

-      //

-      mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStoreHeader;

-    } else {

-      //

-      // All HOB variables have been flushed in flash.

-      //

-      DEBUG ((EFI_D_INFO, "Variable driver: all HOB variables have been flushed in flash.\n"));

-      if (!AtRuntime ()) {

-        FreePool ((VOID *) VariableStoreHeader);

-      }

-    }

-  }

-

-}

-

-/**

-  Initializes variable write service after FTW was ready.

-

-  @retval EFI_SUCCESS          Function successfully executed.

-  @retval Others               Fail to initialize the variable service.

-

-**/

-EFI_STATUS

-VariableWriteServiceInitialize (

-  VOID

-  )

-{

-  EFI_STATUS                      Status;

-  UINTN                           Index;

-  UINT8                           Data;

-  EFI_PHYSICAL_ADDRESS            VariableStoreBase;

-  EFI_PHYSICAL_ADDRESS            NvStorageBase;

-  VARIABLE_ENTRY_PROPERTY         *VariableEntry;

-

-  AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);

-  if (NvStorageBase == 0) {

-    NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);

-  }

-  VariableStoreBase = NvStorageBase + (mNvFvHeaderCache->HeaderLength);

-

-  //

-  // Let NonVolatileVariableBase point to flash variable store base directly after FTW ready.

-  //

-  mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;

-

-  //

-  // Check if the free area is really free.

-  //

-  for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < mNvVariableCache->Size; Index++) {

-    Data = ((UINT8 *) mNvVariableCache)[Index];

-    if (Data != 0xff) {

-      //

-      // There must be something wrong in variable store, do reclaim operation.

-      //

-      Status = Reclaim (

-                 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

-                 &mVariableModuleGlobal->NonVolatileLastVariableOffset,

-                 FALSE,

-                 NULL,

-                 NULL,

-                 0

-                 );

-      if (EFI_ERROR (Status)) {

-        ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-        return Status;

-      }

-      break;

-    }

-  }

-

-  FlushHobVariableToFlash (NULL, NULL);

-

-  Status = EFI_SUCCESS;

-  ZeroMem (&mAuthContextOut, sizeof (mAuthContextOut));

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    //

-    // Authenticated variable initialize.

-    //

-    mAuthContextIn.StructSize = sizeof (AUTH_VAR_LIB_CONTEXT_IN);

-    mAuthContextIn.MaxAuthVariableSize = mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ();

-    Status = AuthVariableLibInitialize (&mAuthContextIn, &mAuthContextOut);

-    if (!EFI_ERROR (Status)) {

-      DEBUG ((EFI_D_INFO, "Variable driver will work with auth variable support!\n"));

-      mVariableModuleGlobal->VariableGlobal.AuthSupport = TRUE;

-      if (mAuthContextOut.AuthVarEntry != NULL) {

-        for (Index = 0; Index < mAuthContextOut.AuthVarEntryCount; Index++) {

-          VariableEntry = &mAuthContextOut.AuthVarEntry[Index];

-          Status = VarCheckLibVariablePropertySet (

-                     VariableEntry->Name,

-                     VariableEntry->Guid,

-                     &VariableEntry->VariableProperty

-                     );

-          ASSERT_EFI_ERROR (Status);

-        }

-      }

-    } else if (Status == EFI_UNSUPPORTED) {

-      DEBUG ((EFI_D_INFO, "NOTICE - AuthVariableLibInitialize() returns %r!\n", Status));

-      DEBUG ((EFI_D_INFO, "Variable driver will continue to work without auth variable support!\n"));

-      mVariableModuleGlobal->VariableGlobal.AuthSupport = FALSE;

-      Status = EFI_SUCCESS;

-    }

-  }

-

-  if (!EFI_ERROR (Status)) {

-    for (Index = 0; Index < ARRAY_SIZE (mVariableEntryProperty); Index++) {

-      VariableEntry = &mVariableEntryProperty[Index];

-      Status = VarCheckLibVariablePropertySet (VariableEntry->Name, VariableEntry->Guid, &VariableEntry->VariableProperty);

-      ASSERT_EFI_ERROR (Status);

-    }

-  }

-

-  ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);

-

-  //

-  // Initialize MOR Lock variable.

-  //

-  MorLockInit ();

-

-  return Status;

-}

-

-

-/**

-  Initializes variable store area for non-volatile and volatile variable.

-

-  @retval EFI_SUCCESS           Function successfully executed.

-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.

-

-**/

-EFI_STATUS

-VariableCommonInitialize (

-  VOID

-  )

-{

-  EFI_STATUS                      Status;

-  VARIABLE_STORE_HEADER           *VolatileVariableStore;

-  VARIABLE_STORE_HEADER           *VariableStoreHeader;

-  UINT64                          VariableStoreLength;

-  UINTN                           ScratchSize;

-  EFI_HOB_GUID_TYPE               *GuidHob;

-  EFI_GUID                        *VariableGuid;

-  EFI_FIRMWARE_VOLUME_HEADER      *NvFvHeader;

-

-  //

-  // Allocate runtime memory for variable driver global structure.

-  //

-  mVariableModuleGlobal = AllocateRuntimeZeroPool (sizeof (VARIABLE_MODULE_GLOBAL));

-  if (mVariableModuleGlobal == NULL) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  InitializeLock (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);

-

-  //

-  // Init non-volatile variable store.

-  //

-  NvFvHeader = NULL;

-  Status = InitNonVolatileVariableStore (&NvFvHeader);

-  if (EFI_ERROR (Status)) {

-    FreePool (mVariableModuleGlobal);

-    return Status;

-  }

-

-  //

-  // mVariableModuleGlobal->VariableGlobal.AuthFormat

-  // has been initialized in InitNonVolatileVariableStore().

-  //

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    DEBUG ((EFI_D_INFO, "Variable driver will work with auth variable format!\n"));

-    //

-    // Set AuthSupport to FALSE first, VariableWriteServiceInitialize() will initialize it.

-    //

-    mVariableModuleGlobal->VariableGlobal.AuthSupport = FALSE;

-    VariableGuid = &gEfiAuthenticatedVariableGuid;

-  } else {

-    DEBUG ((EFI_D_INFO, "Variable driver will work without auth variable support!\n"));

-    mVariableModuleGlobal->VariableGlobal.AuthSupport = FALSE;

-    VariableGuid = &gEfiVariableGuid;

-  }

-

-  //

-  // Get HOB variable store.

-  //

-  GuidHob = GetFirstGuidHob (VariableGuid);

-  if (GuidHob != NULL) {

-    VariableStoreHeader = GET_GUID_HOB_DATA (GuidHob);

-    VariableStoreLength = GuidHob->Header.HobLength - sizeof (EFI_HOB_GUID_TYPE);

-    if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {

-      mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) AllocateRuntimeCopyPool ((UINTN) VariableStoreLength, (VOID *) VariableStoreHeader);

-      if (mVariableModuleGlobal->VariableGlobal.HobVariableBase == 0) {

-        FreePool (NvFvHeader);

-        FreePool (mVariableModuleGlobal);

-        return EFI_OUT_OF_RESOURCES;

-      }

-    } else {

-      DEBUG ((EFI_D_ERROR, "HOB Variable Store header is corrupted!\n"));

-    }

-  }

-

-  //

-  // Allocate memory for volatile variable store, note that there is a scratch space to store scratch data.

-  //

-  ScratchSize = GetNonVolatileMaxVariableSize ();

-  mVariableModuleGlobal->ScratchBufferSize = ScratchSize;

-  VolatileVariableStore = AllocateRuntimePool (PcdGet32 (PcdVariableStoreSize) + ScratchSize);

-  if (VolatileVariableStore == NULL) {

-    if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {

-      FreePool ((VOID *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase);

-    }

-    FreePool (NvFvHeader);

-    FreePool (mVariableModuleGlobal);

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  SetMem (VolatileVariableStore, PcdGet32 (PcdVariableStoreSize) + ScratchSize, 0xff);

-

-  //

-  // Initialize Variable Specific Data.

-  //

-  mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;

-  mVariableModuleGlobal->VolatileLastVariableOffset = (UINTN) GetStartPointer (VolatileVariableStore) - (UINTN) VolatileVariableStore;

-

-  CopyGuid (&VolatileVariableStore->Signature, VariableGuid);

-  VolatileVariableStore->Size        = PcdGet32 (PcdVariableStoreSize);

-  VolatileVariableStore->Format      = VARIABLE_STORE_FORMATTED;

-  VolatileVariableStore->State       = VARIABLE_STORE_HEALTHY;

-  VolatileVariableStore->Reserved    = 0;

-  VolatileVariableStore->Reserved1   = 0;

-

-  return EFI_SUCCESS;

-}

-

-

-/**

-  Get the proper fvb handle and/or fvb protocol by the given Flash address.

-

-  @param[in]  Address       The Flash address.

-  @param[out] FvbHandle     In output, if it is not NULL, it points to the proper FVB handle.

-  @param[out] FvbProtocol   In output, if it is not NULL, it points to the proper FVB protocol.

-

-**/

-EFI_STATUS

-GetFvbInfoByAddress (

-  IN  EFI_PHYSICAL_ADDRESS                Address,

-  OUT EFI_HANDLE                          *FvbHandle OPTIONAL,

-  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvbProtocol OPTIONAL

-  )

-{

-  EFI_STATUS                              Status;

-  EFI_HANDLE                              *HandleBuffer;

-  UINTN                                   HandleCount;

-  UINTN                                   Index;

-  EFI_PHYSICAL_ADDRESS                    FvbBaseAddress;

-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL      *Fvb;

-  EFI_FVB_ATTRIBUTES_2                    Attributes;

-  UINTN                                   BlockSize;

-  UINTN                                   NumberOfBlocks;

-

-  HandleBuffer = NULL;

-  //

-  // Get all FVB handles.

-  //

-  Status = GetFvbCountAndBuffer (&HandleCount, &HandleBuffer);

-  if (EFI_ERROR (Status)) {

-    return EFI_NOT_FOUND;

-  }

-

-  //

-  // Get the FVB to access variable store.

-  //

-  Fvb = NULL;

-  for (Index = 0; Index < HandleCount; Index += 1, Status = EFI_NOT_FOUND, Fvb = NULL) {

-    Status = GetFvbByHandle (HandleBuffer[Index], &Fvb);

-    if (EFI_ERROR (Status)) {

-      Status = EFI_NOT_FOUND;

-      break;

-    }

-

-    //

-    // Ensure this FVB protocol supported Write operation.

-    //

-    Status = Fvb->GetAttributes (Fvb, &Attributes);

-    if (EFI_ERROR (Status) || ((Attributes & EFI_FVB2_WRITE_STATUS) == 0)) {

-      continue;

-    }

-

-    //

-    // Compare the address and select the right one.

-    //

-    Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);

-    if (EFI_ERROR (Status)) {

-      continue;

-    }

-

-    //

-    // Assume one FVB has one type of BlockSize.

-    //

-    Status = Fvb->GetBlockSize (Fvb, 0, &BlockSize, &NumberOfBlocks);

-    if (EFI_ERROR (Status)) {

-      continue;

-    }

-

-    if ((Address >= FvbBaseAddress) && (Address < (FvbBaseAddress + BlockSize * NumberOfBlocks))) {

-      if (FvbHandle != NULL) {

-        *FvbHandle  = HandleBuffer[Index];

-      }

-      if (FvbProtocol != NULL) {

-        *FvbProtocol = Fvb;

-      }

-      Status = EFI_SUCCESS;

-      break;

-    }

-  }

-  FreePool (HandleBuffer);

-

-  if (Fvb == NULL) {

-    Status = EFI_NOT_FOUND;

-  }

-

-  return Status;

-}

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h b/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
deleted file mode 100644
index 55df13191b..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
+++ /dev/null
@@ -1,902 +0,0 @@
-/** @file

-  The internal header file includes the common header files, defines

-  internal structure and functions used by Variable modules.

-

-Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#ifndef _VARIABLE_H_

-#define _VARIABLE_H_

-

-#include <PiDxe.h>

-#include <Protocol/VariableWrite.h>

-#include <Protocol/FaultTolerantWrite.h>

-#include <Protocol/FirmwareVolumeBlock.h>

-#include <Protocol/Variable.h>

-#include <Protocol/VariableLock.h>

-#include <Protocol/VarCheck.h>

-#include <Library/PcdLib.h>

-#include <Library/HobLib.h>

-#include <Library/UefiDriverEntryPoint.h>

-#include <Library/DxeServicesTableLib.h>

-#include <Library/UefiRuntimeLib.h>

-#include <Library/DebugLib.h>

-#include <Library/BaseMemoryLib.h>

-#include <Library/UefiBootServicesTableLib.h>

-#include <Library/UefiLib.h>

-#include <Library/BaseLib.h>

-#include <Library/SynchronizationLib.h>

-#include <Library/MemoryAllocationLib.h>

-#include <Library/AuthVariableLib.h>

-#include <Library/VarCheckLib.h>

-#include <Guid/GlobalVariable.h>

-#include <Guid/EventGroup.h>

-#include <Guid/VariableFormat.h>

-#include <Guid/SystemNvDataGuid.h>

-#include <Guid/FaultTolerantWrite.h>

-#include <Guid/VarErrorFlag.h>

-

-#define EFI_VARIABLE_ATTRIBUTES_MASK (EFI_VARIABLE_NON_VOLATILE | \

-                                      EFI_VARIABLE_BOOTSERVICE_ACCESS | \

-                                      EFI_VARIABLE_RUNTIME_ACCESS | \

-                                      EFI_VARIABLE_HARDWARE_ERROR_RECORD | \

-                                      EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \

-                                      EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \

-                                      EFI_VARIABLE_APPEND_WRITE)

-

-///

-/// The size of a 3 character ISO639 language code.

-///

-#define ISO_639_2_ENTRY_SIZE    3

-

-typedef enum {

-  VariableStoreTypeVolatile,

-  VariableStoreTypeHob,

-  VariableStoreTypeNv,

-  VariableStoreTypeMax

-} VARIABLE_STORE_TYPE;

-

-typedef struct {

-  VARIABLE_HEADER *CurrPtr;

-  //

-  // If both ADDED and IN_DELETED_TRANSITION variable are present,

-  // InDeletedTransitionPtr will point to the IN_DELETED_TRANSITION one.

-  // Otherwise, CurrPtr will point to the ADDED or IN_DELETED_TRANSITION one,

-  // and InDeletedTransitionPtr will be NULL at the same time.

-  //

-  VARIABLE_HEADER *InDeletedTransitionPtr;

-  VARIABLE_HEADER *EndPtr;

-  VARIABLE_HEADER *StartPtr;

-  BOOLEAN         Volatile;

-} VARIABLE_POINTER_TRACK;

-

-typedef struct {

-  EFI_PHYSICAL_ADDRESS  HobVariableBase;

-  EFI_PHYSICAL_ADDRESS  VolatileVariableBase;

-  EFI_PHYSICAL_ADDRESS  NonVolatileVariableBase;

-  EFI_LOCK              VariableServicesLock;

-  UINT32                ReentrantState;

-  BOOLEAN               AuthFormat;

-  BOOLEAN               AuthSupport;

-} VARIABLE_GLOBAL;

-

-typedef struct {

-  VARIABLE_GLOBAL VariableGlobal;

-  UINTN           VolatileLastVariableOffset;

-  UINTN           NonVolatileLastVariableOffset;

-  UINTN           CommonVariableSpace;

-  UINTN           CommonMaxUserVariableSpace;

-  UINTN           CommonRuntimeVariableSpace;

-  UINTN           CommonVariableTotalSize;

-  UINTN           CommonUserVariableTotalSize;

-  UINTN           HwErrVariableTotalSize;

-  UINTN           MaxVariableSize;

-  UINTN           MaxAuthVariableSize;

-  UINTN           ScratchBufferSize;

-  CHAR8           *PlatformLangCodes;

-  CHAR8           *LangCodes;

-  CHAR8           *PlatformLang;

-  CHAR8           Lang[ISO_639_2_ENTRY_SIZE + 1];

-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbInstance;

-} VARIABLE_MODULE_GLOBAL;

-

-/**

-  Flush the HOB variable to flash.

-

-  @param[in] VariableName       Name of variable has been updated or deleted.

-  @param[in] VendorGuid         Guid of variable has been updated or deleted.

-

-**/

-VOID

-FlushHobVariableToFlash (

-  IN CHAR16                     *VariableName,

-  IN EFI_GUID                   *VendorGuid

-  );

-

-/**

-  Writes a buffer to variable storage space, in the working block.

-

-  This function writes a buffer to variable storage space into a firmware

-  volume block device. The destination is specified by the parameter

-  VariableBase. Fault Tolerant Write protocol is used for writing.

-

-  @param  VariableBase   Base address of the variable to write.

-  @param  VariableBuffer Point to the variable data buffer.

-

-  @retval EFI_SUCCESS    The function completed successfully.

-  @retval EFI_NOT_FOUND  Fail to locate Fault Tolerant Write protocol.

-  @retval EFI_ABORTED    The function could not complete successfully.

-

-**/

-EFI_STATUS

-FtwVariableSpace (

-  IN EFI_PHYSICAL_ADDRESS   VariableBase,

-  IN VARIABLE_STORE_HEADER  *VariableBuffer

-  );

-

-/**

-  Finds variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-  If IgnoreRtCheck is TRUE, then we ignore the EFI_VARIABLE_RUNTIME_ACCESS attribute check

-  at runtime when searching existing variable, only VariableName and VendorGuid are compared.

-  Otherwise, variables without EFI_VARIABLE_RUNTIME_ACCESS are not visible at runtime.

-

-  @param[in]   VariableName           Name of the variable to be found.

-  @param[in]   VendorGuid             Vendor GUID to be found.

-  @param[out]  PtrTrack               VARIABLE_POINTER_TRACK structure for output,

-                                      including the range searched and the target position.

-  @param[in]   Global                 Pointer to VARIABLE_GLOBAL structure, including

-                                      base of volatile variable storage area, base of

-                                      NV variable storage area, and a lock.

-  @param[in]   IgnoreRtCheck          Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute

-                                      check at runtime when searching variable.

-

-  @retval EFI_INVALID_PARAMETER       If VariableName is not an empty string, while

-                                      VendorGuid is NULL.

-  @retval EFI_SUCCESS                 Variable successfully found.

-  @retval EFI_NOT_FOUND               Variable not found

-

-**/

-EFI_STATUS

-FindVariable (

-  IN  CHAR16                  *VariableName,

-  IN  EFI_GUID                *VendorGuid,

-  OUT VARIABLE_POINTER_TRACK  *PtrTrack,

-  IN  VARIABLE_GLOBAL         *Global,

-  IN  BOOLEAN                 IgnoreRtCheck

-  );

-

-/**

-

-  Gets the pointer to the end of the variable storage area.

-

-  This function gets pointer to the end of the variable storage

-  area, according to the input variable store header.

-

-  @param VarStoreHeader  Pointer to the Variable Store Header.

-

-  @return Pointer to the end of the variable storage area.

-

-**/

-VARIABLE_HEADER *

-GetEndPointer (

-  IN VARIABLE_STORE_HEADER       *VarStoreHeader

-  );

-

-/**

-  This code gets the size of variable header.

-

-  @return Size of variable header in bytes in type UINTN.

-

-**/

-UINTN

-GetVariableHeaderSize (

-  VOID

-  );

-

-/**

-

-  This code gets the pointer to the variable name.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Pointer to Variable Name which is Unicode encoding.

-

-**/

-CHAR16 *

-GetVariableNamePtr (

-  IN  VARIABLE_HEADER   *Variable

-  );

-

-/**

-  This code gets the pointer to the variable guid.

-

-  @param Variable   Pointer to the Variable Header.

-

-  @return A EFI_GUID* pointer to Vendor Guid.

-

-**/

-EFI_GUID *

-GetVendorGuidPtr (

-  IN VARIABLE_HEADER    *Variable

-  );

-

-/**

-

-  This code gets the pointer to the variable data.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Pointer to Variable Data.

-

-**/

-UINT8 *

-GetVariableDataPtr (

-  IN  VARIABLE_HEADER   *Variable

-  );

-

-/**

-

-  This code gets the size of variable data.

-

-  @param Variable        Pointer to the Variable Header.

-

-  @return Size of variable in bytes.

-

-**/

-UINTN

-DataSizeOfVariable (

-  IN  VARIABLE_HEADER   *Variable

-  );

-

-/**

-  This function is to check if the remaining variable space is enough to set

-  all Variables from argument list successfully. The purpose of the check

-  is to keep the consistency of the Variables to be in variable storage.

-

-  Note: Variables are assumed to be in same storage.

-  The set sequence of Variables will be same with the sequence of VariableEntry from argument list,

-  so follow the argument sequence to check the Variables.

-

-  @param[in] Attributes         Variable attributes for Variable entries.

-  @param[in] Marker             VA_LIST style variable argument list.

-                                The variable argument list with type VARIABLE_ENTRY_CONSISTENCY *.

-                                A NULL terminates the list. The VariableSize of

-                                VARIABLE_ENTRY_CONSISTENCY is the variable data size as input.

-                                It will be changed to variable total size as output.

-

-  @retval TRUE                  Have enough variable space to set the Variables successfully.

-  @retval FALSE                 No enough variable space to set the Variables successfully.

-

-**/

-BOOLEAN

-EFIAPI

-CheckRemainingSpaceForConsistencyInternal (

-  IN UINT32                     Attributes,

-  IN VA_LIST                    Marker

-  );

-

-/**

-  Update the variable region with Variable information. If EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS is set,

-  index of associated public key is needed.

-

-  @param[in] VariableName       Name of variable.

-  @param[in] VendorGuid         Guid of variable.

-  @param[in] Data               Variable data.

-  @param[in] DataSize           Size of data. 0 means delete.

-  @param[in] Attributes         Attributes of the variable.

-  @param[in] KeyIndex           Index of associated public key.

-  @param[in] MonotonicCount     Value of associated monotonic count.

-  @param[in, out] Variable      The variable information that is used to keep track of variable usage.

-

-  @param[in] TimeStamp          Value of associated TimeStamp.

-

-  @retval EFI_SUCCESS           The update operation is success.

-  @retval EFI_OUT_OF_RESOURCES  Variable region is full, cannot write other data into this region.

-

-**/

-EFI_STATUS

-UpdateVariable (

-  IN      CHAR16          *VariableName,

-  IN      EFI_GUID        *VendorGuid,

-  IN      VOID            *Data,

-  IN      UINTN           DataSize,

-  IN      UINT32          Attributes OPTIONAL,

-  IN      UINT32          KeyIndex  OPTIONAL,

-  IN      UINT64          MonotonicCount  OPTIONAL,

-  IN OUT  VARIABLE_POINTER_TRACK *Variable,

-  IN      EFI_TIME        *TimeStamp  OPTIONAL

-  );

-

-

-/**

-  Return TRUE if ExitBootServices () has been called.

-

-  @retval TRUE If ExitBootServices () has been called.

-**/

-BOOLEAN

-AtRuntime (

-  VOID

-  );

-

-/**

-  Initializes a basic mutual exclusion lock.

-

-  This function initializes a basic mutual exclusion lock to the released state

-  and returns the lock.  Each lock provides mutual exclusion access at its task

-  priority level.  Since there is no preemption or multiprocessor support in EFI,

-  acquiring the lock only consists of raising to the locks TPL.

-  If Lock is NULL, then ASSERT().

-  If Priority is not a valid TPL value, then ASSERT().

-

-  @param  Lock       A pointer to the lock data structure to initialize.

-  @param  Priority   EFI TPL is associated with the lock.

-

-  @return The lock.

-

-**/

-EFI_LOCK *

-InitializeLock (

-  IN OUT EFI_LOCK  *Lock,

-  IN EFI_TPL        Priority

-  );

-

-

-/**

-  Acquires lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function that will be removed when

-  EfiAcquireLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiAcquireLock() at boot time, and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to acquire.

-

-**/

-VOID

-AcquireLockOnlyAtBootTime (

-  IN EFI_LOCK  *Lock

-  );

-

-

-/**

-  Releases lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function which will be removed when

-  EfiReleaseLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiReleaseLock() at boot time and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to release.

-

-**/

-VOID

-ReleaseLockOnlyAtBootTime (

-  IN EFI_LOCK  *Lock

-  );

-

-/**

-  Retrieve the FVB protocol interface by HANDLE.

-

-  @param[in]  FvBlockHandle     The handle of FVB protocol that provides services for

-                                reading, writing, and erasing the target block.

-  @param[out] FvBlock           The interface of FVB protocol

-

-  @retval EFI_SUCCESS           The interface information for the specified protocol was returned.

-  @retval EFI_UNSUPPORTED       The device does not support the FVB protocol.

-  @retval EFI_INVALID_PARAMETER FvBlockHandle is not a valid EFI_HANDLE or FvBlock is NULL.

-

-**/

-EFI_STATUS

-GetFvbByHandle (

-  IN  EFI_HANDLE                          FvBlockHandle,

-  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvBlock

-  );

-

-/**

-  Function returns an array of handles that support the FVB protocol

-  in a buffer allocated from pool.

-

-  @param[out]  NumberHandles    The number of handles returned in Buffer.

-  @param[out]  Buffer           A pointer to the buffer to return the requested

-                                array of  handles that support FVB protocol.

-

-  @retval EFI_SUCCESS           The array of handles was returned in Buffer, and the number of

-                                handles in Buffer was returned in NumberHandles.

-  @retval EFI_NOT_FOUND         No FVB handle was found.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the matching results.

-  @retval EFI_INVALID_PARAMETER NumberHandles is NULL or Buffer is NULL.

-

-**/

-EFI_STATUS

-GetFvbCountAndBuffer (

-  OUT UINTN                               *NumberHandles,

-  OUT EFI_HANDLE                          **Buffer

-  );

-

-/**

-  Initializes variable store area for non-volatile and volatile variable.

-

-  @retval EFI_SUCCESS           Function successfully executed.

-  @retval EFI_OUT_OF_RESOURCES  Fail to allocate enough memory resource.

-

-**/

-EFI_STATUS

-VariableCommonInitialize (

-  VOID

-  );

-

-/**

-  This function reclaims variable storage if free size is below the threshold.

-

-**/

-VOID

-ReclaimForOS(

-  VOID

-  );

-

-/**

-  Get non-volatile maximum variable size.

-

-  @return Non-volatile maximum variable size.

-

-**/

-UINTN

-GetNonVolatileMaxVariableSize (

-  VOID

-  );

-

-/**

-  Initializes variable write service after FVB was ready.

-

-  @retval EFI_SUCCESS          Function successfully executed.

-  @retval Others               Fail to initialize the variable service.

-

-**/

-EFI_STATUS

-VariableWriteServiceInitialize (

-  VOID

-  );

-

-/**

-  Retrieve the SMM Fault Tolerent Write protocol interface.

-

-  @param[out] FtwProtocol       The interface of SMM Ftw protocol

-

-  @retval EFI_SUCCESS           The SMM SAR protocol instance was found and returned in SarProtocol.

-  @retval EFI_NOT_FOUND         The SMM SAR protocol instance was not found.

-  @retval EFI_INVALID_PARAMETER SarProtocol is NULL.

-

-**/

-EFI_STATUS

-GetFtwProtocol (

-  OUT VOID                                **FtwProtocol

-  );

-

-/**

-  Get the proper fvb handle and/or fvb protocol by the given Flash address.

-

-  @param[in] Address        The Flash address.

-  @param[out] FvbHandle     In output, if it is not NULL, it points to the proper FVB handle.

-  @param[out] FvbProtocol   In output, if it is not NULL, it points to the proper FVB protocol.

-

-**/

-EFI_STATUS

-GetFvbInfoByAddress (

-  IN  EFI_PHYSICAL_ADDRESS                Address,

-  OUT EFI_HANDLE                          *FvbHandle OPTIONAL,

-  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvbProtocol OPTIONAL

-  );

-

-/**

-

-  This code finds variable in storage blocks (Volatile or Non-Volatile).

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode, and datasize and data are external input.

-  This function will do basic validation, before parse the data.

-

-  @param VariableName               Name of Variable to be found.

-  @param VendorGuid                 Variable vendor GUID.

-  @param Attributes                 Attribute value of the variable found.

-  @param DataSize                   Size of Data found. If size is less than the

-                                    data, this value contains the required size.

-  @param Data                       Data pointer.

-

-  @return EFI_INVALID_PARAMETER     Invalid parameter.

-  @return EFI_SUCCESS               Find the specified variable.

-  @return EFI_NOT_FOUND             Not found.

-  @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceGetVariable (

-  IN      CHAR16            *VariableName,

-  IN      EFI_GUID          *VendorGuid,

-  OUT     UINT32            *Attributes OPTIONAL,

-  IN OUT  UINTN             *DataSize,

-  OUT     VOID              *Data

-  );

-

-/**

-  This code Finds the Next available variable.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param[in] VariableName   Pointer to variable name.

-  @param[in] VendorGuid     Variable Vendor Guid.

-  @param[out] VariablePtr   Pointer to variable header address.

-

-  @return EFI_SUCCESS       Find the specified variable.

-  @return EFI_NOT_FOUND     Not found.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceGetNextVariableInternal (

-  IN  CHAR16                *VariableName,

-  IN  EFI_GUID              *VendorGuid,

-  OUT VARIABLE_HEADER       **VariablePtr

-  );

-

-/**

-

-  This code Finds the Next available variable.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param VariableNameSize           Size of the variable name.

-  @param VariableName               Pointer to variable name.

-  @param VendorGuid                 Variable Vendor Guid.

-

-  @return EFI_INVALID_PARAMETER     Invalid parameter.

-  @return EFI_SUCCESS               Find the specified variable.

-  @return EFI_NOT_FOUND             Not found.

-  @return EFI_BUFFER_TO_SMALL       DataSize is too small for the result.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceGetNextVariableName (

-  IN OUT  UINTN             *VariableNameSize,

-  IN OUT  CHAR16            *VariableName,

-  IN OUT  EFI_GUID          *VendorGuid

-  );

-

-/**

-

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode, and datasize and data are external input.

-  This function will do basic validation, before parse the data.

-  This function will parse the authentication carefully to avoid security issues, like

-  buffer overflow, integer overflow.

-  This function will check attribute carefully to avoid authentication bypass.

-

-  @param VariableName                     Name of Variable to be found.

-  @param VendorGuid                       Variable vendor GUID.

-  @param Attributes                       Attribute value of the variable found

-  @param DataSize                         Size of Data found. If size is less than the

-                                          data, this value contains the required size.

-  @param Data                             Data pointer.

-

-  @return EFI_INVALID_PARAMETER           Invalid parameter.

-  @return EFI_SUCCESS                     Set successfully.

-  @return EFI_OUT_OF_RESOURCES            Resource not enough to set variable.

-  @return EFI_NOT_FOUND                   Not found.

-  @return EFI_WRITE_PROTECTED             Variable is read-only.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceSetVariable (

-  IN CHAR16                  *VariableName,

-  IN EFI_GUID                *VendorGuid,

-  IN UINT32                  Attributes,

-  IN UINTN                   DataSize,

-  IN VOID                    *Data

-  );

-

-/**

-

-  This code returns information about the EFI variables.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param Attributes                     Attributes bitmask to specify the type of variables

-                                        on which to return information.

-  @param MaximumVariableStorageSize     Pointer to the maximum size of the storage space available

-                                        for the EFI variables associated with the attributes specified.

-  @param RemainingVariableStorageSize   Pointer to the remaining size of the storage space available

-                                        for EFI variables associated with the attributes specified.

-  @param MaximumVariableSize            Pointer to the maximum size of an individual EFI variables

-                                        associated with the attributes specified.

-

-  @return EFI_SUCCESS                   Query successfully.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceQueryVariableInfoInternal (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize

-  );

-

-/**

-

-  This code returns information about the EFI variables.

-

-  Caution: This function may receive untrusted input.

-  This function may be invoked in SMM mode. This function will do basic validation, before parse the data.

-

-  @param Attributes                     Attributes bitmask to specify the type of variables

-                                        on which to return information.

-  @param MaximumVariableStorageSize     Pointer to the maximum size of the storage space available

-                                        for the EFI variables associated with the attributes specified.

-  @param RemainingVariableStorageSize   Pointer to the remaining size of the storage space available

-                                        for EFI variables associated with the attributes specified.

-  @param MaximumVariableSize            Pointer to the maximum size of an individual EFI variables

-                                        associated with the attributes specified.

-

-  @return EFI_INVALID_PARAMETER         An invalid combination of attribute bits was supplied.

-  @return EFI_SUCCESS                   Query successfully.

-  @return EFI_UNSUPPORTED               The attribute is not supported on this platform.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceQueryVariableInfo (

-  IN  UINT32                 Attributes,

-  OUT UINT64                 *MaximumVariableStorageSize,

-  OUT UINT64                 *RemainingVariableStorageSize,

-  OUT UINT64                 *MaximumVariableSize

-  );

-

-/**

-  Mark a variable that will become read-only after leaving the DXE phase of execution.

-

-  @param[in] This          The VARIABLE_LOCK_PROTOCOL instance.

-  @param[in] VariableName  A pointer to the variable name that will be made read-only subsequently.

-  @param[in] VendorGuid    A pointer to the vendor GUID that will be made read-only subsequently.

-

-  @retval EFI_SUCCESS           The variable specified by the VariableName and the VendorGuid was marked

-                                as pending to be read-only.

-  @retval EFI_INVALID_PARAMETER VariableName or VendorGuid is NULL.

-                                Or VariableName is an empty string.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource to hold the lock request.

-**/

-EFI_STATUS

-EFIAPI

-VariableLockRequestToLock (

-  IN CONST EDKII_VARIABLE_LOCK_PROTOCOL *This,

-  IN       CHAR16                       *VariableName,

-  IN       EFI_GUID                     *VendorGuid

-  );

-

-/**

-  Register SetVariable check handler.

-

-  @param[in] Handler            Pointer to check handler.

-

-  @retval EFI_SUCCESS           The SetVariable check handler was registered successfully.

-  @retval EFI_INVALID_PARAMETER Handler is NULL.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource for the SetVariable check handler register request.

-  @retval EFI_UNSUPPORTED       This interface is not implemented.

-                                For example, it is unsupported in VarCheck protocol if both VarCheck and SmmVarCheck protocols are present.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckRegisterSetVariableCheckHandler (

-  IN VAR_CHECK_SET_VARIABLE_CHECK_HANDLER   Handler

-  );

-

-/**

-  Variable property set.

-

-  @param[in] Name               Pointer to the variable name.

-  @param[in] Guid               Pointer to the vendor GUID.

-  @param[in] VariableProperty   Pointer to the input variable property.

-

-  @retval EFI_SUCCESS           The property of variable specified by the Name and Guid was set successfully.

-  @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string,

-                                or the fields of VariableProperty are not valid.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource for the variable property set request.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckVariablePropertySet (

-  IN CHAR16                         *Name,

-  IN EFI_GUID                       *Guid,

-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariableProperty

-  );

-

-/**

-  Variable property get.

-

-  @param[in]  Name              Pointer to the variable name.

-  @param[in]  Guid              Pointer to the vendor GUID.

-  @param[out] VariableProperty  Pointer to the output variable property.

-

-  @retval EFI_SUCCESS           The property of variable specified by the Name and Guid was got successfully.

-  @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string.

-  @retval EFI_NOT_FOUND         The property of variable specified by the Name and Guid was not found.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckVariablePropertyGet (

-  IN CHAR16                         *Name,

-  IN EFI_GUID                       *Guid,

-  OUT VAR_CHECK_VARIABLE_PROPERTY   *VariableProperty

-  );

-

-/**

-  Initialize variable quota.

-

-**/

-VOID

-InitializeVariableQuota (

-  VOID

-  );

-

-extern VARIABLE_MODULE_GLOBAL  *mVariableModuleGlobal;

-

-extern AUTH_VAR_LIB_CONTEXT_OUT mAuthContextOut;

-

-/**

-  Finds variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-

-  @param[in]  VariableName          Name of the variable to be found.

-  @param[in]  VendorGuid            Variable vendor GUID to be found.

-  @param[out] AuthVariableInfo      Pointer to AUTH_VARIABLE_INFO structure for

-                                    output of the variable found.

-

-  @retval EFI_INVALID_PARAMETER     If VariableName is not an empty string,

-                                    while VendorGuid is NULL.

-  @retval EFI_SUCCESS               Variable successfully found.

-  @retval EFI_NOT_FOUND             Variable not found

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibFindVariable (

-  IN  CHAR16                *VariableName,

-  IN  EFI_GUID              *VendorGuid,

-  OUT AUTH_VARIABLE_INFO    *AuthVariableInfo

-  );

-

-/**

-  Finds next variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds next variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-

-  @param[in]  VariableName          Name of the variable to be found.

-  @param[in]  VendorGuid            Variable vendor GUID to be found.

-  @param[out] AuthVariableInfo      Pointer to AUTH_VARIABLE_INFO structure for

-                                    output of the next variable.

-

-  @retval EFI_INVALID_PARAMETER     If VariableName is not an empty string,

-                                    while VendorGuid is NULL.

-  @retval EFI_SUCCESS               Variable successfully found.

-  @retval EFI_NOT_FOUND             Variable not found

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibFindNextVariable (

-  IN  CHAR16                *VariableName,

-  IN  EFI_GUID              *VendorGuid,

-  OUT AUTH_VARIABLE_INFO    *AuthVariableInfo

-  );

-

-/**

-  Update the variable region with Variable information.

-

-  @param[in] AuthVariableInfo       Pointer AUTH_VARIABLE_INFO structure for

-                                    input of the variable.

-

-  @retval EFI_SUCCESS               The update operation is success.

-  @retval EFI_INVALID_PARAMETER     Invalid parameter.

-  @retval EFI_WRITE_PROTECTED       Variable is write-protected.

-  @retval EFI_OUT_OF_RESOURCES      There is not enough resource.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibUpdateVariable (

-  IN AUTH_VARIABLE_INFO     *AuthVariableInfo

-  );

-

-/**

-  Get scratch buffer.

-

-  @param[in, out] ScratchBufferSize Scratch buffer size. If input size is greater than

-                                    the maximum supported buffer size, this value contains

-                                    the maximum supported buffer size as output.

-  @param[out]     ScratchBuffer     Pointer to scratch buffer address.

-

-  @retval EFI_SUCCESS       Get scratch buffer successfully.

-  @retval EFI_UNSUPPORTED   If input size is greater than the maximum supported buffer size.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibGetScratchBuffer (

-  IN OUT UINTN      *ScratchBufferSize,

-  OUT    VOID       **ScratchBuffer

-  );

-

-/**

-  This function is to check if the remaining variable space is enough to set

-  all Variables from argument list successfully. The purpose of the check

-  is to keep the consistency of the Variables to be in variable storage.

-

-  Note: Variables are assumed to be in same storage.

-  The set sequence of Variables will be same with the sequence of VariableEntry from argument list,

-  so follow the argument sequence to check the Variables.

-

-  @param[in] Attributes         Variable attributes for Variable entries.

-  @param ...                    The variable argument list with type VARIABLE_ENTRY_CONSISTENCY *.

-                                A NULL terminates the list. The VariableSize of

-                                VARIABLE_ENTRY_CONSISTENCY is the variable data size as input.

-                                It will be changed to variable total size as output.

-

-  @retval TRUE                  Have enough variable space to set the Variables successfully.

-  @retval FALSE                 No enough variable space to set the Variables successfully.

-

-**/

-BOOLEAN

-EFIAPI

-VariableExLibCheckRemainingSpaceForConsistency (

-  IN UINT32                     Attributes,

-  ...

-  );

-

-/**

-  Return TRUE if at OS runtime.

-

-  @retval TRUE If at OS runtime.

-  @retval FALSE If at boot time.

-

-**/

-BOOLEAN

-EFIAPI

-VariableExLibAtRuntime (

-  VOID

-  );

-

-#endif

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c
deleted file mode 100644
index fe1b2b588c..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c
+++ /dev/null
@@ -1,558 +0,0 @@
-/** @file

-  Implement all four UEFI Runtime Variable services for the nonvolatile

-  and volatile storage space and install variable architecture protocol.

-

-Copyright (C) 2013, Red Hat, Inc.

-Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>

-(C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-extern VARIABLE_STORE_HEADER        *mNvVariableCache;

-extern EFI_FIRMWARE_VOLUME_HEADER   *mNvFvHeaderCache;

-extern VARIABLE_INFO_ENTRY          *gVariableInfo;

-EFI_HANDLE                          mHandle                    = NULL;

-EFI_EVENT                           mVirtualAddressChangeEvent = NULL;

-EFI_EVENT                           mFtwRegistration           = NULL;

-extern BOOLEAN                      mEndOfDxe;

-VOID                                ***mVarCheckAddressPointer = NULL;

-UINTN                               mVarCheckAddressPointerCount = 0;

-EDKII_VARIABLE_LOCK_PROTOCOL        mVariableLock              = { VariableLockRequestToLock };

-EDKII_VAR_CHECK_PROTOCOL            mVarCheck                  = { VarCheckRegisterSetVariableCheckHandler,

-                                                                    VarCheckVariablePropertySet,

-                                                                    VarCheckVariablePropertyGet };

-

-/**

-  Some Secure Boot Policy Variable may update following other variable changes(SecureBoot follows PK change, etc).

-  Record their initial State when variable write service is ready.

-

-**/

-VOID

-EFIAPI

-RecordSecureBootPolicyVarData(

-  VOID

-  );

-

-/**

-  Return TRUE if ExitBootServices () has been called.

-

-  @retval TRUE If ExitBootServices () has been called.

-**/

-BOOLEAN

-AtRuntime (

-  VOID

-  )

-{

-  return EfiAtRuntime ();

-}

-

-

-/**

-  Initializes a basic mutual exclusion lock.

-

-  This function initializes a basic mutual exclusion lock to the released state

-  and returns the lock.  Each lock provides mutual exclusion access at its task

-  priority level.  Since there is no preemption or multiprocessor support in EFI,

-  acquiring the lock only consists of raising to the locks TPL.

-  If Lock is NULL, then ASSERT().

-  If Priority is not a valid TPL value, then ASSERT().

-

-  @param  Lock       A pointer to the lock data structure to initialize.

-  @param  Priority   EFI TPL is associated with the lock.

-

-  @return The lock.

-

-**/

-EFI_LOCK *

-InitializeLock (

-  IN OUT EFI_LOCK                         *Lock,

-  IN     EFI_TPL                          Priority

-  )

-{

-  return EfiInitializeLock (Lock, Priority);

-}

-

-

-/**

-  Acquires lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function that will be removed when

-  EfiAcquireLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiAcquireLock() at boot time, and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to acquire.

-

-**/

-VOID

-AcquireLockOnlyAtBootTime (

-  IN EFI_LOCK                             *Lock

-  )

-{

-  if (!AtRuntime ()) {

-    EfiAcquireLock (Lock);

-  }

-}

-

-

-/**

-  Releases lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function which will be removed when

-  EfiReleaseLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiReleaseLock() at boot time and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to release.

-

-**/

-VOID

-ReleaseLockOnlyAtBootTime (

-  IN EFI_LOCK                             *Lock

-  )

-{

-  if (!AtRuntime ()) {

-    EfiReleaseLock (Lock);

-  }

-}

-

-/**

-  Retrieve the Fault Tolerent Write protocol interface.

-

-  @param[out] FtwProtocol       The interface of Ftw protocol

-

-  @retval EFI_SUCCESS           The FTW protocol instance was found and returned in FtwProtocol.

-  @retval EFI_NOT_FOUND         The FTW protocol instance was not found.

-  @retval EFI_INVALID_PARAMETER SarProtocol is NULL.

-

-**/

-EFI_STATUS

-GetFtwProtocol (

-  OUT VOID                                **FtwProtocol

-  )

-{

-  EFI_STATUS                              Status;

-

-  //

-  // Locate Fault Tolerent Write protocol

-  //

-  Status = gBS->LocateProtocol (

-                  &gEfiFaultTolerantWriteProtocolGuid,

-                  NULL,

-                  FtwProtocol

-                  );

-  return Status;

-}

-

-/**

-  Retrieve the FVB protocol interface by HANDLE.

-

-  @param[in]  FvBlockHandle     The handle of FVB protocol that provides services for

-                                reading, writing, and erasing the target block.

-  @param[out] FvBlock           The interface of FVB protocol

-

-  @retval EFI_SUCCESS           The interface information for the specified protocol was returned.

-  @retval EFI_UNSUPPORTED       The device does not support the FVB protocol.

-  @retval EFI_INVALID_PARAMETER FvBlockHandle is not a valid EFI_HANDLE or FvBlock is NULL.

-

-**/

-EFI_STATUS

-GetFvbByHandle (

-  IN  EFI_HANDLE                          FvBlockHandle,

-  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvBlock

-  )

-{

-  //

-  // To get the FVB protocol interface on the handle

-  //

-  return gBS->HandleProtocol (

-                FvBlockHandle,

-                &gEfiFirmwareVolumeBlockProtocolGuid,

-                (VOID **) FvBlock

-                );

-}

-

-

-/**

-  Function returns an array of handles that support the FVB protocol

-  in a buffer allocated from pool.

-

-  @param[out]  NumberHandles    The number of handles returned in Buffer.

-  @param[out]  Buffer           A pointer to the buffer to return the requested

-                                array of  handles that support FVB protocol.

-

-  @retval EFI_SUCCESS           The array of handles was returned in Buffer, and the number of

-                                handles in Buffer was returned in NumberHandles.

-  @retval EFI_NOT_FOUND         No FVB handle was found.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the matching results.

-  @retval EFI_INVALID_PARAMETER NumberHandles is NULL or Buffer is NULL.

-

-**/

-EFI_STATUS

-GetFvbCountAndBuffer (

-  OUT UINTN                               *NumberHandles,

-  OUT EFI_HANDLE                          **Buffer

-  )

-{

-  EFI_STATUS                              Status;

-

-  //

-  // Locate all handles of Fvb protocol

-  //

-  Status = gBS->LocateHandleBuffer (

-                  ByProtocol,

-                  &gEfiFirmwareVolumeBlockProtocolGuid,

-                  NULL,

-                  NumberHandles,

-                  Buffer

-                  );

-  return Status;

-}

-

-

-/**

-  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.

-

-  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-  It convers pointer to new virtual address.

-

-  @param  Event        Event whose notification function is being invoked.

-  @param  Context      Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-VariableClassAddressChangeEvent (

-  IN EFI_EVENT                            Event,

-  IN VOID                                 *Context

-  )

-{

-  UINTN          Index;

-

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetBlockSize);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetPhysicalAddress);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetAttributes);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->SetAttributes);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Read);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Write);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->EraseBlocks);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLangCodes);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->LangCodes);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLang);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.HobVariableBase);

-  EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);

-  EfiConvertPointer (0x0, (VOID **) &mNvVariableCache);

-  EfiConvertPointer (0x0, (VOID **) &mNvFvHeaderCache);

-

-  if (mAuthContextOut.AddressPointer != NULL) {

-    for (Index = 0; Index < mAuthContextOut.AddressPointerCount; Index++) {

-      EfiConvertPointer (0x0, (VOID **) mAuthContextOut.AddressPointer[Index]);

-    }

-  }

-

-  if (mVarCheckAddressPointer != NULL) {

-    for (Index = 0; Index < mVarCheckAddressPointerCount; Index++) {

-      EfiConvertPointer (0x0, (VOID **) mVarCheckAddressPointer[Index]);

-    }

-  }

-}

-

-

-/**

-  Notification function of EVT_GROUP_READY_TO_BOOT event group.

-

-  This is a notification function registered on EVT_GROUP_READY_TO_BOOT event group.

-  When the Boot Manager is about to load and execute a boot option, it reclaims variable

-  storage if free size is below the threshold.

-

-  @param  Event        Event whose notification function is being invoked.

-  @param  Context      Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-OnReadyToBoot (

-  EFI_EVENT                               Event,

-  VOID                                    *Context

-  )

-{

-  if (!mEndOfDxe) {

-    //

-    // Set the End Of DXE bit in case the EFI_END_OF_DXE_EVENT_GROUP_GUID event is not signaled.

-    //

-    mEndOfDxe = TRUE;

-    mVarCheckAddressPointer = VarCheckLibInitializeAtEndOfDxe (&mVarCheckAddressPointerCount);

-    //

-    // The initialization for variable quota.

-    //

-    InitializeVariableQuota ();

-  }

-  ReclaimForOS ();

-  if (FeaturePcdGet (PcdVariableCollectStatistics)) {

-    if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-      gBS->InstallConfigurationTable (&gEfiAuthenticatedVariableGuid, gVariableInfo);

-    } else {

-      gBS->InstallConfigurationTable (&gEfiVariableGuid, gVariableInfo);

-    }

-  }

-

-  gBS->CloseEvent (Event);

-}

-

-/**

-  Notification function of EFI_END_OF_DXE_EVENT_GROUP_GUID event group.

-

-  This is a notification function registered on EFI_END_OF_DXE_EVENT_GROUP_GUID event group.

-

-  @param  Event        Event whose notification function is being invoked.

-  @param  Context      Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-OnEndOfDxe (

-  EFI_EVENT                               Event,

-  VOID                                    *Context

-  )

-{

-  DEBUG ((EFI_D_INFO, "[Variable]END_OF_DXE is signaled\n"));

-  mEndOfDxe = TRUE;

-  mVarCheckAddressPointer = VarCheckLibInitializeAtEndOfDxe (&mVarCheckAddressPointerCount);

-  //

-  // The initialization for variable quota.

-  //

-  InitializeVariableQuota ();

-  if (PcdGetBool (PcdReclaimVariableSpaceAtEndOfDxe)) {

-    ReclaimForOS ();

-  }

-

-  gBS->CloseEvent (Event);

-}

-

-/**

-  Fault Tolerant Write protocol notification event handler.

-

-  Non-Volatile variable write may needs FTW protocol to reclaim when

-  writting variable.

-

-  @param[in] Event    Event whose notification function is being invoked.

-  @param[in] Context  Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-FtwNotificationEvent (

-  IN  EFI_EVENT                           Event,

-  IN  VOID                                *Context

-  )

-{

-  EFI_STATUS                              Status;

-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL      *FvbProtocol;

-  EFI_FAULT_TOLERANT_WRITE_PROTOCOL       *FtwProtocol;

-  EFI_PHYSICAL_ADDRESS                    NvStorageVariableBase;

-  EFI_GCD_MEMORY_SPACE_DESCRIPTOR         GcdDescriptor;

-  EFI_PHYSICAL_ADDRESS                    BaseAddress;

-  UINT64                                  Length;

-  EFI_PHYSICAL_ADDRESS                    VariableStoreBase;

-  UINT64                                  VariableStoreLength;

-  UINTN                                   FtwMaxBlockSize;

-

-  //

-  // Ensure FTW protocol is installed.

-  //

-  Status = GetFtwProtocol ((VOID**) &FtwProtocol);

-  if (EFI_ERROR (Status)) {

-    return ;

-  }

-

-  Status = FtwProtocol->GetMaxBlockSize (FtwProtocol, &FtwMaxBlockSize);

-  if (!EFI_ERROR (Status)) {

-    ASSERT (PcdGet32 (PcdFlashNvStorageVariableSize) <= FtwMaxBlockSize);

-  }

-

-  //

-  // Find the proper FVB protocol for variable.

-  //

-  NvStorageVariableBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);

-  if (NvStorageVariableBase == 0) {

-    NvStorageVariableBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);

-  }

-  Status = GetFvbInfoByAddress (NvStorageVariableBase, NULL, &FvbProtocol);

-  if (EFI_ERROR (Status)) {

-    return ;

-  }

-  mVariableModuleGlobal->FvbInstance = FvbProtocol;

-

-  //

-  // Mark the variable storage region of the FLASH as RUNTIME.

-  //

-  VariableStoreBase   = NvStorageVariableBase + (((EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(NvStorageVariableBase))->HeaderLength);

-  VariableStoreLength = ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase)->Size;

-  BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);

-  Length      = VariableStoreLength + (VariableStoreBase - BaseAddress);

-  Length      = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);

-

-  Status      = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);

-  if (EFI_ERROR (Status)) {

-    DEBUG ((DEBUG_WARN, "Variable driver failed to get flash memory attribute.\n"));

-  } else {

-    Status = gDS->SetMemorySpaceAttributes (

-                    BaseAddress,

-                    Length,

-                    GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME

-                    );

-    if (EFI_ERROR (Status)) {

-      DEBUG ((DEBUG_WARN, "Variable driver failed to add EFI_MEMORY_RUNTIME attribute to Flash.\n"));

-    }

-  }

-

-  Status = VariableWriteServiceInitialize ();

-  if (EFI_ERROR (Status)) {

-    DEBUG ((DEBUG_ERROR, "Variable write service initialization failed. Status = %r\n", Status));

-  }

-

-  //

-  // Some Secure Boot Policy Var (SecureBoot, etc) updates following other

-  // Secure Boot Policy Variable change. Record their initial value.

-  //

-  RecordSecureBootPolicyVarData();

-

-  //

-  // Install the Variable Write Architectural protocol.

-  //

-  Status = gBS->InstallProtocolInterface (

-                  &mHandle,

-                  &gEfiVariableWriteArchProtocolGuid,

-                  EFI_NATIVE_INTERFACE,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Close the notify event to avoid install gEfiVariableWriteArchProtocolGuid again.

-  //

-  gBS->CloseEvent (Event);

-

-}

-

-

-/**

-  Variable Driver main entry point. The Variable driver places the 4 EFI

-  runtime services in the EFI System Table and installs arch protocols

-  for variable read and write services being available. It also registers

-  a notification function for an EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-

-  @param[in] ImageHandle    The firmware allocated handle for the EFI image.

-  @param[in] SystemTable    A pointer to the EFI System Table.

-

-  @retval EFI_SUCCESS       Variable service successfully initialized.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceInitialize (

-  IN EFI_HANDLE                         ImageHandle,

-  IN EFI_SYSTEM_TABLE                   *SystemTable

-  )

-{

-  EFI_STATUS                            Status;

-  EFI_EVENT                             ReadyToBootEvent;

-  EFI_EVENT                             EndOfDxeEvent;

-

-  Status = VariableCommonInitialize ();

-  ASSERT_EFI_ERROR (Status);

-

-  Status = gBS->InstallMultipleProtocolInterfaces (

-                  &mHandle,

-                  &gEdkiiVariableLockProtocolGuid,

-                  &mVariableLock,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  Status = gBS->InstallMultipleProtocolInterfaces (

-                  &mHandle,

-                  &gEdkiiVarCheckProtocolGuid,

-                  &mVarCheck,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  SystemTable->RuntimeServices->GetVariable         = VariableServiceGetVariable;

-  SystemTable->RuntimeServices->GetNextVariableName = VariableServiceGetNextVariableName;

-  SystemTable->RuntimeServices->SetVariable         = VariableServiceSetVariable;

-  SystemTable->RuntimeServices->QueryVariableInfo   = VariableServiceQueryVariableInfo;

-

-  //

-  // Now install the Variable Runtime Architectural protocol on a new handle.

-  //

-  Status = gBS->InstallProtocolInterface (

-                  &mHandle,

-                  &gEfiVariableArchProtocolGuid,

-                  EFI_NATIVE_INTERFACE,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Register FtwNotificationEvent () notify function.

-  //

-  EfiCreateProtocolNotifyEvent (

-    &gEfiFaultTolerantWriteProtocolGuid,

-    TPL_CALLBACK,

-    FtwNotificationEvent,

-    (VOID *)SystemTable,

-    &mFtwRegistration

-    );

-

-  Status = gBS->CreateEventEx (

-                  EVT_NOTIFY_SIGNAL,

-                  TPL_NOTIFY,

-                  VariableClassAddressChangeEvent,

-                  NULL,

-                  &gEfiEventVirtualAddressChangeGuid,

-                  &mVirtualAddressChangeEvent

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Register the event handling function to reclaim variable for OS usage.

-  //

-  Status = EfiCreateEventReadyToBootEx (

-             TPL_NOTIFY,

-             OnReadyToBoot,

-             NULL,

-             &ReadyToBootEvent

-             );

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Register the event handling function to set the End Of DXE flag.

-  //

-  Status = gBS->CreateEventEx (

-                  EVT_NOTIFY_SIGNAL,

-                  TPL_NOTIFY,

-                  OnEndOfDxe,

-                  NULL,

-                  &gEfiEndOfDxeEventGroupGuid,

-                  &EndOfDxeEvent

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  return EFI_SUCCESS;

-}

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableExLib.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableExLib.c
deleted file mode 100644
index 615b4cec28..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableExLib.c
+++ /dev/null
@@ -1,256 +0,0 @@
-/** @file

-  Provides variable driver extended services.

-

-Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include "Variable.h"

-

-/**

-  Finds variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-

-  @param[in]  VariableName          Name of the variable to be found.

-  @param[in]  VendorGuid            Variable vendor GUID to be found.

-  @param[out] AuthVariableInfo      Pointer to AUTH_VARIABLE_INFO structure for

-                                    output of the variable found.

-

-  @retval EFI_INVALID_PARAMETER     If VariableName is not an empty string,

-                                    while VendorGuid is NULL.

-  @retval EFI_SUCCESS               Variable successfully found.

-  @retval EFI_NOT_FOUND             Variable not found

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibFindVariable (

-  IN  CHAR16                *VariableName,

-  IN  EFI_GUID              *VendorGuid,

-  OUT AUTH_VARIABLE_INFO    *AuthVariableInfo

-  )

-{

-  EFI_STATUS                    Status;

-  VARIABLE_POINTER_TRACK        Variable;

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

-

-  Status = FindVariable (

-             VariableName,

-             VendorGuid,

-             &Variable,

-             &mVariableModuleGlobal->VariableGlobal,

-             FALSE

-             );

-  if (EFI_ERROR (Status)) {

-    AuthVariableInfo->Data = NULL;

-    AuthVariableInfo->DataSize = 0;

-    AuthVariableInfo->Attributes = 0;

-    AuthVariableInfo->PubKeyIndex = 0;

-    AuthVariableInfo->MonotonicCount = 0;

-    AuthVariableInfo->TimeStamp = NULL;

-    return Status;

-  }

-

-  AuthVariableInfo->DataSize        = DataSizeOfVariable (Variable.CurrPtr);

-  AuthVariableInfo->Data            = GetVariableDataPtr (Variable.CurrPtr);

-  AuthVariableInfo->Attributes      = Variable.CurrPtr->Attributes;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable.CurrPtr;

-    AuthVariableInfo->PubKeyIndex     = AuthVariable->PubKeyIndex;

-    AuthVariableInfo->MonotonicCount  = ReadUnaligned64 (&(AuthVariable->MonotonicCount));

-    AuthVariableInfo->TimeStamp       = &AuthVariable->TimeStamp;

-  }

-

-  return EFI_SUCCESS;

-}

-

-/**

-  Finds next variable in storage blocks of volatile and non-volatile storage areas.

-

-  This code finds next variable in storage blocks of volatile and non-volatile storage areas.

-  If VariableName is an empty string, then we just return the first

-  qualified variable without comparing VariableName and VendorGuid.

-

-  @param[in]  VariableName          Name of the variable to be found.

-  @param[in]  VendorGuid            Variable vendor GUID to be found.

-  @param[out] AuthVariableInfo      Pointer to AUTH_VARIABLE_INFO structure for

-                                    output of the next variable.

-

-  @retval EFI_INVALID_PARAMETER     If VariableName is not an empty string,

-                                    while VendorGuid is NULL.

-  @retval EFI_SUCCESS               Variable successfully found.

-  @retval EFI_NOT_FOUND             Variable not found

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibFindNextVariable (

-  IN  CHAR16                *VariableName,

-  IN  EFI_GUID              *VendorGuid,

-  OUT AUTH_VARIABLE_INFO    *AuthVariableInfo

-  )

-{

-  EFI_STATUS                    Status;

-  VARIABLE_HEADER               *VariablePtr;

-  AUTHENTICATED_VARIABLE_HEADER *AuthVariablePtr;

-

-  Status = VariableServiceGetNextVariableInternal (

-             VariableName,

-             VendorGuid,

-             &VariablePtr

-             );

-  if (EFI_ERROR (Status)) {

-    AuthVariableInfo->VariableName = NULL;

-    AuthVariableInfo->VendorGuid = NULL;

-    AuthVariableInfo->Data = NULL;

-    AuthVariableInfo->DataSize = 0;

-    AuthVariableInfo->Attributes = 0;

-    AuthVariableInfo->PubKeyIndex = 0;

-    AuthVariableInfo->MonotonicCount = 0;

-    AuthVariableInfo->TimeStamp = NULL;

-    return Status;

-  }

-

-  AuthVariableInfo->VariableName    = GetVariableNamePtr (VariablePtr);

-  AuthVariableInfo->VendorGuid      = GetVendorGuidPtr (VariablePtr);

-  AuthVariableInfo->DataSize        = DataSizeOfVariable (VariablePtr);

-  AuthVariableInfo->Data            = GetVariableDataPtr (VariablePtr);

-  AuthVariableInfo->Attributes      = VariablePtr->Attributes;

-  if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {

-    AuthVariablePtr = (AUTHENTICATED_VARIABLE_HEADER *) VariablePtr;

-    AuthVariableInfo->PubKeyIndex     = AuthVariablePtr->PubKeyIndex;

-    AuthVariableInfo->MonotonicCount  = ReadUnaligned64 (&(AuthVariablePtr->MonotonicCount));

-    AuthVariableInfo->TimeStamp       = &AuthVariablePtr->TimeStamp;

-  }

-

-  return EFI_SUCCESS;

-}

-

-/**

-  Update the variable region with Variable information.

-

-  @param[in] AuthVariableInfo       Pointer AUTH_VARIABLE_INFO structure for

-                                    input of the variable.

-

-  @retval EFI_SUCCESS               The update operation is success.

-  @retval EFI_INVALID_PARAMETER     Invalid parameter.

-  @retval EFI_WRITE_PROTECTED       Variable is write-protected.

-  @retval EFI_OUT_OF_RESOURCES      There is not enough resource.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibUpdateVariable (

-  IN AUTH_VARIABLE_INFO     *AuthVariableInfo

-  )

-{

-  VARIABLE_POINTER_TRACK    Variable;

-

-  FindVariable (AuthVariableInfo->VariableName, AuthVariableInfo->VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-  return UpdateVariable (

-           AuthVariableInfo->VariableName,

-           AuthVariableInfo->VendorGuid,

-           AuthVariableInfo->Data,

-           AuthVariableInfo->DataSize,

-           AuthVariableInfo->Attributes,

-           AuthVariableInfo->PubKeyIndex,

-           AuthVariableInfo->MonotonicCount,

-           &Variable,

-           AuthVariableInfo->TimeStamp

-           );

-}

-

-/**

-  Get scratch buffer.

-

-  @param[in, out] ScratchBufferSize Scratch buffer size. If input size is greater than

-                                    the maximum supported buffer size, this value contains

-                                    the maximum supported buffer size as output.

-  @param[out]     ScratchBuffer     Pointer to scratch buffer address.

-

-  @retval EFI_SUCCESS       Get scratch buffer successfully.

-  @retval EFI_UNSUPPORTED   If input size is greater than the maximum supported buffer size.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableExLibGetScratchBuffer (

-  IN OUT UINTN      *ScratchBufferSize,

-  OUT    VOID       **ScratchBuffer

-  )

-{

-  UINTN MaxBufferSize;

-

-  MaxBufferSize = mVariableModuleGlobal->ScratchBufferSize;

-  if (*ScratchBufferSize > MaxBufferSize) {

-    *ScratchBufferSize = MaxBufferSize;

-    return EFI_UNSUPPORTED;

-  }

-

-  *ScratchBuffer = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));

-  return EFI_SUCCESS;

-}

-

-/**

-  This function is to check if the remaining variable space is enough to set

-  all Variables from argument list successfully. The purpose of the check

-  is to keep the consistency of the Variables to be in variable storage.

-

-  Note: Variables are assumed to be in same storage.

-  The set sequence of Variables will be same with the sequence of VariableEntry from argument list,

-  so follow the argument sequence to check the Variables.

-

-  @param[in] Attributes         Variable attributes for Variable entries.

-  @param ...                    The variable argument list with type VARIABLE_ENTRY_CONSISTENCY *.

-                                A NULL terminates the list. The VariableSize of

-                                VARIABLE_ENTRY_CONSISTENCY is the variable data size as input.

-                                It will be changed to variable total size as output.

-

-  @retval TRUE                  Have enough variable space to set the Variables successfully.

-  @retval FALSE                 No enough variable space to set the Variables successfully.

-

-**/

-BOOLEAN

-EFIAPI

-VariableExLibCheckRemainingSpaceForConsistency (

-  IN UINT32                     Attributes,

-  ...

-  )

-{

-  VA_LIST Marker;

-  BOOLEAN Return;

-

-  VA_START (Marker, Attributes);

-

-  Return = CheckRemainingSpaceForConsistencyInternal (Attributes, Marker);

-

-  VA_END (Marker);

-

-  return Return;

-}

-

-/**

-  Return TRUE if at OS runtime.

-

-  @retval TRUE If at OS runtime.

-  @retval FALSE If at boot time.

-

-**/

-BOOLEAN

-EFIAPI

-VariableExLibAtRuntime (

-  VOID

-  )

-{

-  return AtRuntime ();

-}

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
deleted file mode 100644
index bc24a251c8..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
+++ /dev/null
@@ -1,140 +0,0 @@
-## @file

-#  Provides variable service.

-#

-#  This module installs variable arch protocol and variable write arch protocol to provide

-#  variable services: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo.

-#

-#  Caution: This module requires additional review when modified.

-#  This driver will have external input - variable data.

-#  This external input must be validated carefully to avoid security issues such as

-#  buffer overflow or integer overflow.

-#

-# Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>

-# This program and the accompanying materials

-# are licensed and made available under the terms and conditions of the BSD License

-# which accompanies this distribution. The full text of the license may be found at

-# http://opensource.org/licenses/bsd-license.php

-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-#

-##

-

-[Defines]

-  INF_VERSION                    = 0x00010005

-  BASE_NAME                      = VariableRuntimeDxe

-  MODULE_UNI_FILE                = VariableRuntimeDxe.uni

-  FILE_GUID                      = CBD2E4D5-7068-4FF5-B462-9822B4AD8D60

-  MODULE_TYPE                    = DXE_RUNTIME_DRIVER

-  VERSION_STRING                 = 1.0

-  ENTRY_POINT                    = VariableServiceInitialize

-

-#

-# The following information is for reference only and not required by the build tools.

-#

-#  VALID_ARCHITECTURES           = IA32 X64 EBC

-#

-#  VIRTUAL_ADDRESS_MAP_CALLBACK  =  VariableClassAddressChangeEvent

-#

-

-[Sources]

-  Reclaim.c

-  Variable.c

-  VariableDxe.c

-  Variable.h

-  Measurement.c

-  TcgMorLockDxe.c

-  VarCheck.c

-  VariableExLib.c

-

-[Packages]

-  MdePkg/MdePkg.dec

-  MdeModulePkg/MdeModulePkg.dec

-

-[LibraryClasses]

-  MemoryAllocationLib

-  BaseLib

-  SynchronizationLib

-  UefiLib

-  UefiBootServicesTableLib

-  BaseMemoryLib

-  DebugLib

-  UefiRuntimeLib

-  DxeServicesTableLib

-  UefiDriverEntryPoint

-  PcdLib

-  HobLib

-  TpmMeasurementLib

-  AuthVariableLib

-  VarCheckLib

-

-[Protocols]

-  gEfiFirmwareVolumeBlockProtocolGuid           ## CONSUMES

-  ## CONSUMES

-  ## NOTIFY

-  gEfiFaultTolerantWriteProtocolGuid

-  gEfiVariableWriteArchProtocolGuid             ## PRODUCES

-  gEfiVariableArchProtocolGuid                  ## PRODUCES

-  gEdkiiVariableLockProtocolGuid                ## PRODUCES

-  gEdkiiVarCheckProtocolGuid                    ## PRODUCES

-

-[Guids]

-  ## SOMETIMES_CONSUMES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_PRODUCES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  ## SOMETIMES_PRODUCES   ## SystemTable

-  gEfiAuthenticatedVariableGuid

-

-  ## SOMETIMES_CONSUMES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_PRODUCES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  ## SOMETIMES_PRODUCES   ## SystemTable

-  gEfiVariableGuid

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"PlatformLang"

-  ## SOMETIMES_PRODUCES   ## Variable:L"PlatformLang"

-  ## SOMETIMES_CONSUMES   ## Variable:L"Lang"

-  ## SOMETIMES_PRODUCES   ## Variable:L"Lang"

-  ## SOMETIMES_CONSUMES   ## Variable:L"PK"

-  ## SOMETIMES_CONSUMES   ## Variable:L"KEK"

-  ## SOMETIMES_CONSUMES   ## Variable:L"SecureBoot"

-  gEfiGlobalVariableGuid

-

-  gEfiMemoryOverwriteControlDataGuid            ## SOMETIMES_CONSUMES   ## Variable:L"MemoryOverwriteRequestControl"

-  gEfiMemoryOverwriteRequestControlLockGuid     ## SOMETIMES_PRODUCES   ## Variable:L"MemoryOverwriteRequestControlLock"

-

-  gEfiEventVirtualAddressChangeGuid             ## CONSUMES             ## Event

-  gEfiSystemNvDataFvGuid                        ## CONSUMES             ## GUID

-  gEfiEndOfDxeEventGroupGuid                    ## CONSUMES             ## Event

-  gEdkiiFaultTolerantWriteGuid                  ## SOMETIMES_CONSUMES   ## HOB

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"VarErrorFlag"

-  ## SOMETIMES_PRODUCES   ## Variable:L"VarErrorFlag"

-  gEdkiiVarErrorFlagGuid

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"db"

-  ## SOMETIMES_CONSUMES   ## Variable:L"dbx"

-  ## SOMETIMES_CONSUMES   ## Variable:L"dbt"

-  gEfiImageSecurityDatabaseGuid

-

-[Pcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize      ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase      ## SOMETIMES_CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64    ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxVariableSize                 ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxAuthVariableSize             ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxHardwareErrorVariableSize    ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdVariableStoreSize               ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdHwErrStorageSize                ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxUserNvVariableSpaceSize           ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdBoottimeReservedNvVariableSpaceSize  ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdReclaimVariableSpaceAtEndOfDxe  ## CONSUMES

-

-[FeaturePcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdVariableCollectStatistics  ## CONSUMES # statistic the information of variable.

-  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultLangDeprecate ## CONSUMES # Auto update PlatformLang/Lang

-

-[Depex]

-  TRUE

-

-[UserExtensions.TianoCore."ExtraFiles"]

-  VariableRuntimeDxeExtra.uni

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.uni b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.uni
deleted file mode 100644
index d01df96eb7..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.uni
+++ /dev/null
@@ -1,27 +0,0 @@
-// /** @file

-// Provides variable service.

-//

-// This module installs variable arch protocol and variable write arch protocol to provide

-// variable services: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo.

-//

-// Caution: This module requires additional review when modified.

-// This driver will have external input - variable data.

-// This external input must be validated carefully to avoid security issues such as

-// buffer overflow or integer overflow.

-//

-// Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-

-#string STR_MODULE_ABSTRACT             #language en-US "Provides variable service"

-

-#string STR_MODULE_DESCRIPTION          #language en-US "This module installs variable arch protocol and variable write arch protocol to provide variable services: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo. Caution: This module requires additional review when modified. This driver will have external input - variable data. This external input must be validated carefully to avoid security issues such as buffer overflow or integer overflow."

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxeExtra.uni b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxeExtra.uni
deleted file mode 100644
index 2d8eaf2669..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxeExtra.uni
+++ /dev/null
@@ -1,19 +0,0 @@
-// /** @file

-// VariableRuntimeDxe Localized Strings and Content

-//

-// Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-#string STR_PROPERTIES_MODULE_NAME 

-#language en-US 

-"VariableRuntimeDxe module"

-

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c
deleted file mode 100644
index 2184634f35..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c
+++ /dev/null
@@ -1,1009 +0,0 @@
-/** @file

-  The sample implementation for SMM variable protocol. And this driver

-  implements an SMI handler to communicate with the DXE runtime driver

-  to provide variable services.

-

-  Caution: This module requires additional review when modified.

-  This driver will have external input - variable data and communicate buffer in SMM mode.

-  This external input must be validated carefully to avoid security issue like

-  buffer overflow, integer overflow.

-

-  SmmVariableHandler() will receive untrusted input and do basic validation.

-

-  Each sub function VariableServiceGetVariable(), VariableServiceGetNextVariableName(),

-  VariableServiceSetVariable(), VariableServiceQueryVariableInfo(), ReclaimForOS(),

-  SmmVariableGetStatistics() should also do validation based on its own knowledge.

-

-Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-

-#include <Protocol/SmmVariable.h>

-#include <Protocol/SmmFirmwareVolumeBlock.h>

-#include <Protocol/SmmFaultTolerantWrite.h>

-#include <Protocol/SmmEndOfDxe.h>

-#include <Protocol/SmmVarCheck.h>

-

-#include <Library/SmmServicesTableLib.h>

-#include <Library/SmmMemLib.h>

-

-#include <Guid/SmmVariableCommon.h>

-#include "Variable.h"

-

-extern VARIABLE_INFO_ENTRY                           *gVariableInfo;

-EFI_HANDLE                                           mSmmVariableHandle      = NULL;

-EFI_HANDLE                                           mVariableHandle         = NULL;

-BOOLEAN                                              mAtRuntime              = FALSE;

-UINT8                                                *mVariableBufferPayload = NULL;

-UINTN                                                mVariableBufferPayloadSize;

-extern BOOLEAN                                       mEndOfDxe;

-extern VAR_CHECK_REQUEST_SOURCE                      mRequestSource;

-

-/**

-  SecureBoot Hook for SetVariable.

-

-  @param[in] VariableName                 Name of Variable to be found.

-  @param[in] VendorGuid                   Variable vendor GUID.

-

-**/

-VOID

-EFIAPI

-SecureBootHook (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  )

-{

-  return ;

-}

-

-/**

-

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  @param VariableName                     Name of Variable to be found.

-  @param VendorGuid                       Variable vendor GUID.

-  @param Attributes                       Attribute value of the variable found

-  @param DataSize                         Size of Data found. If size is less than the

-                                          data, this value contains the required size.

-  @param Data                             Data pointer.

-

-  @return EFI_INVALID_PARAMETER           Invalid parameter.

-  @return EFI_SUCCESS                     Set successfully.

-  @return EFI_OUT_OF_RESOURCES            Resource not enough to set variable.

-  @return EFI_NOT_FOUND                   Not found.

-  @return EFI_WRITE_PROTECTED             Variable is read-only.

-

-**/

-EFI_STATUS

-EFIAPI

-SmmVariableSetVariable (

-  IN CHAR16                  *VariableName,

-  IN EFI_GUID                *VendorGuid,

-  IN UINT32                  Attributes,

-  IN UINTN                   DataSize,

-  IN VOID                    *Data

-  )

-{

-  EFI_STATUS                 Status;

-

-  //

-  // Disable write protection when the calling SetVariable() through EFI_SMM_VARIABLE_PROTOCOL.

-  //

-  mRequestSource = VarCheckFromTrusted;

-  Status         = VariableServiceSetVariable (

-                     VariableName,

-                     VendorGuid,

-                     Attributes,

-                     DataSize,

-                     Data

-                     );

-  mRequestSource = VarCheckFromUntrusted;

-  return Status;

-}

-

-EFI_SMM_VARIABLE_PROTOCOL      gSmmVariable = {

-  VariableServiceGetVariable,

-  VariableServiceGetNextVariableName,

-  SmmVariableSetVariable,

-  VariableServiceQueryVariableInfo

-};

-

-EDKII_SMM_VAR_CHECK_PROTOCOL mSmmVarCheck = { VarCheckRegisterSetVariableCheckHandler,

-                                              VarCheckVariablePropertySet,

-                                              VarCheckVariablePropertyGet };

-

-/**

-  Return TRUE if ExitBootServices () has been called.

-

-  @retval TRUE If ExitBootServices () has been called.

-**/

-BOOLEAN

-AtRuntime (

-  VOID

-  )

-{

-  return mAtRuntime;

-}

-

-/**

-  Initializes a basic mutual exclusion lock.

-

-  This function initializes a basic mutual exclusion lock to the released state

-  and returns the lock.  Each lock provides mutual exclusion access at its task

-  priority level.  Since there is no preemption or multiprocessor support in EFI,

-  acquiring the lock only consists of raising to the locks TPL.

-  If Lock is NULL, then ASSERT().

-  If Priority is not a valid TPL value, then ASSERT().

-

-  @param  Lock       A pointer to the lock data structure to initialize.

-  @param  Priority   EFI TPL is associated with the lock.

-

-  @return The lock.

-

-**/

-EFI_LOCK *

-InitializeLock (

-  IN OUT EFI_LOCK                         *Lock,

-  IN EFI_TPL                              Priority

-  )

-{

-  return Lock;

-}

-

-/**

-  Acquires lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function that will be removed when

-  EfiAcquireLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiAcquireLock() at boot time, and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to acquire.

-

-**/

-VOID

-AcquireLockOnlyAtBootTime (

-  IN EFI_LOCK                             *Lock

-  )

-{

-

-}

-

-

-/**

-  Releases lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function which will be removed when

-  EfiReleaseLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiReleaseLock() at boot time and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to release.

-

-**/

-VOID

-ReleaseLockOnlyAtBootTime (

-  IN EFI_LOCK                             *Lock

-  )

-{

-

-}

-

-/**

-  Retrieve the SMM Fault Tolerent Write protocol interface.

-

-  @param[out] FtwProtocol       The interface of SMM Ftw protocol

-

-  @retval EFI_SUCCESS           The SMM FTW protocol instance was found and returned in FtwProtocol.

-  @retval EFI_NOT_FOUND         The SMM FTW protocol instance was not found.

-  @retval EFI_INVALID_PARAMETER SarProtocol is NULL.

-

-**/

-EFI_STATUS

-GetFtwProtocol (

-  OUT VOID                                **FtwProtocol

-  )

-{

-  EFI_STATUS                              Status;

-

-  //

-  // Locate Smm Fault Tolerent Write protocol

-  //

-  Status = gSmst->SmmLocateProtocol (

-                    &gEfiSmmFaultTolerantWriteProtocolGuid,

-                    NULL,

-                    FtwProtocol

-                    );

-  return Status;

-}

-

-

-/**

-  Retrieve the SMM FVB protocol interface by HANDLE.

-

-  @param[in]  FvBlockHandle     The handle of SMM FVB protocol that provides services for

-                                reading, writing, and erasing the target block.

-  @param[out] FvBlock           The interface of SMM FVB protocol

-

-  @retval EFI_SUCCESS           The interface information for the specified protocol was returned.

-  @retval EFI_UNSUPPORTED       The device does not support the SMM FVB protocol.

-  @retval EFI_INVALID_PARAMETER FvBlockHandle is not a valid EFI_HANDLE or FvBlock is NULL.

-

-**/

-EFI_STATUS

-GetFvbByHandle (

-  IN  EFI_HANDLE                          FvBlockHandle,

-  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvBlock

-  )

-{

-  //

-  // To get the SMM FVB protocol interface on the handle

-  //

-  return gSmst->SmmHandleProtocol (

-                  FvBlockHandle,

-                  &gEfiSmmFirmwareVolumeBlockProtocolGuid,

-                  (VOID **) FvBlock

-                  );

-}

-

-

-/**

-  Function returns an array of handles that support the SMM FVB protocol

-  in a buffer allocated from pool.

-

-  @param[out]  NumberHandles    The number of handles returned in Buffer.

-  @param[out]  Buffer           A pointer to the buffer to return the requested

-                                array of  handles that support SMM FVB protocol.

-

-  @retval EFI_SUCCESS           The array of handles was returned in Buffer, and the number of

-                                handles in Buffer was returned in NumberHandles.

-  @retval EFI_NOT_FOUND         No SMM FVB handle was found.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the matching results.

-  @retval EFI_INVALID_PARAMETER NumberHandles is NULL or Buffer is NULL.

-

-**/

-EFI_STATUS

-GetFvbCountAndBuffer (

-  OUT UINTN                               *NumberHandles,

-  OUT EFI_HANDLE                          **Buffer

-  )

-{

-  EFI_STATUS                              Status;

-  UINTN                                   BufferSize;

-

-  if ((NumberHandles == NULL) || (Buffer == NULL)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  BufferSize     = 0;

-  *NumberHandles = 0;

-  *Buffer        = NULL;

-  Status = gSmst->SmmLocateHandle (

-                    ByProtocol,

-                    &gEfiSmmFirmwareVolumeBlockProtocolGuid,

-                    NULL,

-                    &BufferSize,

-                    *Buffer

-                    );

-  if (EFI_ERROR(Status) && Status != EFI_BUFFER_TOO_SMALL) {

-    return EFI_NOT_FOUND;

-  }

-

-  *Buffer = AllocatePool (BufferSize);

-  if (*Buffer == NULL) {

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  Status = gSmst->SmmLocateHandle (

-                    ByProtocol,

-                    &gEfiSmmFirmwareVolumeBlockProtocolGuid,

-                    NULL,

-                    &BufferSize,

-                    *Buffer

-                    );

-

-  *NumberHandles = BufferSize / sizeof(EFI_HANDLE);

-  if (EFI_ERROR(Status)) {

-    *NumberHandles = 0;

-    FreePool (*Buffer);

-    *Buffer = NULL;

-  }

-

-  return Status;

-}

-

-

-/**

-  Get the variable statistics information from the information buffer pointed by gVariableInfo.

-

-  Caution: This function may be invoked at SMM runtime.

-  InfoEntry and InfoSize are external input. Care must be taken to make sure not security issue at runtime.

-

-  @param[in, out]  InfoEntry    A pointer to the buffer of variable information entry.

-                                On input, point to the variable information returned last time. if

-                                InfoEntry->VendorGuid is zero, return the first information.

-                                On output, point to the next variable information.

-  @param[in, out]  InfoSize     On input, the size of the variable information buffer.

-                                On output, the returned variable information size.

-

-  @retval EFI_SUCCESS           The variable information is found and returned successfully.

-  @retval EFI_UNSUPPORTED       No variable inoformation exists in variable driver. The

-                                PcdVariableCollectStatistics should be set TRUE to support it.

-  @retval EFI_BUFFER_TOO_SMALL  The buffer is too small to hold the next variable information.

-  @retval EFI_INVALID_PARAMETER Input parameter is invalid.

-

-**/

-EFI_STATUS

-SmmVariableGetStatistics (

-  IN OUT VARIABLE_INFO_ENTRY                           *InfoEntry,

-  IN OUT UINTN                                         *InfoSize

-  )

-{

-  VARIABLE_INFO_ENTRY                                  *VariableInfo;

-  UINTN                                                NameSize;

-  UINTN                                                StatisticsInfoSize;

-  CHAR16                                               *InfoName;

-  UINTN                                                InfoNameMaxSize;

-  EFI_GUID                                             VendorGuid;

-

-  if (InfoEntry == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  VariableInfo = gVariableInfo;

-  if (VariableInfo == NULL) {

-    return EFI_UNSUPPORTED;

-  }

-

-  StatisticsInfoSize = sizeof (VARIABLE_INFO_ENTRY);

-  if (*InfoSize < StatisticsInfoSize) {

-    *InfoSize = StatisticsInfoSize;

-    return EFI_BUFFER_TOO_SMALL;

-  }

-  InfoName = (CHAR16 *)(InfoEntry + 1);

-  InfoNameMaxSize = (*InfoSize - sizeof (VARIABLE_INFO_ENTRY));

-

-  CopyGuid (&VendorGuid, &InfoEntry->VendorGuid);

-

-  if (IsZeroGuid (&VendorGuid)) {

-    //

-    // Return the first variable info

-    //

-    NameSize = StrSize (VariableInfo->Name);

-    StatisticsInfoSize = sizeof (VARIABLE_INFO_ENTRY) + NameSize;

-    if (*InfoSize < StatisticsInfoSize) {

-      *InfoSize = StatisticsInfoSize;

-      return EFI_BUFFER_TOO_SMALL;

-    }

-    CopyMem (InfoEntry, VariableInfo, sizeof (VARIABLE_INFO_ENTRY));

-    CopyMem (InfoName, VariableInfo->Name, NameSize);

-    *InfoSize = StatisticsInfoSize;

-    return EFI_SUCCESS;

-  }

-

-  //

-  // Get the next variable info

-  //

-  while (VariableInfo != NULL) {

-    if (CompareGuid (&VariableInfo->VendorGuid, &VendorGuid)) {

-      NameSize = StrSize (VariableInfo->Name);

-      if (NameSize <= InfoNameMaxSize) {

-        if (CompareMem (VariableInfo->Name, InfoName, NameSize) == 0) {

-          //

-          // Find the match one

-          //

-          VariableInfo = VariableInfo->Next;

-          break;

-        }

-      }

-    }

-    VariableInfo = VariableInfo->Next;

-  };

-

-  if (VariableInfo == NULL) {

-    *InfoSize = 0;

-    return EFI_SUCCESS;

-  }

-

-  //

-  // Output the new variable info

-  //

-  NameSize = StrSize (VariableInfo->Name);

-  StatisticsInfoSize = sizeof (VARIABLE_INFO_ENTRY) + NameSize;

-  if (*InfoSize < StatisticsInfoSize) {

-    *InfoSize = StatisticsInfoSize;

-    return EFI_BUFFER_TOO_SMALL;

-  }

-

-  CopyMem (InfoEntry, VariableInfo, sizeof (VARIABLE_INFO_ENTRY));

-  CopyMem (InfoName, VariableInfo->Name, NameSize);

-  *InfoSize = StatisticsInfoSize;

-

-  return EFI_SUCCESS;

-}

-

-

-/**

-  Communication service SMI Handler entry.

-

-  This SMI handler provides services for the variable wrapper driver.

-

-  Caution: This function may receive untrusted input.

-  This variable data and communicate buffer are external input, so this function will do basic validation.

-  Each sub function VariableServiceGetVariable(), VariableServiceGetNextVariableName(),

-  VariableServiceSetVariable(), VariableServiceQueryVariableInfo(), ReclaimForOS(),

-  SmmVariableGetStatistics() should also do validation based on its own knowledge.

-

-  @param[in]     DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().

-  @param[in]     RegisterContext Points to an optional handler context which was specified when the

-                                 handler was registered.

-  @param[in, out] CommBuffer     A pointer to a collection of data in memory that will

-                                 be conveyed from a non-SMM environment into an SMM environment.

-  @param[in, out] CommBufferSize The size of the CommBuffer.

-

-  @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers

-                                              should still be called.

-  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should

-                                              still be called.

-  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still

-                                              be called.

-  @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.

-**/

-EFI_STATUS

-EFIAPI

-SmmVariableHandler (

-  IN     EFI_HANDLE                                DispatchHandle,

-  IN     CONST VOID                                *RegisterContext,

-  IN OUT VOID                                      *CommBuffer,

-  IN OUT UINTN                                     *CommBufferSize

-  )

-{

-  EFI_STATUS                                       Status;

-  SMM_VARIABLE_COMMUNICATE_HEADER                  *SmmVariableFunctionHeader;

-  SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE         *SmmVariableHeader;

-  SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME  *GetNextVariableName;

-  SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO     *QueryVariableInfo;

-  SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE        *GetPayloadSize;

-  VARIABLE_INFO_ENTRY                              *VariableInfo;

-  SMM_VARIABLE_COMMUNICATE_LOCK_VARIABLE           *VariableToLock;

-  SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY *CommVariableProperty;

-  UINTN                                            InfoSize;

-  UINTN                                            NameBufferSize;

-  UINTN                                            CommBufferPayloadSize;

-  UINTN                                            TempCommBufferSize;

-

-  //

-  // If input is invalid, stop processing this SMI

-  //

-  if (CommBuffer == NULL || CommBufferSize == NULL) {

-    return EFI_SUCCESS;

-  }

-

-  TempCommBufferSize = *CommBufferSize;

-

-  if (TempCommBufferSize < SMM_VARIABLE_COMMUNICATE_HEADER_SIZE) {

-    DEBUG ((EFI_D_ERROR, "SmmVariableHandler: SMM communication buffer size invalid!\n"));

-    return EFI_SUCCESS;

-  }

-  CommBufferPayloadSize = TempCommBufferSize - SMM_VARIABLE_COMMUNICATE_HEADER_SIZE;

-  if (CommBufferPayloadSize > mVariableBufferPayloadSize) {

-    DEBUG ((EFI_D_ERROR, "SmmVariableHandler: SMM communication buffer payload size invalid!\n"));

-    return EFI_SUCCESS;

-  }

-

-  if (!SmmIsBufferOutsideSmmValid ((UINTN)CommBuffer, TempCommBufferSize)) {

-    DEBUG ((EFI_D_ERROR, "SmmVariableHandler: SMM communication buffer in SMRAM or overflow!\n"));

-    return EFI_SUCCESS;

-  }

-

-  SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *)CommBuffer;

-  switch (SmmVariableFunctionHeader->Function) {

-    case SMM_VARIABLE_FUNCTION_GET_VARIABLE:

-      if (CommBufferPayloadSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)) {

-        DEBUG ((EFI_D_ERROR, "GetVariable: SMM communication buffer size invalid!\n"));

-        return EFI_SUCCESS;

-      }

-      //

-      // Copy the input communicate buffer payload to pre-allocated SMM variable buffer payload.

-      //

-      CopyMem (mVariableBufferPayload, SmmVariableFunctionHeader->Data, CommBufferPayloadSize);

-      SmmVariableHeader = (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE *) mVariableBufferPayload;

-      if (((UINTN)(~0) - SmmVariableHeader->DataSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)) ||

-         ((UINTN)(~0) - SmmVariableHeader->NameSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + SmmVariableHeader->DataSize)) {

-        //

-        // Prevent InfoSize overflow happen

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-      InfoSize = OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)

-                 + SmmVariableHeader->DataSize + SmmVariableHeader->NameSize;

-

-      //

-      // SMRAM range check already covered before

-      //

-      if (InfoSize > CommBufferPayloadSize) {

-        DEBUG ((EFI_D_ERROR, "GetVariable: Data size exceed communication buffer size limit!\n"));

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      if (SmmVariableHeader->NameSize < sizeof (CHAR16) || SmmVariableHeader->Name[SmmVariableHeader->NameSize/sizeof (CHAR16) - 1] != L'\0') {

-        //

-        // Make sure VariableName is A Null-terminated string.

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      Status = VariableServiceGetVariable (

-                 SmmVariableHeader->Name,

-                 &SmmVariableHeader->Guid,

-                 &SmmVariableHeader->Attributes,

-                 &SmmVariableHeader->DataSize,

-                 (UINT8 *)SmmVariableHeader->Name + SmmVariableHeader->NameSize

-                 );

-      CopyMem (SmmVariableFunctionHeader->Data, mVariableBufferPayload, CommBufferPayloadSize);

-      break;

-

-    case SMM_VARIABLE_FUNCTION_GET_NEXT_VARIABLE_NAME:

-      if (CommBufferPayloadSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name)) {

-        DEBUG ((EFI_D_ERROR, "GetNextVariableName: SMM communication buffer size invalid!\n"));

-        return EFI_SUCCESS;

-      }

-      //

-      // Copy the input communicate buffer payload to pre-allocated SMM variable buffer payload.

-      //

-      CopyMem (mVariableBufferPayload, SmmVariableFunctionHeader->Data, CommBufferPayloadSize);

-      GetNextVariableName = (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME *) mVariableBufferPayload;

-      if ((UINTN)(~0) - GetNextVariableName->NameSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name)) {

-        //

-        // Prevent InfoSize overflow happen

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-      InfoSize = OFFSET_OF(SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name) + GetNextVariableName->NameSize;

-

-      //

-      // SMRAM range check already covered before

-      //

-      if (InfoSize > CommBufferPayloadSize) {

-        DEBUG ((EFI_D_ERROR, "GetNextVariableName: Data size exceed communication buffer size limit!\n"));

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      NameBufferSize = CommBufferPayloadSize - OFFSET_OF(SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name);

-      if (NameBufferSize < sizeof (CHAR16) || GetNextVariableName->Name[NameBufferSize/sizeof (CHAR16) - 1] != L'\0') {

-        //

-        // Make sure input VariableName is A Null-terminated string.

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      Status = VariableServiceGetNextVariableName (

-                 &GetNextVariableName->NameSize,

-                 GetNextVariableName->Name,

-                 &GetNextVariableName->Guid

-                 );

-      CopyMem (SmmVariableFunctionHeader->Data, mVariableBufferPayload, CommBufferPayloadSize);

-      break;

-

-    case SMM_VARIABLE_FUNCTION_SET_VARIABLE:

-      if (CommBufferPayloadSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)) {

-        DEBUG ((EFI_D_ERROR, "SetVariable: SMM communication buffer size invalid!\n"));

-        return EFI_SUCCESS;

-      }

-      //

-      // Copy the input communicate buffer payload to pre-allocated SMM variable buffer payload.

-      //

-      CopyMem (mVariableBufferPayload, SmmVariableFunctionHeader->Data, CommBufferPayloadSize);

-      SmmVariableHeader = (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE *) mVariableBufferPayload;

-      if (((UINTN)(~0) - SmmVariableHeader->DataSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)) ||

-         ((UINTN)(~0) - SmmVariableHeader->NameSize < OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + SmmVariableHeader->DataSize)) {

-        //

-        // Prevent InfoSize overflow happen

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-      InfoSize = OFFSET_OF(SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)

-                 + SmmVariableHeader->DataSize + SmmVariableHeader->NameSize;

-

-      //

-      // SMRAM range check already covered before

-      // Data buffer should not contain SMM range

-      //

-      if (InfoSize > CommBufferPayloadSize) {

-        DEBUG ((EFI_D_ERROR, "SetVariable: Data size exceed communication buffer size limit!\n"));

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      if (SmmVariableHeader->NameSize < sizeof (CHAR16) || SmmVariableHeader->Name[SmmVariableHeader->NameSize/sizeof (CHAR16) - 1] != L'\0') {

-        //

-        // Make sure VariableName is A Null-terminated string.

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      Status = VariableServiceSetVariable (

-                 SmmVariableHeader->Name,

-                 &SmmVariableHeader->Guid,

-                 SmmVariableHeader->Attributes,

-                 SmmVariableHeader->DataSize,

-                 (UINT8 *)SmmVariableHeader->Name + SmmVariableHeader->NameSize

-                 );

-      break;

-

-    case SMM_VARIABLE_FUNCTION_QUERY_VARIABLE_INFO:

-      if (CommBufferPayloadSize < sizeof (SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO)) {

-        DEBUG ((EFI_D_ERROR, "QueryVariableInfo: SMM communication buffer size invalid!\n"));

-        return EFI_SUCCESS;

-      }

-      QueryVariableInfo = (SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO *) SmmVariableFunctionHeader->Data;

-

-      Status = VariableServiceQueryVariableInfo (

-                 QueryVariableInfo->Attributes,

-                 &QueryVariableInfo->MaximumVariableStorageSize,

-                 &QueryVariableInfo->RemainingVariableStorageSize,

-                 &QueryVariableInfo->MaximumVariableSize

-                 );

-      break;

-

-    case SMM_VARIABLE_FUNCTION_GET_PAYLOAD_SIZE:

-      if (CommBufferPayloadSize < sizeof (SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE)) {

-        DEBUG ((EFI_D_ERROR, "GetPayloadSize: SMM communication buffer size invalid!\n"));

-        return EFI_SUCCESS;

-      }

-      GetPayloadSize = (SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE *) SmmVariableFunctionHeader->Data;

-      GetPayloadSize->VariablePayloadSize = mVariableBufferPayloadSize;

-      Status = EFI_SUCCESS;

-      break;

-

-    case SMM_VARIABLE_FUNCTION_READY_TO_BOOT:

-      if (AtRuntime()) {

-        Status = EFI_UNSUPPORTED;

-        break;

-      }

-      if (!mEndOfDxe) {

-        mEndOfDxe = TRUE;

-        VarCheckLibInitializeAtEndOfDxe (NULL);

-        //

-        // The initialization for variable quota.

-        //

-        InitializeVariableQuota ();

-      }

-      ReclaimForOS ();

-      Status = EFI_SUCCESS;

-      break;

-

-    case SMM_VARIABLE_FUNCTION_EXIT_BOOT_SERVICE:

-      mAtRuntime = TRUE;

-      Status = EFI_SUCCESS;

-      break;

-

-    case SMM_VARIABLE_FUNCTION_GET_STATISTICS:

-      VariableInfo = (VARIABLE_INFO_ENTRY *) SmmVariableFunctionHeader->Data;

-      InfoSize = TempCommBufferSize - SMM_VARIABLE_COMMUNICATE_HEADER_SIZE;

-

-      //

-      // Do not need to check SmmVariableFunctionHeader->Data in SMRAM here.

-      // It is covered by previous CommBuffer check

-      //

-

-      //

-      // Do not need to check CommBufferSize buffer as it should point to SMRAM

-      // that was used by SMM core to cache CommSize from SmmCommunication protocol.

-      //

-

-      Status = SmmVariableGetStatistics (VariableInfo, &InfoSize);

-      *CommBufferSize = InfoSize + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE;

-      break;

-

-    case SMM_VARIABLE_FUNCTION_LOCK_VARIABLE:

-      if (mEndOfDxe) {

-        Status = EFI_ACCESS_DENIED;

-      } else {

-        VariableToLock = (SMM_VARIABLE_COMMUNICATE_LOCK_VARIABLE *) SmmVariableFunctionHeader->Data;

-        Status = VariableLockRequestToLock (

-                   NULL,

-                   VariableToLock->Name,

-                   &VariableToLock->Guid

-                   );

-      }

-      break;

-    case SMM_VARIABLE_FUNCTION_VAR_CHECK_VARIABLE_PROPERTY_SET:

-      if (mEndOfDxe) {

-        Status = EFI_ACCESS_DENIED;

-      } else {

-        CommVariableProperty = (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY *) SmmVariableFunctionHeader->Data;

-        Status = VarCheckVariablePropertySet (

-                   CommVariableProperty->Name,

-                   &CommVariableProperty->Guid,

-                   &CommVariableProperty->VariableProperty

-                   );

-      }

-      break;

-    case SMM_VARIABLE_FUNCTION_VAR_CHECK_VARIABLE_PROPERTY_GET:

-      if (CommBufferPayloadSize < OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name)) {

-        DEBUG ((EFI_D_ERROR, "VarCheckVariablePropertyGet: SMM communication buffer size invalid!\n"));

-        return EFI_SUCCESS;

-      }

-      //

-      // Copy the input communicate buffer payload to pre-allocated SMM variable buffer payload.

-      //

-      CopyMem (mVariableBufferPayload, SmmVariableFunctionHeader->Data, CommBufferPayloadSize);

-      CommVariableProperty = (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY *) mVariableBufferPayload;

-      if ((UINTN) (~0) - CommVariableProperty->NameSize < OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name)) {

-        //

-        // Prevent InfoSize overflow happen

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-      InfoSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name) + CommVariableProperty->NameSize;

-

-      //

-      // SMRAM range check already covered before

-      //

-      if (InfoSize > CommBufferPayloadSize) {

-        DEBUG ((EFI_D_ERROR, "VarCheckVariablePropertyGet: Data size exceed communication buffer size limit!\n"));

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      if (CommVariableProperty->NameSize < sizeof (CHAR16) || CommVariableProperty->Name[CommVariableProperty->NameSize/sizeof (CHAR16) - 1] != L'\0') {

-        //

-        // Make sure VariableName is A Null-terminated string.

-        //

-        Status = EFI_ACCESS_DENIED;

-        goto EXIT;

-      }

-

-      Status = VarCheckVariablePropertyGet (

-                 CommVariableProperty->Name,

-                 &CommVariableProperty->Guid,

-                 &CommVariableProperty->VariableProperty

-                 );

-      CopyMem (SmmVariableFunctionHeader->Data, mVariableBufferPayload, CommBufferPayloadSize);

-      break;

-

-    default:

-      Status = EFI_UNSUPPORTED;

-  }

-

-EXIT:

-

-  SmmVariableFunctionHeader->ReturnStatus = Status;

-

-  return EFI_SUCCESS;

-}

-

-/**

-  SMM END_OF_DXE protocol notification event handler.

-

-  @param  Protocol   Points to the protocol's unique identifier

-  @param  Interface  Points to the interface instance

-  @param  Handle     The handle on which the interface was installed

-

-  @retval EFI_SUCCESS   SmmEndOfDxeCallback runs successfully

-

-**/

-EFI_STATUS

-EFIAPI

-SmmEndOfDxeCallback (

-  IN CONST EFI_GUID                       *Protocol,

-  IN VOID                                 *Interface,

-  IN EFI_HANDLE                           Handle

-  )

-{

-  DEBUG ((EFI_D_INFO, "[Variable]SMM_END_OF_DXE is signaled\n"));

-  mEndOfDxe = TRUE;

-  VarCheckLibInitializeAtEndOfDxe (NULL);

-  //

-  // The initialization for variable quota.

-  //

-  InitializeVariableQuota ();

-  if (PcdGetBool (PcdReclaimVariableSpaceAtEndOfDxe)) {

-    ReclaimForOS ();

-  }

-

-  return EFI_SUCCESS;

-}

-

-/**

-  SMM Fault Tolerant Write protocol notification event handler.

-

-  Non-Volatile variable write may needs FTW protocol to reclaim when

-  writting variable.

-

-  @param  Protocol   Points to the protocol's unique identifier

-  @param  Interface  Points to the interface instance

-  @param  Handle     The handle on which the interface was installed

-

-  @retval EFI_SUCCESS   SmmEventCallback runs successfully

-  @retval EFI_NOT_FOUND The Fvb protocol for variable is not found.

-

- **/

-EFI_STATUS

-EFIAPI

-SmmFtwNotificationEvent (

-  IN CONST EFI_GUID                       *Protocol,

-  IN VOID                                 *Interface,

-  IN EFI_HANDLE                           Handle

-  )

-{

-  EFI_STATUS                              Status;

-  EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *FvbProtocol;

-  EFI_SMM_FAULT_TOLERANT_WRITE_PROTOCOL   *FtwProtocol;

-  EFI_PHYSICAL_ADDRESS                    NvStorageVariableBase;

-  UINTN                                   FtwMaxBlockSize;

-

-  if (mVariableModuleGlobal->FvbInstance != NULL) {

-    return EFI_SUCCESS;

-  }

-

-  //

-  // Ensure SMM FTW protocol is installed.

-  //

-  Status = GetFtwProtocol ((VOID **)&FtwProtocol);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  Status = FtwProtocol->GetMaxBlockSize (FtwProtocol, &FtwMaxBlockSize);

-  if (!EFI_ERROR (Status)) {

-    ASSERT (PcdGet32 (PcdFlashNvStorageVariableSize) <= FtwMaxBlockSize);

-  }

-

-  //

-  // Find the proper FVB protocol for variable.

-  //

-  NvStorageVariableBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);

-  if (NvStorageVariableBase == 0) {

-    NvStorageVariableBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);

-  }

-  Status = GetFvbInfoByAddress (NvStorageVariableBase, NULL, &FvbProtocol);

-  if (EFI_ERROR (Status)) {

-    return EFI_NOT_FOUND;

-  }

-

-  mVariableModuleGlobal->FvbInstance = FvbProtocol;

-

-  Status = VariableWriteServiceInitialize ();

-  if (EFI_ERROR (Status)) {

-    DEBUG ((DEBUG_ERROR, "Variable write service initialization failed. Status = %r\n", Status));

-  }

-

-  //

-  // Notify the variable wrapper driver the variable write service is ready

-  //

-  Status = gBS->InstallProtocolInterface (

-                  &mSmmVariableHandle,

-                  &gSmmVariableWriteGuid,

-                  EFI_NATIVE_INTERFACE,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  return EFI_SUCCESS;

-}

-

-

-/**

-  Variable Driver main entry point. The Variable driver places the 4 EFI

-  runtime services in the EFI System Table and installs arch protocols

-  for variable read and write services being available. It also registers

-  a notification function for an EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-

-  @param[in] ImageHandle    The firmware allocated handle for the EFI image.

-  @param[in] SystemTable    A pointer to the EFI System Table.

-

-  @retval EFI_SUCCESS       Variable service successfully initialized.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableServiceInitialize (

-  IN EFI_HANDLE                           ImageHandle,

-  IN EFI_SYSTEM_TABLE                     *SystemTable

-  )

-{

-  EFI_STATUS                              Status;

-  EFI_HANDLE                              VariableHandle;

-  VOID                                    *SmmFtwRegistration;

-  VOID                                    *SmmEndOfDxeRegistration;

-

-  //

-  // Variable initialize.

-  //

-  Status = VariableCommonInitialize ();

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Install the Smm Variable Protocol on a new handle.

-  //

-  VariableHandle = NULL;

-  Status = gSmst->SmmInstallProtocolInterface (

-                    &VariableHandle,

-                    &gEfiSmmVariableProtocolGuid,

-                    EFI_NATIVE_INTERFACE,

-                    &gSmmVariable

-                    );

-  ASSERT_EFI_ERROR (Status);

-

-  Status = gSmst->SmmInstallProtocolInterface (

-                    &VariableHandle,

-                    &gEdkiiSmmVarCheckProtocolGuid,

-                    EFI_NATIVE_INTERFACE,

-                    &mSmmVarCheck

-                    );

-  ASSERT_EFI_ERROR (Status);

-

-  mVariableBufferPayloadSize = GetNonVolatileMaxVariableSize () +

-                               OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name) - GetVariableHeaderSize ();

-

-  Status = gSmst->SmmAllocatePool (

-                    EfiRuntimeServicesData,

-                    mVariableBufferPayloadSize,

-                    (VOID **)&mVariableBufferPayload

-                    );

-  ASSERT_EFI_ERROR (Status);

-

-  ///

-  /// Register SMM variable SMI handler

-  ///

-  VariableHandle = NULL;

-  Status = gSmst->SmiHandlerRegister (SmmVariableHandler, &gEfiSmmVariableProtocolGuid, &VariableHandle);

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Notify the variable wrapper driver the variable service is ready

-  //

-  Status = SystemTable->BootServices->InstallProtocolInterface (

-                                        &mVariableHandle,

-                                        &gEfiSmmVariableProtocolGuid,

-                                        EFI_NATIVE_INTERFACE,

-                                        &gSmmVariable

-                                        );

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Register EFI_SMM_END_OF_DXE_PROTOCOL_GUID notify function.

-  //

-  Status = gSmst->SmmRegisterProtocolNotify (

-                    &gEfiSmmEndOfDxeProtocolGuid,

-                    SmmEndOfDxeCallback,

-                    &SmmEndOfDxeRegistration

-                    );

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Register FtwNotificationEvent () notify function.

-  //

-  Status = gSmst->SmmRegisterProtocolNotify (

-                    &gEfiSmmFaultTolerantWriteProtocolGuid,

-                    SmmFtwNotificationEvent,

-                    &SmmFtwRegistration

-                    );

-  ASSERT_EFI_ERROR (Status);

-

-  SmmFtwNotificationEvent (NULL, NULL, NULL);

-

-  return EFI_SUCCESS;

-}

-

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf
deleted file mode 100644
index ccfb6fc740..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf
+++ /dev/null
@@ -1,139 +0,0 @@
-## @file

-#  Provides SMM variable service.

-#

-#  This module installs SMM variable protocol into SMM protocol database,

-#  which can be used by SMM driver, and installs SMM variable protocol

-#  into BS protocol database, which can be used to notify the SMM Runtime

-#  Dxe driver that the SMM variable service is ready.

-#  This module should be used with SMM Runtime DXE module together. The

-#  SMM Runtime DXE module would install variable arch protocol and variable

-#  write arch protocol based on SMM variable module.

-#

-#  Caution: This module requires additional review when modified.

-#  This driver will have external input - variable data and communicate buffer in SMM mode.

-#  This external input must be validated carefully to avoid security issues such as

-#  buffer overflow or integer overflow.

-#    The whole SMM authentication variable design relies on the integrity of flash part and SMM.

-#  which is assumed to be protected by platform.  All variable code and metadata in flash/SMM Memory

-#  may not be modified without authorization. If platform fails to protect these resources,

-#  the authentication service provided in this driver will be broken, and the behavior is undefined.

-#

-# Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>

-# This program and the accompanying materials

-# are licensed and made available under the terms and conditions of the BSD License

-# which accompanies this distribution. The full text of the license may be found at

-# http://opensource.org/licenses/bsd-license.php

-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-#

-##

-

-[Defines]

-  INF_VERSION                    = 0x00010005

-  BASE_NAME                      = VariableSmm

-  MODULE_UNI_FILE                = VariableSmm.uni

-  FILE_GUID                      = 23A089B3-EED5-4ac5-B2AB-43E3298C2343

-  MODULE_TYPE                    = DXE_SMM_DRIVER

-  VERSION_STRING                 = 1.0

-  PI_SPECIFICATION_VERSION       = 0x0001000A

-  ENTRY_POINT                    = VariableServiceInitialize

-

-#

-# The following information is for reference only and not required by the build tools.

-#

-#  VALID_ARCHITECTURES           = IA32 X64

-#

-

-

-[Sources]

-  Reclaim.c

-  Variable.c

-  VariableSmm.c

-  VarCheck.c

-  Variable.h

-  VariableExLib.c

-  TcgMorLockSmm.c

-

-[Packages]

-  MdePkg/MdePkg.dec

-  MdeModulePkg/MdeModulePkg.dec

-

-[LibraryClasses]

-  UefiDriverEntryPoint

-  MemoryAllocationLib

-  BaseLib

-  SynchronizationLib

-  UefiLib

-  SmmServicesTableLib

-  BaseMemoryLib

-  DebugLib

-  DxeServicesTableLib

-  HobLib

-  PcdLib

-  SmmMemLib

-  AuthVariableLib

-  VarCheckLib

-

-[Protocols]

-  gEfiSmmFirmwareVolumeBlockProtocolGuid        ## CONSUMES

-  ## CONSUMES

-  ## NOTIFY

-  gEfiSmmFaultTolerantWriteProtocolGuid

-  ## PRODUCES

-  ## UNDEFINED # SmiHandlerRegister

-  gEfiSmmVariableProtocolGuid

-  gEfiSmmEndOfDxeProtocolGuid                   ## NOTIFY

-  gEdkiiSmmVarCheckProtocolGuid                 ## PRODUCES

-

-[Guids]

-  ## SOMETIMES_CONSUMES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_PRODUCES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  ## SOMETIMES_PRODUCES   ## SystemTable

-  gEfiAuthenticatedVariableGuid

-

-  ## SOMETIMES_CONSUMES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_PRODUCES   ## GUID # Signature of Variable store header

-  ## SOMETIMES_CONSUMES   ## HOB

-  ## SOMETIMES_PRODUCES   ## SystemTable

-  gEfiVariableGuid

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"PlatformLang"

-  ## SOMETIMES_PRODUCES   ## Variable:L"PlatformLang"

-  ## SOMETIMES_CONSUMES   ## Variable:L"Lang"

-  ## SOMETIMES_PRODUCES   ## Variable:L"Lang"

-  gEfiGlobalVariableGuid

-

-  gEfiMemoryOverwriteControlDataGuid            ## SOMETIMES_CONSUMES   ## Variable:L"MemoryOverwriteRequestControl"

-  gEfiMemoryOverwriteRequestControlLockGuid     ## SOMETIMES_PRODUCES   ## Variable:L"MemoryOverwriteRequestControlLock"

-

-  gSmmVariableWriteGuid                         ## PRODUCES             ## GUID # Install protocol

-  gEfiSystemNvDataFvGuid                        ## CONSUMES             ## GUID

-  gEdkiiFaultTolerantWriteGuid                  ## SOMETIMES_CONSUMES   ## HOB

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"VarErrorFlag"

-  ## SOMETIMES_PRODUCES   ## Variable:L"VarErrorFlag"

-  gEdkiiVarErrorFlagGuid

-

-[Pcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize       ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase       ## SOMETIMES_CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64     ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxVariableSize                  ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxAuthVariableSize              ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxHardwareErrorVariableSize     ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdVariableStoreSize                ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdHwErrStorageSize                 ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxUserNvVariableSpaceSize           ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdBoottimeReservedNvVariableSpaceSize  ## CONSUMES

-  gEfiMdeModulePkgTokenSpaceGuid.PcdReclaimVariableSpaceAtEndOfDxe   ## CONSUMES

-

-[FeaturePcd]

-  gEfiMdeModulePkgTokenSpaceGuid.PcdVariableCollectStatistics        ## CONSUMES  # statistic the information of variable.

-  gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultLangDeprecate       ## CONSUMES  # Auto update PlatformLang/Lang

-

-[Depex]

-  TRUE

-

-[UserExtensions.TianoCore."ExtraFiles"]

-  VariableSmmExtra.uni

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.uni b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.uni
deleted file mode 100644
index cb82cda33e..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.uni
+++ /dev/null
@@ -1,32 +0,0 @@
-// /** @file

-// Provides SMM variable service.

-//

-// This module installs SMM variable protocol into SMM protocol database,

-// which can be used by SMM driver, and installs SMM variable protocol

-// into BS protocol database, which can be used to notify the SMM Runtime

-// Dxe driver that the SMM variable service is ready.

-// This module should be used with SMM Runtime DXE module together. The

-// SMM Runtime DXE module would install variable arch protocol and variable

-// write arch protocol based on SMM variable module.

-//

-// Caution: This module requires additional review when modified.

-// This driver will have external input - variable data and communicate buffer in SMM mode.

-// This external input must be validated carefully to avoid security issues such as

-// buffer overflow or integer overflow.

-//

-// Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-

-#string STR_MODULE_ABSTRACT             #language en-US "Provides SMM variable service"

-

-#string STR_MODULE_DESCRIPTION          #language en-US "This module installs SMM variable protocol into SMM protocol database, which can be used by SMM driver, and installs SMM variable protocol into BS protocol database, which can be used to notify the SMM Runtime DXE driver that the SMM variable service is ready. This module should be used with SMM Runtime DXE module together. The SMM Runtime DXE module would install variable arch protocol and variable write arch protocol based on SMM variable module. Caution: This module requires additional review when modified. This driver will have external input - variable data and communicate buffer in SMM mode. This external input must be validated carefully to avoid security issues such as buffer overflow or integer overflow."

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmExtra.uni b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmExtra.uni
deleted file mode 100644
index 0de8776086..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmExtra.uni
+++ /dev/null
@@ -1,19 +0,0 @@
-// /** @file

-// VariableSmm Localized Strings and Content

-//

-// Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-#string STR_PROPERTIES_MODULE_NAME 

-#language en-US 

-"VariableSmm module"

-

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c
deleted file mode 100644
index e209d54755..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c
+++ /dev/null
@@ -1,1207 +0,0 @@
-/** @file

-  Implement all four UEFI Runtime Variable services for the nonvolatile

-  and volatile storage space and install variable architecture protocol

-  based on SMM variable module.

-

-  Caution: This module requires additional review when modified.

-  This driver will have external input - variable data.

-  This external input must be validated carefully to avoid security issue like

-  buffer overflow, integer overflow.

-

-  RuntimeServiceGetVariable() and RuntimeServiceSetVariable() are external API

-  to receive data buffer. The size should be checked carefully.

-

-  InitCommunicateBuffer() is really function to check the variable data size.

-

-Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>

-This program and the accompanying materials

-are licensed and made available under the terms and conditions of the BSD License

-which accompanies this distribution.  The full text of the license may be found at

-http://opensource.org/licenses/bsd-license.php

-

-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-

-**/

-#include <PiDxe.h>

-#include <Protocol/VariableWrite.h>

-#include <Protocol/Variable.h>

-#include <Protocol/SmmCommunication.h>

-#include <Protocol/SmmVariable.h>

-#include <Protocol/VariableLock.h>

-#include <Protocol/VarCheck.h>

-

-#include <Library/UefiBootServicesTableLib.h>

-#include <Library/UefiRuntimeServicesTableLib.h>

-#include <Library/MemoryAllocationLib.h>

-#include <Library/UefiDriverEntryPoint.h>

-#include <Library/UefiRuntimeLib.h>

-#include <Library/BaseMemoryLib.h>

-#include <Library/DebugLib.h>

-#include <Library/UefiLib.h>

-#include <Library/BaseLib.h>

-

-#include <Guid/EventGroup.h>

-#include <Guid/SmmVariableCommon.h>

-

-EFI_HANDLE                       mHandle                    = NULL;

-EFI_SMM_VARIABLE_PROTOCOL       *mSmmVariable               = NULL;

-EFI_EVENT                        mVirtualAddressChangeEvent = NULL;

-EFI_SMM_COMMUNICATION_PROTOCOL  *mSmmCommunication          = NULL;

-UINT8                           *mVariableBuffer            = NULL;

-UINT8                           *mVariableBufferPhysical    = NULL;

-UINTN                            mVariableBufferSize;

-UINTN                            mVariableBufferPayloadSize;

-EFI_LOCK                         mVariableServicesLock;

-EDKII_VARIABLE_LOCK_PROTOCOL     mVariableLock;

-EDKII_VAR_CHECK_PROTOCOL         mVarCheck;

-

-/**

-  SecureBoot Hook for SetVariable.

-

-  @param[in] VariableName                 Name of Variable to be found.

-  @param[in] VendorGuid                   Variable vendor GUID.

-

-**/

-VOID

-EFIAPI

-SecureBootHook (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid

-  );

-

-/**

-  Some Secure Boot Policy Variable may update following other variable changes(SecureBoot follows PK change, etc).

-  Record their initial State when variable write service is ready.

-

-**/

-VOID

-EFIAPI

-RecordSecureBootPolicyVarData(

-  VOID

-  );

-

-/**

-  Acquires lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function that will be removed when

-  EfiAcquireLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiAcquireLock() at boot time, and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to acquire.

-

-**/

-VOID

-AcquireLockOnlyAtBootTime (

-  IN EFI_LOCK                             *Lock

-  )

-{

-  if (!EfiAtRuntime ()) {

-    EfiAcquireLock (Lock);

-  }

-}

-

-/**

-  Releases lock only at boot time. Simply returns at runtime.

-

-  This is a temperary function which will be removed when

-  EfiReleaseLock() in UefiLib can handle the call in UEFI

-  Runtimer driver in RT phase.

-  It calls EfiReleaseLock() at boot time and simply returns

-  at runtime.

-

-  @param  Lock         A pointer to the lock to release.

-

-**/

-VOID

-ReleaseLockOnlyAtBootTime (

-  IN EFI_LOCK                             *Lock

-  )

-{

-  if (!EfiAtRuntime ()) {

-    EfiReleaseLock (Lock);

-  }

-}

-

-/**

-  Initialize the communicate buffer using DataSize and Function.

-

-  The communicate size is: SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE +

-  DataSize.

-

-  Caution: This function may receive untrusted input.

-  The data size external input, so this function will validate it carefully to avoid buffer overflow.

-

-  @param[out]      DataPtr          Points to the data in the communicate buffer.

-  @param[in]       DataSize         The data size to send to SMM.

-  @param[in]       Function         The function number to initialize the communicate header.

-

-  @retval EFI_INVALID_PARAMETER     The data size is too big.

-  @retval EFI_SUCCESS               Find the specified variable.

-

-**/

-EFI_STATUS

-InitCommunicateBuffer (

-  OUT     VOID                              **DataPtr OPTIONAL,

-  IN      UINTN                             DataSize,

-  IN      UINTN                             Function

-  )

-{

-  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;

-  SMM_VARIABLE_COMMUNICATE_HEADER           *SmmVariableFunctionHeader;

-

-

-  if (DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE > mVariableBufferSize) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  SmmCommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *) mVariableBuffer;

-  CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmVariableProtocolGuid);

-  SmmCommunicateHeader->MessageLength = DataSize + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE;

-

-  SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) SmmCommunicateHeader->Data;

-  SmmVariableFunctionHeader->Function = Function;

-  if (DataPtr != NULL) {

-    *DataPtr = SmmVariableFunctionHeader->Data;

-  }

-

-  return EFI_SUCCESS;

-}

-

-

-/**

-  Send the data in communicate buffer to SMM.

-

-  @param[in]   DataSize               This size of the function header and the data.

-

-  @retval      EFI_SUCCESS            Success is returned from the functin in SMM.

-  @retval      Others                 Failure is returned from the function in SMM.

-

-**/

-EFI_STATUS

-SendCommunicateBuffer (

-  IN      UINTN                             DataSize

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     CommSize;

-  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;

-  SMM_VARIABLE_COMMUNICATE_HEADER           *SmmVariableFunctionHeader;

-

-  CommSize = DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE;

-  Status = mSmmCommunication->Communicate (mSmmCommunication, mVariableBufferPhysical, &CommSize);

-  ASSERT_EFI_ERROR (Status);

-

-  SmmCommunicateHeader      = (EFI_SMM_COMMUNICATE_HEADER *) mVariableBuffer;

-  SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *)SmmCommunicateHeader->Data;

-  return  SmmVariableFunctionHeader->ReturnStatus;

-}

-

-/**

-  Mark a variable that will become read-only after leaving the DXE phase of execution.

-

-  @param[in] This          The VARIABLE_LOCK_PROTOCOL instance.

-  @param[in] VariableName  A pointer to the variable name that will be made read-only subsequently.

-  @param[in] VendorGuid    A pointer to the vendor GUID that will be made read-only subsequently.

-

-  @retval EFI_SUCCESS           The variable specified by the VariableName and the VendorGuid was marked

-                                as pending to be read-only.

-  @retval EFI_INVALID_PARAMETER VariableName or VendorGuid is NULL.

-                                Or VariableName is an empty string.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource to hold the lock request.

-**/

-EFI_STATUS

-EFIAPI

-VariableLockRequestToLock (

-  IN CONST EDKII_VARIABLE_LOCK_PROTOCOL *This,

-  IN       CHAR16                       *VariableName,

-  IN       EFI_GUID                     *VendorGuid

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     VariableNameSize;

-  UINTN                                     PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_LOCK_VARIABLE    *VariableToLock;

-

-  if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  VariableNameSize = StrSize (VariableName);

-  VariableToLock   = NULL;

-

-  //

-  // If VariableName exceeds SMM payload limit. Return failure

-  //

-  if (VariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_LOCK_VARIABLE, Name)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

-  //

-  PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_LOCK_VARIABLE, Name) + VariableNameSize;

-  Status = InitCommunicateBuffer ((VOID **) &VariableToLock, PayloadSize, SMM_VARIABLE_FUNCTION_LOCK_VARIABLE);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (VariableToLock != NULL);

-

-  CopyGuid (&VariableToLock->Guid, VendorGuid);

-  VariableToLock->NameSize = VariableNameSize;

-  CopyMem (VariableToLock->Name, VariableName, VariableToLock->NameSize);

-

-  //

-  // Send data to SMM.

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-/**

-  Register SetVariable check handler.

-

-  @param[in] Handler            Pointer to check handler.

-

-  @retval EFI_SUCCESS           The SetVariable check handler was registered successfully.

-  @retval EFI_INVALID_PARAMETER Handler is NULL.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource for the SetVariable check handler register request.

-  @retval EFI_UNSUPPORTED       This interface is not implemented.

-                                For example, it is unsupported in VarCheck protocol if both VarCheck and SmmVarCheck protocols are present.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckRegisterSetVariableCheckHandler (

-  IN VAR_CHECK_SET_VARIABLE_CHECK_HANDLER   Handler

-  )

-{

-  return EFI_UNSUPPORTED;

-}

-

-/**

-  Variable property set.

-

-  @param[in] Name               Pointer to the variable name.

-  @param[in] Guid               Pointer to the vendor GUID.

-  @param[in] VariableProperty   Pointer to the input variable property.

-

-  @retval EFI_SUCCESS           The property of variable specified by the Name and Guid was set successfully.

-  @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string,

-                                or the fields of VariableProperty are not valid.

-  @retval EFI_ACCESS_DENIED     EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has

-                                already been signaled.

-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource for the variable property set request.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckVariablePropertySet (

-  IN CHAR16                         *Name,

-  IN EFI_GUID                       *Guid,

-  IN VAR_CHECK_VARIABLE_PROPERTY    *VariableProperty

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     VariableNameSize;

-  UINTN                                     PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY *CommVariableProperty;

-

-  if (Name == NULL || Name[0] == 0 || Guid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (VariableProperty == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (VariableProperty->Revision != VAR_CHECK_VARIABLE_PROPERTY_REVISION) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  VariableNameSize = StrSize (Name);

-  CommVariableProperty = NULL;

-

-  //

-  // If VariableName exceeds SMM payload limit. Return failure

-  //

-  if (VariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime (&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

-  //

-  PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name) + VariableNameSize;

-  Status = InitCommunicateBuffer ((VOID **) &CommVariableProperty, PayloadSize, SMM_VARIABLE_FUNCTION_VAR_CHECK_VARIABLE_PROPERTY_SET);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (CommVariableProperty != NULL);

-

-  CopyGuid (&CommVariableProperty->Guid, Guid);

-  CopyMem (&CommVariableProperty->VariableProperty, VariableProperty, sizeof (*VariableProperty));

-  CommVariableProperty->NameSize = VariableNameSize;

-  CopyMem (CommVariableProperty->Name, Name, CommVariableProperty->NameSize);

-

-  //

-  // Send data to SMM.

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-/**

-  Variable property get.

-

-  @param[in]  Name              Pointer to the variable name.

-  @param[in]  Guid              Pointer to the vendor GUID.

-  @param[out] VariableProperty  Pointer to the output variable property.

-

-  @retval EFI_SUCCESS           The property of variable specified by the Name and Guid was got successfully.

-  @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string.

-  @retval EFI_NOT_FOUND         The property of variable specified by the Name and Guid was not found.

-

-**/

-EFI_STATUS

-EFIAPI

-VarCheckVariablePropertyGet (

-  IN CHAR16                         *Name,

-  IN EFI_GUID                       *Guid,

-  OUT VAR_CHECK_VARIABLE_PROPERTY   *VariableProperty

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     VariableNameSize;

-  UINTN                                     PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY *CommVariableProperty;

-

-  if (Name == NULL || Name[0] == 0 || Guid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (VariableProperty == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  VariableNameSize = StrSize (Name);

-  CommVariableProperty = NULL;

-

-  //

-  // If VariableName exceeds SMM payload limit. Return failure

-  //

-  if (VariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime (&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

-  //

-  PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_VAR_CHECK_VARIABLE_PROPERTY, Name) + VariableNameSize;

-  Status = InitCommunicateBuffer ((VOID **) &CommVariableProperty, PayloadSize, SMM_VARIABLE_FUNCTION_VAR_CHECK_VARIABLE_PROPERTY_GET);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (CommVariableProperty != NULL);

-

-  CopyGuid (&CommVariableProperty->Guid, Guid);

-  CommVariableProperty->NameSize = VariableNameSize;

-  CopyMem (CommVariableProperty->Name, Name, CommVariableProperty->NameSize);

-

-  //

-  // Send data to SMM.

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-  if (Status == EFI_SUCCESS) {

-    CopyMem (VariableProperty, &CommVariableProperty->VariableProperty, sizeof (*VariableProperty));

-  }

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-/**

-  This code finds variable in storage blocks (Volatile or Non-Volatile).

-

-  Caution: This function may receive untrusted input.

-  The data size is external input, so this function will validate it carefully to avoid buffer overflow.

-

-  @param[in]      VariableName       Name of Variable to be found.

-  @param[in]      VendorGuid         Variable vendor GUID.

-  @param[out]     Attributes         Attribute value of the variable found.

-  @param[in, out] DataSize           Size of Data found. If size is less than the

-                                     data, this value contains the required size.

-  @param[out]     Data               Data pointer.

-

-  @retval EFI_INVALID_PARAMETER      Invalid parameter.

-  @retval EFI_SUCCESS                Find the specified variable.

-  @retval EFI_NOT_FOUND              Not found.

-  @retval EFI_BUFFER_TO_SMALL        DataSize is too small for the result.

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceGetVariable (

-  IN      CHAR16                            *VariableName,

-  IN      EFI_GUID                          *VendorGuid,

-  OUT     UINT32                            *Attributes OPTIONAL,

-  IN OUT  UINTN                             *DataSize,

-  OUT     VOID                              *Data

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE  *SmmVariableHeader;

-  UINTN                                     TempDataSize;

-  UINTN                                     VariableNameSize;

-

-  if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  TempDataSize          = *DataSize;

-  VariableNameSize      = StrSize (VariableName);

-  SmmVariableHeader     = NULL;

-

-  //

-  // If VariableName exceeds SMM payload limit. Return failure

-  //

-  if (VariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

-  //

-  if (TempDataSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) - VariableNameSize) {

-    //

-    // If output data buffer exceed SMM payload limit. Trim output buffer to SMM payload size

-    //

-    TempDataSize = mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) - VariableNameSize;

-  }

-  PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + VariableNameSize + TempDataSize;

-

-  Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_GET_VARIABLE);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (SmmVariableHeader != NULL);

-

-  CopyGuid (&SmmVariableHeader->Guid, VendorGuid);

-  SmmVariableHeader->DataSize   = TempDataSize;

-  SmmVariableHeader->NameSize   = VariableNameSize;

-  if (Attributes == NULL) {

-    SmmVariableHeader->Attributes = 0;

-  } else {

-    SmmVariableHeader->Attributes = *Attributes;

-  }

-  CopyMem (SmmVariableHeader->Name, VariableName, SmmVariableHeader->NameSize);

-

-  //

-  // Send data to SMM.

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-

-  //

-  // Get data from SMM.

-  //

-  if (Status == EFI_SUCCESS || Status == EFI_BUFFER_TOO_SMALL) {

-    //

-    // SMM CommBuffer DataSize can be a trimed value

-    // Only update DataSize when needed

-    //

-    *DataSize = SmmVariableHeader->DataSize;

-  }

-  if (Attributes != NULL) {

-    *Attributes = SmmVariableHeader->Attributes;

-  }

-

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  if (Data != NULL) {

-    CopyMem (Data, (UINT8 *)SmmVariableHeader->Name + SmmVariableHeader->NameSize, SmmVariableHeader->DataSize);

-  } else {

-    Status = EFI_INVALID_PARAMETER;

-  }

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-

-/**

-  This code Finds the Next available variable.

-

-  @param[in, out] VariableNameSize   Size of the variable name.

-  @param[in, out] VariableName       Pointer to variable name.

-  @param[in, out] VendorGuid         Variable Vendor Guid.

-

-  @retval EFI_INVALID_PARAMETER      Invalid parameter.

-  @retval EFI_SUCCESS                Find the specified variable.

-  @retval EFI_NOT_FOUND              Not found.

-  @retval EFI_BUFFER_TO_SMALL        DataSize is too small for the result.

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceGetNextVariableName (

-  IN OUT  UINTN                             *VariableNameSize,

-  IN OUT  CHAR16                            *VariableName,

-  IN OUT  EFI_GUID                          *VendorGuid

-  )

-{

-  EFI_STATUS                                      Status;

-  UINTN                                           PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME *SmmGetNextVariableName;

-  UINTN                                           OutVariableNameSize;

-  UINTN                                           InVariableNameSize;

-

-  if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  OutVariableNameSize   = *VariableNameSize;

-  InVariableNameSize    = StrSize (VariableName);

-  SmmGetNextVariableName = NULL;

-

-  //

-  // If input string exceeds SMM payload limit. Return failure

-  //

-  if (InVariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

-  //

-  if (OutVariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name)) {

-    //

-    // If output buffer exceed SMM payload limit. Trim output buffer to SMM payload size

-    //

-    OutVariableNameSize = mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name);

-  }

-  //

-  // Payload should be Guid + NameSize + MAX of Input & Output buffer

-  //

-  PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name) + MAX (OutVariableNameSize, InVariableNameSize);

-

-  Status = InitCommunicateBuffer ((VOID **)&SmmGetNextVariableName, PayloadSize, SMM_VARIABLE_FUNCTION_GET_NEXT_VARIABLE_NAME);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (SmmGetNextVariableName != NULL);

-

-  //

-  // SMM comm buffer->NameSize is buffer size for return string

-  //

-  SmmGetNextVariableName->NameSize = OutVariableNameSize;

-

-  CopyGuid (&SmmGetNextVariableName->Guid, VendorGuid);

-  //

-  // Copy whole string

-  //

-  CopyMem (SmmGetNextVariableName->Name, VariableName, InVariableNameSize);

-  if (OutVariableNameSize > InVariableNameSize) {

-    ZeroMem ((UINT8 *) SmmGetNextVariableName->Name + InVariableNameSize, OutVariableNameSize - InVariableNameSize);

-  }

-

-  //

-  // Send data to SMM

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-

-  //

-  // Get data from SMM.

-  //

-  if (Status == EFI_SUCCESS || Status == EFI_BUFFER_TOO_SMALL) {

-    //

-    // SMM CommBuffer NameSize can be a trimed value

-    // Only update VariableNameSize when needed

-    //

-    *VariableNameSize = SmmGetNextVariableName->NameSize;

-  }

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  CopyGuid (VendorGuid, &SmmGetNextVariableName->Guid);

-  CopyMem (VariableName, SmmGetNextVariableName->Name, SmmGetNextVariableName->NameSize);

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-/**

-  This code sets variable in storage blocks (Volatile or Non-Volatile).

-

-  Caution: This function may receive untrusted input.

-  The data size and data are external input, so this function will validate it carefully to avoid buffer overflow.

-

-  @param[in] VariableName                 Name of Variable to be found.

-  @param[in] VendorGuid                   Variable vendor GUID.

-  @param[in] Attributes                   Attribute value of the variable found

-  @param[in] DataSize                     Size of Data found. If size is less than the

-                                          data, this value contains the required size.

-  @param[in] Data                         Data pointer.

-

-  @retval EFI_INVALID_PARAMETER           Invalid parameter.

-  @retval EFI_SUCCESS                     Set successfully.

-  @retval EFI_OUT_OF_RESOURCES            Resource not enough to set variable.

-  @retval EFI_NOT_FOUND                   Not found.

-  @retval EFI_WRITE_PROTECTED             Variable is read-only.

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceSetVariable (

-  IN CHAR16                                 *VariableName,

-  IN EFI_GUID                               *VendorGuid,

-  IN UINT32                                 Attributes,

-  IN UINTN                                  DataSize,

-  IN VOID                                   *Data

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE  *SmmVariableHeader;

-  UINTN                                     VariableNameSize;

-

-  //

-  // Check input parameters.

-  //

-  if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if (DataSize != 0 && Data == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  VariableNameSize      = StrSize (VariableName);

-  SmmVariableHeader     = NULL;

-

-  //

-  // If VariableName or DataSize exceeds SMM payload limit. Return failure

-  //

-  if ((VariableNameSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name)) ||

-      (DataSize > mVariableBufferPayloadSize - OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) - VariableNameSize)){

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

-  //

-  PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + VariableNameSize + DataSize;

-  Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_SET_VARIABLE);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (SmmVariableHeader != NULL);

-

-  CopyGuid ((EFI_GUID *) &SmmVariableHeader->Guid, VendorGuid);

-  SmmVariableHeader->DataSize   = DataSize;

-  SmmVariableHeader->NameSize   = VariableNameSize;

-  SmmVariableHeader->Attributes = Attributes;

-  CopyMem (SmmVariableHeader->Name, VariableName, SmmVariableHeader->NameSize);

-  CopyMem ((UINT8 *) SmmVariableHeader->Name + SmmVariableHeader->NameSize, Data, DataSize);

-

-  //

-  // Send data to SMM.

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-

-  if (!EfiAtRuntime ()) {

-    if (!EFI_ERROR (Status)) {

-      SecureBootHook (

-        VariableName,

-        VendorGuid

-        );

-    }

-  }

-  return Status;

-}

-

-

-/**

-  This code returns information about the EFI variables.

-

-  @param[in]  Attributes                   Attributes bitmask to specify the type of variables

-                                           on which to return information.

-  @param[out] MaximumVariableStorageSize   Pointer to the maximum size of the storage space available

-                                           for the EFI variables associated with the attributes specified.

-  @param[out] RemainingVariableStorageSize Pointer to the remaining size of the storage space available

-                                           for EFI variables associated with the attributes specified.

-  @param[out] MaximumVariableSize          Pointer to the maximum size of an individual EFI variables

-                                           associated with the attributes specified.

-

-  @retval EFI_INVALID_PARAMETER            An invalid combination of attribute bits was supplied.

-  @retval EFI_SUCCESS                      Query successfully.

-  @retval EFI_UNSUPPORTED                  The attribute is not supported on this platform.

-

-**/

-EFI_STATUS

-EFIAPI

-RuntimeServiceQueryVariableInfo (

-  IN  UINT32                                Attributes,

-  OUT UINT64                                *MaximumVariableStorageSize,

-  OUT UINT64                                *RemainingVariableStorageSize,

-  OUT UINT64                                *MaximumVariableSize

-  )

-{

-  EFI_STATUS                                Status;

-  UINTN                                     PayloadSize;

-  SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO *SmmQueryVariableInfo;

-

-  SmmQueryVariableInfo = NULL;

-

-  if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize;

-  //

-  PayloadSize = sizeof (SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO);

-  Status = InitCommunicateBuffer ((VOID **)&SmmQueryVariableInfo, PayloadSize, SMM_VARIABLE_FUNCTION_QUERY_VARIABLE_INFO);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-  ASSERT (SmmQueryVariableInfo != NULL);

-

-  SmmQueryVariableInfo->Attributes  = Attributes;

-

-  //

-  // Send data to SMM.

-  //

-  Status = SendCommunicateBuffer (PayloadSize);

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  //

-  // Get data from SMM.

-  //

-  *MaximumVariableSize          = SmmQueryVariableInfo->MaximumVariableSize;

-  *MaximumVariableStorageSize   = SmmQueryVariableInfo->MaximumVariableStorageSize;

-  *RemainingVariableStorageSize = SmmQueryVariableInfo->RemainingVariableStorageSize;

-

-Done:

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-

-/**

-  Exit Boot Services Event notification handler.

-

-  Notify SMM variable driver about the event.

-

-  @param[in]  Event     Event whose notification function is being invoked.

-  @param[in]  Context   Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-OnExitBootServices (

-  IN      EFI_EVENT                         Event,

-  IN      VOID                              *Context

-  )

-{

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE.

-  //

-  InitCommunicateBuffer (NULL, 0, SMM_VARIABLE_FUNCTION_EXIT_BOOT_SERVICE);

-

-  //

-  // Send data to SMM.

-  //

-  SendCommunicateBuffer (0);

-}

-

-

-/**

-  On Ready To Boot Services Event notification handler.

-

-  Notify SMM variable driver about the event.

-

-  @param[in]  Event     Event whose notification function is being invoked

-  @param[in]  Context   Pointer to the notification function's context

-

-**/

-VOID

-EFIAPI

-OnReadyToBoot (

-  IN      EFI_EVENT                         Event,

-  IN      VOID                              *Context

-  )

-{

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE.

-  //

-  InitCommunicateBuffer (NULL, 0, SMM_VARIABLE_FUNCTION_READY_TO_BOOT);

-

-  //

-  // Send data to SMM.

-  //

-  SendCommunicateBuffer (0);

-

-  gBS->CloseEvent (Event);

-}

-

-

-/**

-  Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.

-

-  This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-  It convers pointer to new virtual address.

-

-  @param[in]  Event        Event whose notification function is being invoked.

-  @param[in]  Context      Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-VariableAddressChangeEvent (

-  IN EFI_EVENT                              Event,

-  IN VOID                                   *Context

-  )

-{

-  EfiConvertPointer (0x0, (VOID **) &mVariableBuffer);

-  EfiConvertPointer (0x0, (VOID **) &mSmmCommunication);

-}

-

-/**

-  This code gets variable payload size.

-

-  @param[out] VariablePayloadSize   Output pointer to variable payload size.

-

-  @retval EFI_SUCCESS               Get successfully.

-  @retval Others                    Get unsuccessfully.

-

-**/

-EFI_STATUS

-EFIAPI

-GetVariablePayloadSize (

-  OUT UINTN                         *VariablePayloadSize

-  )

-{

-  EFI_STATUS                                Status;

-  SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE *SmmGetPayloadSize;

-  EFI_SMM_COMMUNICATE_HEADER                *SmmCommunicateHeader;

-  SMM_VARIABLE_COMMUNICATE_HEADER           *SmmVariableFunctionHeader;

-  UINTN                                     CommSize;

-  UINT8                                     *CommBuffer;

-

-  SmmGetPayloadSize = NULL;

-  CommBuffer = NULL;

-

-  if(VariablePayloadSize == NULL) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

-

-  //

-  // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE);

-  //

-  CommSize = SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE);

-  CommBuffer = AllocateZeroPool (CommSize);

-  if (CommBuffer == NULL) {

-    Status = EFI_OUT_OF_RESOURCES;

-    goto Done;

-  }

-

-  SmmCommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *) CommBuffer;

-  CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmVariableProtocolGuid);

-  SmmCommunicateHeader->MessageLength = SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE);

-

-  SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) SmmCommunicateHeader->Data;

-  SmmVariableFunctionHeader->Function = SMM_VARIABLE_FUNCTION_GET_PAYLOAD_SIZE;

-  SmmGetPayloadSize = (SMM_VARIABLE_COMMUNICATE_GET_PAYLOAD_SIZE *) SmmVariableFunctionHeader->Data;

-

-  //

-  // Send data to SMM.

-  //

-  Status = mSmmCommunication->Communicate (mSmmCommunication, CommBuffer, &CommSize);

-  ASSERT_EFI_ERROR (Status);

-

-  Status = SmmVariableFunctionHeader->ReturnStatus;

-  if (EFI_ERROR (Status)) {

-    goto Done;

-  }

-

-  //

-  // Get data from SMM.

-  //

-  *VariablePayloadSize = SmmGetPayloadSize->VariablePayloadSize;

-

-Done:

-  if (CommBuffer != NULL) {

-    FreePool (CommBuffer);

-  }

-  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

-  return Status;

-}

-

-/**

-  Initialize variable service and install Variable Architectural protocol.

-

-  @param[in] Event    Event whose notification function is being invoked.

-  @param[in] Context  Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-SmmVariableReady (

-  IN  EFI_EVENT                             Event,

-  IN  VOID                                  *Context

-  )

-{

-  EFI_STATUS                                Status;

-

-  Status = gBS->LocateProtocol (&gEfiSmmVariableProtocolGuid, NULL, (VOID **)&mSmmVariable);

-  if (EFI_ERROR (Status)) {

-    return;

-  }

-

-  Status = gBS->LocateProtocol (&gEfiSmmCommunicationProtocolGuid, NULL, (VOID **) &mSmmCommunication);

-  ASSERT_EFI_ERROR (Status);

-

-  //

-  // Allocate memory for variable communicate buffer.

-  //

-  Status = GetVariablePayloadSize (&mVariableBufferPayloadSize);

-  ASSERT_EFI_ERROR (Status);

-  mVariableBufferSize  = SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + mVariableBufferPayloadSize;

-  mVariableBuffer      = AllocateRuntimePool (mVariableBufferSize);

-  ASSERT (mVariableBuffer != NULL);

-

-  //

-  // Save the buffer physical address used for SMM conmunication.

-  //

-  mVariableBufferPhysical = mVariableBuffer;

-

-  gRT->GetVariable         = RuntimeServiceGetVariable;

-  gRT->GetNextVariableName = RuntimeServiceGetNextVariableName;

-  gRT->SetVariable         = RuntimeServiceSetVariable;

-  gRT->QueryVariableInfo   = RuntimeServiceQueryVariableInfo;

-

-  //

-  // Install the Variable Architectural Protocol on a new handle.

-  //

-  Status = gBS->InstallProtocolInterface (

-                  &mHandle,

-                  &gEfiVariableArchProtocolGuid,

-                  EFI_NATIVE_INTERFACE,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  mVariableLock.RequestToLock = VariableLockRequestToLock;

-  Status = gBS->InstallMultipleProtocolInterfaces (

-                  &mHandle,

-                  &gEdkiiVariableLockProtocolGuid,

-                  &mVariableLock,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  mVarCheck.RegisterSetVariableCheckHandler = VarCheckRegisterSetVariableCheckHandler;

-  mVarCheck.VariablePropertySet = VarCheckVariablePropertySet;

-  mVarCheck.VariablePropertyGet = VarCheckVariablePropertyGet;

-  Status = gBS->InstallMultipleProtocolInterfaces (

-                  &mHandle,

-                  &gEdkiiVarCheckProtocolGuid,

-                  &mVarCheck,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  gBS->CloseEvent (Event);

-}

-

-

-/**

-  SMM Non-Volatile variable write service is ready notify event handler.

-

-  @param[in] Event    Event whose notification function is being invoked.

-  @param[in] Context  Pointer to the notification function's context.

-

-**/

-VOID

-EFIAPI

-SmmVariableWriteReady (

-  IN  EFI_EVENT                             Event,

-  IN  VOID                                  *Context

-  )

-{

-  EFI_STATUS                                Status;

-  VOID                                      *ProtocolOps;

-

-  //

-  // Check whether the protocol is installed or not.

-  //

-  Status = gBS->LocateProtocol (&gSmmVariableWriteGuid, NULL, (VOID **) &ProtocolOps);

-  if (EFI_ERROR (Status)) {

-    return;

-  }

-

-  //

-  // Some Secure Boot Policy Var (SecureBoot, etc) updates following other

-  // Secure Boot Policy Variable change.  Record their initial value.

-  //

-  RecordSecureBootPolicyVarData();

-

-  Status = gBS->InstallProtocolInterface (

-                  &mHandle,

-                  &gEfiVariableWriteArchProtocolGuid,

-                  EFI_NATIVE_INTERFACE,

-                  NULL

-                  );

-  ASSERT_EFI_ERROR (Status);

-

-  gBS->CloseEvent (Event);

-}

-

-

-/**

-  Variable Driver main entry point. The Variable driver places the 4 EFI

-  runtime services in the EFI System Table and installs arch protocols

-  for variable read and write services being available. It also registers

-  a notification function for an EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.

-

-  @param[in] ImageHandle    The firmware allocated handle for the EFI image.

-  @param[in] SystemTable    A pointer to the EFI System Table.

-

-  @retval EFI_SUCCESS       Variable service successfully initialized.

-

-**/

-EFI_STATUS

-EFIAPI

-VariableSmmRuntimeInitialize (

-  IN EFI_HANDLE                             ImageHandle,

-  IN EFI_SYSTEM_TABLE                       *SystemTable

-  )

-{

-  VOID                                      *SmmVariableRegistration;

-  VOID                                      *SmmVariableWriteRegistration;

-  EFI_EVENT                                 OnReadyToBootEvent;

-  EFI_EVENT                                 ExitBootServiceEvent;

-  EFI_EVENT                                 LegacyBootEvent;

-

-  EfiInitializeLock (&mVariableServicesLock, TPL_NOTIFY);

-

-  //

-  // Smm variable service is ready

-  //

-  EfiCreateProtocolNotifyEvent (

-    &gEfiSmmVariableProtocolGuid,

-    TPL_CALLBACK,

-    SmmVariableReady,

-    NULL,

-    &SmmVariableRegistration

-    );

-

-  //

-  // Smm Non-Volatile variable write service is ready

-  //

-  EfiCreateProtocolNotifyEvent (

-    &gSmmVariableWriteGuid,

-    TPL_CALLBACK,

-    SmmVariableWriteReady,

-    NULL,

-    &SmmVariableWriteRegistration

-    );

-

-  //

-  // Register the event to reclaim variable for OS usage.

-  //

-  EfiCreateEventReadyToBootEx (

-    TPL_NOTIFY,

-    OnReadyToBoot,

-    NULL,

-    &OnReadyToBootEvent

-    );

-

-  //

-  // Register the event to inform SMM variable that it is at runtime.

-  //

-  gBS->CreateEventEx (

-         EVT_NOTIFY_SIGNAL,

-         TPL_NOTIFY,

-         OnExitBootServices,

-         NULL,

-         &gEfiEventExitBootServicesGuid,

-         &ExitBootServiceEvent

-         );

-

-  //

-  // Register the event to inform SMM variable that it is at runtime for legacy boot.

-  // Reuse OnExitBootServices() here.

-  //

-  EfiCreateEventLegacyBootEx(

-    TPL_NOTIFY,

-    OnExitBootServices,

-    NULL,

-    &LegacyBootEvent

-    );

-

-  //

-  // Register the event to convert the pointer for runtime.

-  //

-  gBS->CreateEventEx (

-         EVT_NOTIFY_SIGNAL,

-         TPL_NOTIFY,

-         VariableAddressChangeEvent,

-         NULL,

-         &gEfiEventVirtualAddressChangeGuid,

-         &mVirtualAddressChangeEvent

-         );

-

-  return EFI_SUCCESS;

-}

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.inf b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.inf
deleted file mode 100644
index 9975f5ae1d..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.inf
+++ /dev/null
@@ -1,93 +0,0 @@
-## @file

-#  Runtime DXE part corresponding to SMM authenticated variable module.

-#

-#  This module installs variable arch protocol and variable write arch protocol to provide

-#  variable service. This module need work together with SMM authenticated variable module.

-#

-#  Caution: This module requires additional review when modified.

-#  This driver will have external input - variable data.

-#  This external input must be validated carefully to avoid security issues such as

-#  buffer overflow or integer overflow.

-#    The whole SMM authentication variable design relies on the integrity of flash part and SMM.

-#  which is assumed to be protected by platform.  All variable code and metadata in flash/SMM Memory

-#  may not be modified without authorization. If platform fails to protect these resources,

-#  the authentication service provided in this driver will be broken, and the behavior is undefined.

-#

-# Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>

-# This program and the accompanying materials

-# are licensed and made available under the terms and conditions of the BSD License

-# which accompanies this distribution. The full text of the license may be found at

-# http://opensource.org/licenses/bsd-license.php

-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-#

-##

-

-[Defines]

-  INF_VERSION                    = 0x00010005

-  BASE_NAME                      = VariableSmmRuntimeDxe

-  MODULE_UNI_FILE                = VariableSmmRuntimeDxe.uni

-  FILE_GUID                      = 9F7DCADE-11EA-448a-A46F-76E003657DD1

-  MODULE_TYPE                    = DXE_RUNTIME_DRIVER

-  VERSION_STRING                 = 1.0

-  ENTRY_POINT                    = VariableSmmRuntimeInitialize

-

-#

-# The following information is for reference only and not required by the build tools.

-#

-#  VALID_ARCHITECTURES           = IA32 X64

-#

-#  VIRTUAL_ADDRESS_MAP_CALLBACK  =  VariableAddressChangeEvent

-#

-

-[Sources]

-  VariableSmmRuntimeDxe.c

-  Measurement.c

-

-[Packages]

-  MdePkg/MdePkg.dec

-  MdeModulePkg/MdeModulePkg.dec

-

-[LibraryClasses]

-  MemoryAllocationLib

-  BaseLib

-  UefiBootServicesTableLib

-  DebugLib

-  UefiRuntimeLib

-  DxeServicesTableLib

-  UefiDriverEntryPoint

-  TpmMeasurementLib

-

-[Protocols]

-  gEfiVariableWriteArchProtocolGuid             ## PRODUCES

-  gEfiVariableArchProtocolGuid                  ## PRODUCES

-  gEfiSmmCommunicationProtocolGuid              ## CONSUMES

-  ## CONSUMES

-  ## NOTIFY

-  ## UNDEFINED # Used to do smm communication

-  gEfiSmmVariableProtocolGuid

-  gEdkiiVariableLockProtocolGuid                ## PRODUCES

-  gEdkiiVarCheckProtocolGuid                    ## PRODUCES

-

-[Guids]

-  gEfiEventVirtualAddressChangeGuid             ## CONSUMES ## Event

-  gEfiEventExitBootServicesGuid                 ## CONSUMES ## Event

-  ## CONSUMES ## GUID # Locate protocol

-  ## CONSUMES ## GUID # Protocol notify

-  gSmmVariableWriteGuid

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"PK"

-  ## SOMETIMES_CONSUMES   ## Variable:L"KEK"

-  ## SOMETIMES_CONSUMES   ## Variable:L"SecureBoot"

-  gEfiGlobalVariableGuid

-

-  ## SOMETIMES_CONSUMES   ## Variable:L"db"

-  ## SOMETIMES_CONSUMES   ## Variable:L"dbx"

-  ## SOMETIMES_CONSUMES   ## Variable:L"dbt"

-  gEfiImageSecurityDatabaseGuid

-

-[Depex]

-  gEfiSmmCommunicationProtocolGuid

-

-[UserExtensions.TianoCore."ExtraFiles"]

-  VariableSmmRuntimeDxeExtra.uni

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.uni b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.uni
deleted file mode 100644
index b5a6bd1eec..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.uni
+++ /dev/null
@@ -1,28 +0,0 @@
-// /** @file

-// This module is the Runtime DXE part correspond to SMM variable module.

-//

-// It installs variable arch protocol and variable write arch protocol to provide

-// four EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo

-// and works with SMM variable module together.

-//

-// Caution: This module requires additional review when modified.

-// This driver will have external input - variable data.

-// This external input must be validated carefully to avoid security issues such as

-// buffer overflow or integer overflow.

-//

-// Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-

-#string STR_MODULE_ABSTRACT             #language en-US "The Runtime DXE part corresponding to the SMM variable module"

-

-#string STR_MODULE_DESCRIPTION          #language en-US "It installs variable arch protocol and variable write arch protocol to provide four EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName and QueryVariableInfo and works with SMM variable module together."

-

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxeExtra.uni b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxeExtra.uni
deleted file mode 100644
index 674e201e88..0000000000
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxeExtra.uni
+++ /dev/null
@@ -1,19 +0,0 @@
-// /** @file

-// VariableSmmRuntimeDxe Localized Strings and Content

-//

-// Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>

-//

-// This program and the accompanying materials

-// are licensed and made available under the terms and conditions of the BSD License

-// which accompanies this distribution. The full text of the license may be found at

-// http://opensource.org/licenses/bsd-license.php

-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

-//

-// **/

-

-#string STR_PROPERTIES_MODULE_NAME 

-#language en-US 

-"VariableSmmRuntimeDxe module"

-

-