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 - 2019, Intel Corporation. All rights reserved.<BR>\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
+Copyright (c) 2022, ARM Limited. All rights reserved.<BR>\r
+\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
/// 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
+VARIABLE_STORE_HEADER *mNvVariableCache = NULL;\r
\r
///\r
/// Memory cache of Fv Header.\r
///\r
-EFI_FIRMWARE_VOLUME_HEADER *mNvFvHeaderCache = NULL;\r
+EFI_FIRMWARE_VOLUME_HEADER *mNvFvHeaderCache = NULL;\r
\r
///\r
/// The memory entry used for variable statistics data.\r
///\r
-VARIABLE_INFO_ENTRY *gVariableInfo = NULL;\r
+VARIABLE_INFO_ENTRY *gVariableInfo = NULL;\r
\r
///\r
/// The flag to indicate whether the platform has left the DXE phase of execution.\r
///\r
-BOOLEAN mEndOfDxe = FALSE;\r
+BOOLEAN mEndOfDxe = FALSE;\r
\r
///\r
/// It indicates the var check request source.\r
/// In the implementation, DXE is regarded as untrusted, and SMM is trusted.\r
///\r
-VAR_CHECK_REQUEST_SOURCE mRequestSource = VarCheckFromUntrusted;\r
+VAR_CHECK_REQUEST_SOURCE mRequestSource = VarCheckFromUntrusted;\r
\r
//\r
// It will record the current boot error flag before EndOfDxe.\r
//\r
-VAR_ERROR_FLAG mCurrentBootVarErrFlag = VAR_ERROR_FLAG_NO_ERROR;\r
+VAR_ERROR_FLAG mCurrentBootVarErrFlag = VAR_ERROR_FLAG_NO_ERROR;\r
\r
-VARIABLE_ENTRY_PROPERTY mVariableEntryProperty[] = {\r
+VARIABLE_ENTRY_PROPERTY mVariableEntryProperty[] = {\r
{\r
&gEdkiiVarErrorFlagGuid,\r
VAR_ERROR_FLAG_NAME,\r
},\r
};\r
\r
-AUTH_VAR_LIB_CONTEXT_IN mAuthContextIn = {\r
+AUTH_VAR_LIB_CONTEXT_IN mAuthContextIn = {\r
AUTH_VAR_LIB_CONTEXT_IN_STRUCT_VERSION,\r
//\r
// StructSize, TO BE FILLED\r
VariableExLibAtRuntime,\r
};\r
\r
-AUTH_VAR_LIB_CONTEXT_OUT mAuthContextOut;\r
+AUTH_VAR_LIB_CONTEXT_OUT mAuthContextOut;\r
\r
/**\r
\r
IN UINT8 *Buffer\r
)\r
{\r
- EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;\r
- UINTN BlockIndex2;\r
- UINTN LinearOffset;\r
- UINTN CurrWriteSize;\r
- UINTN CurrWritePtr;\r
- UINT8 *CurrBuffer;\r
- EFI_LBA LbaNumber;\r
- UINTN Size;\r
- VARIABLE_STORE_HEADER *VolatileBase;\r
- EFI_PHYSICAL_ADDRESS FvVolHdr;\r
- EFI_PHYSICAL_ADDRESS DataPtr;\r
- EFI_STATUS Status;\r
+ EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;\r
+ UINTN BlockIndex2;\r
+ UINTN LinearOffset;\r
+ UINTN CurrWriteSize;\r
+ UINTN CurrWritePtr;\r
+ UINT8 *CurrBuffer;\r
+ EFI_LBA LbaNumber;\r
+ UINTN Size;\r
+ VARIABLE_STORE_HEADER *VolatileBase;\r
+ EFI_PHYSICAL_ADDRESS FvVolHdr;\r
+ EFI_PHYSICAL_ADDRESS DataPtr;\r
+ EFI_STATUS Status;\r
\r
- FvVolHdr = 0;\r
- DataPtr = DataPtrIndex;\r
+ FvVolHdr = 0;\r
+ DataPtr = DataPtrIndex;\r
\r
//\r
// Check if the Data is Volatile.\r
if (Fvb == NULL) {\r
return EFI_UNSUPPORTED;\r
}\r
- Status = Fvb->GetPhysicalAddress(Fvb, &FvVolHdr);\r
+\r
+ Status = Fvb->GetPhysicalAddress (Fvb, &FvVolHdr);\r
ASSERT_EFI_ERROR (Status);\r
\r
//\r
// written.\r
//\r
if (Volatile) {\r
- VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
+ VolatileBase = (VARIABLE_STORE_HEADER *)((UINTN)mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
if (SetByIndex) {\r
DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;\r
}\r
\r
- if ((DataPtr + DataSize) > ((UINTN) VolatileBase + VolatileBase->Size)) {\r
+ if ((DataPtr + DataSize) > ((UINTN)VolatileBase + VolatileBase->Size)) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
} else {\r
// Emulated non-volatile variable mode.\r
//\r
if (SetByIndex) {\r
- DataPtr += (UINTN) mNvVariableCache;\r
+ DataPtr += (UINTN)mNvVariableCache;\r
}\r
\r
- if ((DataPtr + DataSize) > ((UINTN) mNvVariableCache + mNvVariableCache->Size)) {\r
+ if ((DataPtr + DataSize) > ((UINTN)mNvVariableCache + mNvVariableCache->Size)) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
}\r
//\r
// If we are here we are dealing with Non-Volatile Variables.\r
//\r
- LinearOffset = (UINTN) FvVolHdr;\r
- CurrWritePtr = (UINTN) DataPtr;\r
+ LinearOffset = (UINTN)FvVolHdr;\r
+ CurrWritePtr = (UINTN)DataPtr;\r
CurrWriteSize = DataSize;\r
CurrBuffer = Buffer;\r
LbaNumber = 0;\r
if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->Length)) {\r
if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->Length)) {\r
Status = Fvb->Write (\r
- Fvb,\r
- LbaNumber,\r
- (UINTN) (CurrWritePtr - LinearOffset),\r
- &CurrWriteSize,\r
- CurrBuffer\r
- );\r
+ Fvb,\r
+ LbaNumber,\r
+ (UINTN)(CurrWritePtr - LinearOffset),\r
+ &CurrWriteSize,\r
+ CurrBuffer\r
+ );\r
return Status;\r
} else {\r
- Size = (UINT32) (LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);\r
+ Size = (UINT32)(LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);\r
Status = Fvb->Write (\r
- Fvb,\r
- LbaNumber,\r
- (UINTN) (CurrWritePtr - LinearOffset),\r
- &Size,\r
- CurrBuffer\r
- );\r
+ Fvb,\r
+ LbaNumber,\r
+ (UINTN)(CurrWritePtr - LinearOffset),\r
+ &Size,\r
+ CurrBuffer\r
+ );\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
**/\r
VOID\r
RecordVarErrorFlag (\r
- IN VAR_ERROR_FLAG Flag,\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- IN UINT32 Attributes,\r
- IN UINTN VariableSize\r
+ IN VAR_ERROR_FLAG Flag,\r
+ IN CHAR16 *VariableName,\r
+ IN EFI_GUID *VendorGuid,\r
+ IN UINT32 Attributes,\r
+ IN UINTN VariableSize\r
)\r
{\r
- EFI_STATUS Status;\r
- VARIABLE_POINTER_TRACK Variable;\r
- VAR_ERROR_FLAG *VarErrFlag;\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
- 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
- } else {\r
- DEBUG ((EFI_D_ERROR, "CommonVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
- }\r
+ EFI_STATUS Status;\r
+ VARIABLE_POINTER_TRACK Variable;\r
+ VAR_ERROR_FLAG *VarErrFlag;\r
+ VAR_ERROR_FLAG TempFlag;\r
+\r
+ DEBUG_CODE_BEGIN ();\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 ((DEBUG_ERROR, "CommonRuntimeVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonRuntimeVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
} else {\r
- DEBUG ((EFI_D_ERROR, "CommonMaxUserVariableSpace = 0x%x - CommonUserVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonUserVariableTotalSize));\r
+ DEBUG ((DEBUG_ERROR, "CommonVariableSpace = 0x%x - CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonVariableSpace, mVariableModuleGlobal->CommonVariableTotalSize));\r
}\r
- );\r
+ } else {\r
+ DEBUG ((DEBUG_ERROR, "CommonMaxUserVariableSpace = 0x%x - CommonUserVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonMaxUserVariableSpace, mVariableModuleGlobal->CommonUserVariableTotalSize));\r
+ }\r
+\r
+ DEBUG_CODE_END ();\r
\r
if (!mEndOfDxe) {\r
//\r
FALSE\r
);\r
if (!EFI_ERROR (Status)) {\r
- VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr);\r
- TempFlag = *VarErrFlag;\r
- TempFlag &= Flag;\r
+ VarErrFlag = (VAR_ERROR_FLAG *)GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ TempFlag = *VarErrFlag;\r
+ TempFlag &= Flag;\r
if (TempFlag == *VarErrFlag) {\r
return;\r
}\r
+\r
Status = UpdateVariableStore (\r
&mVariableModuleGlobal->VariableGlobal,\r
FALSE,\r
FALSE,\r
mVariableModuleGlobal->FvbInstance,\r
- (UINTN) VarErrFlag - (UINTN) mNvVariableCache + (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
+ (UINTN)VarErrFlag - (UINTN)mNvVariableCache + (UINTN)mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
sizeof (TempFlag),\r
&TempFlag\r
);\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
VOID\r
)\r
{\r
- EFI_STATUS Status;\r
- VARIABLE_POINTER_TRACK Variable;\r
- VAR_ERROR_FLAG Flag;\r
- VAR_ERROR_FLAG VarErrFlag;\r
+ EFI_STATUS Status;\r
+ VARIABLE_POINTER_TRACK Variable;\r
+ VAR_ERROR_FLAG Flag;\r
+ VAR_ERROR_FLAG VarErrFlag;\r
\r
if (!mEndOfDxe) {\r
return;\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
**/\r
BOOLEAN\r
IsUserVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable\r
)\r
{\r
- VAR_CHECK_VARIABLE_PROPERTY Property;\r
+ VAR_CHECK_VARIABLE_PROPERTY Property;\r
\r
//\r
// Only after End Of Dxe, the variables belong to system variable are fixed.\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
+ {\r
return TRUE;\r
}\r
}\r
+\r
return FALSE;\r
}\r
\r
VOID\r
)\r
{\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *NextVariable;\r
- UINTN VariableSize;\r
- VAR_CHECK_VARIABLE_PROPERTY Property;\r
+ VARIABLE_HEADER *Variable;\r
+ VARIABLE_HEADER *NextVariable;\r
+ UINTN VariableSize;\r
+ VAR_CHECK_VARIABLE_PROPERTY Property;\r
\r
//\r
// Only after End Of Dxe, the variables belong to system variable are fixed.\r
if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {\r
Variable = GetStartPointer (mNvVariableCache);\r
while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- VariableSize = (UINTN) NextVariable - (UINTN) 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
//\r
// No property, it is user variable.\r
//\r
**/\r
EFI_STATUS\r
Reclaim (\r
- IN EFI_PHYSICAL_ADDRESS VariableBase,\r
- OUT UINTN *LastVariableOffset,\r
- IN BOOLEAN IsVolatile,\r
- IN OUT VARIABLE_POINTER_TRACK *UpdatingPtrTrack,\r
- IN VARIABLE_HEADER *NewVariable,\r
- IN UINTN NewVariableSize\r
+ IN EFI_PHYSICAL_ADDRESS VariableBase,\r
+ OUT UINTN *LastVariableOffset,\r
+ IN BOOLEAN IsVolatile,\r
+ IN OUT VARIABLE_POINTER_TRACK *UpdatingPtrTrack,\r
+ IN VARIABLE_HEADER *NewVariable,\r
+ IN UINTN NewVariableSize\r
)\r
{\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *AddedVariable;\r
- VARIABLE_HEADER *NextVariable;\r
- VARIABLE_HEADER *NextAddedVariable;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINT8 *ValidBuffer;\r
- UINTN MaximumBufferSize;\r
- UINTN VariableSize;\r
- UINTN NameSize;\r
- UINT8 *CurrPtr;\r
- VOID *Point0;\r
- VOID *Point1;\r
- BOOLEAN FoundAdded;\r
- EFI_STATUS Status;\r
- UINTN CommonVariableTotalSize;\r
- UINTN CommonUserVariableTotalSize;\r
- UINTN HwErrVariableTotalSize;\r
- VARIABLE_HEADER *UpdatingVariable;\r
- VARIABLE_HEADER *UpdatingInDeletedTransition;\r
-\r
- UpdatingVariable = NULL;\r
+ VARIABLE_HEADER *Variable;\r
+ VARIABLE_HEADER *AddedVariable;\r
+ VARIABLE_HEADER *NextVariable;\r
+ VARIABLE_HEADER *NextAddedVariable;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader;\r
+ UINT8 *ValidBuffer;\r
+ UINTN MaximumBufferSize;\r
+ UINTN VariableSize;\r
+ UINTN NameSize;\r
+ UINT8 *CurrPtr;\r
+ VOID *Point0;\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
- UpdatingVariable = UpdatingPtrTrack->CurrPtr;\r
+ UpdatingVariable = UpdatingPtrTrack->CurrPtr;\r
UpdatingInDeletedTransition = UpdatingPtrTrack->InDeletedTransitionPtr;\r
}\r
\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);\r
+ VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)VariableBase);\r
\r
- CommonVariableTotalSize = 0;\r
+ CommonVariableTotalSize = 0;\r
CommonUserVariableTotalSize = 0;\r
- HwErrVariableTotalSize = 0;\r
+ HwErrVariableTotalSize = 0;\r
\r
if (IsVolatile || mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
//\r
MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);\r
\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- if ((Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) &&\r
- Variable != UpdatingVariable &&\r
- Variable != UpdatingInDeletedTransition\r
- ) {\r
- VariableSize = (UINTN) NextVariable - (UINTN) 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
+ {\r
+ VariableSize = (UINTN)NextVariable - (UINTN)Variable;\r
MaximumBufferSize += VariableSize;\r
}\r
\r
// end of the variable buffer.\r
//\r
MaximumBufferSize += 1;\r
- ValidBuffer = AllocatePool (MaximumBufferSize);\r
+ ValidBuffer = AllocatePool (MaximumBufferSize);\r
if (ValidBuffer == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
// as the buffer to reduce SMRAM consumption for SMM variable driver.\r
//\r
MaximumBufferSize = mNvVariableCache->Size;\r
- ValidBuffer = (UINT8 *) mNvVariableCache;\r
+ ValidBuffer = (UINT8 *)mNvVariableCache;\r
}\r
\r
SetMem (ValidBuffer, MaximumBufferSize, 0xff);\r
// Copy variable store header.\r
//\r
CopyMem (ValidBuffer, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));\r
- CurrPtr = (UINT8 *) GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);\r
+ CurrPtr = (UINT8 *)GetStartPointer ((VARIABLE_STORE_HEADER *)ValidBuffer);\r
\r
//\r
// Reinstall all ADDED variables as long as they are not identical to Updating Variable.\r
//\r
Variable = GetStartPointer (VariableStoreHeader);\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- if (Variable != UpdatingVariable && Variable->State == VAR_ADDED) {\r
- VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
- CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\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
CurrPtr += VariableSize;\r
if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
HwErrVariableTotalSize += VariableSize;\r
}\r
}\r
}\r
+\r
Variable = NextVariable;\r
}\r
\r
//\r
Variable = GetStartPointer (VariableStoreHeader);\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- if (Variable != UpdatingVariable && Variable != UpdatingInDeletedTransition && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
-\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
+ if ((Variable != UpdatingVariable) && (Variable != UpdatingInDeletedTransition) && (Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED))) {\r
//\r
// Buffer has cached all ADDED variable.\r
// Per IN_DELETED variable, we have to guarantee that\r
// no ADDED one in previous buffer.\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
+ FoundAdded = FALSE;\r
+ AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *)ValidBuffer);\r
+ while (IsValidVariableHeader (AddedVariable, GetEndPointer ((VARIABLE_STORE_HEADER *)ValidBuffer))) {\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
+ {\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
}\r
}\r
+\r
AddedVariable = NextAddedVariable;\r
}\r
+\r
if (!FoundAdded) {\r
//\r
// Promote VAR_IN_DELETED_TRANSITION to VAR_ADDED.\r
//\r
- VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
- CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
- ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
- CurrPtr += VariableSize;\r
+ VariableSize = (UINTN)NextVariable - (UINTN)Variable;\r
+ CopyMem (CurrPtr, (UINT8 *)Variable, VariableSize);\r
+ ((VARIABLE_HEADER *)CurrPtr)->State = VAR_ADDED;\r
+ CurrPtr += VariableSize;\r
if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
HwErrVariableTotalSize += VariableSize;\r
} else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
// Install the new variable if it is not NULL.\r
//\r
if (NewVariable != NULL) {\r
- if (((UINTN) CurrPtr - (UINTN) 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
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
}\r
+\r
if (!IsVolatile) {\r
if ((NewVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
HwErrVariableTotalSize += NewVariableSize;\r
CommonUserVariableTotalSize += NewVariableSize;\r
}\r
}\r
+\r
if ((HwErrVariableTotalSize > PcdGet32 (PcdHwErrStorageSize)) ||\r
(CommonVariableTotalSize > mVariableModuleGlobal->CommonVariableSpace) ||\r
- (CommonUserVariableTotalSize > mVariableModuleGlobal->CommonMaxUserVariableSpace)) {\r
+ (CommonUserVariableTotalSize > mVariableModuleGlobal->CommonMaxUserVariableSpace))\r
+ {\r
//\r
// No enough space to store the new variable by NV or NV+HR attribute.\r
//\r
}\r
}\r
\r
- CopyMem (CurrPtr, (UINT8 *) NewVariable, NewVariableSize);\r
- ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
+ CopyMem (CurrPtr, (UINT8 *)NewVariable, NewVariableSize);\r
+ ((VARIABLE_HEADER *)CurrPtr)->State = VAR_ADDED;\r
if (UpdatingVariable != NULL) {\r
- UpdatingPtrTrack->CurrPtr = (VARIABLE_HEADER *)((UINTN)UpdatingPtrTrack->StartPtr + ((UINTN)CurrPtr - (UINTN)GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer)));\r
+ UpdatingPtrTrack->CurrPtr = (VARIABLE_HEADER *)((UINTN)UpdatingPtrTrack->StartPtr + ((UINTN)CurrPtr - (UINTN)GetStartPointer ((VARIABLE_STORE_HEADER *)ValidBuffer)));\r
UpdatingPtrTrack->InDeletedTransitionPtr = NULL;\r
}\r
+\r
CurrPtr += NewVariableSize;\r
}\r
\r
//\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 - (UINTN) ValidBuffer);\r
- *LastVariableOffset = (UINTN) CurrPtr - (UINTN) ValidBuffer;\r
+ SetMem ((UINT8 *)(UINTN)VariableBase, VariableStoreHeader->Size, 0xff);\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->HwErrVariableTotalSize = HwErrVariableTotalSize;\r
+ mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;\r
mVariableModuleGlobal->CommonUserVariableTotalSize = CommonUserVariableTotalSize;\r
}\r
- Status = EFI_SUCCESS;\r
+\r
+ Status = EFI_SUCCESS;\r
} else {\r
//\r
// If non-volatile variable store, perform FTW here.\r
//\r
Status = FtwVariableSpace (\r
- VariableBase,\r
- (VARIABLE_STORE_HEADER *) ValidBuffer\r
- );\r
+ VariableBase,\r
+ (VARIABLE_STORE_HEADER *)ValidBuffer\r
+ );\r
if (!EFI_ERROR (Status)) {\r
- *LastVariableOffset = (UINTN) CurrPtr - (UINTN) ValidBuffer;\r
- mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;\r
- mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;\r
+ *LastVariableOffset = (UINTN)CurrPtr - (UINTN)ValidBuffer;\r
+ mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;\r
+ mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;\r
mVariableModuleGlobal->CommonUserVariableTotalSize = CommonUserVariableTotalSize;\r
} else {\r
- mVariableModuleGlobal->HwErrVariableTotalSize = 0;\r
- mVariableModuleGlobal->CommonVariableTotalSize = 0;\r
+ mVariableModuleGlobal->HwErrVariableTotalSize = 0;\r
+ mVariableModuleGlobal->CommonVariableTotalSize = 0;\r
mVariableModuleGlobal->CommonUserVariableTotalSize = 0;\r
- Variable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase);\r
+ Variable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase);\r
while (IsValidVariableHeader (Variable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- VariableSize = (UINTN) NextVariable - (UINTN) 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
\r
Variable = NextVariable;\r
}\r
- *LastVariableOffset = (UINTN) Variable - (UINTN) VariableBase;\r
+\r
+ *LastVariableOffset = (UINTN)Variable - (UINTN)VariableBase;\r
}\r
}\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
IN BOOLEAN IgnoreRtCheck\r
)\r
{\r
- EFI_STATUS Status;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];\r
- VARIABLE_STORE_TYPE Type;\r
+ EFI_STATUS Status;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];\r
+ VARIABLE_STORE_TYPE Type;\r
\r
- if (VariableName[0] != 0 && VendorGuid == NULL) {\r
+ if ((VariableName[0] != 0) && (VendorGuid == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
// The index and attributes mapping must be kept in this order as RuntimeServiceGetNextVariableName\r
// make use of this mapping to implement search algorithm.\r
//\r
- VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *) (UINTN) Global->VolatileVariableBase;\r
- VariableStoreHeader[VariableStoreTypeHob] = (VARIABLE_STORE_HEADER *) (UINTN) Global->HobVariableBase;\r
+ VariableStoreHeader[VariableStoreTypeVolatile] = (VARIABLE_STORE_HEADER *)(UINTN)Global->VolatileVariableBase;\r
+ VariableStoreHeader[VariableStoreTypeHob] = (VARIABLE_STORE_HEADER *)(UINTN)Global->HobVariableBase;\r
VariableStoreHeader[VariableStoreTypeNv] = mNvVariableCache;\r
\r
//\r
// Find the variable by walk through HOB, volatile and non-volatile variable store.\r
//\r
- for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {\r
+ for (Type = (VARIABLE_STORE_TYPE)0; Type < VariableStoreTypeMax; Type++) {\r
if (VariableStoreHeader[Type] == NULL) {\r
continue;\r
}\r
\r
PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Type]);\r
- PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Type]);\r
- PtrTrack->Volatile = (BOOLEAN) (Type == VariableStoreTypeVolatile);\r
-\r
- Status = FindVariableEx (VariableName, VendorGuid, IgnoreRtCheck, PtrTrack);\r
+ PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Type]);\r
+ PtrTrack->Volatile = (BOOLEAN)(Type == VariableStoreTypeVolatile);\r
+\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
}\r
+\r
return EFI_NOT_FOUND;\r
}\r
\r
\r
**/\r
UINTN\r
-GetIndexFromSupportedLangCodes(\r
- IN CHAR8 *SupportedLang,\r
- IN CHAR8 *Lang,\r
- IN BOOLEAN Iso639Language\r
+GetIndexFromSupportedLangCodes (\r
+ IN CHAR8 *SupportedLang,\r
+ IN CHAR8 *Lang,\r
+ IN BOOLEAN Iso639Language\r
)\r
{\r
- UINTN Index;\r
- UINTN CompareLength;\r
- UINTN LanguageLength;\r
+ UINTN Index;\r
+ UINTN CompareLength;\r
+ UINTN LanguageLength;\r
\r
if (Iso639Language) {\r
CompareLength = ISO_639_2_ENTRY_SIZE;\r
return Index;\r
}\r
}\r
+\r
ASSERT (FALSE);\r
return 0;\r
} else {\r
// Compare RFC4646 language code\r
//\r
Index = 0;\r
- for (LanguageLength = 0; Lang[LanguageLength] != '\0'; LanguageLength++);\r
+ for (LanguageLength = 0; Lang[LanguageLength] != '\0'; LanguageLength++) {\r
+ }\r
\r
for (Index = 0; *SupportedLang != '\0'; Index++, SupportedLang += CompareLength) {\r
//\r
// Skip ';' characters in SupportedLang\r
//\r
- for (; *SupportedLang != '\0' && *SupportedLang == ';'; SupportedLang++);\r
+ for ( ; *SupportedLang != '\0' && *SupportedLang == ';'; SupportedLang++) {\r
+ }\r
+\r
//\r
// Determine the length of the next language code in SupportedLang\r
//\r
- for (CompareLength = 0; SupportedLang[CompareLength] != '\0' && SupportedLang[CompareLength] != ';'; CompareLength++);\r
+ for (CompareLength = 0; SupportedLang[CompareLength] != '\0' && SupportedLang[CompareLength] != ';'; CompareLength++) {\r
+ }\r
\r
if ((CompareLength == LanguageLength) &&\r
- (AsciiStrnCmp (Lang, SupportedLang, CompareLength) == 0)) {\r
+ (AsciiStrnCmp (Lang, SupportedLang, CompareLength) == 0))\r
+ {\r
//\r
// Successfully find the index of Lang string in SupportedLang string.\r
//\r
return Index;\r
}\r
}\r
+\r
ASSERT (FALSE);\r
return 0;\r
}\r
**/\r
CHAR8 *\r
GetLangFromSupportedLangCodes (\r
- IN CHAR8 *SupportedLang,\r
- IN UINTN Index,\r
- IN BOOLEAN Iso639Language\r
-)\r
+ IN CHAR8 *SupportedLang,\r
+ IN UINTN Index,\r
+ IN BOOLEAN Iso639Language\r
+ )\r
{\r
- UINTN SubIndex;\r
- UINTN CompareLength;\r
- CHAR8 *Supported;\r
+ UINTN SubIndex;\r
+ UINTN CompareLength;\r
+ CHAR8 *Supported;\r
\r
SubIndex = 0;\r
Supported = SupportedLang;\r
// This code will be invoked in RUNTIME, therefore there is not a memory allocate/free operation.\r
// In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.\r
//\r
- CompareLength = ISO_639_2_ENTRY_SIZE;\r
+ CompareLength = ISO_639_2_ENTRY_SIZE;\r
mVariableModuleGlobal->Lang[CompareLength] = '\0';\r
return CopyMem (mVariableModuleGlobal->Lang, SupportedLang + Index * CompareLength, CompareLength);\r
-\r
} else {\r
while (TRUE) {\r
//\r
for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {\r
Supported++;\r
}\r
+\r
if ((*Supported == '\0') && (SubIndex != Index)) {\r
//\r
// Have completed the traverse, but not find corrsponding string.\r
// This case is not allowed to happen.\r
//\r
- ASSERT(FALSE);\r
+ ASSERT (FALSE);\r
return NULL;\r
}\r
+\r
if (SubIndex == Index) {\r
//\r
// According to the index of Lang string in SupportedLang string to get the language.\r
mVariableModuleGlobal->PlatformLang[CompareLength] = '\0';\r
return CopyMem (mVariableModuleGlobal->PlatformLang, Supported - CompareLength, CompareLength);\r
}\r
+\r
SubIndex++;\r
\r
//\r
// Skip ';' characters in Supported\r
//\r
- for (; *Supported != '\0' && *Supported == ';'; Supported++);\r
+ for ( ; *Supported != '\0' && *Supported == ';'; Supported++) {\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 == 0) {\r
- for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);\r
+ for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++) {\r
+ }\r
}\r
\r
//\r
//\r
// Skip ';' characters in Supported\r
//\r
- for (; *Supported != '\0' && *Supported == ';'; Supported++);\r
+ for ( ; *Supported != '\0' && *Supported == ';'; Supported++) {\r
+ }\r
+\r
//\r
// Determine the length of the next language code in Supported\r
//\r
- for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);\r
+ for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++) {\r
+ }\r
+\r
//\r
// If Language is longer than the Supported, then skip to the next language\r
//\r
continue;\r
}\r
}\r
+\r
//\r
// See if the first LanguageLength characters in Supported match Language\r
//\r
if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {\r
VA_END (Args);\r
\r
- Buffer = (Iso639Language != 0) ? 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
// If RFC 4646 mode, then trim Language from the right to the next '-' character\r
//\r
- for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);\r
+ for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--) {\r
+ }\r
}\r
}\r
}\r
+\r
VA_END (Args);\r
\r
//\r
BOOLEAN\r
EFIAPI\r
CheckRemainingSpaceForConsistencyInternal (\r
- IN UINT32 Attributes,\r
- IN VA_LIST Marker\r
+ IN UINT32 Attributes,\r
+ IN VA_LIST Marker\r
)\r
{\r
- EFI_STATUS Status;\r
- VA_LIST Args;\r
- VARIABLE_ENTRY_CONSISTENCY *VariableEntry;\r
- UINT64 MaximumVariableStorageSize;\r
- UINT64 RemainingVariableStorageSize;\r
- UINT64 MaximumVariableSize;\r
- UINTN TotalNeededSize;\r
- UINTN OriginalVarSize;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- VARIABLE_POINTER_TRACK VariablePtrTrack;\r
- VARIABLE_HEADER *NextVariable;\r
- UINTN VarNameSize;\r
- UINTN VarDataSize;\r
+ EFI_STATUS Status;\r
+ VA_LIST Args;\r
+ VARIABLE_ENTRY_CONSISTENCY *VariableEntry;\r
+ UINT64 MaximumVariableStorageSize;\r
+ UINT64 RemainingVariableStorageSize;\r
+ UINT64 MaximumVariableSize;\r
+ UINTN TotalNeededSize;\r
+ UINTN OriginalVarSize;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader;\r
+ VARIABLE_POINTER_TRACK VariablePtrTrack;\r
+ VARIABLE_HEADER *NextVariable;\r
+ UINTN VarNameSize;\r
+ UINTN VarDataSize;\r
\r
//\r
// Non-Volatile related.\r
//\r
// Calculate variable total size.\r
//\r
- VarNameSize = StrSize (VariableEntry->Name);\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
+ VarNameSize = StrSize (VariableEntry->Name);\r
+ VarNameSize += GET_PAD_SIZE (VarNameSize);\r
+ VarDataSize = VariableEntry->VariableSize;\r
+ VarDataSize += GET_PAD_SIZE (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
+ VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);\r
}\r
- VA_END (Args);\r
+\r
+ VA_END (Args);\r
\r
if (RemainingVariableStorageSize >= TotalNeededSize) {\r
//\r
//\r
// Check if Variable[Index] has been present and get its size.\r
//\r
- OriginalVarSize = 0;\r
+ OriginalVarSize = 0;\r
VariablePtrTrack.StartPtr = GetStartPointer (VariableStoreHeader);\r
- VariablePtrTrack.EndPtr = GetEndPointer (VariableStoreHeader);\r
- Status = FindVariableEx (\r
- VariableEntry->Name,\r
- VariableEntry->Guid,\r
- FALSE,\r
- &VariablePtrTrack\r
- );\r
+ VariablePtrTrack.EndPtr = GetEndPointer (VariableStoreHeader);\r
+ Status = FindVariableEx (\r
+ VariableEntry->Name,\r
+ VariableEntry->Guid,\r
+ FALSE,\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
- OriginalVarSize = (UINTN) NextVariable - (UINTN) 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
RemainingVariableStorageSize += OriginalVarSize;\r
}\r
+\r
if (VariableEntry->VariableSize > RemainingVariableStorageSize) {\r
//\r
// No enough space for Variable[Index].\r
VA_END (Args);\r
return FALSE;\r
}\r
+\r
//\r
// Sub the (new) size of Variable[Index] from remaining variable storage size.\r
//\r
RemainingVariableStorageSize -= VariableEntry->VariableSize;\r
- VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);\r
+ VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);\r
}\r
- VA_END (Args);\r
+\r
+ VA_END (Args);\r
\r
return TRUE;\r
}\r
BOOLEAN\r
EFIAPI\r
CheckRemainingSpaceForConsistency (\r
- IN UINT32 Attributes,\r
+ IN UINT32 Attributes,\r
...\r
)\r
{\r
- VA_LIST Marker;\r
- BOOLEAN Return;\r
+ VA_LIST Marker;\r
+ BOOLEAN Return;\r
\r
VA_START (Marker, Attributes);\r
\r
**/\r
EFI_STATUS\r
AutoUpdateLangVariable (\r
- IN CHAR16 *VariableName,\r
- IN VOID *Data,\r
- IN UINTN DataSize\r
+ IN CHAR16 *VariableName,\r
+ IN VOID *Data,\r
+ IN UINTN DataSize\r
)\r
{\r
- EFI_STATUS Status;\r
- CHAR8 *BestPlatformLang;\r
- CHAR8 *BestLang;\r
- UINTN Index;\r
- UINT32 Attributes;\r
- VARIABLE_POINTER_TRACK Variable;\r
- BOOLEAN SetLanguageCodes;\r
- VARIABLE_ENTRY_CONSISTENCY VariableEntry[2];\r
+ EFI_STATUS Status;\r
+ CHAR8 *BestPlatformLang;\r
+ CHAR8 *BestLang;\r
+ UINTN Index;\r
+ UINT32 Attributes;\r
+ VARIABLE_POINTER_TRACK Variable;\r
+ BOOLEAN SetLanguageCodes;\r
+ VARIABLE_ENTRY_CONSISTENCY VariableEntry[2];\r
\r
//\r
// Don't do updates for delete operation\r
if (mVariableModuleGlobal->PlatformLangCodes != NULL) {\r
FreePool (mVariableModuleGlobal->PlatformLangCodes);\r
}\r
+\r
mVariableModuleGlobal->PlatformLangCodes = AllocateRuntimeCopyPool (DataSize, Data);\r
ASSERT (mVariableModuleGlobal->PlatformLangCodes != NULL);\r
\r
if (mVariableModuleGlobal->PlatformLang != NULL) {\r
FreePool (mVariableModuleGlobal->PlatformLang);\r
}\r
+\r
mVariableModuleGlobal->PlatformLang = AllocateRuntimePool (DataSize);\r
ASSERT (mVariableModuleGlobal->PlatformLang != NULL);\r
-\r
} else if (StrCmp (VariableName, EFI_LANG_CODES_VARIABLE_NAME) == 0) {\r
//\r
// LangCodes is a volatile variable, so it can not be updated at runtime.\r
if (mVariableModuleGlobal->LangCodes != NULL) {\r
FreePool (mVariableModuleGlobal->LangCodes);\r
}\r
+\r
mVariableModuleGlobal->LangCodes = AllocateRuntimeCopyPool (DataSize, Data);\r
ASSERT (mVariableModuleGlobal->LangCodes != NULL);\r
}\r
\r
- if (SetLanguageCodes\r
- && (mVariableModuleGlobal->PlatformLangCodes != NULL)\r
- && (mVariableModuleGlobal->LangCodes != NULL)) {\r
+ if ( SetLanguageCodes\r
+ && (mVariableModuleGlobal->PlatformLangCodes != NULL)\r
+ && (mVariableModuleGlobal->LangCodes != NULL))\r
+ {\r
//\r
// Update Lang if PlatformLang is already set\r
// Update PlatformLang if Lang is already set\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
// Check the variable space for both Lang and PlatformLang variable.\r
//\r
VariableEntry[0].VariableSize = ISO_639_2_ENTRY_SIZE + 1;\r
- VariableEntry[0].Guid = &gEfiGlobalVariableGuid;\r
- VariableEntry[0].Name = EFI_LANG_VARIABLE_NAME;\r
+ VariableEntry[0].Guid = &gEfiGlobalVariableGuid;\r
+ VariableEntry[0].Name = EFI_LANG_VARIABLE_NAME;\r
\r
VariableEntry[1].VariableSize = AsciiStrSize (BestPlatformLang);\r
- VariableEntry[1].Guid = &gEfiGlobalVariableGuid;\r
- VariableEntry[1].Name = EFI_PLATFORM_LANG_VARIABLE_NAME;\r
+ VariableEntry[1].Guid = &gEfiGlobalVariableGuid;\r
+ VariableEntry[1].Name = EFI_PLATFORM_LANG_VARIABLE_NAME;\r
if (!CheckRemainingSpaceForConsistency (VARIABLE_ATTRIBUTE_NV_BS_RT, &VariableEntry[0], &VariableEntry[1], NULL)) {\r
//\r
// No enough variable space to set both Lang and PlatformLang successfully.\r
//\r
FindVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
\r
- Status = UpdateVariable (EFI_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, BestLang,\r
- ISO_639_2_ENTRY_SIZE + 1, Attributes, 0, 0, &Variable, NULL);\r
+ Status = UpdateVariable (\r
+ EFI_LANG_VARIABLE_NAME,\r
+ &gEfiGlobalVariableGuid,\r
+ BestLang,\r
+ ISO_639_2_ENTRY_SIZE + 1,\r
+ Attributes,\r
+ 0,\r
+ 0,\r
+ &Variable,\r
+ NULL\r
+ );\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
} else if (StrCmp (VariableName, EFI_LANG_VARIABLE_NAME) == 0) {\r
//\r
// Update PlatformLang when PlatformLangCodes/LangCodes were set.\r
// Check the variable space for both PlatformLang and Lang variable.\r
//\r
VariableEntry[0].VariableSize = AsciiStrSize (BestPlatformLang);\r
- VariableEntry[0].Guid = &gEfiGlobalVariableGuid;\r
- VariableEntry[0].Name = EFI_PLATFORM_LANG_VARIABLE_NAME;\r
+ VariableEntry[0].Guid = &gEfiGlobalVariableGuid;\r
+ VariableEntry[0].Name = EFI_PLATFORM_LANG_VARIABLE_NAME;\r
\r
VariableEntry[1].VariableSize = ISO_639_2_ENTRY_SIZE + 1;\r
- VariableEntry[1].Guid = &gEfiGlobalVariableGuid;\r
- VariableEntry[1].Name = EFI_LANG_VARIABLE_NAME;\r
+ VariableEntry[1].Guid = &gEfiGlobalVariableGuid;\r
+ VariableEntry[1].Name = EFI_LANG_VARIABLE_NAME;\r
if (!CheckRemainingSpaceForConsistency (VARIABLE_ATTRIBUTE_NV_BS_RT, &VariableEntry[0], &VariableEntry[1], NULL)) {\r
//\r
// No enough variable space to set both PlatformLang and Lang successfully.\r
//\r
FindVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
\r
- Status = UpdateVariable (EFI_PLATFORM_LANG_VARIABLE_NAME, &gEfiGlobalVariableGuid, BestPlatformLang,\r
- AsciiStrSize (BestPlatformLang), Attributes, 0, 0, &Variable, NULL);\r
+ Status = UpdateVariable (\r
+ EFI_PLATFORM_LANG_VARIABLE_NAME,\r
+ &gEfiGlobalVariableGuid,\r
+ BestPlatformLang,\r
+ AsciiStrSize (BestPlatformLang),\r
+ Attributes,\r
+ 0,\r
+ 0,\r
+ &Variable,\r
+ NULL\r
+ );\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
EFI_STATUS\r
UpdateVariable (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- IN VOID *Data,\r
- IN UINTN DataSize,\r
- IN UINT32 Attributes OPTIONAL,\r
- IN UINT32 KeyIndex OPTIONAL,\r
- IN UINT64 MonotonicCount OPTIONAL,\r
- IN OUT VARIABLE_POINTER_TRACK *CacheVariable,\r
- IN EFI_TIME *TimeStamp OPTIONAL\r
+ IN CHAR16 *VariableName,\r
+ IN EFI_GUID *VendorGuid,\r
+ IN VOID *Data,\r
+ IN UINTN DataSize,\r
+ IN UINT32 Attributes OPTIONAL,\r
+ IN UINT32 KeyIndex OPTIONAL,\r
+ IN UINT64 MonotonicCount OPTIONAL,\r
+ IN OUT VARIABLE_POINTER_TRACK *CacheVariable,\r
+ IN EFI_TIME *TimeStamp OPTIONAL\r
)\r
{\r
EFI_STATUS Status;\r
VARIABLE_POINTER_TRACK *Variable;\r
VARIABLE_POINTER_TRACK NvVariable;\r
VARIABLE_STORE_HEADER *VariableStoreHeader;\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 && !mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\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
//\r
if ((CacheVariable->CurrPtr != NULL) &&\r
(mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) &&\r
- (CacheVariable->StartPtr == GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase))\r
- ) {\r
+ (CacheVariable->StartPtr == GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)mVariableModuleGlobal->VariableGlobal.HobVariableBase))\r
+ )\r
+ {\r
CacheVariable->StartPtr = GetStartPointer (mNvVariableCache);\r
- CacheVariable->EndPtr = GetEndPointer (mNvVariableCache);\r
+ CacheVariable->EndPtr = GetEndPointer (mNvVariableCache);\r
CacheVariable->Volatile = FALSE;\r
- Status = FindVariableEx (VariableName, VendorGuid, FALSE, CacheVariable);\r
- if (CacheVariable->CurrPtr == NULL || EFI_ERROR (Status)) {\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
//\r
// CacheVariable points to the variable in the memory copy of Flash area\r
// Now let Variable points to the same variable in Flash area.\r
//\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);\r
- Variable = &NvVariable;\r
- Variable->StartPtr = GetStartPointer (VariableStoreHeader);\r
- Variable->EndPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->EndPtr - (UINTN)CacheVariable->StartPtr));\r
+ VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);\r
+ Variable = &NvVariable;\r
+ Variable->StartPtr = GetStartPointer (VariableStoreHeader);\r
+ Variable->EndPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->EndPtr - (UINTN)CacheVariable->StartPtr));\r
\r
- Variable->CurrPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));\r
+ Variable->CurrPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));\r
if (CacheVariable->InDeletedTransitionPtr != NULL) {\r
Variable->InDeletedTransitionPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->InDeletedTransitionPtr - (UINTN)CacheVariable->StartPtr));\r
} else {\r
Variable->InDeletedTransitionPtr = NULL;\r
}\r
+\r
Variable->Volatile = FALSE;\r
}\r
\r
- Fvb = mVariableModuleGlobal->FvbInstance;\r
+ Fvb = mVariableModuleGlobal->FvbInstance;\r
\r
//\r
// Tricky part: Use scratch data area at the end of volatile variable store\r
// as a temporary storage.\r
//\r
- NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));\r
- ScratchSize = mVariableModuleGlobal->ScratchBufferSize;\r
+ NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *)((UINTN)mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));\r
+ ScratchSize = mVariableModuleGlobal->ScratchBufferSize;\r
SetMem (NextVariable, ScratchSize, 0xff);\r
DataReady = FALSE;\r
\r
Status = EFI_WRITE_PROTECTED;\r
goto Done;\r
}\r
+\r
//\r
// Only variable that have NV attributes can be updated/deleted in Runtime.\r
//\r
// When the EFI_VARIABLE_APPEND_WRITE attribute is set, DataSize of zero will\r
// not delete the variable.\r
//\r
- if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0))|| ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0)) {\r
+ if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0)) {\r
if (Variable->InDeletedTransitionPtr != NULL) {\r
//\r
// Both ADDED and IN_DELETED_TRANSITION variable are present,\r
// set IN_DELETED_TRANSITION one to DELETED state first.\r
//\r
ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);\r
- State = CacheVariable->InDeletedTransitionPtr->State;\r
+ State = CacheVariable->InDeletedTransitionPtr->State;\r
State &= VAR_DELETED;\r
Status = UpdateVariableStore (\r
&mVariableModuleGlobal->VariableGlobal,\r
Variable->Volatile,\r
FALSE,\r
Fvb,\r
- (UINTN) &Variable->InDeletedTransitionPtr->State,\r
+ (UINTN)&Variable->InDeletedTransitionPtr->State,\r
sizeof (UINT8),\r
&State\r
);\r
}\r
}\r
\r
- State = CacheVariable->CurrPtr->State;\r
+ State = CacheVariable->CurrPtr->State;\r
State &= VAR_DELETED;\r
\r
Status = UpdateVariableStore (\r
Variable->Volatile,\r
FALSE,\r
Fvb,\r
- (UINTN) &Variable->CurrPtr->State,\r
+ (UINTN)&Variable->CurrPtr->State,\r
sizeof (UINT8),\r
&State\r
);\r
FlushHobVariableToFlash (VariableName, VendorGuid);\r
}\r
}\r
+\r
goto Done;\r
}\r
+\r
//\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
+ (TimeStamp == NULL))\r
+ {\r
//\r
// Variable content unchanged and no need to update timestamp, just return.\r
//\r
Status = EFI_SUCCESS;\r
goto Done;\r
} else if ((CacheVariable->CurrPtr->State == VAR_ADDED) ||\r
- (CacheVariable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {\r
-\r
+ (CacheVariable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)))\r
+ {\r
//\r
// EFI_VARIABLE_APPEND_WRITE attribute only effects for existing variable.\r
//\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
- BufferForMerge = (UINT8 *) ((UINTN) NextVariable + DataOffset);\r
- CopyMem (BufferForMerge, (UINT8 *) ((UINTN) CacheVariable->CurrPtr + DataOffset), DataSizeOfVariable (CacheVariable->CurrPtr));\r
+ DataOffset = GetVariableDataOffset (CacheVariable->CurrPtr, AuthFormat);\r
+ BufferForMerge = (UINT8 *)((UINTN)NextVariable + DataOffset);\r
+ CopyMem (\r
+ BufferForMerge,\r
+ (UINT8 *)((UINTN)CacheVariable->CurrPtr + DataOffset),\r
+ DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat)\r
+ );\r
\r
//\r
// Set Max Auth/Non-Volatile/Volatile Variable Data Size as default MaxDataSize.\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
+\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
//\r
// Mark the old variable as in delete transition.\r
//\r
- State = CacheVariable->CurrPtr->State;\r
+ State = CacheVariable->CurrPtr->State;\r
State &= VAR_IN_DELETED_TRANSITION;\r
\r
Status = UpdateVariableStore (\r
Variable->Volatile,\r
FALSE,\r
Fvb,\r
- (UINTN) &Variable->CurrPtr->State,\r
+ (UINTN)&Variable->CurrPtr->State,\r
sizeof (UINT8),\r
&State\r
);\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
}\r
+\r
if (!Variable->Volatile) {\r
CacheVariable->CurrPtr->State = State;\r
}\r
// Make sure we are trying to create a new variable.\r
// Setting a data variable with zero DataSize or no access attributes means to delete it.\r
//\r
- if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {\r
+ if ((DataSize == 0) || ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0)) {\r
Status = EFI_NOT_FOUND;\r
goto Done;\r
}\r
// Only variable have NV|RT attribute can be created in Runtime.\r
//\r
if (AtRuntime () &&\r
- (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0))) {\r
+ (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0)))\r
+ {\r
Status = EFI_INVALID_PARAMETER;\r
goto Done;\r
}\r
// Function part - create a new variable and copy the data.\r
// Both update a variable and create a variable will come here.\r
//\r
- NextVariable->StartId = VARIABLE_DATA;\r
+ NextVariable->StartId = VARIABLE_DATA;\r
//\r
// NextVariable->State = VAR_ADDED;\r
//\r
- NextVariable->Reserved = 0;\r
+ NextVariable->Reserved = 0;\r
if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
- AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) NextVariable;\r
+ AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)NextVariable;\r
AuthVariable->PubKeyIndex = KeyIndex;\r
AuthVariable->MonotonicCount = MonotonicCount;\r
ZeroMem (&AuthVariable->TimeStamp, sizeof (EFI_TIME));\r
\r
if (((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) &&\r
- (TimeStamp != NULL)) {\r
+ (TimeStamp != NULL))\r
+ {\r
if ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) {\r
CopyMem (&AuthVariable->TimeStamp, TimeStamp, sizeof (EFI_TIME));\r
} else {\r
// with the variable, we need associate the new timestamp with the updated value.\r
//\r
if (Variable->CurrPtr != NULL) {\r
- if (VariableCompareTimeStampInternal (&(((AUTHENTICATED_VARIABLE_HEADER *) CacheVariable->CurrPtr)->TimeStamp), TimeStamp)) {\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
+ CopyMem (&AuthVariable->TimeStamp, &(((AUTHENTICATED_VARIABLE_HEADER *)CacheVariable->CurrPtr)->TimeStamp), sizeof (EFI_TIME));\r
}\r
}\r
}\r
// The EFI_VARIABLE_APPEND_WRITE attribute will never be set in the returned\r
// Attributes bitmask parameter of a GetVariable() call.\r
//\r
- NextVariable->Attributes = Attributes & (~EFI_VARIABLE_APPEND_WRITE);\r
+ NextVariable->Attributes = Attributes & (~EFI_VARIABLE_APPEND_WRITE);\r
\r
- VarNameOffset = GetVariableHeaderSize ();\r
- VarNameSize = StrSize (VariableName);\r
+ VarNameOffset = GetVariableHeaderSize (AuthFormat);\r
+ VarNameSize = StrSize (VariableName);\r
CopyMem (\r
- (UINT8 *) ((UINTN) NextVariable + VarNameOffset),\r
+ (UINT8 *)((UINTN)NextVariable + VarNameOffset),\r
VariableName,\r
VarNameSize\r
);\r
//\r
if (!DataReady) {\r
CopyMem (\r
- (UINT8 *) ((UINTN) NextVariable + VarDataOffset),\r
+ (UINT8 *)((UINTN)NextVariable + VarDataOffset),\r
Data,\r
DataSize\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
//\r
Volatile = FALSE;\r
\r
- IsCommonVariable = FALSE;\r
+ IsCommonVariable = FALSE;\r
IsCommonUserVariable = FALSE;\r
if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0) {\r
- IsCommonVariable = TRUE;\r
+ IsCommonVariable = TRUE;\r
IsCommonUserVariable = IsUserVariable (NextVariable);\r
}\r
- if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0)\r
- && ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))\r
- || (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonVariableSpace))\r
- || (IsCommonVariable && AtRuntime () && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonRuntimeVariableSpace))\r
- || (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace))) {\r
+\r
+ if ( ( ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0)\r
+ && ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))\r
+ || (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonVariableSpace))\r
+ || (IsCommonVariable && AtRuntime () && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonRuntimeVariableSpace))\r
+ || (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace)))\r
+ {\r
if (AtRuntime ()) {\r
if (IsCommonUserVariable && ((VarSize + mVariableModuleGlobal->CommonUserVariableTotalSize) > mVariableModuleGlobal->CommonMaxUserVariableSpace)) {\r
RecordVarErrorFlag (VAR_ERROR_FLAG_USER_ERROR, VariableName, VendorGuid, Attributes, VarSize);\r
}\r
+\r
if (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonRuntimeVariableSpace)) {\r
RecordVarErrorFlag (VAR_ERROR_FLAG_SYSTEM_ERROR, VariableName, VendorGuid, Attributes, VarSize);\r
}\r
+\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
}\r
+\r
//\r
// Perform garbage collection & reclaim operation, and integrate the new variable at the same time.\r
//\r
// The new variable has been integrated successfully during reclaiming.\r
//\r
if (Variable->CurrPtr != NULL) {\r
- CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));\r
+ CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN)CacheVariable->StartPtr + ((UINTN)Variable->CurrPtr - (UINTN)Variable->StartPtr));\r
CacheVariable->InDeletedTransitionPtr = NULL;\r
}\r
+\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
RecordVarErrorFlag (VAR_ERROR_FLAG_USER_ERROR, VariableName, VendorGuid, Attributes, VarSize);\r
}\r
+\r
if (IsCommonVariable && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > mVariableModuleGlobal->CommonVariableSpace)) {\r
RecordVarErrorFlag (VAR_ERROR_FLAG_SYSTEM_ERROR, VariableName, VendorGuid, Attributes, VarSize);\r
}\r
}\r
+\r
goto Done;\r
}\r
\r
TRUE,\r
Fvb,\r
mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
- (UINT32) GetVariableHeaderSize (),\r
- (UINT8 *) NextVariable\r
+ (UINT32)GetVariableHeaderSize (AuthFormat),\r
+ (UINT8 *)NextVariable\r
);\r
\r
if (EFI_ERROR (Status)) {\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
+ 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
// Step 3:\r
//\r
FALSE,\r
TRUE,\r
Fvb,\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset + GetVariableHeaderSize (),\r
- (UINT32) (VarSize - GetVariableHeaderSize ()),\r
- (UINT8 *) NextVariable + GetVariableHeaderSize ()\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
}\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
+ 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
// 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
+ 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
Volatile = TRUE;\r
\r
- if ((UINT32) (VarSize + mVariableModuleGlobal->VolatileLastVariableOffset) >\r
- ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {\r
+ if ((UINT32)(VarSize + mVariableModuleGlobal->VolatileLastVariableOffset) >\r
+ ((VARIABLE_STORE_HEADER *)((UINTN)(mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size)\r
+ {\r
//\r
// Perform garbage collection & reclaim operation, and integrate the new variable at the same time.\r
//\r
// The new variable has been integrated successfully during reclaiming.\r
//\r
if (Variable->CurrPtr != NULL) {\r
- CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));\r
+ CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN)CacheVariable->StartPtr + ((UINTN)Variable->CurrPtr - (UINTN)Variable->StartPtr));\r
CacheVariable->InDeletedTransitionPtr = NULL;\r
}\r
+\r
UpdateVariableInfo (VariableName, VendorGuid, TRUE, FALSE, TRUE, FALSE, FALSE, &gVariableInfo);\r
}\r
+\r
goto Done;\r
}\r
\r
NextVariable->State = VAR_ADDED;\r
- Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal,\r
- TRUE,\r
- TRUE,\r
- Fvb,\r
- mVariableModuleGlobal->VolatileLastVariableOffset,\r
- (UINT32) VarSize,\r
- (UINT8 *) NextVariable\r
- );\r
+ Status = UpdateVariableStore (\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ TRUE,\r
+ TRUE,\r
+ Fvb,\r
+ mVariableModuleGlobal->VolatileLastVariableOffset,\r
+ (UINT32)VarSize,\r
+ (UINT8 *)NextVariable\r
+ );\r
\r
if (EFI_ERROR (Status)) {\r
goto Done;\r
//\r
// Mark the old variable as deleted.\r
//\r
- if (!EFI_ERROR (Status) && Variable->CurrPtr != NULL) {\r
+ if (!EFI_ERROR (Status) && (Variable->CurrPtr != NULL)) {\r
if (Variable->InDeletedTransitionPtr != NULL) {\r
//\r
// Both ADDED and IN_DELETED_TRANSITION old variable are present,\r
// set IN_DELETED_TRANSITION one to DELETED state first.\r
//\r
ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);\r
- State = CacheVariable->InDeletedTransitionPtr->State;\r
+ State = CacheVariable->InDeletedTransitionPtr->State;\r
State &= VAR_DELETED;\r
Status = UpdateVariableStore (\r
&mVariableModuleGlobal->VariableGlobal,\r
Variable->Volatile,\r
FALSE,\r
Fvb,\r
- (UINTN) &Variable->InDeletedTransitionPtr->State,\r
+ (UINTN)&Variable->InDeletedTransitionPtr->State,\r
sizeof (UINT8),\r
&State\r
);\r
}\r
}\r
\r
- State = CacheVariable->CurrPtr->State;\r
+ State = CacheVariable->CurrPtr->State;\r
State &= VAR_DELETED;\r
\r
Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal,\r
- Variable->Volatile,\r
- FALSE,\r
- Fvb,\r
- (UINTN) &Variable->CurrPtr->State,\r
- sizeof (UINT8),\r
- &State\r
- );\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ Variable->Volatile,\r
+ FALSE,\r
+ Fvb,\r
+ (UINTN)&Variable->CurrPtr->State,\r
+ sizeof (UINT8),\r
+ &State\r
+ );\r
if (!EFI_ERROR (Status) && !Variable->Volatile) {\r
CacheVariable->CurrPtr->State = State;\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
EFI_STATUS\r
EFIAPI\r
VariableServiceGetVariable (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- OUT UINT32 *Attributes OPTIONAL,\r
- IN OUT UINTN *DataSize,\r
- OUT VOID *Data OPTIONAL\r
+ IN CHAR16 *VariableName,\r
+ IN EFI_GUID *VendorGuid,\r
+ OUT UINT32 *Attributes OPTIONAL,\r
+ IN OUT UINTN *DataSize,\r
+ OUT VOID *Data OPTIONAL\r
)\r
{\r
EFI_STATUS Status;\r
VARIABLE_POINTER_TRACK Variable;\r
UINTN VarDataSize;\r
\r
- if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {\r
+ if ((VariableName == NULL) || (VendorGuid == NULL) || (DataSize == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
return EFI_NOT_FOUND;\r
}\r
\r
- AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
+ AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
- if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
+ if ((Variable.CurrPtr == NULL) || EFI_ERROR (Status)) {\r
goto Done;\r
}\r
\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
goto Done;\r
}\r
\r
- CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);\r
- if (Attributes != NULL) {\r
- *Attributes = Variable.CurrPtr->Attributes;\r
- }\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
goto Done;\r
} else {\r
*DataSize = VarDataSize;\r
- Status = EFI_BUFFER_TOO_SMALL;\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
+\r
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
return Status;\r
}\r
EFI_STATUS\r
EFIAPI\r
VariableServiceGetNextVariableName (\r
- IN OUT UINTN *VariableNameSize,\r
- IN OUT CHAR16 *VariableName,\r
- IN OUT EFI_GUID *VendorGuid\r
+ IN OUT UINTN *VariableNameSize,\r
+ IN OUT CHAR16 *VariableName,\r
+ IN OUT EFI_GUID *VendorGuid\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN MaxLen;\r
- UINTN VarNameSize;\r
- VARIABLE_HEADER *VariablePtr;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];\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
+ 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
return EFI_INVALID_PARAMETER;\r
}\r
\r
- AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
+ AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\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[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 (VariableName, VendorGuid, VariableStoreHeader, &VariablePtr);\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
EFI_STATUS\r
EFIAPI\r
VariableServiceSetVariable (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- IN UINT32 Attributes,\r
- IN UINTN DataSize,\r
- IN VOID *Data\r
+ IN CHAR16 *VariableName,\r
+ IN EFI_GUID *VendorGuid,\r
+ IN UINT32 Attributes,\r
+ IN UINTN DataSize,\r
+ IN VOID *Data\r
)\r
{\r
- VARIABLE_POINTER_TRACK Variable;\r
- EFI_STATUS Status;\r
- VARIABLE_HEADER *NextVariable;\r
- EFI_PHYSICAL_ADDRESS Point;\r
- UINTN PayloadSize;\r
+ VARIABLE_POINTER_TRACK Variable;\r
+ EFI_STATUS Status;\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
- if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {\r
+ if ((VariableName == NULL) || (VariableName[0] == 0) || (VendorGuid == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- if (DataSize != 0 && Data == NULL) {\r
+ if ((DataSize != 0) && (Data == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
}\r
\r
//\r
- // Make sure if runtime bit is set, boot service bit is set also.\r
+ // Check if the combination of attribute bits is valid.\r
//\r
if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {\r
+ //\r
+ // Make sure if runtime bit is set, boot service bit is set also.\r
+ //\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 & EFI_VARIABLE_ATTRIBUTES_MASK) == EFI_VARIABLE_NON_VOLATILE) {\r
+ //\r
+ // Only EFI_VARIABLE_NON_VOLATILE attribute is invalid\r
+ //\r
+ return EFI_INVALID_PARAMETER;\r
} else if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
if (!mVariableModuleGlobal->VariableGlobal.AuthSupport) {\r
//\r
// EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS and EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute\r
// cannot be set both.\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
+ 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
+ {\r
return EFI_UNSUPPORTED;\r
}\r
\r
if (DataSize != AUTHINFO_SIZE) {\r
return EFI_UNSUPPORTED;\r
}\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
//\r
// Sanity check for EFI_VARIABLE_AUTHENTICATION_2 descriptor.\r
//\r
- if (DataSize < OFFSET_OF_AUTHINFO2_CERT_DATA ||\r
- ((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->AuthInfo.Hdr.dwLength > DataSize - (OFFSET_OF (EFI_VARIABLE_AUTHENTICATION_2, AuthInfo)) ||\r
- ((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->AuthInfo.Hdr.dwLength < OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)) {\r
+ if ((DataSize < OFFSET_OF_AUTHINFO2_CERT_DATA) ||\r
+ (((EFI_VARIABLE_AUTHENTICATION_2 *)Data)->AuthInfo.Hdr.dwLength > DataSize - (OFFSET_OF (EFI_VARIABLE_AUTHENTICATION_2, AuthInfo))) ||\r
+ (((EFI_VARIABLE_AUTHENTICATION_2 *)Data)->AuthInfo.Hdr.dwLength < OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)))\r
+ {\r
return EFI_SECURITY_VIOLATION;\r
}\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
PayloadSize = DataSize;\r
}\r
\r
- if ((UINTN)(~0) - PayloadSize < StrSize(VariableName)){\r
+ if ((UINTN)(~0) - PayloadSize < StrSize (VariableName)) {\r
//\r
// Prevent whole variable size overflow\r
//\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
+ {\r
return EFI_INVALID_PARAMETER;\r
}\r
} else {\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
- DEBUG ((DEBUG_ERROR,\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxAuthVariableSize -\r
+ GetVariableHeaderSize (AuthFormat))\r
+ {\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
"%a: Failed to set variable '%s' with Guid %g\n",\r
- __FUNCTION__, VariableName, VendorGuid));\r
- DEBUG ((DEBUG_ERROR,\r
+ __FUNCTION__,\r
+ VariableName,\r
+ VendorGuid\r
+ ));\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
"NameSize(0x%x) + PayloadSize(0x%x) > "\r
"MaxAuthVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
- StrSize (VariableName), PayloadSize,\r
+ StrSize (VariableName),\r
+ PayloadSize,\r
mVariableModuleGlobal->MaxAuthVariableSize,\r
- GetVariableHeaderSize ()\r
+ GetVariableHeaderSize (AuthFormat)\r
));\r
return EFI_INVALID_PARAMETER;\r
}\r
} else if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
- if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize ()) {\r
- DEBUG ((DEBUG_ERROR,\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize (AuthFormat))\r
+ {\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
"%a: Failed to set variable '%s' with Guid %g\n",\r
- __FUNCTION__, VariableName, VendorGuid));\r
- DEBUG ((DEBUG_ERROR,\r
+ __FUNCTION__,\r
+ VariableName,\r
+ VendorGuid\r
+ ));\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
"NameSize(0x%x) + PayloadSize(0x%x) > "\r
"MaxVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
- StrSize (VariableName), PayloadSize,\r
+ StrSize (VariableName),\r
+ PayloadSize,\r
mVariableModuleGlobal->MaxVariableSize,\r
- GetVariableHeaderSize ()\r
+ GetVariableHeaderSize (AuthFormat)\r
));\r
return EFI_INVALID_PARAMETER;\r
}\r
} else {\r
- if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxVolatileVariableSize - GetVariableHeaderSize ()) {\r
- DEBUG ((DEBUG_ERROR,\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxVolatileVariableSize - GetVariableHeaderSize (AuthFormat))\r
+ {\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
"%a: Failed to set variable '%s' with Guid %g\n",\r
- __FUNCTION__, VariableName, VendorGuid));\r
- DEBUG ((DEBUG_ERROR,\r
+ __FUNCTION__,\r
+ VariableName,\r
+ VendorGuid\r
+ ));\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
"NameSize(0x%x) + PayloadSize(0x%x) > "\r
"MaxVolatileVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
- StrSize (VariableName), PayloadSize,\r
+ StrSize (VariableName),\r
+ PayloadSize,\r
mVariableModuleGlobal->MaxVolatileVariableSize,\r
- GetVariableHeaderSize ()\r
+ GetVariableHeaderSize (AuthFormat)\r
));\r
return EFI_INVALID_PARAMETER;\r
}\r
//\r
// Special Handling for MOR Lock variable.\r
//\r
- Status = SetVariableCheckHandlerMor (VariableName, VendorGuid, Attributes, PayloadSize, (VOID *) ((UINTN) Data + DataSize - PayloadSize));\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
//\r
return EFI_SUCCESS;\r
}\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
+ Status = VarCheckLibSetVariableCheck (VariableName, VendorGuid, Attributes, PayloadSize, (VOID *)((UINTN)Data + DataSize - PayloadSize), mRequestSource);\r
if (EFI_ERROR (Status)) {\r
return Status;\r
}\r
\r
- AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
+ AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
//\r
// Consider reentrant in MCA/INIT/NMI. It needs be reupdated.\r
//\r
// Parse non-volatile variable data and get last variable offset.\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 = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)Point);\r
+ while (IsValidVariableHeader (NextVariable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)Point))) {\r
+ NextVariable = GetNextVariablePtr (NextVariable, AuthFormat);\r
}\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;\r
+\r
+ mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN)NextVariable - (UINTN)Point;\r
}\r
\r
//\r
Status = EFI_WRITE_PROTECTED;\r
goto Done;\r
}\r
- if (Attributes != 0 && (Attributes & (~EFI_VARIABLE_APPEND_WRITE)) != Variable.CurrPtr->Attributes) {\r
+\r
+ if ((Attributes != 0) && ((Attributes & (~EFI_VARIABLE_APPEND_WRITE)) != Variable.CurrPtr->Attributes)) {\r
//\r
// If a preexisting variable is rewritten with different attributes, SetVariable() shall not\r
// modify the variable and shall return EFI_INVALID_PARAMETER. Two exceptions to this rule:\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
EFI_STATUS\r
EFIAPI\r
VariableServiceQueryVariableInfoInternal (\r
- IN UINT32 Attributes,\r
- OUT UINT64 *MaximumVariableStorageSize,\r
- OUT UINT64 *RemainingVariableStorageSize,\r
- OUT UINT64 *MaximumVariableSize\r
+ IN UINT32 Attributes,\r
+ OUT UINT64 *MaximumVariableStorageSize,\r
+ OUT UINT64 *RemainingVariableStorageSize,\r
+ OUT UINT64 *MaximumVariableSize\r
)\r
{\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *NextVariable;\r
- UINT64 VariableSize;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINT64 CommonVariableTotalSize;\r
- UINT64 HwErrVariableTotalSize;\r
- EFI_STATUS Status;\r
- VARIABLE_POINTER_TRACK VariablePtrTrack;\r
+ VARIABLE_HEADER *Variable;\r
+ VARIABLE_HEADER *NextVariable;\r
+ UINT64 VariableSize;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader;\r
+ UINT64 CommonVariableTotalSize;\r
+ UINT64 HwErrVariableTotalSize;\r
+ EFI_STATUS Status;\r
+ VARIABLE_POINTER_TRACK VariablePtrTrack;\r
\r
CommonVariableTotalSize = 0;\r
- HwErrVariableTotalSize = 0;\r
+ HwErrVariableTotalSize = 0;\r
\r
- if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {\r
+ if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {\r
//\r
// Query is Volatile related.\r
//\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
+ VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINTN)mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
} else {\r
//\r
// Query is Non-Volatile related.\r
// Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize\r
// with the storage size (excluding the storage header size).\r
//\r
- *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);\r
+ *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);\r
\r
//\r
// Harware error record variable needs larger size.\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
// 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 - GetVariableHeaderSize ();\r
+ *MaximumVariableSize = mVariableModuleGlobal->MaxVariableSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
} else {\r
- *MaximumVariableSize = mVariableModuleGlobal->MaxVolatileVariableSize - 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
- VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;\r
+ NextVariable = GetNextVariablePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
+ VariableSize = (UINT64)(UINTN)NextVariable - (UINT64)(UINTN)Variable;\r
\r
if (AtRuntime ()) {\r
//\r
// this IN_DELETED_TRANSITION variable is valid.\r
//\r
VariablePtrTrack.StartPtr = GetStartPointer (VariableStoreHeader);\r
- VariablePtrTrack.EndPtr = GetEndPointer (VariableStoreHeader);\r
- Status = FindVariableEx (\r
- GetVariableNamePtr (Variable),\r
- GetVendorGuidPtr (Variable),\r
- FALSE,\r
- &VariablePtrTrack\r
- );\r
- if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State != VAR_ADDED) {\r
+ VariablePtrTrack.EndPtr = GetEndPointer (VariableStoreHeader);\r
+ Status = FindVariableEx (\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ FALSE,\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
HwErrVariableTotalSize += VariableSize;\r
} else {\r
Variable = NextVariable;\r
}\r
\r
- if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){\r
+ if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
*RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;\r
} else {\r
if (*MaximumVariableStorageSize < CommonVariableTotalSize) {\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
+ {\r
+ *MaximumVariableSize = *RemainingVariableStorageSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\r
\r
return EFI_SUCCESS;\r
EFI_STATUS\r
EFIAPI\r
VariableServiceQueryVariableInfo (\r
- IN UINT32 Attributes,\r
- OUT UINT64 *MaximumVariableStorageSize,\r
- OUT UINT64 *RemainingVariableStorageSize,\r
- OUT UINT64 *MaximumVariableSize\r
+ IN UINT32 Attributes,\r
+ OUT UINT64 *MaximumVariableStorageSize,\r
+ OUT UINT64 *RemainingVariableStorageSize,\r
+ OUT UINT64 *MaximumVariableSize\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
- if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {\r
+ if ((MaximumVariableStorageSize == NULL) || (RemainingVariableStorageSize == NULL) || (MaximumVariableSize == NULL) || (Attributes == 0)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
// Make sure the Attributes combination is supported by the platform.\r
//\r
return EFI_UNSUPPORTED;\r
+ } else if ((Attributes & EFI_VARIABLE_ATTRIBUTES_MASK) == EFI_VARIABLE_NON_VOLATILE) {\r
+ //\r
+ // Only EFI_VARIABLE_NON_VOLATILE attribute is invalid\r
+ //\r
+ return EFI_INVALID_PARAMETER;\r
} else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {\r
//\r
// Make sure if runtime bit is set, boot service bit is set also.\r
}\r
}\r
\r
- AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
+ AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
Status = VariableServiceQueryVariableInfoInternal (\r
Attributes,\r
\r
**/\r
VOID\r
-ReclaimForOS(\r
+ReclaimForOS (\r
VOID\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN RemainingCommonRuntimeVariableSpace;\r
- UINTN RemainingHwErrVariableSpace;\r
- STATIC BOOLEAN Reclaimed;\r
+ EFI_STATUS Status;\r
+ UINTN RemainingCommonRuntimeVariableSpace;\r
+ UINTN RemainingHwErrVariableSpace;\r
+ STATIC BOOLEAN Reclaimed;\r
\r
//\r
// This function will be called only once at EndOfDxe or ReadyToBoot event.\r
if (Reclaimed) {\r
return;\r
}\r
+\r
Reclaimed = TRUE;\r
\r
- Status = EFI_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
\r
if (mVariableModuleGlobal->CommonRuntimeVariableSpace < mVariableModuleGlobal->CommonVariableTotalSize) {\r
RemainingCommonRuntimeVariableSpace = 0;\r
if (((RemainingCommonRuntimeVariableSpace < mVariableModuleGlobal->MaxVariableSize) ||\r
(RemainingCommonRuntimeVariableSpace < mVariableModuleGlobal->MaxAuthVariableSize)) ||\r
((PcdGet32 (PcdHwErrStorageSize) != 0) &&\r
- (RemainingHwErrVariableSpace < PcdGet32 (PcdMaxHardwareErrorVariableSize)))){\r
+ (RemainingHwErrVariableSpace < PcdGet32 (PcdMaxHardwareErrorVariableSize))))\r
+ {\r
Status = Reclaim (\r
- mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
- &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
- FALSE,\r
- NULL,\r
- NULL,\r
- 0\r
- );\r
+ mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
+ &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
+ FALSE,\r
+ NULL,\r
+ NULL,\r
+ 0\r
+ );\r
ASSERT_EFI_ERROR (Status);\r
}\r
}\r
\r
-/**\r
- Get non-volatile maximum variable size.\r
-\r
- @return Non-volatile maximum variable size.\r
-\r
-**/\r
-UINTN\r
-GetNonVolatileMaxVariableSize (\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
Get maximum variable size, covering both non-volatile and volatile variables.\r
\r
VOID\r
)\r
{\r
- UINTN MaxVariableSize;\r
+ UINTN MaxVariableSize;\r
\r
- MaxVariableSize = GetNonVolatileMaxVariableSize();\r
+ MaxVariableSize = GetNonVolatileMaxVariableSize ();\r
//\r
// The condition below fails implicitly if PcdMaxVolatileVariableSize equals\r
// the default zero value.\r
if (MaxVariableSize < PcdGet32 (PcdMaxVolatileVariableSize)) {\r
MaxVariableSize = PcdGet32 (PcdMaxVolatileVariableSize);\r
}\r
- return MaxVariableSize;\r
-}\r
-\r
-/**\r
- Init real non-volatile variable store.\r
-\r
- @param[out] VariableStoreBase Output pointer to real non-volatile variable store base.\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
-InitRealNonVolatileVariableStore (\r
- OUT EFI_PHYSICAL_ADDRESS *VariableStoreBase\r
- )\r
-{\r
- EFI_FIRMWARE_VOLUME_HEADER *FvHeader;\r
- VARIABLE_STORE_HEADER *VariableStore;\r
- UINT32 VariableStoreLength;\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 = NV_STORAGE_VARIABLE_BASE;\r
- ASSERT (NvStorageBase != 0);\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
- VariableStore = (VARIABLE_STORE_HEADER *) ((UINTN) FvHeader + FvHeader->HeaderLength);\r
- VariableStoreLength = NvStorageSize - FvHeader->HeaderLength;\r
- ASSERT (sizeof (VARIABLE_STORE_HEADER) <= VariableStoreLength);\r
- ASSERT (VariableStore->Size == VariableStoreLength);\r
-\r
- //\r
- // Check if the Variable Store header is not corrupted\r
- //\r
- if (GetVariableStoreStatus (VariableStore) != EfiValid) {\r
- FreePool (NvStorageData);\r
- DEBUG((EFI_D_ERROR, "Variable Store header is corrupted\n"));\r
- return EFI_VOLUME_CORRUPTED;\r
- }\r
-\r
- mNvFvHeaderCache = FvHeader;\r
-\r
- *VariableStoreBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStore;\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
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- Init emulated non-volatile variable store.\r
-\r
- @param[out] VariableStoreBase Output pointer to emulated non-volatile variable store base.\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
-InitEmuNonVolatileVariableStore (\r
- EFI_PHYSICAL_ADDRESS *VariableStoreBase\r
- )\r
-{\r
- VARIABLE_STORE_HEADER *VariableStore;\r
- UINT32 VariableStoreLength;\r
- BOOLEAN FullyInitializeStore;\r
- UINT32 HwErrStorageSize;\r
-\r
- FullyInitializeStore = TRUE;\r
-\r
- VariableStoreLength = PcdGet32 (PcdVariableStoreSize);\r
- ASSERT (sizeof (VARIABLE_STORE_HEADER) <= VariableStoreLength);\r
-\r
- //\r
- // Allocate memory for variable store.\r
- //\r
- if (PcdGet64 (PcdEmuVariableNvStoreReserved) == 0) {\r
- VariableStore = (VARIABLE_STORE_HEADER *) AllocateRuntimePool (VariableStoreLength);\r
- if (VariableStore == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
- } else {\r
- //\r
- // A memory location has been reserved for the NV variable store. Certain\r
- // platforms may be able to preserve a memory range across system resets,\r
- // thereby providing better NV variable emulation.\r
- //\r
- VariableStore =\r
- (VARIABLE_STORE_HEADER *)(VOID*)(UINTN)\r
- PcdGet64 (PcdEmuVariableNvStoreReserved);\r
- if ((VariableStore->Size == VariableStoreLength) &&\r
- (CompareGuid (&VariableStore->Signature, &gEfiAuthenticatedVariableGuid) ||\r
- CompareGuid (&VariableStore->Signature, &gEfiVariableGuid)) &&\r
- (VariableStore->Format == VARIABLE_STORE_FORMATTED) &&\r
- (VariableStore->State == VARIABLE_STORE_HEALTHY)) {\r
- DEBUG((\r
- DEBUG_INFO,\r
- "Variable Store reserved at %p appears to be valid\n",\r
- VariableStore\r
- ));\r
- FullyInitializeStore = FALSE;\r
- }\r
- }\r
-\r
- if (FullyInitializeStore) {\r
- SetMem (VariableStore, VariableStoreLength, 0xff);\r
- //\r
- // Use gEfiAuthenticatedVariableGuid for potential auth variable support.\r
- //\r
- CopyGuid (&VariableStore->Signature, &gEfiAuthenticatedVariableGuid);\r
- VariableStore->Size = VariableStoreLength;\r
- VariableStore->Format = VARIABLE_STORE_FORMATTED;\r
- VariableStore->State = VARIABLE_STORE_HEALTHY;\r
- VariableStore->Reserved = 0;\r
- VariableStore->Reserved1 = 0;\r
- }\r
-\r
- *VariableStoreBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStore;\r
-\r
- HwErrStorageSize = PcdGet32 (PcdHwErrStorageSize);\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
- mVariableModuleGlobal->CommonVariableSpace = ((UINTN) VariableStoreLength - sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize);\r
- mVariableModuleGlobal->CommonMaxUserVariableSpace = mVariableModuleGlobal->CommonVariableSpace;\r
- mVariableModuleGlobal->CommonRuntimeVariableSpace = mVariableModuleGlobal->CommonVariableSpace;\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-/**\r
- Init non-volatile variable store.\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
- VOID\r
- )\r
-{\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *NextVariable;\r
- EFI_PHYSICAL_ADDRESS VariableStoreBase;\r
- UINTN VariableSize;\r
- EFI_STATUS Status;\r
-\r
- if (PcdGetBool (PcdEmuVariableNvModeEnable)) {\r
- Status = InitEmuNonVolatileVariableStore (&VariableStoreBase);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
- mVariableModuleGlobal->VariableGlobal.EmuNvMode = TRUE;\r
- DEBUG ((DEBUG_INFO, "Variable driver will work at emulated non-volatile variable mode!\n"));\r
- } else {\r
- Status = InitRealNonVolatileVariableStore (&VariableStoreBase);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
- mVariableModuleGlobal->VariableGlobal.EmuNvMode = FALSE;\r
- }\r
-\r
- mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;\r
- mNvVariableCache = (VARIABLE_STORE_HEADER *) (UINTN) VariableStoreBase;\r
- mVariableModuleGlobal->VariableGlobal.AuthFormat = (BOOLEAN)(CompareGuid (&mNvVariableCache->Signature, &gEfiAuthenticatedVariableGuid));\r
-\r
- mVariableModuleGlobal->MaxVariableSize = PcdGet32 (PcdMaxVariableSize);\r
- mVariableModuleGlobal->MaxAuthVariableSize = ((PcdGet32 (PcdMaxAuthVariableSize) != 0) ? PcdGet32 (PcdMaxAuthVariableSize) : mVariableModuleGlobal->MaxVariableSize);\r
-\r
- //\r
- // Parse non-volatile variable data and get last variable offset.\r
- //\r
- Variable = GetStartPointer (mNvVariableCache);\r
- while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache))) {\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
- }\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) Variable - (UINTN) mNvVariableCache;\r
\r
- return EFI_SUCCESS;\r
+ return MaxVariableSize;\r
}\r
\r
/**\r
**/\r
VOID\r
FlushHobVariableToFlash (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid\r
+ IN CHAR16 *VariableName,\r
+ IN EFI_GUID *VendorGuid\r
)\r
{\r
- EFI_STATUS Status;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- VARIABLE_HEADER *Variable;\r
- VOID *VariableData;\r
- VARIABLE_POINTER_TRACK VariablePtrTrack;\r
- BOOLEAN ErrorFlag;\r
+ EFI_STATUS Status;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader;\r
+ VARIABLE_HEADER *Variable;\r
+ VOID *VariableData;\r
+ VARIABLE_POINTER_TRACK VariablePtrTrack;\r
+ BOOLEAN ErrorFlag;\r
+ BOOLEAN AuthFormat;\r
\r
- ErrorFlag = FALSE;\r
+ ErrorFlag = FALSE;\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
\r
//\r
// Flush the HOB variable to flash.\r
//\r
if (mVariableModuleGlobal->VariableGlobal.HobVariableBase != 0) {\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.HobVariableBase;\r
+ VariableStoreHeader = (VARIABLE_STORE_HEADER *)(UINTN)mVariableModuleGlobal->VariableGlobal.HobVariableBase;\r
//\r
// Set HobVariableBase to 0, it can avoid SetVariable to call back.\r
//\r
mVariableModuleGlobal->VariableGlobal.HobVariableBase = 0;\r
for ( Variable = GetStartPointer (VariableStoreHeader)\r
- ; IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))\r
- ; Variable = GetNextVariablePtr (Variable)\r
- ) {\r
+ ; IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))\r
+ ; Variable = GetNextVariablePtr (Variable, AuthFormat)\r
+ )\r
+ {\r
if (Variable->State != VAR_ADDED) {\r
//\r
// The HOB variable has been set to DELETED state in local.\r
//\r
continue;\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
+ if ((VendorGuid == NULL) || (VariableName == NULL) ||\r
+ !CompareGuid (VendorGuid, GetVendorGuidPtr (Variable, AuthFormat)) ||\r
+ (StrCmp (VariableName, GetVariableNamePtr (Variable, AuthFormat)) != 0))\r
+ {\r
+ VariableData = GetVariableDataPtr (Variable, AuthFormat);\r
+ FindVariable (\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ &VariablePtrTrack,\r
+ &mVariableModuleGlobal->VariableGlobal,\r
+ 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
+ );\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
//\r
Status = EFI_SUCCESS;\r
}\r
+\r
if (!EFI_ERROR (Status)) {\r
//\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
+\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
+\r
if (ErrorFlag) {\r
//\r
// We still have HOB variable(s) not flushed in flash.\r
//\r
- mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStoreHeader;\r
+ mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS)(UINTN)VariableStoreHeader;\r
} else {\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
+\r
if (!AtRuntime ()) {\r
- FreePool ((VOID *) VariableStoreHeader);\r
+ FreePool ((VOID *)VariableStoreHeader);\r
}\r
}\r
}\r
-\r
}\r
\r
/**\r
VOID\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN Index;\r
- UINT8 Data;\r
- VARIABLE_ENTRY_PROPERTY *VariableEntry;\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+ UINT8 Data;\r
+ VARIABLE_ENTRY_PROPERTY *VariableEntry;\r
\r
- AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
+ AcquireLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
\r
//\r
// Check if the free area is really free.\r
//\r
for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < mNvVariableCache->Size; Index++) {\r
- Data = ((UINT8 *) mNvVariableCache)[Index];\r
+ Data = ((UINT8 *)mNvVariableCache)[Index];\r
if (Data != 0xff) {\r
//\r
// There must be something wrong in variable store, do reclaim operation.\r
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
return Status;\r
}\r
+\r
break;\r
}\r
}\r
//\r
// Authenticated variable initialize.\r
//\r
- mAuthContextIn.StructSize = sizeof (AUTH_VAR_LIB_CONTEXT_IN);\r
- mAuthContextIn.MaxAuthVariableSize = mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ();\r
+ mAuthContextIn.StructSize = sizeof (AUTH_VAR_LIB_CONTEXT_IN);\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
VariableEntry = &mAuthContextOut.AuthVarEntry[Index];\r
- Status = VarCheckLibVariablePropertySet (\r
- VariableEntry->Name,\r
- VariableEntry->Guid,\r
- &VariableEntry->VariableProperty\r
- );\r
+ Status = VarCheckLibVariablePropertySet (\r
+ VariableEntry->Name,\r
+ VariableEntry->Guid,\r
+ &VariableEntry->VariableProperty\r
+ );\r
ASSERT_EFI_ERROR (Status);\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
+ Status = EFI_SUCCESS;\r
}\r
}\r
\r
if (!EFI_ERROR (Status)) {\r
for (Index = 0; Index < ARRAY_SIZE (mVariableEntryProperty); Index++) {\r
VariableEntry = &mVariableEntryProperty[Index];\r
- Status = VarCheckLibVariablePropertySet (VariableEntry->Name, VariableEntry->Guid, &VariableEntry->VariableProperty);\r
+ Status = VarCheckLibVariablePropertySet (VariableEntry->Name, VariableEntry->Guid, &VariableEntry->VariableProperty);\r
ASSERT_EFI_ERROR (Status);\r
}\r
}\r
**/\r
VOID *\r
ConvertNormalVarStorageToAuthVarStorage (\r
- VARIABLE_STORE_HEADER *NormalVarStorage\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
+ 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
+ AuthVarStroageSize = sizeof (VARIABLE_STORE_HEADER);\r
//\r
// Set AuthFormat as FALSE for normal variable storage\r
//\r
EndPtr = GetEndPointer (NormalVarStorage);\r
while (StartPtr < EndPtr) {\r
if (StartPtr->State == VAR_ADDED) {\r
- AuthVarStroageSize = HEADER_ALIGN (AuthVarStroageSize);\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);\r
+\r
+ StartPtr = GetNextVariablePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\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
+ 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
+ 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
+ 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 (NextPtr, GetVariableNamePtr (StartPtr), AuthStartPtr->NameSize);\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), AuthStartPtr->DataSize);\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
+ AuthStartPtr = (AUTHENTICATED_VARIABLE_HEADER *)(NextPtr + AuthStartPtr->DataSize + GET_PAD_SIZE (AuthStartPtr->DataSize));\r
}\r
- StartPtr = GetNextVariablePtr (StartPtr);\r
+\r
+ StartPtr = GetNextVariablePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\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
+ AuthVarStorage->Size = (UINT32)((UINTN)AuthStartPtr - (UINTN)AuthVarStorage);\r
CopyGuid (&AuthVarStorage->Signature, &gEfiAuthenticatedVariableGuid);\r
ASSERT (AuthVarStorage->Size <= AuthVarStroageSize);\r
\r
**/\r
EFI_STATUS\r
GetHobVariableStore (\r
- IN EFI_GUID *VariableGuid\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
+ 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
+ DEBUG_CODE_BEGIN ();\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 (&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
+ if ((GetNextGuidHob (&gEfiVariableGuid, GET_NEXT_HOB (GuidHob)) != NULL)) {\r
+ DEBUG ((DEBUG_ERROR, "ERROR: Found two 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
+ DEBUG_CODE_END ();\r
\r
//\r
// Combinations supported:\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
+ GuidHob = GetFirstGuidHob (VariableGuid);\r
+ if ((GuidHob == NULL) && (VariableGuid == &gEfiAuthenticatedVariableGuid)) {\r
//\r
// Try getting it from normal variable HOB\r
//\r
- GuidHob = GetFirstGuidHob (&gEfiVariableGuid);\r
+ GuidHob = GetFirstGuidHob (&gEfiVariableGuid);\r
NeedConvertNormalToAuth = TRUE;\r
}\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
+ 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
+ mVariableModuleGlobal->VariableGlobal.HobVariableBase = (EFI_PHYSICAL_ADDRESS)(UINTN)ConvertNormalVarStorageToAuthVarStorage ((VOID *)VariableStoreHeader);\r
}\r
+\r
if (mVariableModuleGlobal->VariableGlobal.HobVariableBase == 0) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
} else {\r
- DEBUG ((EFI_D_ERROR, "HOB Variable Store header is corrupted!\n"));\r
+ DEBUG ((DEBUG_ERROR, "HOB Variable Store header is corrupted!\n"));\r
}\r
}\r
\r
VOID\r
)\r
{\r
- EFI_STATUS Status;\r
- VARIABLE_STORE_HEADER *VolatileVariableStore;\r
- UINTN ScratchSize;\r
- EFI_GUID *VariableGuid;\r
+ EFI_STATUS Status;\r
+ VARIABLE_STORE_HEADER *VolatileVariableStore;\r
+ UINTN ScratchSize;\r
+ EFI_GUID *VariableGuid;\r
\r
//\r
// Allocate runtime memory for variable driver global structure.\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
+ 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
+ VariableGuid = &gEfiVariableGuid;\r
}\r
\r
//\r
if (mNvFvHeaderCache != NULL) {\r
FreePool (mNvFvHeaderCache);\r
}\r
+\r
FreePool (mVariableModuleGlobal);\r
return Status;\r
}\r
//\r
// Allocate memory for volatile variable store, note that there is a scratch space to store scratch data.\r
//\r
- ScratchSize = GetMaxVariableSize ();\r
+ ScratchSize = GetMaxVariableSize ();\r
mVariableModuleGlobal->ScratchBufferSize = ScratchSize;\r
- VolatileVariableStore = AllocateRuntimePool (PcdGet32 (PcdVariableStoreSize) + 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
+ FreePool ((VOID *)(UINTN)mVariableModuleGlobal->VariableGlobal.HobVariableBase);\r
}\r
+\r
if (mNvFvHeaderCache != NULL) {\r
FreePool (mNvFvHeaderCache);\r
}\r
+\r
FreePool (mVariableModuleGlobal);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
//\r
// Initialize Variable Specific Data.\r
//\r
- mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;\r
- mVariableModuleGlobal->VolatileLastVariableOffset = (UINTN) GetStartPointer (VolatileVariableStore) - (UINTN) VolatileVariableStore;\r
+ mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS)(UINTN)VolatileVariableStore;\r
+ mVariableModuleGlobal->VolatileLastVariableOffset = (UINTN)GetStartPointer (VolatileVariableStore) - (UINTN)VolatileVariableStore;\r
\r
CopyGuid (&VolatileVariableStore->Signature, VariableGuid);\r
- VolatileVariableStore->Size = PcdGet32 (PcdVariableStoreSize);\r
- VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;\r
- VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;\r
- VolatileVariableStore->Reserved = 0;\r
- VolatileVariableStore->Reserved1 = 0;\r
+ VolatileVariableStore->Size = PcdGet32 (PcdVariableStoreSize);\r
+ VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;\r
+ VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;\r
+ VolatileVariableStore->Reserved = 0;\r
+ VolatileVariableStore->Reserved1 = 0;\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Get the proper fvb handle and/or fvb protocol by the given Flash address.\r
\r
OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvbProtocol OPTIONAL\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_HANDLE *HandleBuffer;\r
- UINTN HandleCount;\r
- UINTN Index;\r
- EFI_PHYSICAL_ADDRESS FvbBaseAddress;\r
- EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
- EFI_FVB_ATTRIBUTES_2 Attributes;\r
- UINTN BlockSize;\r
- UINTN NumberOfBlocks;\r
+ EFI_STATUS Status;\r
+ EFI_HANDLE *HandleBuffer;\r
+ UINTN HandleCount;\r
+ UINTN Index;\r
+ EFI_PHYSICAL_ADDRESS FvbBaseAddress;\r
+ EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
+ EFI_FVB_ATTRIBUTES_2 Attributes;\r
+ UINTN BlockSize;\r
+ UINTN NumberOfBlocks;\r
\r
HandleBuffer = NULL;\r
//\r
\r
if ((Address >= FvbBaseAddress) && (Address < (FvbBaseAddress + BlockSize * NumberOfBlocks))) {\r
if (FvbHandle != NULL) {\r
- *FvbHandle = HandleBuffer[Index];\r
+ *FvbHandle = HandleBuffer[Index];\r
}\r
+\r
if (FvbProtocol != NULL) {\r
*FvbProtocol = Fvb;\r
}\r
+\r
Status = EFI_SUCCESS;\r
break;\r
}\r
}\r
+\r
FreePool (HandleBuffer);\r
\r
if (Fvb == NULL) {\r
\r
return Status;\r
}\r
-\r
projects / mirror_edk2.git / blobdiff