VariableServiceSetVariable() should also check authenticate data to avoid buffer overflow,\r
integer overflow. It should also check attribute to avoid authentication bypass.\r
\r
-Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>\r
-(C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>\r
-This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution. The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
+Copyright (c) 2006 - 2020, Intel Corporation. All rights reserved.<BR>\r
+(C) Copyright 2015-2018 Hewlett Packard Enterprise Development LP<BR>\r
+Copyright (c) Microsoft Corporation.<BR>\r
\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Variable.h"\r
+#include "VariableNonVolatile.h"\r
+#include "VariableParsing.h"\r
+#include "VariableRuntimeCache.h"\r
\r
VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal;\r
\r
///\r
/// Define a memory cache that improves the search performance for a variable.\r
+/// For EmuNvMode == TRUE, it will be equal to NonVolatileVariableBase.\r
///\r
VARIABLE_STORE_HEADER *mNvVariableCache = NULL;\r
\r
\r
AUTH_VAR_LIB_CONTEXT_OUT mAuthContextOut;\r
\r
-/**\r
-\r
- SecureBoot Hook for auth variable update.\r
-\r
- @param[in] VariableName Name of Variable to be found.\r
- @param[in] VendorGuid Variable vendor GUID.\r
-**/\r
-VOID\r
-EFIAPI\r
-SecureBootHook (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid\r
- );\r
-\r
-/**\r
- Routine used to track statistical information about variable usage.\r
- The data is stored in the EFI system table so it can be accessed later.\r
- VariableInfo.efi can dump out the table. Only Boot Services variable\r
- accesses are tracked by this code. The PcdVariableCollectStatistics\r
- build flag controls if this feature is enabled.\r
-\r
- A read that hits in the cache will have Read and Cache true for\r
- the transaction. Data is allocated by this routine, but never\r
- freed.\r
-\r
- @param[in] VariableName Name of the Variable to track.\r
- @param[in] VendorGuid Guid of the Variable to track.\r
- @param[in] Volatile TRUE if volatile FALSE if non-volatile.\r
- @param[in] Read TRUE if GetVariable() was called.\r
- @param[in] Write TRUE if SetVariable() was called.\r
- @param[in] Delete TRUE if deleted via SetVariable().\r
- @param[in] Cache TRUE for a cache hit.\r
-\r
-**/\r
-VOID\r
-UpdateVariableInfo (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- IN BOOLEAN Volatile,\r
- IN BOOLEAN Read,\r
- IN BOOLEAN Write,\r
- IN BOOLEAN Delete,\r
- IN BOOLEAN Cache\r
- )\r
-{\r
- VARIABLE_INFO_ENTRY *Entry;\r
-\r
- if (FeaturePcdGet (PcdVariableCollectStatistics)) {\r
-\r
- if (AtRuntime ()) {\r
- // Don't collect statistics at runtime.\r
- return;\r
- }\r
-\r
- if (gVariableInfo == NULL) {\r
- //\r
- // On the first call allocate a entry and place a pointer to it in\r
- // the EFI System Table.\r
- //\r
- gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));\r
- ASSERT (gVariableInfo != NULL);\r
-\r
- CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);\r
- gVariableInfo->Name = AllocateZeroPool (StrSize (VariableName));\r
- ASSERT (gVariableInfo->Name != NULL);\r
- StrCpyS (gVariableInfo->Name, StrSize(VariableName)/sizeof(CHAR16), VariableName);\r
- gVariableInfo->Volatile = Volatile;\r
- }\r
-\r
-\r
- for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) {\r
- if (CompareGuid (VendorGuid, &Entry->VendorGuid)) {\r
- if (StrCmp (VariableName, Entry->Name) == 0) {\r
- if (Read) {\r
- Entry->ReadCount++;\r
- }\r
- if (Write) {\r
- Entry->WriteCount++;\r
- }\r
- if (Delete) {\r
- Entry->DeleteCount++;\r
- }\r
- if (Cache) {\r
- Entry->CacheCount++;\r
- }\r
-\r
- return;\r
- }\r
- }\r
-\r
- if (Entry->Next == NULL) {\r
- //\r
- // If the entry is not in the table add it.\r
- // Next iteration of the loop will fill in the data.\r
- //\r
- Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));\r
- ASSERT (Entry->Next != NULL);\r
-\r
- CopyGuid (&Entry->Next->VendorGuid, VendorGuid);\r
- Entry->Next->Name = AllocateZeroPool (StrSize (VariableName));\r
- ASSERT (Entry->Next->Name != NULL);\r
- StrCpyS (Entry->Next->Name, StrSize(VariableName)/sizeof(CHAR16), VariableName);\r
- Entry->Next->Volatile = Volatile;\r
- }\r
-\r
- }\r
- }\r
-}\r
-\r
-\r
-/**\r
-\r
- This code checks if variable header is valid or not.\r
-\r
- @param Variable Pointer to the Variable Header.\r
- @param VariableStoreEnd Pointer to the Variable Store End.\r
-\r
- @retval TRUE Variable header is valid.\r
- @retval FALSE Variable header is not valid.\r
-\r
-**/\r
-BOOLEAN\r
-IsValidVariableHeader (\r
- IN VARIABLE_HEADER *Variable,\r
- IN VARIABLE_HEADER *VariableStoreEnd\r
- )\r
-{\r
- if ((Variable == NULL) || (Variable >= VariableStoreEnd) || (Variable->StartId != VARIABLE_DATA)) {\r
- //\r
- // Variable is NULL or has reached the end of variable store,\r
- // or the StartId is not correct.\r
- //\r
- return FALSE;\r
- }\r
-\r
- return TRUE;\r
-}\r
-\r
-\r
/**\r
\r
This function writes data to the FWH at the correct LBA even if the LBAs\r
@param Buffer Pointer to the buffer from which data is written.\r
\r
@retval EFI_INVALID_PARAMETER Parameters not valid.\r
+ @retval EFI_UNSUPPORTED Fvb is a NULL for Non-Volatile variable update.\r
+ @retval EFI_OUT_OF_RESOURCES The remaining size is not enough.\r
@retval EFI_SUCCESS Variable store successfully updated.\r
\r
**/\r
UINT8 *CurrBuffer;\r
EFI_LBA LbaNumber;\r
UINTN Size;\r
- EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
VARIABLE_STORE_HEADER *VolatileBase;\r
EFI_PHYSICAL_ADDRESS FvVolHdr;\r
EFI_PHYSICAL_ADDRESS DataPtr;\r
EFI_STATUS Status;\r
\r
- FwVolHeader = NULL;\r
+ FvVolHdr = 0;\r
DataPtr = DataPtrIndex;\r
\r
//\r
// Check if the Data is Volatile.\r
//\r
- if (!Volatile) {\r
+ if (!Volatile && !mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
if (Fvb == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
+ return EFI_UNSUPPORTED;\r
}\r
Status = Fvb->GetPhysicalAddress(Fvb, &FvVolHdr);\r
ASSERT_EFI_ERROR (Status);\r
\r
- FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);\r
//\r
// Data Pointer should point to the actual Address where data is to be\r
// written.\r
DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;\r
}\r
\r
- if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {\r
- return EFI_INVALID_PARAMETER;\r
+ if ((DataPtr + DataSize) > (FvVolHdr + mNvFvHeaderCache->FvLength)) {\r
+ return EFI_OUT_OF_RESOURCES;\r
}\r
} else {\r
//\r
// Data Pointer should point to the actual Address where data is to be\r
// written.\r
//\r
- VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
- if (SetByIndex) {\r
- DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;\r
- }\r
+ if (Volatile) {\r
+ VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
+ if (SetByIndex) {\r
+ DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;\r
+ }\r
\r
- if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {\r
- return EFI_INVALID_PARAMETER;\r
+ if ((DataPtr + DataSize) > ((UINTN) VolatileBase + VolatileBase->Size)) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+ } else {\r
+ //\r
+ // Emulated non-volatile variable mode.\r
+ //\r
+ if (SetByIndex) {\r
+ DataPtr += (UINTN) mNvVariableCache;\r
+ }\r
+\r
+ if ((DataPtr + DataSize) > ((UINTN) mNvVariableCache + mNvVariableCache->Size)) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
}\r
\r
//\r
- // If Volatile Variable just do a simple mem copy.\r
+ // If Volatile/Emulated Non-volatile Variable just do a simple mem copy.\r
//\r
CopyMem ((UINT8 *)(UINTN)DataPtr, Buffer, DataSize);\r
return EFI_SUCCESS;\r
//\r
// If we are here we are dealing with Non-Volatile Variables.\r
//\r
- LinearOffset = (UINTN) FwVolHeader;\r
+ LinearOffset = (UINTN) FvVolHdr;\r
CurrWritePtr = (UINTN) DataPtr;\r
CurrWriteSize = DataSize;\r
CurrBuffer = Buffer;\r
return EFI_SUCCESS;\r
}\r
\r
-\r
-/**\r
-\r
- This code gets the current status of Variable Store.\r
-\r
- @param VarStoreHeader Pointer to the Variable Store Header.\r
-\r
- @retval EfiRaw Variable store status is raw.\r
- @retval EfiValid Variable store status is valid.\r
- @retval EfiInvalid Variable store status is invalid.\r
-\r
-**/\r
-VARIABLE_STORE_STATUS\r
-GetVariableStoreStatus (\r
- IN VARIABLE_STORE_HEADER *VarStoreHeader\r
- )\r
-{\r
- if ((CompareGuid (&VarStoreHeader->Signature, &gEfiAuthenticatedVariableGuid) ||\r
- CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid)) &&\r
- VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&\r
- VarStoreHeader->State == VARIABLE_STORE_HEALTHY\r
- ) {\r
-\r
- return EfiValid;\r
- } else if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&\r
- ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&\r
- ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&\r
- ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&\r
- VarStoreHeader->Size == 0xffffffff &&\r
- VarStoreHeader->Format == 0xff &&\r
- VarStoreHeader->State == 0xff\r
- ) {\r
-\r
- return EfiRaw;\r
- } else {\r
- return EfiInvalid;\r
- }\r
-}\r
-\r
-/**\r
- This code gets the size of variable header.\r
-\r
- @return Size of variable header in bytes in type UINTN.\r
-\r
-**/\r
-UINTN\r
-GetVariableHeaderSize (\r
- VOID\r
- )\r
-{\r
- UINTN Value;\r
-\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
- } else {\r
- Value = sizeof (VARIABLE_HEADER);\r
- }\r
-\r
- return Value;\r
-}\r
-\r
-/**\r
-\r
- This code gets the size of name of variable.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return UINTN Size of variable in bytes.\r
-\r
-**/\r
-UINTN\r
-NameSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
-\r
- AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- if (AuthVariable->State == (UINT8) (-1) ||\r
- AuthVariable->DataSize == (UINT32) (-1) ||\r
- AuthVariable->NameSize == (UINT32) (-1) ||\r
- AuthVariable->Attributes == (UINT32) (-1)) {\r
- return 0;\r
- }\r
- return (UINTN) AuthVariable->NameSize;\r
- } else {\r
- if (Variable->State == (UINT8) (-1) ||\r
- Variable->DataSize == (UINT32) (-1) ||\r
- Variable->NameSize == (UINT32) (-1) ||\r
- Variable->Attributes == (UINT32) (-1)) {\r
- return 0;\r
- }\r
- return (UINTN) Variable->NameSize;\r
- }\r
-}\r
-\r
-/**\r
- This code sets the size of name of variable.\r
-\r
- @param[in] Variable Pointer to the Variable Header.\r
- @param[in] NameSize Name size to set.\r
-\r
-**/\r
-VOID\r
-SetNameSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable,\r
- IN UINTN NameSize\r
- )\r
-{\r
- AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
-\r
- AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- AuthVariable->NameSize = (UINT32) NameSize;\r
- } else {\r
- Variable->NameSize = (UINT32) NameSize;\r
- }\r
-}\r
-\r
-/**\r
-\r
- This code gets the size of variable data.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return Size of variable in bytes.\r
-\r
-**/\r
-UINTN\r
-DataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
-\r
- AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- if (AuthVariable->State == (UINT8) (-1) ||\r
- AuthVariable->DataSize == (UINT32) (-1) ||\r
- AuthVariable->NameSize == (UINT32) (-1) ||\r
- AuthVariable->Attributes == (UINT32) (-1)) {\r
- return 0;\r
- }\r
- return (UINTN) AuthVariable->DataSize;\r
- } else {\r
- if (Variable->State == (UINT8) (-1) ||\r
- Variable->DataSize == (UINT32) (-1) ||\r
- Variable->NameSize == (UINT32) (-1) ||\r
- Variable->Attributes == (UINT32) (-1)) {\r
- return 0;\r
- }\r
- return (UINTN) Variable->DataSize;\r
- }\r
-}\r
-\r
-/**\r
- This code sets the size of variable data.\r
-\r
- @param[in] Variable Pointer to the Variable Header.\r
- @param[in] DataSize Data size to set.\r
-\r
-**/\r
-VOID\r
-SetDataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable,\r
- IN UINTN DataSize\r
- )\r
-{\r
- AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
-\r
- AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- AuthVariable->DataSize = (UINT32) DataSize;\r
- } else {\r
- Variable->DataSize = (UINT32) DataSize;\r
- }\r
-}\r
-\r
-/**\r
-\r
- This code gets the pointer to the variable name.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return Pointer to Variable Name which is Unicode encoding.\r
-\r
-**/\r
-CHAR16 *\r
-GetVariableNamePtr (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- return (CHAR16 *) ((UINTN) Variable + GetVariableHeaderSize ());\r
-}\r
-\r
-/**\r
- This code gets the pointer to the variable guid.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return A EFI_GUID* pointer to Vendor Guid.\r
-\r
-**/\r
-EFI_GUID *\r
-GetVendorGuidPtr (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
-\r
- AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- return &AuthVariable->VendorGuid;\r
- } else {\r
- return &Variable->VendorGuid;\r
- }\r
-}\r
-\r
-/**\r
-\r
- This code gets the pointer to the variable data.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return Pointer to Variable Data.\r
-\r
-**/\r
-UINT8 *\r
-GetVariableDataPtr (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- UINTN Value;\r
-\r
- //\r
- // Be careful about pad size for alignment.\r
- //\r
- Value = (UINTN) GetVariableNamePtr (Variable);\r
- Value += NameSizeOfVariable (Variable);\r
- Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));\r
-\r
- return (UINT8 *) Value;\r
-}\r
-\r
-/**\r
- This code gets the variable data offset related to variable header.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return Variable Data offset.\r
-\r
-**/\r
-UINTN\r
-GetVariableDataOffset (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- UINTN Value;\r
-\r
- //\r
- // Be careful about pad size for alignment\r
- //\r
- Value = GetVariableHeaderSize ();\r
- Value += NameSizeOfVariable (Variable);\r
- Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));\r
-\r
- return Value;\r
-}\r
-\r
-/**\r
-\r
- This code gets the pointer to the next variable header.\r
-\r
- @param Variable Pointer to the Variable Header.\r
-\r
- @return Pointer to next variable header.\r
-\r
-**/\r
-VARIABLE_HEADER *\r
-GetNextVariablePtr (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-{\r
- UINTN Value;\r
-\r
- Value = (UINTN) GetVariableDataPtr (Variable);\r
- Value += DataSizeOfVariable (Variable);\r
- Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));\r
-\r
- //\r
- // Be careful about pad size for alignment.\r
- //\r
- return (VARIABLE_HEADER *) HEADER_ALIGN (Value);\r
-}\r
-\r
-/**\r
-\r
- Gets the pointer to the first variable header in given variable store area.\r
-\r
- @param VarStoreHeader Pointer to the Variable Store Header.\r
-\r
- @return Pointer to the first variable header.\r
-\r
-**/\r
-VARIABLE_HEADER *\r
-GetStartPointer (\r
- IN VARIABLE_STORE_HEADER *VarStoreHeader\r
- )\r
-{\r
- //\r
- // The end of variable store.\r
- //\r
- return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);\r
-}\r
-\r
-/**\r
-\r
- Gets the pointer to the end of the variable storage area.\r
-\r
- This function gets pointer to the end of the variable storage\r
- area, according to the input variable store header.\r
-\r
- @param VarStoreHeader Pointer to the Variable Store Header.\r
-\r
- @return Pointer to the end of the variable storage area.\r
-\r
-**/\r
-VARIABLE_HEADER *\r
-GetEndPointer (\r
- IN VARIABLE_STORE_HEADER *VarStoreHeader\r
- )\r
-{\r
- //\r
- // The end of variable store\r
- //\r
- return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);\r
-}\r
-\r
/**\r
Record variable error flag.\r
\r
VAR_ERROR_FLAG TempFlag;\r
\r
DEBUG_CODE (\r
- DEBUG ((EFI_D_ERROR, "RecordVarErrorFlag (0x%02x) %s:%g - 0x%08x - 0x%x\n", Flag, VariableName, VendorGuid, Attributes, VariableSize));\r
+ DEBUG ((DEBUG_ERROR, "RecordVarErrorFlag (0x%02x) %s:%g - 0x%08x - 0x%x\n", Flag, VariableName, VendorGuid, Attributes, VariableSize));\r
if (Flag == VAR_ERROR_FLAG_SYSTEM_ERROR) {\r
if (AtRuntime ()) {\r
- DEBUG ((EFI_D_ERROR, "CommonRuntimeVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonRuntimeVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
+ DEBUG ((DEBUG_ERROR, "CommonRuntimeVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonRuntimeVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
} else {\r
- DEBUG ((EFI_D_ERROR, "CommonVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
+ DEBUG ((DEBUG_ERROR, "CommonVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
}\r
} else {\r
- DEBUG ((EFI_D_ERROR, "CommonMaxUserVariableSpace = 0x%x - CommonUserVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonUserVariableTotalSize));\r
+ DEBUG ((DEBUG_ERROR, "CommonMaxUserVariableSpace = 0x%x - CommonUserVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonUserVariableTotalSize));\r
}\r
);\r
\r
FALSE\r
);\r
if (!EFI_ERROR (Status)) {\r
- VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr);\r
+ VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
TempFlag = *VarErrFlag;\r
TempFlag &= Flag;\r
if (TempFlag == *VarErrFlag) {\r
// Update the data in NV cache.\r
//\r
*VarErrFlag = TempFlag;\r
+ Status = SynchronizeRuntimeVariableCache (\r
+ &mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeNvCache,\r
+ 0,\r
+ mNvVariableCache->Size\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
}\r
}\r
}\r
}\r
\r
Flag = mCurrentBootVarErrFlag;\r
- DEBUG ((EFI_D_INFO, "Initialize variable error flag (%02x)\n", Flag));\r
+ DEBUG ((DEBUG_INFO, "Initialize variable error flag (%02x)\n", Flag));\r
\r
Status = FindVariable (\r
VAR_ERROR_FLAG_NAME,\r
FALSE\r
);\r
if (!EFI_ERROR (Status)) {\r
- VarErrFlag = *((VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr));\r
+ VarErrFlag = *((VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat));\r
if (VarErrFlag == Flag) {\r
return;\r
}\r
// then no need to check if the variable is user variable or not specially.\r
//\r
if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {\r
- if (VarCheckLibVariablePropertyGet (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &Property) == EFI_NOT_FOUND) {\r
+ if (VarCheckLibVariablePropertyGet (\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ &Property\r
+ ) == EFI_NOT_FOUND) {\r
return TRUE;\r
}\r
}\r
if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {\r
Variable = GetStartPointer (mNvVariableCache);\r
while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
- if (VarCheckLibVariablePropertyGet (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &Property) == EFI_NOT_FOUND) {\r
+ if (VarCheckLibVariablePropertyGet (\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ &Property\r
+ ) == EFI_NOT_FOUND) {\r
//\r
// No property, it is user variable.\r
//\r
VOID *Point1;\r
BOOLEAN FoundAdded;\r
EFI_STATUS Status;\r
+ EFI_STATUS DoneStatus;\r
UINTN CommonVariableTotalSize;\r
UINTN CommonUserVariableTotalSize;\r
UINTN HwErrVariableTotalSize;\r
VARIABLE_HEADER *UpdatingVariable;\r
VARIABLE_HEADER *UpdatingInDeletedTransition;\r
+ BOOLEAN AuthFormat;\r
\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
UpdatingVariable = NULL;\r
UpdatingInDeletedTransition = NULL;\r
if (UpdatingPtrTrack != NULL) {\r
CommonUserVariableTotalSize = 0;\r
HwErrVariableTotalSize = 0;\r
\r
- if (IsVolatile) {\r
+ if (IsVolatile || mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
//\r
// Start Pointers for the variable.\r
//\r
MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);\r
\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
if ((Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) &&\r
Variable != UpdatingVariable &&\r
Variable != UpdatingInDeletedTransition\r
//\r
Variable = GetStartPointer (VariableStoreHeader);\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
if (Variable != UpdatingVariable && Variable->State == VAR_ADDED) {\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
//\r
Variable = GetStartPointer (VariableStoreHeader);\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
if (Variable != UpdatingVariable && Variable != UpdatingInDeletedTransition && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
\r
//\r
FoundAdded = FALSE;\r
AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);\r
while (IsValidVariableHeader (AddedVariable, GetEndPointer ((VARIABLE_STORE_HEADER *) ValidBuffer))) {\r
- NextAddedVariable = GetNextVariablePtr (AddedVariable);\r
- NameSize = NameSizeOfVariable (AddedVariable);\r
- if (CompareGuid (GetVendorGuidPtr (AddedVariable), GetVendorGuidPtr (Variable)) &&\r
- NameSize == NameSizeOfVariable (Variable)\r
- ) {\r
- Point0 = (VOID *) GetVariableNamePtr (AddedVariable);\r
- Point1 = (VOID *) GetVariableNamePtr (Variable);\r
+ NextAddedVariable = GetNextVariablePtr (AddedVariable, AuthFormat);\r
+ NameSize = NameSizeOfVariable (AddedVariable, AuthFormat);\r
+ if (CompareGuid (\r
+ GetVendorGuidPtr (AddedVariable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat)\r
+ ) && NameSize == NameSizeOfVariable (Variable, AuthFormat)) {\r
+ Point0 = (VOID *) GetVariableNamePtr (AddedVariable, AuthFormat);\r
+ Point1 = (VOID *) GetVariableNamePtr (Variable, AuthFormat);\r
if (CompareMem (Point0, Point1, NameSize) == 0) {\r
FoundAdded = TRUE;\r
break;\r
// Install the new variable if it is not NULL.\r
//\r
if (NewVariable != NULL) {\r
- if ((UINTN) (CurrPtr - ValidBuffer) + NewVariableSize > VariableStoreHeader->Size) {\r
+ if (((UINTN) CurrPtr - (UINTN) ValidBuffer) + NewVariableSize > VariableStoreHeader->Size) {\r
//\r
// No enough space to store the new variable.\r
//\r
CurrPtr += NewVariableSize;\r
}\r
\r
- if (IsVolatile) {\r
+ if (IsVolatile || mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
//\r
- // If volatile variable store, just copy valid buffer.\r
+ // If volatile/emulated non-volatile variable store, just copy valid buffer.\r
//\r
SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);\r
- CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, (UINTN) (CurrPtr - ValidBuffer));\r
- *LastVariableOffset = (UINTN) (CurrPtr - ValidBuffer);\r
+ CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, (UINTN) CurrPtr - (UINTN) ValidBuffer);\r
+ *LastVariableOffset = (UINTN) CurrPtr - (UINTN) ValidBuffer;\r
+ if (!IsVolatile) {\r
+ //\r
+ // Emulated non-volatile variable mode.\r
+ //\r
+ mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;\r
+ mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;\r
+ mVariableModuleGlobal->CommonUserVariableTotalSize = CommonUserVariableTotalSize;\r
+ }\r
Status = EFI_SUCCESS;\r
} else {\r
//\r
(VARIABLE_STORE_HEADER *) ValidBuffer\r
);\r
if (!EFI_ERROR (Status)) {\r
- *LastVariableOffset = (UINTN) (CurrPtr - ValidBuffer);\r
+ *LastVariableOffset = (UINTN) CurrPtr - (UINTN) ValidBuffer;\r
mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;\r
mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;\r
mVariableModuleGlobal->CommonUserVariableTotalSize = CommonUserVariableTotalSize;\r
mVariableModuleGlobal->CommonUserVariableTotalSize = 0;\r
Variable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase);\r
while (IsValidVariableHeader (Variable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
} else if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;\r
if (IsUserVariable (Variable)) {\r
- mVariableModuleGlobal->CommonUserVariableTotalSize += VariableSize;\r
- }\r
- }\r
-\r
- Variable = NextVariable;\r
- }\r
- *LastVariableOffset = (UINTN) Variable - (UINTN) VariableBase;\r
- }\r
- }\r
-\r
-Done:\r
- if (IsVolatile) {\r
- FreePool (ValidBuffer);\r
- } else {\r
- //\r
- // For NV variable reclaim, we use mNvVariableCache as the buffer, so copy the data back.\r
- //\r
- CopyMem (mNvVariableCache, (UINT8 *)(UINTN)VariableBase, VariableStoreHeader->Size);\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-/**\r
- Find the variable in the specified variable store.\r
-\r
- @param[in] VariableName Name of the variable to be found\r
- @param[in] VendorGuid Vendor GUID to be found.\r
- @param[in] IgnoreRtCheck Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute\r
- check at runtime when searching variable.\r
- @param[in, out] PtrTrack Variable Track Pointer structure that contains Variable Information.\r
-\r
- @retval EFI_SUCCESS Variable found successfully\r
- @retval EFI_NOT_FOUND Variable not found\r
-**/\r
-EFI_STATUS\r
-FindVariableEx (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- IN BOOLEAN IgnoreRtCheck,\r
- IN OUT VARIABLE_POINTER_TRACK *PtrTrack\r
- )\r
-{\r
- VARIABLE_HEADER *InDeletedVariable;\r
- VOID *Point;\r
-\r
- PtrTrack->InDeletedTransitionPtr = NULL;\r
-\r
- //\r
- // Find the variable by walk through HOB, volatile and non-volatile variable store.\r
- //\r
- InDeletedVariable = NULL;\r
-\r
- for ( PtrTrack->CurrPtr = PtrTrack->StartPtr\r
- ; IsValidVariableHeader (PtrTrack->CurrPtr, PtrTrack->EndPtr)\r
- ; PtrTrack->CurrPtr = GetNextVariablePtr (PtrTrack->CurrPtr)\r
- ) {\r
- if (PtrTrack->CurrPtr->State == VAR_ADDED ||\r
- PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)\r
- ) {\r
- if (IgnoreRtCheck || !AtRuntime () || ((PtrTrack->CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {\r
- if (VariableName[0] == 0) {\r
- if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
- InDeletedVariable = PtrTrack->CurrPtr;\r
- } else {\r
- PtrTrack->InDeletedTransitionPtr = InDeletedVariable;\r
- return EFI_SUCCESS;\r
- }\r
- } else {\r
- if (CompareGuid (VendorGuid, GetVendorGuidPtr (PtrTrack->CurrPtr))) {\r
- Point = (VOID *) GetVariableNamePtr (PtrTrack->CurrPtr);\r
-\r
- ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr) != 0);\r
- if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr)) == 0) {\r
- if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
- InDeletedVariable = PtrTrack->CurrPtr;\r
- } else {\r
- PtrTrack->InDeletedTransitionPtr = InDeletedVariable;\r
- return EFI_SUCCESS;\r
- }\r
- }\r
+ mVariableModuleGlobal->CommonUserVariableTotalSize += VariableSize;\r
}\r
}\r
+\r
+ Variable = NextVariable;\r
}\r
+ *LastVariableOffset = (UINTN) Variable - (UINTN) VariableBase;\r
}\r
}\r
\r
- PtrTrack->CurrPtr = InDeletedVariable;\r
- return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;\r
-}\r
+Done:\r
+ DoneStatus = EFI_SUCCESS;\r
+ if (IsVolatile || mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
+ DoneStatus = SynchronizeRuntimeVariableCache (\r
+ &mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeVolatileCache,\r
+ 0,\r
+ VariableStoreHeader->Size\r
+ );\r
+ ASSERT_EFI_ERROR (DoneStatus);\r
+ FreePool (ValidBuffer);\r
+ } else {\r
+ //\r
+ // For NV variable reclaim, we use mNvVariableCache as the buffer, so copy the data back.\r
+ //\r
+ CopyMem (mNvVariableCache, (UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size);\r
+ DoneStatus = SynchronizeRuntimeVariableCache (\r
+ &mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeNvCache,\r
+ 0,\r
+ VariableStoreHeader->Size\r
+ );\r
+ ASSERT_EFI_ERROR (DoneStatus);\r
+ }\r
\r
+ if (!EFI_ERROR (Status) && EFI_ERROR (DoneStatus)) {\r
+ Status = DoneStatus;\r
+ }\r
+\r
+ return Status;\r
+}\r
\r
/**\r
Finds variable in storage blocks of volatile and non-volatile storage areas.\r
PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Type]);\r
PtrTrack->Volatile = (BOOLEAN) (Type == VariableStoreTypeVolatile);\r
\r
- Status = FindVariableEx (VariableName, VendorGuid, IgnoreRtCheck, PtrTrack);\r
+ Status = FindVariableEx (\r
+ VariableName,\r
+ VendorGuid,\r
+ IgnoreRtCheck,\r
+ PtrTrack,\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
+ );\r
if (!EFI_ERROR (Status)) {\r
return Status;\r
}\r
@param[in] SupportedLanguages A pointer to a Null-terminated ASCII string that\r
contains a set of language codes in the format\r
specified by Iso639Language.\r
- @param[in] Iso639Language If TRUE, then all language codes are assumed to be\r
- in ISO 639-2 format. If FALSE, then all language\r
+ @param[in] Iso639Language If not zero, then all language codes are assumed to be\r
+ in ISO 639-2 format. If zero, then all language\r
codes are assumed to be in RFC 4646 language format\r
@param[in] ... A variable argument list that contains pointers to\r
Null-terminated ASCII strings that contain one or more\r
EFIAPI\r
VariableGetBestLanguage (\r
IN CONST CHAR8 *SupportedLanguages,\r
- IN BOOLEAN Iso639Language,\r
+ IN UINTN Iso639Language,\r
...\r
)\r
{\r
//\r
// If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language\r
//\r
- if (!Iso639Language) {\r
+ if (Iso639Language == 0) {\r
for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);\r
}\r
\r
//\r
// In RFC 4646 mode, then Loop through all language codes in SupportedLanguages\r
//\r
- if (!Iso639Language) {\r
+ if (Iso639Language == 0) {\r
//\r
// Skip ';' characters in Supported\r
//\r
if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {\r
VA_END (Args);\r
\r
- Buffer = Iso639Language ? mVariableModuleGlobal->Lang : mVariableModuleGlobal->PlatformLang;\r
+ Buffer = (Iso639Language != 0) ? mVariableModuleGlobal->Lang : mVariableModuleGlobal->PlatformLang;\r
Buffer[CompareLength] = '\0';\r
return CopyMem (Buffer, Supported, CompareLength);\r
}\r
}\r
\r
- if (Iso639Language) {\r
+ if (Iso639Language != 0) {\r
//\r
// If ISO 639 mode, then each language can only be tested once\r
//\r
VarNameSize += GET_PAD_SIZE (VarNameSize);\r
VarDataSize = VariableEntry->VariableSize;\r
VarDataSize += GET_PAD_SIZE (VarDataSize);\r
- VariableEntry->VariableSize = HEADER_ALIGN (GetVariableHeaderSize () + VarNameSize + VarDataSize);\r
+ VariableEntry->VariableSize = HEADER_ALIGN (\r
+ GetVariableHeaderSize (\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
+ ) + VarNameSize + VarDataSize\r
+ );\r
\r
TotalNeededSize += VariableEntry->VariableSize;\r
VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);\r
}\r
+ VA_END (Args);\r
\r
if (RemainingVariableStorageSize >= TotalNeededSize) {\r
//\r
VariableEntry->Name,\r
VariableEntry->Guid,\r
FALSE,\r
- &VariablePtrTrack\r
+ &VariablePtrTrack,\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
);\r
if (!EFI_ERROR (Status)) {\r
//\r
// Get size of Variable[Index].\r
//\r
- NextVariable = GetNextVariablePtr (VariablePtrTrack.CurrPtr);\r
+ NextVariable = GetNextVariablePtr (VariablePtrTrack.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
OriginalVarSize = (UINTN) NextVariable - (UINTN) VariablePtrTrack.CurrPtr;\r
//\r
// Add the original size of Variable[Index] to remaining variable storage size.\r
//\r
// No enough space for Variable[Index].\r
//\r
+ VA_END (Args);\r
return FALSE;\r
}\r
//\r
RemainingVariableStorageSize -= VariableEntry->VariableSize;\r
VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);\r
}\r
+ VA_END (Args);\r
\r
return TRUE;\r
}\r
// Update Lang\r
//\r
VariableName = EFI_PLATFORM_LANG_VARIABLE_NAME;\r
- Data = GetVariableDataPtr (Variable.CurrPtr);\r
- DataSize = DataSizeOfVariable (Variable.CurrPtr);\r
+ Data = GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ DataSize = DataSizeOfVariable (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
} else {\r
Status = FindVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
if (!EFI_ERROR (Status)) {\r
// Update PlatformLang\r
//\r
VariableName = EFI_LANG_VARIABLE_NAME;\r
- Data = GetVariableDataPtr (Variable.CurrPtr);\r
- DataSize = DataSizeOfVariable (Variable.CurrPtr);\r
+ Data = GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ DataSize = DataSizeOfVariable (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
} else {\r
//\r
// Neither PlatformLang nor Lang is set, directly return\r
ISO_639_2_ENTRY_SIZE + 1, Attributes, 0, 0, &Variable, NULL);\r
}\r
\r
- DEBUG ((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a Status: %r\n", BestPlatformLang, BestLang, Status));\r
+ DEBUG ((DEBUG_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a Status: %r\n", BestPlatformLang, BestLang, Status));\r
}\r
}\r
\r
AsciiStrSize (BestPlatformLang), Attributes, 0, 0, &Variable, NULL);\r
}\r
\r
- DEBUG ((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a Status: %r\n", BestLang, BestPlatformLang, Status));\r
+ DEBUG ((DEBUG_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a Status: %r\n", BestLang, BestPlatformLang, Status));\r
}\r
}\r
}\r
}\r
}\r
\r
-/**\r
- Compare two EFI_TIME data.\r
-\r
-\r
- @param FirstTime A pointer to the first EFI_TIME data.\r
- @param SecondTime A pointer to the second EFI_TIME data.\r
-\r
- @retval TRUE The FirstTime is not later than the SecondTime.\r
- @retval FALSE The FirstTime is later than the SecondTime.\r
-\r
-**/\r
-BOOLEAN\r
-VariableCompareTimeStampInternal (\r
- IN EFI_TIME *FirstTime,\r
- IN EFI_TIME *SecondTime\r
- )\r
-{\r
- if (FirstTime->Year != SecondTime->Year) {\r
- return (BOOLEAN) (FirstTime->Year < SecondTime->Year);\r
- } else if (FirstTime->Month != SecondTime->Month) {\r
- return (BOOLEAN) (FirstTime->Month < SecondTime->Month);\r
- } else if (FirstTime->Day != SecondTime->Day) {\r
- return (BOOLEAN) (FirstTime->Day < SecondTime->Day);\r
- } else if (FirstTime->Hour != SecondTime->Hour) {\r
- return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);\r
- } else if (FirstTime->Minute != SecondTime->Minute) {\r
- return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);\r
- }\r
-\r
- return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);\r
-}\r
-\r
/**\r
Update the variable region with Variable information. If EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS is set,\r
index of associated public key is needed.\r
VARIABLE_POINTER_TRACK *Variable;\r
VARIABLE_POINTER_TRACK NvVariable;\r
VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINTN CacheOffset;\r
+ VARIABLE_RUNTIME_CACHE *VolatileCacheInstance;\r
UINT8 *BufferForMerge;\r
UINTN MergedBufSize;\r
BOOLEAN DataReady;\r
BOOLEAN IsCommonVariable;\r
BOOLEAN IsCommonUserVariable;\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
+ BOOLEAN AuthFormat;\r
\r
- if (mVariableModuleGlobal->FvbInstance == NULL) {\r
+ if (mVariableModuleGlobal->FvbInstance == NULL && !mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
//\r
// The FVB protocol is not ready, so the EFI_VARIABLE_WRITE_ARCH_PROTOCOL is not installed.\r
//\r
//\r
// Trying to update NV variable prior to the installation of EFI_VARIABLE_WRITE_ARCH_PROTOCOL\r
//\r
- DEBUG ((EFI_D_ERROR, "Update NV variable before EFI_VARIABLE_WRITE_ARCH_PROTOCOL ready - %r\n", EFI_NOT_AVAILABLE_YET));\r
+ DEBUG ((DEBUG_ERROR, "Update NV variable before EFI_VARIABLE_WRITE_ARCH_PROTOCOL ready - %r\n", EFI_NOT_AVAILABLE_YET));\r
return EFI_NOT_AVAILABLE_YET;\r
} else if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
//\r
// Trying to update volatile authenticated variable prior to the installation of EFI_VARIABLE_WRITE_ARCH_PROTOCOL\r
// The authenticated variable perhaps is not initialized, just return here.\r
//\r
- DEBUG ((EFI_D_ERROR, "Update AUTH variable before EFI_VARIABLE_WRITE_ARCH_PROTOCOL ready - %r\n", EFI_NOT_AVAILABLE_YET));\r
+ DEBUG ((DEBUG_ERROR, "Update AUTH variable before EFI_VARIABLE_WRITE_ARCH_PROTOCOL ready - %r\n", EFI_NOT_AVAILABLE_YET));\r
return EFI_NOT_AVAILABLE_YET;\r
}\r
}\r
\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
+\r
//\r
// Check if CacheVariable points to the variable in variable HOB.\r
// If yes, let CacheVariable points to the variable in NV variable cache.\r
CacheVariable->StartPtr = GetStartPointer (mNvVariableCache);\r
CacheVariable->EndPtr = GetEndPointer (mNvVariableCache);\r
CacheVariable->Volatile = FALSE;\r
- Status = FindVariableEx (VariableName, VendorGuid, FALSE, CacheVariable);\r
+ Status = FindVariableEx (VariableName, VendorGuid, FALSE, CacheVariable, AuthFormat);\r
if (CacheVariable->CurrPtr == NULL || EFI_ERROR (Status)) {\r
//\r
// There is no matched variable in NV variable cache.\r
// go to delete this variable in variable HOB and\r
// try to flush other variables from HOB to flash.\r
//\r
- UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, FALSE, TRUE, FALSE);\r
+ UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, FALSE, TRUE, FALSE, &gVariableInfo);\r
FlushHobVariableToFlash (VariableName, VendorGuid);\r
return EFI_SUCCESS;\r
}\r
&State\r
);\r
if (!EFI_ERROR (Status)) {\r
- UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, FALSE, TRUE, FALSE);\r
+ UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, FALSE, TRUE, FALSE, &gVariableInfo);\r
if (!Variable->Volatile) {\r
CacheVariable->CurrPtr->State = State;\r
FlushHobVariableToFlash (VariableName, VendorGuid);\r
// If the variable is marked valid, and the same data has been passed in,\r
// then return to the caller immediately.\r
//\r
- if (DataSizeOfVariable (CacheVariable->CurrPtr) == DataSize &&\r
- (CompareMem (Data, GetVariableDataPtr (CacheVariable->CurrPtr), DataSize) == 0) &&\r
+ if (DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat) == DataSize &&\r
+ (CompareMem (Data, GetVariableDataPtr (CacheVariable->CurrPtr, AuthFormat), DataSize) == 0) &&\r
((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) &&\r
(TimeStamp == NULL)) {\r
//\r
// Variable content unchanged and no need to update timestamp, just return.\r
//\r
- UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, TRUE, FALSE, FALSE);\r
+ UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, TRUE, FALSE, FALSE, &gVariableInfo);\r
Status = EFI_SUCCESS;\r
goto Done;\r
} else if ((CacheVariable->CurrPtr->State == VAR_ADDED) ||\r
// NOTE: From 0 to DataOffset of NextVariable is reserved for Variable Header and Name.\r
// From DataOffset of NextVariable is to save the existing variable data.\r
//\r
- DataOffset = GetVariableDataOffset (CacheVariable->CurrPtr);\r
+ DataOffset = GetVariableDataOffset (CacheVariable->CurrPtr, AuthFormat);\r
BufferForMerge = (UINT8 *) ((UINTN) NextVariable + DataOffset);\r
- CopyMem (BufferForMerge, (UINT8 *) ((UINTN) CacheVariable->CurrPtr + DataOffset), DataSizeOfVariable (CacheVariable->CurrPtr));\r
+ CopyMem (\r
+ BufferForMerge,\r
+ (UINT8 *) ((UINTN) CacheVariable->CurrPtr + DataOffset),\r
+ DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat)\r
+ );\r
\r
//\r
- // Set Max Common/Auth Variable Data Size as default MaxDataSize.\r
+ // Set Max Auth/Non-Volatile/Volatile Variable Data Size as default MaxDataSize.\r
//\r
if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
MaxDataSize = mVariableModuleGlobal->MaxAuthVariableSize - DataOffset;\r
- } else {\r
+ } else if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
MaxDataSize = mVariableModuleGlobal->MaxVariableSize - DataOffset;\r
+ } else {\r
+ MaxDataSize = mVariableModuleGlobal->MaxVolatileVariableSize - DataOffset;\r
}\r
\r
//\r
MaxDataSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - DataOffset;\r
}\r
\r
- if (DataSizeOfVariable (CacheVariable->CurrPtr) + DataSize > MaxDataSize) {\r
+ if (DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat) + DataSize > MaxDataSize) {\r
//\r
// Existing data size + new data size exceed maximum variable size limitation.\r
//\r
Status = EFI_INVALID_PARAMETER;\r
goto Done;\r
}\r
- CopyMem ((UINT8*) ((UINTN) BufferForMerge + DataSizeOfVariable (CacheVariable->CurrPtr)), Data, DataSize);\r
- MergedBufSize = DataSizeOfVariable (CacheVariable->CurrPtr) + DataSize;\r
+ CopyMem (\r
+ (UINT8*) (\r
+ (UINTN) BufferForMerge + DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat)\r
+ ),\r
+ Data,\r
+ DataSize\r
+ );\r
+ MergedBufSize = DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat) +\r
+ DataSize;\r
\r
//\r
// BufferForMerge(from DataOffset of NextVariable) has included the merged existing and new data.\r
if (Variable->CurrPtr != NULL) {\r
if (VariableCompareTimeStampInternal (&(((AUTHENTICATED_VARIABLE_HEADER *) CacheVariable->CurrPtr)->TimeStamp), TimeStamp)) {\r
CopyMem (&AuthVariable->TimeStamp, TimeStamp, sizeof (EFI_TIME));\r
+ } else {\r
+ CopyMem (&AuthVariable->TimeStamp, &(((AUTHENTICATED_VARIABLE_HEADER *) CacheVariable->CurrPtr)->TimeStamp), sizeof (EFI_TIME));\r
}\r
}\r
}\r
//\r
NextVariable->Attributes = Attributes & (~EFI_VARIABLE_APPEND_WRITE);\r
\r
- VarNameOffset = GetVariableHeaderSize ();\r
+ VarNameOffset = GetVariableHeaderSize (AuthFormat);\r
VarNameSize = StrSize (VariableName);\r
CopyMem (\r
(UINT8 *) ((UINTN) NextVariable + VarNameOffset),\r
);\r
}\r
\r
- CopyMem (GetVendorGuidPtr (NextVariable), VendorGuid, sizeof (EFI_GUID));\r
+ CopyMem (\r
+ GetVendorGuidPtr (NextVariable, AuthFormat),\r
+ VendorGuid,\r
+ sizeof (EFI_GUID)\r
+ );\r
//\r
// There will be pad bytes after Data, the NextVariable->NameSize and\r
// NextVariable->DataSize should not include pad size so that variable\r
// service can get actual size in GetVariable.\r
//\r
- SetNameSizeOfVariable (NextVariable, VarNameSize);\r
- SetDataSizeOfVariable (NextVariable, DataSize);\r
+ SetNameSizeOfVariable (NextVariable, VarNameSize, AuthFormat);\r
+ SetDataSizeOfVariable (NextVariable, DataSize, AuthFormat);\r
\r
//\r
// The actual size of the variable that stores in storage should\r
CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));\r
CacheVariable->InDeletedTransitionPtr = NULL;\r
}\r
- UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, TRUE, FALSE, FALSE);\r
+ UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, TRUE, FALSE, FALSE, &gVariableInfo);\r
FlushHobVariableToFlash (VariableName, VendorGuid);\r
} else {\r
if (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace)) {\r
}\r
goto Done;\r
}\r
- //\r
- // Four steps\r
- // 1. Write variable header\r
- // 2. Set variable state to header valid\r
- // 3. Write variable data\r
- // 4. Set variable state to valid\r
- //\r
- //\r
- // Step 1:\r
- //\r
- CacheOffset = mVariableModuleGlobal->NonVolatileLastVariableOffset;\r
- Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal,\r
- FALSE,\r
- TRUE,\r
- Fvb,\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
- (UINT32) GetVariableHeaderSize (),\r
- (UINT8 *) NextVariable\r
- );\r
\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
+ if (!mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
+ //\r
+ // Four steps\r
+ // 1. Write variable header\r
+ // 2. Set variable state to header valid\r
+ // 3. Write variable data\r
+ // 4. Set variable state to valid\r
+ //\r
+ //\r
+ // Step 1:\r
+ //\r
+ Status = UpdateVariableStore (\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ FALSE,\r
+ TRUE,\r
+ Fvb,\r
+ mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
+ (UINT32) GetVariableHeaderSize (AuthFormat),\r
+ (UINT8 *) NextVariable\r
+ );\r
\r
- //\r
- // Step 2:\r
- //\r
- NextVariable->State = VAR_HEADER_VALID_ONLY;\r
- Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal,\r
- FALSE,\r
- TRUE,\r
- Fvb,\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),\r
- sizeof (UINT8),\r
- &NextVariable->State\r
- );\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // Step 3:\r
- //\r
- Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal,\r
- FALSE,\r
- TRUE,\r
- Fvb,\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset + GetVariableHeaderSize (),\r
- (UINT32) (VarSize - GetVariableHeaderSize ()),\r
- (UINT8 *) NextVariable + GetVariableHeaderSize ()\r
- );\r
+ //\r
+ // Step 2:\r
+ //\r
+ NextVariable->State = VAR_HEADER_VALID_ONLY;\r
+ Status = UpdateVariableStore (\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ FALSE,\r
+ TRUE,\r
+ Fvb,\r
+ mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),\r
+ sizeof (UINT8),\r
+ &NextVariable->State\r
+ );\r
\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // Step 4:\r
- //\r
- NextVariable->State = VAR_ADDED;\r
- Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal,\r
- FALSE,\r
- TRUE,\r
- Fvb,\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),\r
- sizeof (UINT8),\r
- &NextVariable->State\r
- );\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
+ //\r
+ // Step 3:\r
+ //\r
+ Status = UpdateVariableStore (\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ FALSE,\r
+ TRUE,\r
+ Fvb,\r
+ mVariableModuleGlobal->NonVolatileLastVariableOffset + GetVariableHeaderSize (AuthFormat),\r
+ (UINT32) (VarSize - GetVariableHeaderSize (AuthFormat)),\r
+ (UINT8 *) NextVariable + GetVariableHeaderSize (AuthFormat)\r
+ );\r
\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
+ //\r
+ // Step 4:\r
+ //\r
+ NextVariable->State = VAR_ADDED;\r
+ Status = UpdateVariableStore (\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ FALSE,\r
+ TRUE,\r
+ Fvb,\r
+ mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),\r
+ sizeof (UINT8),\r
+ &NextVariable->State\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
+\r
+ //\r
+ // Update the memory copy of Flash region.\r
+ //\r
+ CopyMem ((UINT8 *)mNvVariableCache + mVariableModuleGlobal->NonVolatileLastVariableOffset, (UINT8 *)NextVariable, VarSize);\r
+ } else {\r
+ //\r
+ // Emulated non-volatile variable mode.\r
+ //\r
+ NextVariable->State = VAR_ADDED;\r
+ Status = UpdateVariableStore (\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ FALSE,\r
+ TRUE,\r
+ Fvb,\r
+ mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
+ (UINT32) VarSize,\r
+ (UINT8 *) NextVariable\r
+ );\r
+\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
}\r
\r
mVariableModuleGlobal->NonVolatileLastVariableOffset += HEADER_ALIGN (VarSize);\r
mVariableModuleGlobal->CommonUserVariableTotalSize += HEADER_ALIGN (VarSize);\r
}\r
}\r
- //\r
- // update the memory copy of Flash region.\r
- //\r
- CopyMem ((UINT8 *)mNvVariableCache + CacheOffset, (UINT8 *)NextVariable, VarSize);\r
} else {\r
//\r
// Create a volatile variable.\r
CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));\r
CacheVariable->InDeletedTransitionPtr = NULL;\r
}\r
- UpdateVariableInfo (VariableName, VendorGuid, TRUE, FALSE, TRUE, FALSE, FALSE);\r
+ UpdateVariableInfo (VariableName, VendorGuid, TRUE, FALSE, TRUE, FALSE, FALSE, &gVariableInfo);\r
}\r
goto Done;\r
}\r
}\r
}\r
\r
- State = Variable->CurrPtr->State;\r
+ State = CacheVariable->CurrPtr->State;\r
State &= VAR_DELETED;\r
\r
Status = UpdateVariableStore (\r
}\r
\r
if (!EFI_ERROR (Status)) {\r
- UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);\r
+ UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE, &gVariableInfo);\r
if (!Volatile) {\r
FlushHobVariableToFlash (VariableName, VendorGuid);\r
}\r
}\r
\r
Done:\r
+ if (!EFI_ERROR (Status)) {\r
+ if ((Variable->CurrPtr != NULL && !Variable->Volatile) || (Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
+ VolatileCacheInstance = &(mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeNvCache);\r
+ } else {\r
+ VolatileCacheInstance = &(mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeVolatileCache);\r
+ }\r
+\r
+ if (VolatileCacheInstance->Store != NULL) {\r
+ Status = SynchronizeRuntimeVariableCache (\r
+ VolatileCacheInstance,\r
+ 0,\r
+ VolatileCacheInstance->Store->Size\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+ }\r
+\r
return Status;\r
}\r
\r
@param Attributes Attribute value of the variable found.\r
@param DataSize Size of Data found. If size is less than the\r
data, this value contains the required size.\r
- @param Data Data pointer.\r
+ @param Data The buffer to return the contents of the variable. May be NULL\r
+ with a zero DataSize in order to determine the size buffer needed.\r
\r
@return EFI_INVALID_PARAMETER Invalid parameter.\r
@return EFI_SUCCESS Find the specified variable.\r
IN EFI_GUID *VendorGuid,\r
OUT UINT32 *Attributes OPTIONAL,\r
IN OUT UINTN *DataSize,\r
- OUT VOID *Data\r
+ OUT VOID *Data OPTIONAL\r
)\r
{\r
EFI_STATUS Status;\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
+ if (VariableName[0] == 0) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
//\r
// Get data size\r
//\r
- VarDataSize = DataSizeOfVariable (Variable.CurrPtr);\r
+ VarDataSize = DataSizeOfVariable (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
ASSERT (VarDataSize != 0);\r
\r
- if (*DataSize >= VarDataSize) {\r
- if (Data == NULL) {\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- }\r
-\r
- CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);\r
- if (Attributes != NULL) {\r
- *Attributes = Variable.CurrPtr->Attributes;\r
- }\r
-\r
- *DataSize = VarDataSize;\r
- UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);\r
-\r
- Status = EFI_SUCCESS;\r
- goto Done;\r
- } else {\r
- *DataSize = VarDataSize;\r
- Status = EFI_BUFFER_TOO_SMALL;\r
- goto Done;\r
- }\r
-\r
-Done:\r
- ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
- return Status;\r
-}\r
-\r
-/**\r
- This code Finds the Next available variable.\r
-\r
- Caution: This function may receive untrusted input.\r
- This function may be invoked in SMM mode. This function will do basic validation, before parse the data.\r
-\r
- @param[in] VariableName Pointer to variable name.\r
- @param[in] VendorGuid Variable Vendor Guid.\r
- @param[out] VariablePtr Pointer to variable header address.\r
-\r
- @return EFI_SUCCESS Find the specified variable.\r
- @return EFI_NOT_FOUND Not found.\r
-\r
-**/\r
-EFI_STATUS\r
-EFIAPI\r
-VariableServiceGetNextVariableInternal (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- OUT VARIABLE_HEADER **VariablePtr\r
- )\r
-{\r
- VARIABLE_STORE_TYPE Type;\r
- VARIABLE_POINTER_TRACK Variable;\r
- VARIABLE_POINTER_TRACK VariableInHob;\r
- VARIABLE_POINTER_TRACK VariablePtrTrack;\r
- EFI_STATUS Status;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];\r
-\r
- Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
- if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
-\r
- if (VariableName[0] != 0) {\r
- //\r
- // If variable name is not NULL, get next variable.\r
- //\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
- }\r
-\r
- //\r
- // 0: Volatile, 1: HOB, 2: Non-Volatile.\r
- // The index and attributes mapping must be kept in this order as FindVariable\r
- // makes use of this mapping to implement search algorithm.\r
- //\r
- VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;\r
- VariableStoreHeader[VariableStoreTypeHob] = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;\r
- VariableStoreHeader[VariableStoreTypeNv] = mNvVariableCache;\r
-\r
- while (TRUE) {\r
- //\r
- // Switch from Volatile to HOB, to Non-Volatile.\r
- //\r
- while (!IsValidVariableHeader (Variable.CurrPtr, Variable.EndPtr)) {\r
- //\r
- // Find current storage index\r
- //\r
- for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {\r
- if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {\r
- break;\r
- }\r
- }\r
- ASSERT (Type < VariableStoreTypeMax);\r
- //\r
- // Switch to next storage\r
- //\r
- for (Type++; Type < VariableStoreTypeMax; Type++) {\r
- if (VariableStoreHeader[Type] != NULL) {\r
- break;\r
- }\r
- }\r
- //\r
- // Capture the case that\r
- // 1. current storage is the last one, or\r
- // 2. no further storage\r
- //\r
- if (Type == VariableStoreTypeMax) {\r
- Status = EFI_NOT_FOUND;\r
- goto Done;\r
- }\r
- Variable.StartPtr = GetStartPointer (VariableStoreHeader[Type]);\r
- Variable.EndPtr = GetEndPointer (VariableStoreHeader[Type]);\r
- Variable.CurrPtr = Variable.StartPtr;\r
- }\r
-\r
- //\r
- // Variable is found\r
- //\r
- if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
- if (!AtRuntime () || ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {\r
- if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
- //\r
- // If it is a IN_DELETED_TRANSITION variable,\r
- // and there is also a same ADDED one at the same time,\r
- // don't return it.\r
- //\r
- VariablePtrTrack.StartPtr = Variable.StartPtr;\r
- VariablePtrTrack.EndPtr = Variable.EndPtr;\r
- Status = FindVariableEx (\r
- GetVariableNamePtr (Variable.CurrPtr),\r
- GetVendorGuidPtr (Variable.CurrPtr),\r
- FALSE,\r
- &VariablePtrTrack\r
- );\r
- if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
- continue;\r
- }\r
- }\r
-\r
- //\r
- // Don't return NV variable when HOB overrides it\r
- //\r
- if ((VariableStoreHeader[VariableStoreTypeHob] != NULL) && (VariableStoreHeader[VariableStoreTypeNv] != NULL) &&\r
- (Variable.StartPtr == GetStartPointer (VariableStoreHeader[VariableStoreTypeNv]))\r
- ) {\r
- VariableInHob.StartPtr = GetStartPointer (VariableStoreHeader[VariableStoreTypeHob]);\r
- VariableInHob.EndPtr = GetEndPointer (VariableStoreHeader[VariableStoreTypeHob]);\r
- Status = FindVariableEx (\r
- GetVariableNamePtr (Variable.CurrPtr),\r
- GetVendorGuidPtr (Variable.CurrPtr),\r
- FALSE,\r
- &VariableInHob\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
- continue;\r
- }\r
- }\r
-\r
- *VariablePtr = Variable.CurrPtr;\r
- Status = EFI_SUCCESS;\r
- goto Done;\r
- }\r
+ if (*DataSize >= VarDataSize) {\r
+ if (Data == NULL) {\r
+ Status = EFI_INVALID_PARAMETER;\r
+ goto Done;\r
}\r
\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
+ CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat), VarDataSize);\r
+\r
+ *DataSize = VarDataSize;\r
+ UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE, &gVariableInfo);\r
+\r
+ Status = EFI_SUCCESS;\r
+ goto Done;\r
+ } else {\r
+ *DataSize = VarDataSize;\r
+ Status = EFI_BUFFER_TOO_SMALL;\r
+ goto Done;\r
}\r
\r
Done:\r
+ if (Status == EFI_SUCCESS || Status == EFI_BUFFER_TOO_SMALL) {\r
+ if (Attributes != NULL && Variable.CurrPtr != NULL) {\r
+ *Attributes = Variable.CurrPtr->Attributes;\r
+ }\r
+ }\r
+ ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
return Status;\r
}\r
\r
Caution: This function may receive untrusted input.\r
This function may be invoked in SMM mode. This function will do basic validation, before parse the data.\r
\r
- @param VariableNameSize Size of the variable name.\r
+ @param VariableNameSize The size of the VariableName buffer. The size must be large\r
+ enough to fit input string supplied in VariableName buffer.\r
@param VariableName Pointer to variable name.\r
@param VendorGuid Variable Vendor Guid.\r
\r
- @return EFI_INVALID_PARAMETER Invalid parameter.\r
- @return EFI_SUCCESS Find the specified variable.\r
- @return EFI_NOT_FOUND Not found.\r
- @return EFI_BUFFER_TO_SMALL DataSize is too small for the result.\r
+ @retval EFI_SUCCESS The function completed successfully.\r
+ @retval EFI_NOT_FOUND The next variable was not found.\r
+ @retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the result.\r
+ VariableNameSize has been updated with the size needed to complete the request.\r
+ @retval EFI_INVALID_PARAMETER VariableNameSize is NULL.\r
+ @retval EFI_INVALID_PARAMETER VariableName is NULL.\r
+ @retval EFI_INVALID_PARAMETER VendorGuid is NULL.\r
+ @retval EFI_INVALID_PARAMETER The input values of VariableName and VendorGuid are not a name and\r
+ GUID of an existing variable.\r
+ @retval EFI_INVALID_PARAMETER Null-terminator is not found in the first VariableNameSize bytes of\r
+ the input VariableName buffer.\r
\r
**/\r
EFI_STATUS\r
)\r
{\r
EFI_STATUS Status;\r
+ UINTN MaxLen;\r
UINTN VarNameSize;\r
+ BOOLEAN AuthFormat;\r
VARIABLE_HEADER *VariablePtr;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];\r
\r
if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
+\r
+ //\r
+ // Calculate the possible maximum length of name string, including the Null terminator.\r
+ //\r
+ MaxLen = *VariableNameSize / sizeof (CHAR16);\r
+ if ((MaxLen == 0) || (StrnLenS (VariableName, MaxLen) == MaxLen)) {\r
+ //\r
+ // Null-terminator is not found in the first VariableNameSize bytes of the input VariableName buffer,\r
+ // follow spec to return EFI_INVALID_PARAMETER.\r
+ //\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
- Status = VariableServiceGetNextVariableInternal (VariableName, VendorGuid, &VariablePtr);\r
+ //\r
+ // 0: Volatile, 1: HOB, 2: Non-Volatile.\r
+ // The index and attributes mapping must be kept in this order as FindVariable\r
+ // makes use of this mapping to implement search algorithm.\r
+ //\r
+ VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;\r
+ VariableStoreHeader[VariableStoreTypeHob] = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;\r
+ VariableStoreHeader[VariableStoreTypeNv] = mNvVariableCache;\r
+\r
+ Status = VariableServiceGetNextVariableInternal (\r
+ VariableName,\r
+ VendorGuid,\r
+ VariableStoreHeader,\r
+ &VariablePtr,\r
+ AuthFormat\r
+ );\r
if (!EFI_ERROR (Status)) {\r
- VarNameSize = NameSizeOfVariable (VariablePtr);\r
+ VarNameSize = NameSizeOfVariable (VariablePtr, AuthFormat);\r
ASSERT (VarNameSize != 0);\r
if (VarNameSize <= *VariableNameSize) {\r
- CopyMem (VariableName, GetVariableNamePtr (VariablePtr), VarNameSize);\r
- CopyMem (VendorGuid, GetVendorGuidPtr (VariablePtr), sizeof (EFI_GUID));\r
+ CopyMem (\r
+ VariableName,\r
+ GetVariableNamePtr (VariablePtr, AuthFormat),\r
+ VarNameSize\r
+ );\r
+ CopyMem (\r
+ VendorGuid,\r
+ GetVendorGuidPtr (VariablePtr, AuthFormat),\r
+ sizeof (EFI_GUID)\r
+ );\r
Status = EFI_SUCCESS;\r
} else {\r
Status = EFI_BUFFER_TOO_SMALL;\r
VARIABLE_HEADER *NextVariable;\r
EFI_PHYSICAL_ADDRESS Point;\r
UINTN PayloadSize;\r
+ BOOLEAN AuthFormat;\r
+\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
\r
//\r
// Check input parameters.\r
\r
//\r
// Check for reserverd bit in variable attribute.\r
+ // EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS is deprecated but we still allow\r
+ // the delete operation of common authenticated variable at user physical presence.\r
+ // So leave EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS attribute check to AuthVariableLib\r
//\r
- if ((Attributes & (~EFI_VARIABLE_ATTRIBUTES_MASK)) != 0) {\r
+ if ((Attributes & (~(EFI_VARIABLE_ATTRIBUTES_MASK | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS))) != 0) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
// Make sure if runtime bit is set, boot service bit is set also.\r
//\r
if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {\r
- return EFI_INVALID_PARAMETER;\r
+ if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
+ return EFI_UNSUPPORTED;\r
+ } else {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
} else if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
if (!mVariableModuleGlobal->VariableGlobal.AuthSupport) {\r
//\r
//\r
if (((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)\r
&& ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) {\r
- return EFI_INVALID_PARAMETER;\r
+ return EFI_UNSUPPORTED;\r
}\r
\r
if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) {\r
- if (DataSize < AUTHINFO_SIZE) {\r
- //\r
- // Try to write Authenticated Variable without AuthInfo.\r
- //\r
- return EFI_SECURITY_VIOLATION;\r
+ //\r
+ // If DataSize == AUTHINFO_SIZE and then PayloadSize is 0.\r
+ // Maybe it's the delete operation of common authenticated variable at user physical presence.\r
+ //\r
+ if (DataSize != AUTHINFO_SIZE) {\r
+ return EFI_UNSUPPORTED;\r
}\r
PayloadSize = DataSize - AUTHINFO_SIZE;\r
} else if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) {\r
((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->AuthInfo.Hdr.dwLength < OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)) {\r
return EFI_SECURITY_VIOLATION;\r
}\r
+ //\r
+ // The VariableSpeculationBarrier() call here is to ensure the above sanity\r
+ // check for the EFI_VARIABLE_AUTHENTICATION_2 descriptor has been completed\r
+ // before the execution of subsequent codes.\r
+ //\r
+ VariableSpeculationBarrier ();\r
PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
} else {\r
PayloadSize = DataSize;\r
// bytes for HwErrRec#### variable.\r
//\r
if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
- if (StrSize (VariableName) + PayloadSize > PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize ()) {\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize (AuthFormat)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
} else {\r
//\r
// The size of the VariableName, including the Unicode Null in bytes plus\r
- // the DataSize is limited to maximum size of Max(Auth)VariableSize bytes.\r
+ // the DataSize is limited to maximum size of Max(Auth|Volatile)VariableSize bytes.\r
//\r
if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
- if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ()) {\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxAuthVariableSize -\r
+ GetVariableHeaderSize (AuthFormat)) {\r
+ DEBUG ((DEBUG_ERROR,\r
+ "%a: Failed to set variable '%s' with Guid %g\n",\r
+ __FUNCTION__, VariableName, VendorGuid));\r
+ DEBUG ((DEBUG_ERROR,\r
+ "NameSize(0x%x) + PayloadSize(0x%x) > "\r
+ "MaxAuthVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
+ StrSize (VariableName), PayloadSize,\r
+ mVariableModuleGlobal->MaxAuthVariableSize,\r
+ GetVariableHeaderSize (AuthFormat)\r
+ ));\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+ } else if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize (AuthFormat)) {\r
+ DEBUG ((DEBUG_ERROR,\r
+ "%a: Failed to set variable '%s' with Guid %g\n",\r
+ __FUNCTION__, VariableName, VendorGuid));\r
+ DEBUG ((DEBUG_ERROR,\r
+ "NameSize(0x%x) + PayloadSize(0x%x) > "\r
+ "MaxVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
+ StrSize (VariableName), PayloadSize,\r
+ mVariableModuleGlobal->MaxVariableSize,\r
+ GetVariableHeaderSize (AuthFormat)\r
+ ));\r
return EFI_INVALID_PARAMETER;\r
}\r
} else {\r
- if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize ()) {\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxVolatileVariableSize - GetVariableHeaderSize (AuthFormat)) {\r
+ DEBUG ((DEBUG_ERROR,\r
+ "%a: Failed to set variable '%s' with Guid %g\n",\r
+ __FUNCTION__, VariableName, VendorGuid));\r
+ DEBUG ((DEBUG_ERROR,\r
+ "NameSize(0x%x) + PayloadSize(0x%x) > "\r
+ "MaxVolatileVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
+ StrSize (VariableName), PayloadSize,\r
+ mVariableModuleGlobal->MaxVolatileVariableSize,\r
+ GetVariableHeaderSize (AuthFormat)\r
+ ));\r
return EFI_INVALID_PARAMETER;\r
}\r
}\r
}\r
\r
+ //\r
+ // Special Handling for MOR Lock variable.\r
+ //\r
+ Status = SetVariableCheckHandlerMor (VariableName, VendorGuid, Attributes, PayloadSize, (VOID *) ((UINTN) Data + DataSize - PayloadSize));\r
+ if (Status == EFI_ALREADY_STARTED) {\r
+ //\r
+ // EFI_ALREADY_STARTED means the SetVariable() action is handled inside of SetVariableCheckHandlerMor().\r
+ // Variable driver can just return SUCCESS.\r
+ //\r
+ return EFI_SUCCESS;\r
+ }\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
+\r
Status = VarCheckLibSetVariableCheck (VariableName, VendorGuid, Attributes, PayloadSize, (VOID *) ((UINTN) Data + DataSize - PayloadSize), mRequestSource);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
//\r
NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point);\r
while (IsValidVariableHeader (NextVariable, GetEndPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point))) {\r
- NextVariable = GetNextVariablePtr (NextVariable);\r
+ NextVariable = GetNextVariablePtr (NextVariable, AuthFormat);\r
}\r
mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;\r
}\r
// 2. The only attribute differing is EFI_VARIABLE_APPEND_WRITE\r
//\r
Status = EFI_INVALID_PARAMETER;\r
- 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));\r
+ DEBUG ((DEBUG_INFO, "[Variable]: Rewritten a preexisting variable(0x%08x) with different attributes(0x%08x) - %g:%s\n", Variable.CurrPtr->Attributes, Attributes, VendorGuid, VariableName));\r
goto Done;\r
}\r
}\r
//\r
if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
*MaximumVariableStorageSize = PcdGet32 (PcdHwErrStorageSize);\r
- *MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize ();\r
+ *MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
} else {\r
if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
if (AtRuntime ()) {\r
}\r
\r
//\r
- // Let *MaximumVariableSize be Max(Auth)VariableSize with the exception of the variable header size.\r
+ // Let *MaximumVariableSize be Max(Auth|Volatile)VariableSize with the exception of the variable header size.\r
//\r
if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
- *MaximumVariableSize = mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ();\r
+ *MaximumVariableSize = mVariableModuleGlobal->MaxAuthVariableSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ } else if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
+ *MaximumVariableSize = mVariableModuleGlobal->MaxVariableSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
} else {\r
- *MaximumVariableSize = mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize ();\r
+ *MaximumVariableSize = mVariableModuleGlobal->MaxVolatileVariableSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\r
}\r
\r
// Now walk through the related variable store.\r
//\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;\r
\r
if (AtRuntime ()) {\r
VariablePtrTrack.StartPtr = GetStartPointer (VariableStoreHeader);\r
VariablePtrTrack.EndPtr = GetEndPointer (VariableStoreHeader);\r
Status = FindVariableEx (\r
- GetVariableNamePtr (Variable),\r
- GetVendorGuidPtr (Variable),\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
FALSE,\r
- &VariablePtrTrack\r
+ &VariablePtrTrack,\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
);\r
if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State != VAR_ADDED) {\r
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
}\r
}\r
\r
- if (*RemainingVariableStorageSize < GetVariableHeaderSize ()) {\r
+ if (*RemainingVariableStorageSize < GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat)) {\r
*MaximumVariableSize = 0;\r
- } else if ((*RemainingVariableStorageSize - GetVariableHeaderSize ()) < *MaximumVariableSize) {\r
- *MaximumVariableSize = *RemainingVariableStorageSize - GetVariableHeaderSize ();\r
+ } else if ((*RemainingVariableStorageSize - GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat)) <\r
+ *MaximumVariableSize\r
+ ) {\r
+ *MaximumVariableSize = *RemainingVariableStorageSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\r
\r
return EFI_SUCCESS;\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
+ if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
+ //\r
+ // Deprecated attribute, make this check as highest priority.\r
+ //\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
if ((Attributes & EFI_VARIABLE_ATTRIBUTES_MASK) == 0) {\r
//\r
// Make sure the Attributes combination is supported by the platform.\r
}\r
\r
/**\r
- Get non-volatile maximum variable size.\r
+ Get maximum variable size, covering both non-volatile and volatile variables.\r
\r
- @return Non-volatile maximum variable size.\r
+ @return Maximum variable size.\r
\r
**/\r
UINTN\r
-GetNonVolatileMaxVariableSize (\r
+GetMaxVariableSize (\r
VOID\r
)\r
{\r
- if (PcdGet32 (PcdHwErrStorageSize) != 0) {\r
- return MAX (MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxAuthVariableSize)),\r
- PcdGet32 (PcdMaxHardwareErrorVariableSize));\r
- } else {\r
- return MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxAuthVariableSize));\r
- }\r
-}\r
-\r
-/**\r
- Init non-volatile variable store.\r
-\r
- @param[out] NvFvHeader Output pointer to non-volatile FV header address.\r
-\r
- @retval EFI_SUCCESS Function successfully executed.\r
- @retval EFI_OUT_OF_RESOURCES Fail to allocate enough memory resource.\r
- @retval EFI_VOLUME_CORRUPTED Variable Store or Firmware Volume for Variable Store is corrupted.\r
-\r
-**/\r
-EFI_STATUS\r
-InitNonVolatileVariableStore (\r
- OUT EFI_FIRMWARE_VOLUME_HEADER **NvFvHeader\r
- )\r
-{\r
- EFI_FIRMWARE_VOLUME_HEADER *FvHeader;\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *NextVariable;\r
- EFI_PHYSICAL_ADDRESS VariableStoreBase;\r
- UINT64 VariableStoreLength;\r
- UINTN VariableSize;\r
- EFI_HOB_GUID_TYPE *GuidHob;\r
- EFI_PHYSICAL_ADDRESS NvStorageBase;\r
- UINT8 *NvStorageData;\r
- UINT32 NvStorageSize;\r
- FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *FtwLastWriteData;\r
- UINT32 BackUpOffset;\r
- UINT32 BackUpSize;\r
- UINT32 HwErrStorageSize;\r
- UINT32 MaxUserNvVariableSpaceSize;\r
- UINT32 BoottimeReservedNvVariableSpaceSize;\r
- EFI_STATUS Status;\r
- VOID *FtwProtocol;\r
-\r
- mVariableModuleGlobal->FvbInstance = NULL;\r
-\r
- //\r
- // Allocate runtime memory used for a memory copy of the FLASH region.\r
- // Keep the memory and the FLASH in sync as updates occur.\r
- //\r
- NvStorageSize = PcdGet32 (PcdFlashNvStorageVariableSize);\r
- NvStorageData = AllocateRuntimeZeroPool (NvStorageSize);\r
- if (NvStorageData == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);\r
- if (NvStorageBase == 0) {\r
- NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);\r
- }\r
- //\r
- // Copy NV storage data to the memory buffer.\r
- //\r
- CopyMem (NvStorageData, (UINT8 *) (UINTN) NvStorageBase, NvStorageSize);\r
-\r
- Status = GetFtwProtocol ((VOID **)&FtwProtocol);\r
- //\r
- // If FTW protocol has been installed, no need to check FTW last write data hob.\r
- //\r
- if (EFI_ERROR (Status)) {\r
- //\r
- // Check the FTW last write data hob.\r
- //\r
- GuidHob = GetFirstGuidHob (&gEdkiiFaultTolerantWriteGuid);\r
- if (GuidHob != NULL) {\r
- FtwLastWriteData = (FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *) GET_GUID_HOB_DATA (GuidHob);\r
- if (FtwLastWriteData->TargetAddress == NvStorageBase) {\r
- DEBUG ((EFI_D_INFO, "Variable: NV storage is backed up in spare block: 0x%x\n", (UINTN) FtwLastWriteData->SpareAddress));\r
- //\r
- // Copy the backed up NV storage data to the memory buffer from spare block.\r
- //\r
- CopyMem (NvStorageData, (UINT8 *) (UINTN) (FtwLastWriteData->SpareAddress), NvStorageSize);\r
- } else if ((FtwLastWriteData->TargetAddress > NvStorageBase) &&\r
- (FtwLastWriteData->TargetAddress < (NvStorageBase + NvStorageSize))) {\r
- //\r
- // Flash NV storage from the Offset is backed up in spare block.\r
- //\r
- BackUpOffset = (UINT32) (FtwLastWriteData->TargetAddress - NvStorageBase);\r
- BackUpSize = NvStorageSize - BackUpOffset;\r
- 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));\r
- //\r
- // Copy the partial backed up NV storage data to the memory buffer from spare block.\r
- //\r
- CopyMem (NvStorageData + BackUpOffset, (UINT8 *) (UINTN) FtwLastWriteData->SpareAddress, BackUpSize);\r
- }\r
- }\r
- }\r
-\r
- FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) NvStorageData;\r
-\r
- //\r
- // Check if the Firmware Volume is not corrupted\r
- //\r
- if ((FvHeader->Signature != EFI_FVH_SIGNATURE) || (!CompareGuid (&gEfiSystemNvDataFvGuid, &FvHeader->FileSystemGuid))) {\r
- FreePool (NvStorageData);\r
- DEBUG ((EFI_D_ERROR, "Firmware Volume for Variable Store is corrupted\n"));\r
- return EFI_VOLUME_CORRUPTED;\r
- }\r
-\r
- VariableStoreBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) FvHeader + FvHeader->HeaderLength);\r
- VariableStoreLength = (UINT64) (NvStorageSize - FvHeader->HeaderLength);\r
-\r
- mNvFvHeaderCache = FvHeader;\r
- mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;\r
- mNvVariableCache = (VARIABLE_STORE_HEADER *) (UINTN) VariableStoreBase;\r
- if (GetVariableStoreStatus (mNvVariableCache) != EfiValid) {\r
- FreePool (NvStorageData);\r
- mNvFvHeaderCache = NULL;\r
- mNvVariableCache = NULL;\r
- DEBUG((EFI_D_ERROR, "Variable Store header is corrupted\n"));\r
- return EFI_VOLUME_CORRUPTED;\r
- }\r
- ASSERT(mNvVariableCache->Size == VariableStoreLength);\r
-\r
- ASSERT (sizeof (VARIABLE_STORE_HEADER) <= VariableStoreLength);\r
-\r
- mVariableModuleGlobal->VariableGlobal.AuthFormat = (BOOLEAN)(CompareGuid (&mNvVariableCache->Signature, &gEfiAuthenticatedVariableGuid));\r
-\r
- HwErrStorageSize = PcdGet32 (PcdHwErrStorageSize);\r
- MaxUserNvVariableSpaceSize = PcdGet32 (PcdMaxUserNvVariableSpaceSize);\r
- BoottimeReservedNvVariableSpaceSize = PcdGet32 (PcdBoottimeReservedNvVariableSpaceSize);\r
-\r
- //\r
- // Note that in EdkII variable driver implementation, Hardware Error Record type variable\r
- // is stored with common variable in the same NV region. So the platform integrator should\r
- // ensure that the value of PcdHwErrStorageSize is less than the value of\r
- // (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)).\r
- //\r
- ASSERT (HwErrStorageSize < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)));\r
- //\r
- // Ensure that the value of PcdMaxUserNvVariableSpaceSize is less than the value of\r
- // (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)) - PcdGet32 (PcdHwErrStorageSize).\r
- //\r
- ASSERT (MaxUserNvVariableSpaceSize < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize));\r
- //\r
- // Ensure that the value of PcdBoottimeReservedNvVariableSpaceSize is less than the value of\r
- // (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)) - PcdGet32 (PcdHwErrStorageSize).\r
- //\r
- ASSERT (BoottimeReservedNvVariableSpaceSize < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize));\r
-\r
- mVariableModuleGlobal->CommonVariableSpace = ((UINTN) VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize);\r
- mVariableModuleGlobal->CommonMaxUserVariableSpace = ((MaxUserNvVariableSpaceSize != 0) ? MaxUserNvVariableSpaceSize : mVariableModuleGlobal->CommonVariableSpace);\r
- mVariableModuleGlobal->CommonRuntimeVariableSpace = mVariableModuleGlobal->CommonVariableSpace - BoottimeReservedNvVariableSpaceSize;\r
-\r
- DEBUG ((EFI_D_INFO, "Variable driver common space: 0x%x 0x%x 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonRuntimeVariableSpace));\r
-\r
- //\r
- // The max NV variable size should be < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)).\r
- //\r
- ASSERT (GetNonVolatileMaxVariableSize () < (VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)));\r
-\r
- mVariableModuleGlobal->MaxVariableSize = PcdGet32 (PcdMaxVariableSize);\r
- mVariableModuleGlobal->MaxAuthVariableSize = ((PcdGet32 (PcdMaxAuthVariableSize) != 0) ? PcdGet32 (PcdMaxAuthVariableSize) : mVariableModuleGlobal->MaxVariableSize);\r
+ UINTN MaxVariableSize;\r
\r
+ MaxVariableSize = GetNonVolatileMaxVariableSize();\r
//\r
- // Parse non-volatile variable data and get last variable offset.\r
+ // The condition below fails implicitly if PcdMaxVolatileVariableSize equals\r
+ // the default zero value.\r
//\r
- Variable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase);\r
- while (IsValidVariableHeader (Variable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
- if ((Variable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
- mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
- } else {\r
- mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;\r
- }\r
-\r
- Variable = NextVariable;\r
+ if (MaxVariableSize < PcdGet32 (PcdMaxVolatileVariableSize)) {\r
+ MaxVariableSize = PcdGet32 (PcdMaxVolatileVariableSize);\r
}\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) Variable - (UINTN) VariableStoreBase;\r
-\r
- *NvFvHeader = FvHeader;\r
- return EFI_SUCCESS;\r
+ return MaxVariableSize;\r
}\r
\r
/**\r
VOID *VariableData;\r
VARIABLE_POINTER_TRACK VariablePtrTrack;\r
BOOLEAN ErrorFlag;\r
+ BOOLEAN AuthFormat;\r
\r
ErrorFlag = FALSE;\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
\r
//\r
// Flush the HOB variable to flash.\r
mVariableModuleGlobal->VariableGlobal.HobVariableBase = 0;\r
for ( Variable = GetStartPointer (VariableStoreHeader)\r
; IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))\r
- ; Variable = GetNextVariablePtr (Variable)\r
+ ; Variable = GetNextVariablePtr (Variable, AuthFormat)\r
) {\r
if (Variable->State != VAR_ADDED) {\r
//\r
}\r
ASSERT ((Variable->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0);\r
if (VendorGuid == NULL || VariableName == NULL ||\r
- !CompareGuid (VendorGuid, GetVendorGuidPtr (Variable)) ||\r
- StrCmp (VariableName, GetVariableNamePtr (Variable)) != 0) {\r
- VariableData = GetVariableDataPtr (Variable);\r
- FindVariable (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &VariablePtrTrack, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
+ !CompareGuid (VendorGuid, GetVendorGuidPtr (Variable, AuthFormat)) ||\r
+ StrCmp (VariableName, GetVariableNamePtr (Variable, AuthFormat)) != 0) {\r
+ VariableData = GetVariableDataPtr (Variable, AuthFormat);\r
+ FindVariable (\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ &VariablePtrTrack,\r
+ &mVariableModuleGlobal->VariableGlobal, FALSE\r
+ );\r
Status = UpdateVariable (\r
- GetVariableNamePtr (Variable),\r
- GetVendorGuidPtr (Variable),\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
VariableData,\r
- DataSizeOfVariable (Variable),\r
+ DataSizeOfVariable (Variable, AuthFormat),\r
Variable->Attributes,\r
0,\r
0,\r
&VariablePtrTrack,\r
NULL\r
);\r
- DEBUG ((EFI_D_INFO, "Variable driver flush the HOB variable to flash: %g %s %r\n", GetVendorGuidPtr (Variable), GetVariableNamePtr (Variable), Status));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "Variable driver flush the HOB variable to flash: %g %s %r\n",\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ Status\r
+ ));\r
} else {\r
//\r
// The updated or deleted variable is matched with this HOB variable.\r
// If set variable successful, or the updated or deleted variable is matched with the HOB variable,\r
// set the HOB variable to DELETED state in local.\r
//\r
- DEBUG ((EFI_D_INFO, "Variable driver set the HOB variable to DELETED state in local: %g %s\n", GetVendorGuidPtr (Variable), GetVariableNamePtr (Variable)));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "Variable driver set the HOB variable to DELETED state in local: %g %s\n",\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ GetVariableNamePtr (Variable, AuthFormat)\r
+ ));\r
Variable->State &= VAR_DELETED;\r
} else {\r
ErrorFlag = TRUE;\r
}\r
}\r
+ if (mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeHobCache.Store != NULL) {\r
+ Status = SynchronizeRuntimeVariableCache (\r
+ &mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeHobCache,\r
+ 0,\r
+ mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.VariableRuntimeHobCache.Store->Size\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
if (ErrorFlag) {\r
//\r
// We still have HOB variable(s) not flushed in flash.\r
//\r
// All HOB variables have been flushed in flash.\r
//\r
- DEBUG ((EFI_D_INFO, "Variable driver: all HOB variables have been flushed in flash.\n"));\r
+ DEBUG ((DEBUG_INFO, "Variable driver: all HOB variables have been flushed in flash.\n"));\r
+ if (mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.HobFlushComplete != NULL) {\r
+ *(mVariableModuleGlobal->VariableGlobal.VariableRuntimeCacheContext.HobFlushComplete) = TRUE;\r
+ }\r
if (!AtRuntime ()) {\r
FreePool ((VOID *) VariableStoreHeader);\r
}\r
}\r
\r
/**\r
- Initializes variable write service after FTW was ready.\r
+ Initializes variable write service.\r
\r
@retval EFI_SUCCESS Function successfully executed.\r
@retval Others Fail to initialize the variable service.\r
EFI_STATUS Status;\r
UINTN Index;\r
UINT8 Data;\r
- EFI_PHYSICAL_ADDRESS VariableStoreBase;\r
- EFI_PHYSICAL_ADDRESS NvStorageBase;\r
VARIABLE_ENTRY_PROPERTY *VariableEntry;\r
\r
AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
- NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);\r
- if (NvStorageBase == 0) {\r
- NvStorageBase = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);\r
- }\r
- VariableStoreBase = NvStorageBase + (mNvFvHeaderCache->HeaderLength);\r
-\r
- //\r
- // Let NonVolatileVariableBase point to flash variable store base directly after FTW ready.\r
- //\r
- mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;\r
-\r
//\r
// Check if the free area is really free.\r
//\r
// Authenticated variable initialize.\r
//\r
mAuthContextIn.StructSize = sizeof (AUTH_VAR_LIB_CONTEXT_IN);\r
- mAuthContextIn.MaxAuthVariableSize = mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ();\r
+ mAuthContextIn.MaxAuthVariableSize = mVariableModuleGlobal->MaxAuthVariableSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
Status = AuthVariableLibInitialize (&mAuthContextIn, &mAuthContextOut);\r
if (!EFI_ERROR (Status)) {\r
- DEBUG ((EFI_D_INFO, "Variable driver will work with auth variable support!\n"));\r
+ DEBUG ((DEBUG_INFO, "Variable driver will work with auth variable support!\n"));\r
mVariableModuleGlobal->VariableGlobal.AuthSupport = TRUE;\r
if (mAuthContextOut.AuthVarEntry != NULL) {\r
for (Index = 0; Index < mAuthContextOut.AuthVarEntryCount; Index++) {\r
}\r
}\r
} else if (Status == EFI_UNSUPPORTED) {\r
- DEBUG ((EFI_D_INFO, "NOTICE - AuthVariableLibInitialize() returns %r!\n", Status));\r
- DEBUG ((EFI_D_INFO, "Variable driver will continue to work without auth variable support!\n"));\r
+ DEBUG ((DEBUG_INFO, "NOTICE - AuthVariableLibInitialize() returns %r!\n", Status));\r
+ DEBUG ((DEBUG_INFO, "Variable driver will continue to work without auth variable support!\n"));\r
mVariableModuleGlobal->VariableGlobal.AuthSupport = FALSE;\r
Status = EFI_SUCCESS;\r
}\r
}\r
\r
if (!EFI_ERROR (Status)) {\r
- for (Index = 0; Index < sizeof (mVariableEntryProperty) / sizeof (mVariableEntryProperty[0]); Index++) {\r
+ for (Index = 0; Index < ARRAY_SIZE (mVariableEntryProperty); Index++) {\r
VariableEntry = &mVariableEntryProperty[Index];\r
Status = VarCheckLibVariablePropertySet (VariableEntry->Name, VariableEntry->Guid, &VariableEntry->VariableProperty);\r
ASSERT_EFI_ERROR (Status);\r
}\r
\r
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
+\r
+ //\r
+ // Initialize MOR Lock variable.\r
+ //\r
+ MorLockInit ();\r
+\r
return Status;\r
}\r
\r
+/**\r
+ Convert normal variable storage to the allocated auth variable storage.\r
+\r
+ @param[in] NormalVarStorage Pointer to the normal variable storage header\r
+\r
+ @retval the allocated auth variable storage\r
+**/\r
+VOID *\r
+ConvertNormalVarStorageToAuthVarStorage (\r
+ VARIABLE_STORE_HEADER *NormalVarStorage\r
+ )\r
+{\r
+ VARIABLE_HEADER *StartPtr;\r
+ UINT8 *NextPtr;\r
+ VARIABLE_HEADER *EndPtr;\r
+ UINTN AuthVarStroageSize;\r
+ AUTHENTICATED_VARIABLE_HEADER *AuthStartPtr;\r
+ VARIABLE_STORE_HEADER *AuthVarStorage;\r
+\r
+ AuthVarStroageSize = sizeof (VARIABLE_STORE_HEADER);\r
+ //\r
+ // Set AuthFormat as FALSE for normal variable storage\r
+ //\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat = FALSE;\r
+\r
+ //\r
+ // Calculate Auth Variable Storage Size\r
+ //\r
+ StartPtr = GetStartPointer (NormalVarStorage);\r
+ EndPtr = GetEndPointer (NormalVarStorage);\r
+ while (StartPtr < EndPtr) {\r
+ if (StartPtr->State == VAR_ADDED) {\r
+ AuthVarStroageSize = HEADER_ALIGN (AuthVarStroageSize);\r
+ AuthVarStroageSize += sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
+ AuthVarStroageSize += StartPtr->NameSize + GET_PAD_SIZE (StartPtr->NameSize);\r
+ AuthVarStroageSize += StartPtr->DataSize + GET_PAD_SIZE (StartPtr->DataSize);\r
+ }\r
+ StartPtr = GetNextVariablePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ }\r
+\r
+ //\r
+ // Allocate Runtime memory for Auth Variable Storage\r
+ //\r
+ AuthVarStorage = AllocateRuntimeZeroPool (AuthVarStroageSize);\r
+ ASSERT (AuthVarStorage != NULL);\r
+ if (AuthVarStorage == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // Copy Variable from Normal storage to Auth storage\r
+ //\r
+ StartPtr = GetStartPointer (NormalVarStorage);\r
+ EndPtr = GetEndPointer (NormalVarStorage);\r
+ AuthStartPtr = (AUTHENTICATED_VARIABLE_HEADER *) GetStartPointer (AuthVarStorage);\r
+ while (StartPtr < EndPtr) {\r
+ if (StartPtr->State == VAR_ADDED) {\r
+ AuthStartPtr = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN (AuthStartPtr);\r
+ //\r
+ // Copy Variable Header\r
+ //\r
+ AuthStartPtr->StartId = StartPtr->StartId;\r
+ AuthStartPtr->State = StartPtr->State;\r
+ AuthStartPtr->Attributes = StartPtr->Attributes;\r
+ AuthStartPtr->NameSize = StartPtr->NameSize;\r
+ AuthStartPtr->DataSize = StartPtr->DataSize;\r
+ CopyGuid (&AuthStartPtr->VendorGuid, &StartPtr->VendorGuid);\r
+ //\r
+ // Copy Variable Name\r
+ //\r
+ NextPtr = (UINT8 *) (AuthStartPtr + 1);\r
+ CopyMem (\r
+ NextPtr,\r
+ GetVariableNamePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ AuthStartPtr->NameSize\r
+ );\r
+ //\r
+ // Copy Variable Data\r
+ //\r
+ NextPtr = NextPtr + AuthStartPtr->NameSize + GET_PAD_SIZE (AuthStartPtr->NameSize);\r
+ CopyMem (NextPtr, GetVariableDataPtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat), AuthStartPtr->DataSize);\r
+ //\r
+ // Go to next variable\r
+ //\r
+ AuthStartPtr = (AUTHENTICATED_VARIABLE_HEADER *) (NextPtr + AuthStartPtr->DataSize + GET_PAD_SIZE (AuthStartPtr->DataSize));\r
+ }\r
+ StartPtr = GetNextVariablePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ }\r
+ //\r
+ // Update Auth Storage Header\r
+ //\r
+ AuthVarStorage->Format = NormalVarStorage->Format;\r
+ AuthVarStorage->State = NormalVarStorage->State;\r
+ AuthVarStorage->Size = (UINT32)((UINTN)AuthStartPtr - (UINTN)AuthVarStorage);\r
+ CopyGuid (&AuthVarStorage->Signature, &gEfiAuthenticatedVariableGuid);\r
+ ASSERT (AuthVarStorage->Size <= AuthVarStroageSize);\r
+\r
+ //\r
+ // Restore AuthFormat\r
+ //\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat = TRUE;\r
+ return AuthVarStorage;\r
+}\r
+\r
+/**\r
+ Get HOB variable store.\r
+\r
+ @param[in] VariableGuid NV variable store signature.\r
+\r
+ @retval EFI_SUCCESS Function successfully executed.\r
+ @retval EFI_OUT_OF_RESOURCES Fail to allocate enough memory resource.\r
+\r
+**/\r
+EFI_STATUS\r
+GetHobVariableStore (\r
+ IN EFI_GUID *VariableGuid\r
+ )\r
+{\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader;\r
+ UINT64 VariableStoreLength;\r
+ EFI_HOB_GUID_TYPE *GuidHob;\r
+ BOOLEAN NeedConvertNormalToAuth;\r
+\r
+ //\r
+ // Make sure there is no more than one Variable HOB.\r
+ //\r
+ DEBUG_CODE (\r
+ GuidHob = GetFirstGuidHob (&gEfiAuthenticatedVariableGuid);\r
+ if (GuidHob != NULL) {\r
+ if ((GetNextGuidHob (&gEfiAuthenticatedVariableGuid, GET_NEXT_HOB (GuidHob)) != NULL)) {\r
+ DEBUG ((DEBUG_ERROR, "ERROR: Found two Auth Variable HOBs\n"));\r
+ ASSERT (FALSE);\r
+ } else if (GetFirstGuidHob (&gEfiVariableGuid) != NULL) {\r
+ DEBUG ((DEBUG_ERROR, "ERROR: Found one Auth + one Normal Variable HOBs\n"));\r
+ ASSERT (FALSE);\r
+ }\r
+ } else {\r
+ GuidHob = GetFirstGuidHob (&gEfiVariableGuid);\r
+ if (GuidHob != NULL) {\r
+ if ((GetNextGuidHob (&gEfiVariableGuid, GET_NEXT_HOB (GuidHob)) != NULL)) {\r
+ DEBUG ((DEBUG_ERROR, "ERROR: Found two Normal Variable HOBs\n"));\r
+ ASSERT (FALSE);\r
+ }\r
+ }\r
+ }\r
+ );\r
+\r
+ //\r
+ // Combinations supported:\r
+ // 1. Normal NV variable store +\r
+ // Normal HOB variable store\r
+ // 2. Auth NV variable store +\r
+ // Auth HOB variable store\r
+ // 3. Auth NV variable store +\r
+ // Normal HOB variable store (code will convert it to Auth Format)\r
+ //\r
+ NeedConvertNormalToAuth = FALSE;\r
+ GuidHob = GetFirstGuidHob (VariableGuid);\r
+ if (GuidHob == NULL && VariableGuid == &gEfiAuthenticatedVariableGuid) {\r
+ //\r
+ // Try getting it from normal variable HOB\r
+ //\r
+ GuidHob = GetFirstGuidHob (&gEfiVariableGuid);\r
+ NeedConvertNormalToAuth = TRUE;\r
+ }\r
+ if (GuidHob != NULL) {\r
+ VariableStoreHeader = GET_GUID_HOB_DATA (GuidHob);\r
+ VariableStoreLength = GuidHob->Header.HobLength - sizeof (EFI_HOB_GUID_TYPE);\r
+ if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {\r
+ if (!NeedConvertNormalToAuth) {\r
+ mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) AllocateRuntimeCopyPool ((UINTN) VariableStoreLength, (VOID *) VariableStoreHeader);\r
+ } else {\r
+ mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) ConvertNormalVarStorageToAuthVarStorage ((VOID *) VariableStoreHeader);\r
+ }\r
+ if (mVariableModuleGlobal->VariableGlobal.HobVariableBase == 0) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+ } else {\r
+ DEBUG ((DEBUG_ERROR, "HOB Variable Store header is corrupted!\n"));\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
\r
/**\r
Initializes variable store area for non-volatile and volatile variable.\r
{\r
EFI_STATUS Status;\r
VARIABLE_STORE_HEADER *VolatileVariableStore;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINT64 VariableStoreLength;\r
UINTN ScratchSize;\r
- EFI_HOB_GUID_TYPE *GuidHob;\r
EFI_GUID *VariableGuid;\r
- EFI_FIRMWARE_VOLUME_HEADER *NvFvHeader;\r
\r
//\r
// Allocate runtime memory for variable driver global structure.\r
//\r
// Init non-volatile variable store.\r
//\r
- NvFvHeader = NULL;\r
- Status = InitNonVolatileVariableStore (&NvFvHeader);\r
+ Status = InitNonVolatileVariableStore ();\r
if (EFI_ERROR (Status)) {\r
FreePool (mVariableModuleGlobal);\r
return Status;\r
// has been initialized in InitNonVolatileVariableStore().\r
//\r
if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- DEBUG ((EFI_D_INFO, "Variable driver will work with auth variable format!\n"));\r
+ DEBUG ((DEBUG_INFO, "Variable driver will work with auth variable format!\n"));\r
//\r
// Set AuthSupport to FALSE first, VariableWriteServiceInitialize() will initialize it.\r
//\r
mVariableModuleGlobal->VariableGlobal.AuthSupport = FALSE;\r
VariableGuid = &gEfiAuthenticatedVariableGuid;\r
} else {\r
- DEBUG ((EFI_D_INFO, "Variable driver will work without auth variable support!\n"));\r
+ DEBUG ((DEBUG_INFO, "Variable driver will work without auth variable support!\n"));\r
mVariableModuleGlobal->VariableGlobal.AuthSupport = FALSE;\r
VariableGuid = &gEfiVariableGuid;\r
}\r
//\r
// Get HOB variable store.\r
//\r
- GuidHob = GetFirstGuidHob (VariableGuid);\r
- if (GuidHob != NULL) {\r
- VariableStoreHeader = GET_GUID_HOB_DATA (GuidHob);\r
- VariableStoreLength = (UINT64) (GuidHob->Header.HobLength - sizeof (EFI_HOB_GUID_TYPE));\r
- if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {\r
- mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) AllocateRuntimeCopyPool ((UINTN) VariableStoreLength, (VOID *) VariableStoreHeader);\r
- if (mVariableModuleGlobal->VariableGlobal.HobVariableBase == 0) {\r
- FreePool (NvFvHeader);\r
- FreePool (mVariableModuleGlobal);\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
- } else {\r
- DEBUG ((EFI_D_ERROR, "HOB Variable Store header is corrupted!\n"));\r
+ Status = GetHobVariableStore (VariableGuid);\r
+ if (EFI_ERROR (Status)) {\r
+ if (mNvFvHeaderCache != NULL) {\r
+ FreePool (mNvFvHeaderCache);\r
}\r
+ FreePool (mVariableModuleGlobal);\r
+ return Status;\r
}\r
\r
+ mVariableModuleGlobal->MaxVolatileVariableSize = ((PcdGet32 (PcdMaxVolatileVariableSize) != 0) ?\r
+ PcdGet32 (PcdMaxVolatileVariableSize) :\r
+ mVariableModuleGlobal->MaxVariableSize\r
+ );\r
//\r
// Allocate memory for volatile variable store, note that there is a scratch space to store scratch data.\r
//\r
- ScratchSize = GetNonVolatileMaxVariableSize ();\r
+ ScratchSize = GetMaxVariableSize ();\r
mVariableModuleGlobal->ScratchBufferSize = ScratchSize;\r
VolatileVariableStore = AllocateRuntimePool (PcdGet32 (PcdVariableStoreSize) + ScratchSize);\r
if (VolatileVariableStore == NULL) {\r
if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {\r
FreePool ((VOID *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase);\r
}\r
- FreePool (NvFvHeader);\r
+ if (mNvFvHeaderCache != NULL) {\r
+ FreePool (mNvFvHeaderCache);\r
+ }\r
FreePool (mVariableModuleGlobal);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
return Status;\r
}\r
-\r
projects / mirror_edk2.git / blobdiff