MdeModulePkg/Universal/Variable/RuntimeDxe/VariableParsing.c - third_party/edk2 - Git at Google

 /** @file
   Functions in this module are associated with variable parsing operations and
   are intended to be usable across variable driver source files.

 Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
 SPDX-License-Identifier: BSD-2-Clause-Patent

 **/

 #include "VariableParsing.h"

 /**

   This code checks if variable header is valid or not.

   @param[in] Variable           Pointer to the Variable Header.
   @param[in] 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 code gets the current status of Variable Store.

   @param[in] 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.

   @param[in]  AuthFormat    TRUE indicates authenticated variables are used.
                             FALSE indicates authenticated variables are not used.

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

 **/
 UINTN
 GetVariableHeaderSize (
   IN  BOOLEAN  AuthFormat
   )
 {
   UINTN  Value;

   if (AuthFormat) {
     Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);
   } else {
     Value = sizeof (VARIABLE_HEADER);
   }

   return Value;
 }

 /**

   This code gets the size of name of variable.

   @param[in]  Variable      Pointer to the variable header.
   @param[in]  AuthFormat    TRUE indicates authenticated variables are used.
                             FALSE indicates authenticated variables are not used.

   @return UINTN          Size of variable in bytes.

 **/
 UINTN
 NameSizeOfVariable (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   AUTHENTICATED_VARIABLE_HEADER  *AuthVariable;

   AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
   if (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.
   @param[in]  AuthFormat    TRUE indicates authenticated variables are used.
                             FALSE indicates authenticated variables are not used.

 **/
 VOID
 SetNameSizeOfVariable (
   IN VARIABLE_HEADER  *Variable,
   IN UINTN            NameSize,
   IN BOOLEAN          AuthFormat
   )
 {
   AUTHENTICATED_VARIABLE_HEADER  *AuthVariable;

   AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
   if (AuthFormat) {
     AuthVariable->NameSize = (UINT32)NameSize;
   } else {
     Variable->NameSize = (UINT32)NameSize;
   }
 }

 /**

   This code gets the size of variable data.

   @param[in]  Variable      Pointer to the Variable Header.
   @param[in]  AuthFormat    TRUE indicates authenticated variables are used.
                             FALSE indicates authenticated variables are not used.

   @return Size of variable in bytes.

 **/
 UINTN
 DataSizeOfVariable (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   AUTHENTICATED_VARIABLE_HEADER  *AuthVariable;

   AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
   if (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.
   @param[in] AuthFormat TRUE indicates authenticated variables are used.
                         FALSE indicates authenticated variables are not used.

 **/
 VOID
 SetDataSizeOfVariable (
   IN  VARIABLE_HEADER  *Variable,
   IN  UINTN            DataSize,
   IN  BOOLEAN          AuthFormat
   )
 {
   AUTHENTICATED_VARIABLE_HEADER  *AuthVariable;

   AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
   if (AuthFormat) {
     AuthVariable->DataSize = (UINT32)DataSize;
   } else {
     Variable->DataSize = (UINT32)DataSize;
   }
 }

 /**

   This code gets the pointer to the variable name.

   @param[in] Variable     Pointer to the Variable Header.
   @param[in] AuthFormat   TRUE indicates authenticated variables are used.
                           FALSE indicates authenticated variables are not used.

   @return Pointer to Variable Name which is Unicode encoding.

 **/
 CHAR16 *
 GetVariableNamePtr (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   return (CHAR16 *)((UINTN)Variable + GetVariableHeaderSize (AuthFormat));
 }

 /**
   This code gets the pointer to the variable guid.

   @param[in] Variable     Pointer to the Variable Header.
   @param[in] AuthFormat   TRUE indicates authenticated variables are used.
                           FALSE indicates authenticated variables are not used.

   @return A EFI_GUID* pointer to Vendor Guid.

 **/
 EFI_GUID *
 GetVendorGuidPtr (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   AUTHENTICATED_VARIABLE_HEADER  *AuthVariable;

   AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
   if (AuthFormat) {
     return &AuthVariable->VendorGuid;
   } else {
     return &Variable->VendorGuid;
   }
 }

 /**

   This code gets the pointer to the variable data.

   @param[in] Variable     Pointer to the Variable Header.
   @param[in] AuthFormat   TRUE indicates authenticated variables are used.
                           FALSE indicates authenticated variables are not used.

   @return Pointer to Variable Data.

 **/
 UINT8 *
 GetVariableDataPtr (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   UINTN  Value;

   //
   // Be careful about pad size for alignment.
   //
   Value  =  (UINTN)GetVariableNamePtr (Variable, AuthFormat);
   Value += NameSizeOfVariable (Variable, AuthFormat);
   Value += GET_PAD_SIZE (NameSizeOfVariable (Variable, AuthFormat));

   return (UINT8 *)Value;
 }

 /**
   This code gets the variable data offset related to variable header.

   @param[in] Variable     Pointer to the Variable Header.
   @param[in] AuthFormat   TRUE indicates authenticated variables are used.
                           FALSE indicates authenticated variables are not used.

   @return Variable Data offset.

 **/
 UINTN
 GetVariableDataOffset (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   UINTN  Value;

   //
   // Be careful about pad size for alignment
   //
   Value  = GetVariableHeaderSize (AuthFormat);
   Value += NameSizeOfVariable (Variable, AuthFormat);
   Value += GET_PAD_SIZE (NameSizeOfVariable (Variable, AuthFormat));

   return Value;
 }

 /**

   This code gets the pointer to the next variable header.

   @param[in] Variable     Pointer to the Variable Header.
   @param[in] AuthFormat   TRUE indicates authenticated variables are used.
                           FALSE indicates authenticated variables are not used.

   @return Pointer to next variable header.

 **/
 VARIABLE_HEADER *
 GetNextVariablePtr (
   IN  VARIABLE_HEADER  *Variable,
   IN  BOOLEAN          AuthFormat
   )
 {
   UINTN  Value;

   Value  =  (UINTN)GetVariableDataPtr (Variable, AuthFormat);
   Value += DataSizeOfVariable (Variable, AuthFormat);
   Value += GET_PAD_SIZE (DataSizeOfVariable (Variable, AuthFormat));

   //
   // 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[in] VarStoreHeader  Pointer to the Variable Store Header.

   @return Pointer to the first variable header.

 **/
 VARIABLE_HEADER *
 GetStartPointer (
   IN VARIABLE_STORE_HEADER  *VarStoreHeader
   )
 {
   //
   // The start 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[in] 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);
 }

 /**
   Compare two EFI_TIME data.


   @param[in] FirstTime       A pointer to the first EFI_TIME data.
   @param[in] 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);
 }

 /**
   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.
   @param[in]       AuthFormat          TRUE indicates authenticated variables are used.
                                        FALSE indicates authenticated variables are not used.

   @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,
   IN     BOOLEAN                 AuthFormat
   )
 {
   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, AuthFormat)
         )
   {
     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, AuthFormat))) {
             Point = (VOID *)GetVariableNamePtr (PtrTrack->CurrPtr, AuthFormat);

             ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr, AuthFormat) != 0);
             if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr, AuthFormat)) == 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;
 }

 /**
   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[in]  VariableStoreList A list of variable stores that should be used to get the next variable.
                                 The maximum number of entries is the max value of VARIABLE_STORE_TYPE.
   @param[out] VariablePtr       Pointer to variable header address.
   @param[in]  AuthFormat        TRUE indicates authenticated variables are used.
                                 FALSE indicates authenticated variables are not used.

   @retval EFI_SUCCESS           The function completed successfully.
   @retval EFI_NOT_FOUND         The next variable was not found.
   @retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while VendorGuid is NULL.
   @retval EFI_INVALID_PARAMETER The input values of VariableName and VendorGuid are not a name and
                                 GUID of an existing variable.

 **/
 EFI_STATUS
 EFIAPI
 VariableServiceGetNextVariableInternal (
   IN  CHAR16                 *VariableName,
   IN  EFI_GUID               *VendorGuid,
   IN  VARIABLE_STORE_HEADER  **VariableStoreList,
   OUT VARIABLE_HEADER        **VariablePtr,
   IN  BOOLEAN                AuthFormat
   )
 {
   EFI_STATUS              Status;
   VARIABLE_STORE_TYPE     StoreType;
   VARIABLE_POINTER_TRACK  Variable;
   VARIABLE_POINTER_TRACK  VariableInHob;
   VARIABLE_POINTER_TRACK  VariablePtrTrack;

   Status = EFI_NOT_FOUND;

   if (VariableStoreList == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   ZeroMem (&Variable, sizeof (Variable));

   // Check if the variable exists in the given variable store list
   for (StoreType = (VARIABLE_STORE_TYPE)0; StoreType < VariableStoreTypeMax; StoreType++) {
     if (VariableStoreList[StoreType] == NULL) {
       continue;
     }

     Variable.StartPtr = GetStartPointer (VariableStoreList[StoreType]);
     Variable.EndPtr   = GetEndPointer (VariableStoreList[StoreType]);
     Variable.Volatile = (BOOLEAN)(StoreType == VariableStoreTypeVolatile);

     Status = FindVariableEx (VariableName, VendorGuid, FALSE, &Variable, AuthFormat);
     if (!EFI_ERROR (Status)) {
       break;
     }
   }

   if ((Variable.CurrPtr == NULL) || EFI_ERROR (Status)) {
     //
     // For VariableName is an empty string, FindVariableEx() will try to find and return
     // the first qualified variable, and if FindVariableEx() returns error (EFI_NOT_FOUND)
     // as no any variable is found, still go to return the error (EFI_NOT_FOUND).
     //
     if (VariableName[0] != 0) {
       //
       // For VariableName is not an empty string, and FindVariableEx() returns error as
       // VariableName and VendorGuid are not a name and GUID of an existing variable,
       // there is no way to get next variable, follow spec to return EFI_INVALID_PARAMETER.
       //
       Status = EFI_INVALID_PARAMETER;
     }

     goto Done;
   }

   if (VariableName[0] != 0) {
     //
     // If variable name is not empty, get next variable.
     //
     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
   }

   while (TRUE) {
     //
     // Switch to the next variable store if needed
     //
     while (!IsValidVariableHeader (Variable.CurrPtr, Variable.EndPtr)) {
       //
       // Find current storage index
       //
       for (StoreType = (VARIABLE_STORE_TYPE)0; StoreType < VariableStoreTypeMax; StoreType++) {
         if ((VariableStoreList[StoreType] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreList[StoreType]))) {
           break;
         }
       }

       ASSERT (StoreType < VariableStoreTypeMax);
       //
       // Switch to next storage
       //
       for (StoreType++; StoreType < VariableStoreTypeMax; StoreType++) {
         if (VariableStoreList[StoreType] != NULL) {
           break;
         }
       }

       //
       // Capture the case that
       // 1. current storage is the last one, or
       // 2. no further storage
       //
       if (StoreType == VariableStoreTypeMax) {
         Status = EFI_NOT_FOUND;
         goto Done;
       }

       Variable.StartPtr = GetStartPointer (VariableStoreList[StoreType]);
       Variable.EndPtr   = GetEndPointer (VariableStoreList[StoreType]);
       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, AuthFormat),
                                         GetVendorGuidPtr (Variable.CurrPtr, AuthFormat),
                                         FALSE,
                                         &VariablePtrTrack,
                                         AuthFormat
                                         );
           if (!EFI_ERROR (Status) && (VariablePtrTrack.CurrPtr->State == VAR_ADDED)) {
             Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
             continue;
           }
         }

         //
         // Don't return NV variable when HOB overrides it
         //
         if ((VariableStoreList[VariableStoreTypeHob] != NULL) && (VariableStoreList[VariableStoreTypeNv] != NULL) &&
             (Variable.StartPtr == GetStartPointer (VariableStoreList[VariableStoreTypeNv]))
             )
         {
           VariableInHob.StartPtr = GetStartPointer (VariableStoreList[VariableStoreTypeHob]);
           VariableInHob.EndPtr   = GetEndPointer (VariableStoreList[VariableStoreTypeHob]);
           Status                 = FindVariableEx (
                                      GetVariableNamePtr (Variable.CurrPtr, AuthFormat),
                                      GetVendorGuidPtr (Variable.CurrPtr, AuthFormat),
                                      FALSE,
                                      &VariableInHob,
                                      AuthFormat
                                      );
           if (!EFI_ERROR (Status)) {
             Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
             continue;
           }
         }

         *VariablePtr = Variable.CurrPtr;
         Status       = EFI_SUCCESS;
         goto Done;
       }
     }

     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
   }

 Done:
   return Status;
 }

 /**
   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.
   @param[in,out]  VariableInfo   Pointer to a pointer of VARIABLE_INFO_ENTRY structures.

 **/
 VOID
 UpdateVariableInfo (
   IN  CHAR16                  *VariableName,
   IN  EFI_GUID                *VendorGuid,
   IN  BOOLEAN                 Volatile,
   IN  BOOLEAN                 Read,
   IN  BOOLEAN                 Write,
   IN  BOOLEAN                 Delete,
   IN  BOOLEAN                 Cache,
   IN OUT VARIABLE_INFO_ENTRY  **VariableInfo
   )
 {
   VARIABLE_INFO_ENTRY  *Entry;

   if (FeaturePcdGet (PcdVariableCollectStatistics)) {
     if ((VariableName == NULL) || (VendorGuid == NULL) || (VariableInfo == NULL)) {
       return;
     }

     if (AtRuntime ()) {
       // Don't collect statistics at runtime.
       return;
     }

     if (*VariableInfo == NULL) {
       //
       // On the first call allocate a entry and place a pointer to it in
       // the EFI System Table.
       //
       *VariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
       ASSERT (*VariableInfo != NULL);

       CopyGuid (&(*VariableInfo)->VendorGuid, VendorGuid);
       (*VariableInfo)->Name = AllocateZeroPool (StrSize (VariableName));
       ASSERT ((*VariableInfo)->Name != NULL);
       StrCpyS ((*VariableInfo)->Name, StrSize (VariableName)/sizeof (CHAR16), VariableName);
       (*VariableInfo)->Volatile = Volatile;
     }

     for (Entry = (*VariableInfo); 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;
       }
     }
   }
 }
	/** @file
	Functions in this module are associated with variable parsing operations and
	are intended to be usable across variable driver source files.

	Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
	SPDX-License-Identifier: BSD-2-Clause-Patent

	**/

	#include "VariableParsing.h"

	/**

	This code checks if variable header is valid or not.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] 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 code gets the current status of Variable Store.

	@param[in] 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.

	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

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

	**/
	UINTN
	GetVariableHeaderSize (
	IN BOOLEAN AuthFormat
	)
	{
	UINTN Value;

	if (AuthFormat) {
	Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);
	} else {
	Value = sizeof (VARIABLE_HEADER);
	}

	return Value;
	}

	/**

	This code gets the size of name of variable.

	@param[in] Variable Pointer to the variable header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return UINTN Size of variable in bytes.

	**/
	UINTN
	NameSizeOfVariable (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

	AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
	if (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.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	**/
	VOID
	SetNameSizeOfVariable (
	IN VARIABLE_HEADER *Variable,
	IN UINTN NameSize,
	IN BOOLEAN AuthFormat
	)
	{
	AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

	AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
	if (AuthFormat) {
	AuthVariable->NameSize = (UINT32)NameSize;
	} else {
	Variable->NameSize = (UINT32)NameSize;
	}
	}

	/**

	This code gets the size of variable data.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return Size of variable in bytes.

	**/
	UINTN
	DataSizeOfVariable (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

	AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
	if (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.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	**/
	VOID
	SetDataSizeOfVariable (
	IN VARIABLE_HEADER *Variable,
	IN UINTN DataSize,
	IN BOOLEAN AuthFormat
	)
	{
	AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

	AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
	if (AuthFormat) {
	AuthVariable->DataSize = (UINT32)DataSize;
	} else {
	Variable->DataSize = (UINT32)DataSize;
	}
	}

	/**

	This code gets the pointer to the variable name.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return Pointer to Variable Name which is Unicode encoding.

	**/
	CHAR16 *
	GetVariableNamePtr (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	return (CHAR16 *)((UINTN)Variable + GetVariableHeaderSize (AuthFormat));
	}

	/**
	This code gets the pointer to the variable guid.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return A EFI_GUID* pointer to Vendor Guid.

	**/
	EFI_GUID *
	GetVendorGuidPtr (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	AUTHENTICATED_VARIABLE_HEADER *AuthVariable;

	AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
	if (AuthFormat) {
	return &AuthVariable->VendorGuid;
	} else {
	return &Variable->VendorGuid;
	}
	}

	/**

	This code gets the pointer to the variable data.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return Pointer to Variable Data.

	**/
	UINT8 *
	GetVariableDataPtr (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	UINTN Value;

	//
	// Be careful about pad size for alignment.
	//
	Value = (UINTN)GetVariableNamePtr (Variable, AuthFormat);
	Value += NameSizeOfVariable (Variable, AuthFormat);
	Value += GET_PAD_SIZE (NameSizeOfVariable (Variable, AuthFormat));

	return (UINT8 *)Value;
	}

	/**
	This code gets the variable data offset related to variable header.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return Variable Data offset.

	**/
	UINTN
	GetVariableDataOffset (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	UINTN Value;

	//
	// Be careful about pad size for alignment
	//
	Value = GetVariableHeaderSize (AuthFormat);
	Value += NameSizeOfVariable (Variable, AuthFormat);
	Value += GET_PAD_SIZE (NameSizeOfVariable (Variable, AuthFormat));

	return Value;
	}

	/**

	This code gets the pointer to the next variable header.

	@param[in] Variable Pointer to the Variable Header.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@return Pointer to next variable header.

	**/
	VARIABLE_HEADER *
	GetNextVariablePtr (
	IN VARIABLE_HEADER *Variable,
	IN BOOLEAN AuthFormat
	)
	{
	UINTN Value;

	Value = (UINTN)GetVariableDataPtr (Variable, AuthFormat);
	Value += DataSizeOfVariable (Variable, AuthFormat);
	Value += GET_PAD_SIZE (DataSizeOfVariable (Variable, AuthFormat));

	//
	// 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[in] VarStoreHeader Pointer to the Variable Store Header.

	@return Pointer to the first variable header.

	**/
	VARIABLE_HEADER *
	GetStartPointer (
	IN VARIABLE_STORE_HEADER *VarStoreHeader
	)
	{
	//
	// The start 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[in] 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);
	}

	/**
	Compare two EFI_TIME data.


	@param[in] FirstTime A pointer to the first EFI_TIME data.
	@param[in] 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);
	}

	/**
	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.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@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,
	IN BOOLEAN AuthFormat
	)
	{
	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, AuthFormat)
	)
	{
	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, AuthFormat))) {
	Point = (VOID *)GetVariableNamePtr (PtrTrack->CurrPtr, AuthFormat);

	ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr, AuthFormat) != 0);
	if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr, AuthFormat)) == 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;
	}

	/**
	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[in] VariableStoreList A list of variable stores that should be used to get the next variable.
	The maximum number of entries is the max value of VARIABLE_STORE_TYPE.
	@param[out] VariablePtr Pointer to variable header address.
	@param[in] AuthFormat TRUE indicates authenticated variables are used.
	FALSE indicates authenticated variables are not used.

	@retval EFI_SUCCESS The function completed successfully.
	@retval EFI_NOT_FOUND The next variable was not found.
	@retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while VendorGuid is NULL.
	@retval EFI_INVALID_PARAMETER The input values of VariableName and VendorGuid are not a name and
	GUID of an existing variable.

	**/
	EFI_STATUS
	EFIAPI
	VariableServiceGetNextVariableInternal (
	IN CHAR16 *VariableName,
	IN EFI_GUID *VendorGuid,
	IN VARIABLE_STORE_HEADER **VariableStoreList,
	OUT VARIABLE_HEADER **VariablePtr,
	IN BOOLEAN AuthFormat
	)
	{
	EFI_STATUS Status;
	VARIABLE_STORE_TYPE StoreType;
	VARIABLE_POINTER_TRACK Variable;
	VARIABLE_POINTER_TRACK VariableInHob;
	VARIABLE_POINTER_TRACK VariablePtrTrack;

	Status = EFI_NOT_FOUND;

	if (VariableStoreList == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	ZeroMem (&Variable, sizeof (Variable));

	// Check if the variable exists in the given variable store list
	for (StoreType = (VARIABLE_STORE_TYPE)0; StoreType < VariableStoreTypeMax; StoreType++) {
	if (VariableStoreList[StoreType] == NULL) {
	continue;
	}

	Variable.StartPtr = GetStartPointer (VariableStoreList[StoreType]);
	Variable.EndPtr = GetEndPointer (VariableStoreList[StoreType]);
	Variable.Volatile = (BOOLEAN)(StoreType == VariableStoreTypeVolatile);

	Status = FindVariableEx (VariableName, VendorGuid, FALSE, &Variable, AuthFormat);
	if (!EFI_ERROR (Status)) {
	break;
	}
	}

	if ((Variable.CurrPtr == NULL) \|\| EFI_ERROR (Status)) {
	//
	// For VariableName is an empty string, FindVariableEx() will try to find and return
	// the first qualified variable, and if FindVariableEx() returns error (EFI_NOT_FOUND)
	// as no any variable is found, still go to return the error (EFI_NOT_FOUND).
	//
	if (VariableName[0] != 0) {
	//
	// For VariableName is not an empty string, and FindVariableEx() returns error as
	// VariableName and VendorGuid are not a name and GUID of an existing variable,
	// there is no way to get next variable, follow spec to return EFI_INVALID_PARAMETER.
	//
	Status = EFI_INVALID_PARAMETER;
	}

	goto Done;
	}

	if (VariableName[0] != 0) {
	//
	// If variable name is not empty, get next variable.
	//
	Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
	}

	while (TRUE) {
	//
	// Switch to the next variable store if needed
	//
	while (!IsValidVariableHeader (Variable.CurrPtr, Variable.EndPtr)) {
	//
	// Find current storage index
	//
	for (StoreType = (VARIABLE_STORE_TYPE)0; StoreType < VariableStoreTypeMax; StoreType++) {
	if ((VariableStoreList[StoreType] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreList[StoreType]))) {
	break;
	}
	}

	ASSERT (StoreType < VariableStoreTypeMax);
	//
	// Switch to next storage
	//
	for (StoreType++; StoreType < VariableStoreTypeMax; StoreType++) {
	if (VariableStoreList[StoreType] != NULL) {
	break;
	}
	}

	//
	// Capture the case that
	// 1. current storage is the last one, or
	// 2. no further storage
	//
	if (StoreType == VariableStoreTypeMax) {
	Status = EFI_NOT_FOUND;
	goto Done;
	}

	Variable.StartPtr = GetStartPointer (VariableStoreList[StoreType]);
	Variable.EndPtr = GetEndPointer (VariableStoreList[StoreType]);
	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, AuthFormat),
	GetVendorGuidPtr (Variable.CurrPtr, AuthFormat),
	FALSE,
	&VariablePtrTrack,
	AuthFormat
	);
	if (!EFI_ERROR (Status) && (VariablePtrTrack.CurrPtr->State == VAR_ADDED)) {
	Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
	continue;
	}
	}

	//
	// Don't return NV variable when HOB overrides it
	//
	if ((VariableStoreList[VariableStoreTypeHob] != NULL) && (VariableStoreList[VariableStoreTypeNv] != NULL) &&
	(Variable.StartPtr == GetStartPointer (VariableStoreList[VariableStoreTypeNv]))
	)
	{
	VariableInHob.StartPtr = GetStartPointer (VariableStoreList[VariableStoreTypeHob]);
	VariableInHob.EndPtr = GetEndPointer (VariableStoreList[VariableStoreTypeHob]);
	Status = FindVariableEx (
	GetVariableNamePtr (Variable.CurrPtr, AuthFormat),
	GetVendorGuidPtr (Variable.CurrPtr, AuthFormat),
	FALSE,
	&VariableInHob,
	AuthFormat
	);
	if (!EFI_ERROR (Status)) {
	Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
	continue;
	}
	}

	*VariablePtr = Variable.CurrPtr;
	Status = EFI_SUCCESS;
	goto Done;
	}
	}

	Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);
	}

	Done:
	return Status;
	}

	/**
	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.
	@param[in,out] VariableInfo Pointer to a pointer of VARIABLE_INFO_ENTRY structures.

	**/
	VOID
	UpdateVariableInfo (
	IN CHAR16 *VariableName,
	IN EFI_GUID *VendorGuid,
	IN BOOLEAN Volatile,
	IN BOOLEAN Read,
	IN BOOLEAN Write,
	IN BOOLEAN Delete,
	IN BOOLEAN Cache,
	IN OUT VARIABLE_INFO_ENTRY **VariableInfo
	)
	{
	VARIABLE_INFO_ENTRY *Entry;

	if (FeaturePcdGet (PcdVariableCollectStatistics)) {
	if ((VariableName == NULL) \|\| (VendorGuid == NULL) \|\| (VariableInfo == NULL)) {
	return;
	}

	if (AtRuntime ()) {
	// Don't collect statistics at runtime.
	return;
	}

	if (*VariableInfo == NULL) {
	//
	// On the first call allocate a entry and place a pointer to it in
	// the EFI System Table.
	//
	*VariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
	ASSERT (*VariableInfo != NULL);

	CopyGuid (&(*VariableInfo)->VendorGuid, VendorGuid);
	(*VariableInfo)->Name = AllocateZeroPool (StrSize (VariableName));
	ASSERT ((*VariableInfo)->Name != NULL);
	StrCpyS ((*VariableInfo)->Name, StrSize (VariableName)/sizeof (CHAR16), VariableName);
	(*VariableInfo)->Volatile = Volatile;
	}

	for (Entry = (*VariableInfo); 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;
	}
	}
	}
	}