/** @file\r
The implementation of Extended SAL variable services.\r
\r
-Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials \r
are licensed and made available under the terms and conditions of the BSD License \r
which accompanies this distribution. The full text of the license may be found at \r
FALSE - Variable is non-volatile.\r
@param[in] Global Pointer to VARAIBLE_GLOBAL structure.\r
@param[in] Instance Instance of FV Block services.\r
- @param[out] VariableHeader Pointer to VARIABLE_HEADER for output.\r
+ @param[out] VariableHeader Pointer to AUTHENTICATED_VARIABLE_HEADER for output.\r
\r
@retval TRUE Variable header is valid.\r
@retval FALSE Variable header is not valid.\r
**/\r
BOOLEAN\r
IsValidVariableHeader (\r
- IN EFI_PHYSICAL_ADDRESS VariableAddress,\r
- IN BOOLEAN Volatile,\r
- IN VARIABLE_GLOBAL *Global,\r
- IN UINTN Instance,\r
- OUT VARIABLE_HEADER *VariableHeader OPTIONAL\r
+ IN EFI_PHYSICAL_ADDRESS VariableAddress,\r
+ IN BOOLEAN Volatile,\r
+ IN VARIABLE_GLOBAL *Global,\r
+ IN UINTN Instance,\r
+ OUT AUTHENTICATED_VARIABLE_HEADER *VariableHeader OPTIONAL\r
)\r
{\r
- EFI_STATUS Status;\r
- VARIABLE_HEADER LocalVariableHeader;\r
+ EFI_STATUS Status;\r
+ AUTHENTICATED_VARIABLE_HEADER LocalVariableHeader;\r
\r
Status = AccessVariableStore (\r
FALSE,\r
Volatile,\r
Instance,\r
VariableAddress,\r
- sizeof (VARIABLE_HEADER),\r
+ sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
&LocalVariableHeader \r
);\r
\r
}\r
\r
if (VariableHeader != NULL) {\r
- CopyMem (VariableHeader, &LocalVariableHeader, sizeof (VARIABLE_HEADER));\r
+ CopyMem (VariableHeader, &LocalVariableHeader, sizeof (AUTHENTICATED_VARIABLE_HEADER));\r
}\r
\r
return TRUE;\r
**/\r
UINTN\r
NameSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN AUTHENTICATED_VARIABLE_HEADER *Variable\r
)\r
{\r
if (Variable->State == (UINT8) (-1) ||\r
**/\r
UINTN\r
DataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN AUTHENTICATED_VARIABLE_HEADER *Variable\r
)\r
{\r
if (Variable->State == (UINT8) -1 ||\r
OUT CHAR16 *VariableName\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_PHYSICAL_ADDRESS Address;\r
- VARIABLE_HEADER VariableHeader;\r
- BOOLEAN IsValid;\r
+ EFI_STATUS Status;\r
+ EFI_PHYSICAL_ADDRESS Address;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ BOOLEAN IsValid;\r
\r
IsValid = IsValidVariableHeader (VariableAddress, Volatile, Global, Instance, &VariableHeader);\r
ASSERT (IsValid);\r
//\r
// Name area follows variable header.\r
//\r
- Address = VariableAddress + sizeof (VARIABLE_HEADER);\r
+ Address = VariableAddress + sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
\r
Status = AccessVariableStore (\r
FALSE,\r
OUT CHAR16 *VariableData\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_PHYSICAL_ADDRESS Address;\r
- VARIABLE_HEADER VariableHeader;\r
- BOOLEAN IsValid;\r
+ EFI_STATUS Status;\r
+ EFI_PHYSICAL_ADDRESS Address;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ BOOLEAN IsValid;\r
\r
IsValid = IsValidVariableHeader (VariableAddress, Volatile, Global, Instance, &VariableHeader);\r
ASSERT (IsValid);\r
// Data area follows variable name.\r
// Be careful about pad size for alignment\r
//\r
- Address = VariableAddress + sizeof (VARIABLE_HEADER);\r
+ Address = VariableAddress + sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
Address += NameSizeOfVariable (&VariableHeader);\r
Address += GET_PAD_SIZE (NameSizeOfVariable (&VariableHeader));\r
\r
IN UINTN Instance\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS Address;\r
- VARIABLE_HEADER VariableHeader;\r
+ EFI_PHYSICAL_ADDRESS Address;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
\r
if (!IsValidVariableHeader (VariableAddress, Volatile, Global, Instance, &VariableHeader)) {\r
return 0x0;\r
//\r
// Header of next variable follows data area of this variable\r
//\r
- Address = VariableAddress + sizeof (VARIABLE_HEADER);\r
+ Address = VariableAddress + sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
Address += NameSizeOfVariable (&VariableHeader);\r
Address += GET_PAD_SIZE (NameSizeOfVariable (&VariableHeader));\r
Address += DataSizeOfVariable (&VariableHeader);\r
CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);\r
gVariableInfo->Name = AllocatePool (StrSize (VariableName));\r
ASSERT (gVariableInfo->Name != NULL);\r
- StrCpy (gVariableInfo->Name, VariableName);\r
+ StrCpyS (gVariableInfo->Name, StrSize (VariableName) / sizeof (CHAR16), VariableName);\r
gVariableInfo->Volatile = Volatile;\r
\r
gBS->InstallConfigurationTable (&gEfiAuthenticatedVariableGuid, gVariableInfo);\r
CopyGuid (&Entry->Next->VendorGuid, VendorGuid);\r
Entry->Next->Name = AllocatePool (StrSize (VariableName));\r
ASSERT (Entry->Next->Name != NULL);\r
- StrCpy (Entry->Next->Name, VariableName);\r
+ StrCpyS (Entry->Next->Name, StrSize (VariableName) / sizeof (CHAR16), VariableName);\r
Entry->Next->Volatile = Volatile;\r
}\r
\r
IN UINTN Instance\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS Variable[2];\r
- EFI_PHYSICAL_ADDRESS InDeletedVariable;\r
- EFI_PHYSICAL_ADDRESS VariableStoreHeader[2];\r
- UINTN InDeletedStorageIndex;\r
- UINTN Index;\r
- CHAR16 LocalVariableName[MAX_NAME_SIZE];\r
- BOOLEAN Volatile;\r
- VARIABLE_HEADER VariableHeader;\r
+ EFI_PHYSICAL_ADDRESS Variable[2];\r
+ EFI_PHYSICAL_ADDRESS InDeletedVariable;\r
+ EFI_PHYSICAL_ADDRESS VariableStoreHeader[2];\r
+ UINTN InDeletedStorageIndex;\r
+ UINTN Index;\r
+ CHAR16 LocalVariableName[MAX_NAME_SIZE];\r
+ BOOLEAN Volatile;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
\r
//\r
// 0: Volatile, 1: Non-Volatile\r
IN EFI_PHYSICAL_ADDRESS UpdatingVariable\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS Variable;\r
- EFI_PHYSICAL_ADDRESS AddedVariable;\r
- EFI_PHYSICAL_ADDRESS NextVariable;\r
- EFI_PHYSICAL_ADDRESS NextAddedVariable;\r
- VARIABLE_STORE_HEADER VariableStoreHeader;\r
- VARIABLE_HEADER VariableHeader;\r
- VARIABLE_HEADER AddedVariableHeader;\r
- CHAR16 VariableName[MAX_NAME_SIZE];\r
- CHAR16 AddedVariableName[MAX_NAME_SIZE];\r
- UINT8 *ValidBuffer;\r
- UINTN MaximumBufferSize;\r
- UINTN VariableSize;\r
- UINTN NameSize;\r
- UINT8 *CurrPtr;\r
- BOOLEAN FoundAdded;\r
- EFI_STATUS Status;\r
- VARIABLE_GLOBAL *VariableGlobal;\r
- UINT32 Instance;\r
+ EFI_PHYSICAL_ADDRESS Variable;\r
+ EFI_PHYSICAL_ADDRESS AddedVariable;\r
+ EFI_PHYSICAL_ADDRESS NextVariable;\r
+ EFI_PHYSICAL_ADDRESS NextAddedVariable;\r
+ VARIABLE_STORE_HEADER VariableStoreHeader;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ AUTHENTICATED_VARIABLE_HEADER AddedVariableHeader;\r
+ CHAR16 VariableName[MAX_NAME_SIZE];\r
+ CHAR16 AddedVariableName[MAX_NAME_SIZE];\r
+ UINT8 *ValidBuffer;\r
+ UINTN MaximumBufferSize;\r
+ UINTN VariableSize;\r
+ UINTN NameSize;\r
+ UINT8 *CurrPtr;\r
+ BOOLEAN FoundAdded;\r
+ EFI_STATUS Status;\r
+ VARIABLE_GLOBAL *VariableGlobal;\r
+ UINT32 Instance;\r
\r
VariableGlobal = &Global->VariableGlobal[VirtualMode];\r
Instance = Global->FvbInstance;\r
VariableSize = NextVariable - Variable;\r
CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
CurrPtr += VariableSize;\r
- if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+ if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
Global->HwErrVariableTotalSize += VariableSize;\r
- } else if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+ } else if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
Global->CommonVariableTotalSize += VariableSize;\r
}\r
}\r
// 1. No valid instance of this variable exists.\r
// 2. It is not the variable that is going to be updated.\r
//\r
- ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
+ ((AUTHENTICATED_VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
}\r
CurrPtr += VariableSize;\r
- if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+ if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
Global->HwErrVariableTotalSize += VariableSize;\r
- } else if ((!IsVolatile) && ((((VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+ } else if ((!IsVolatile) && ((((AUTHENTICATED_VARIABLE_HEADER*)Variable)->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
Global->CommonVariableTotalSize += VariableSize;\r
}\r
}\r
FreePool (Global->PlatformLangCodes[VirtualMode]);\r
}\r
Global->PlatformLangCodes[VirtualMode] = AllocateRuntimeCopyPool (DataSize, Data);\r
- ASSERT (mVariableModuleGlobal->PlatformLangCodes[VirtualMode] != NULL);\r
+ ASSERT (Global->PlatformLangCodes[VirtualMode] != NULL);\r
\r
//\r
// PlatformLang holds a single language from PlatformLangCodes, \r
VariableGlobal,\r
Variable.Volatile,\r
Instance,\r
- (UINTN) &(((VARIABLE_HEADER *)Variable.CurrPtr)->DataSize),\r
+ (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable.CurrPtr)->DataSize),\r
sizeof (DataSize),\r
&DataSize\r
); \r
)\r
{\r
EFI_STATUS Status;\r
- VARIABLE_HEADER *NextVariable;\r
+ AUTHENTICATED_VARIABLE_HEADER *NextVariable;\r
UINTN VarNameOffset;\r
UINTN VarDataOffset;\r
UINTN VarNameSize;\r
UINTN VarSize;\r
BOOLEAN Volatile;\r
UINT8 State;\r
- VARIABLE_HEADER VariableHeader;\r
- VARIABLE_HEADER *NextVariableHeader;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ AUTHENTICATED_VARIABLE_HEADER *NextVariableHeader;\r
BOOLEAN Valid;\r
BOOLEAN Reclaimed;\r
VARIABLE_STORE_HEADER VariableStoreHeader;\r
VariableGlobal,\r
Variable->Volatile,\r
Instance,\r
- (UINTN) &(((VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
+ (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
sizeof (UINT8),\r
&State\r
); \r
// then return to the caller immediately.\r
//\r
if (DataSizeOfVariable (&VariableHeader) == DataSize) {\r
- NextVariable = (VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
+ NextVariable = (AUTHENTICATED_VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
GetVariableDataPtr (Variable->CurrPtr, Variable->Volatile, VariableGlobal, Instance, (CHAR16 *) NextVariable);\r
if (CompareMem (Data, (VOID *) NextVariable, DataSize) == 0) {\r
UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);\r
VariableGlobal,\r
Variable->Volatile,\r
Instance,\r
- (UINTN) &(((VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
+ (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
sizeof (UINT8),\r
&State\r
); \r
// Tricky part: Use scratch data area at the end of volatile variable store\r
// as a temporary storage.\r
//\r
- NextVariable = (VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
+ NextVariable = (AUTHENTICATED_VARIABLE_HEADER *)GetEndPointer (VariableGlobal->VolatileVariableBase, TRUE, VariableGlobal, Instance);\r
ScratchSize = MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize));\r
- NextVariableHeader = (VARIABLE_HEADER *) NextVariable;\r
+ NextVariableHeader = (AUTHENTICATED_VARIABLE_HEADER *) NextVariable;\r
\r
SetMem (NextVariableHeader, ScratchSize, 0xff);\r
\r
NextVariableHeader->PubKeyIndex = KeyIndex;\r
NextVariableHeader->MonotonicCount = MonotonicCount;\r
NextVariableHeader->Reserved = 0;\r
- VarNameOffset = sizeof (VARIABLE_HEADER);\r
+ VarNameOffset = sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
VarNameSize = StrSize (VariableName);\r
CopyMem (\r
(UINT8 *) ((UINTN)NextVariable + VarNameOffset),\r
FALSE,\r
Instance,\r
VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset,\r
- sizeof (VARIABLE_HEADER),\r
+ sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
(UINT8 *) NextVariable\r
);\r
\r
FALSE,\r
Instance,\r
VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset,\r
- sizeof (VARIABLE_HEADER),\r
+ sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
(UINT8 *) NextVariable\r
);\r
\r
VariableGlobal,\r
FALSE,\r
Instance,\r
- VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset + sizeof (VARIABLE_HEADER),\r
- (UINT32) VarSize - sizeof (VARIABLE_HEADER),\r
- (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)\r
+ VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset + sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
+ (UINT32) VarSize - sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
+ (UINT8 *) NextVariable + sizeof (AUTHENTICATED_VARIABLE_HEADER)\r
);\r
\r
if (EFI_ERROR (Status)) {\r
FALSE,\r
Instance,\r
VariableGlobal->NonVolatileVariableBase + Global->NonVolatileLastVariableOffset,\r
- sizeof (VARIABLE_HEADER),\r
+ sizeof (AUTHENTICATED_VARIABLE_HEADER),\r
(UINT8 *) NextVariable\r
);\r
\r
// has already been eliminated, so no need to delete it.\r
//\r
if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != 0) {\r
- State = ((VARIABLE_HEADER *)Variable->CurrPtr)->State;\r
+ State = ((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State;\r
State &= VAR_DELETED;\r
\r
Status = AccessVariableStore (\r
VariableGlobal,\r
Variable->Volatile,\r
Instance,\r
- (UINTN) &(((VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
+ (UINTN) &(((AUTHENTICATED_VARIABLE_HEADER *)Variable->CurrPtr)->State),\r
sizeof (UINT8),\r
&State\r
);\r
IN ESAL_VARIABLE_GLOBAL *Global\r
)\r
{\r
- VARIABLE_POINTER_TRACK Variable;\r
- UINTN VarDataSize;\r
- EFI_STATUS Status;\r
- VARIABLE_HEADER VariableHeader;\r
- BOOLEAN Valid;\r
- VARIABLE_GLOBAL *VariableGlobal;\r
- UINT32 Instance;\r
+ VARIABLE_POINTER_TRACK Variable;\r
+ UINTN VarDataSize;\r
+ EFI_STATUS Status;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ BOOLEAN Valid;\r
+ VARIABLE_GLOBAL *VariableGlobal;\r
+ UINT32 Instance;\r
\r
if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {\r
return EFI_INVALID_PARAMETER;\r
IN ESAL_VARIABLE_GLOBAL *Global\r
)\r
{\r
- VARIABLE_POINTER_TRACK Variable;\r
- UINTN VarNameSize;\r
- EFI_STATUS Status;\r
- VARIABLE_HEADER VariableHeader;\r
- VARIABLE_GLOBAL *VariableGlobal;\r
- UINT32 Instance;\r
+ VARIABLE_POINTER_TRACK Variable;\r
+ UINTN VarNameSize;\r
+ EFI_STATUS Status;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ VARIABLE_GLOBAL *VariableGlobal;\r
+ UINT32 Instance;\r
\r
if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {\r
return EFI_INVALID_PARAMETER;\r
PayloadSize = DataSize; \r
}\r
\r
+ \r
+ if ((UINTN)(~0) - PayloadSize < StrSize(VariableName)){\r
+ //\r
+ // Prevent whole variable size overflow \r
+ // \r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
VariableGlobal = &Global->VariableGlobal[VirtualMode];\r
Instance = Global->FvbInstance;\r
\r
// For variable for hardware error record, the size of the VariableName, including the Unicode Null\r
// in bytes plus the DataSize is limited to maximum size of PcdGet32(PcdMaxHardwareErrorVariableSize) bytes.\r
//\r
- if ((PayloadSize > PcdGet32(PcdMaxHardwareErrorVariableSize)) || \r
- (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxHardwareErrorVariableSize))) {\r
+ if (StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
//\r
// For variable not for hardware error record, the size of the VariableName, including the\r
// Unicode Null in bytes plus the DataSize is limited to maximum size of PcdGet32(PcdMaxVariableSize) bytes.\r
//\r
- if ((PayloadSize > PcdGet32(PcdMaxVariableSize)) ||\r
- (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxVariableSize))) {\r
+ if (StrSize (VariableName) + PayloadSize > PcdGet32(PcdMaxVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER)) {\r
return EFI_INVALID_PARAMETER;\r
} \r
} \r
IN ESAL_VARIABLE_GLOBAL *Global\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS Variable;\r
- EFI_PHYSICAL_ADDRESS NextVariable;\r
- UINT64 VariableSize;\r
- EFI_PHYSICAL_ADDRESS VariableStoreHeaderAddress;\r
- BOOLEAN Volatile;\r
- VARIABLE_STORE_HEADER VarStoreHeader;\r
- VARIABLE_HEADER VariableHeader;\r
- UINT64 CommonVariableTotalSize;\r
- UINT64 HwErrVariableTotalSize;\r
- VARIABLE_GLOBAL *VariableGlobal;\r
- UINT32 Instance;\r
+ EFI_PHYSICAL_ADDRESS Variable;\r
+ EFI_PHYSICAL_ADDRESS NextVariable;\r
+ UINT64 VariableSize;\r
+ EFI_PHYSICAL_ADDRESS VariableStoreHeaderAddress;\r
+ BOOLEAN Volatile;\r
+ VARIABLE_STORE_HEADER VarStoreHeader;\r
+ AUTHENTICATED_VARIABLE_HEADER VariableHeader;\r
+ UINT64 CommonVariableTotalSize;\r
+ UINT64 HwErrVariableTotalSize;\r
+ VARIABLE_GLOBAL *VariableGlobal;\r
+ UINT32 Instance;\r
\r
CommonVariableTotalSize = 0;\r
HwErrVariableTotalSize = 0;\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) - sizeof (VARIABLE_HEADER);\r
+ *MaximumVariableSize = PcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
} else {\r
if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
ASSERT (PcdGet32(PcdHwErrStorageSize) < VarStoreHeader.Size);\r
//\r
// Let *MaximumVariableSize be PcdGet32(PcdMaxVariableSize) with the exception of the variable header size.\r
//\r
- *MaximumVariableSize = PcdGet32(PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);\r
+ *MaximumVariableSize = PcdGet32(PcdMaxVariableSize) - sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
}\r
\r
//\r
*RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;\r
}\r
\r
- if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {\r
+ if (*RemainingVariableStorageSize < sizeof (AUTHENTICATED_VARIABLE_HEADER)) {\r
*MaximumVariableSize = 0;\r
- } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {\r
- *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);\r
+ } else if ((*RemainingVariableStorageSize - sizeof (AUTHENTICATED_VARIABLE_HEADER)) < *MaximumVariableSize) {\r
+ *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
}\r
\r
ReleaseLockOnlyAtBootTime (&VariableGlobal->VariableServicesLock);\r
}\r
}\r
\r
+/**\r
+ Flush the HOB variable to NV variable storage.\r
+**/\r
+VOID\r
+FlushHob2Nv (\r
+ VOID\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ VOID *GuidHob;\r
+ VARIABLE_STORE_HEADER *VariableStoreHeader;\r
+ AUTHENTICATED_VARIABLE_HEADER *VariableHeader;\r
+ //\r
+ // Get HOB variable store.\r
+ //\r
+ GuidHob = GetFirstGuidHob (&gEfiAuthenticatedVariableGuid);\r
+ if (GuidHob != NULL) {\r
+ VariableStoreHeader = (VARIABLE_STORE_HEADER *) GET_GUID_HOB_DATA (GuidHob);\r
+ if (CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid) &&\r
+ (VariableStoreHeader->Format == VARIABLE_STORE_FORMATTED) &&\r
+ (VariableStoreHeader->State == VARIABLE_STORE_HEALTHY)\r
+ ) {\r
+ DEBUG ((EFI_D_INFO, "HOB Variable Store appears to be valid.\n"));\r
+ //\r
+ // Flush the HOB variable to NV Variable storage.\r
+ //\r
+ for ( VariableHeader = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN (VariableStoreHeader + 1)\r
+ ; (VariableHeader < (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VariableStoreHeader + VariableStoreHeader->Size)\r
+ &&\r
+ (VariableHeader->StartId == VARIABLE_DATA))\r
+ ; VariableHeader = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) (VariableHeader + 1)\r
+ + VariableHeader->NameSize + GET_PAD_SIZE (VariableHeader->NameSize)\r
+ + VariableHeader->DataSize + GET_PAD_SIZE (VariableHeader->DataSize)\r
+ )\r
+ ) {\r
+ ASSERT (VariableHeader->State == VAR_ADDED);\r
+ ASSERT ((VariableHeader->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0);\r
+ Status = EsalSetVariable (\r
+ (CHAR16 *) (VariableHeader + 1),\r
+ &VariableHeader->VendorGuid,\r
+ VariableHeader->Attributes,\r
+ VariableHeader->DataSize,\r
+ (UINT8 *) (VariableHeader + 1) + VariableHeader->NameSize + GET_PAD_SIZE (VariableHeader->NameSize),\r
+ Physical,\r
+ mVariableModuleGlobal\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
/**\r
Initializes variable store area for non-volatile and volatile variable.\r
\r
Instance\r
);\r
VariableSize = NextVariable - Variable;\r
- if ((((VARIABLE_HEADER *)Variable)->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
+ if ((((AUTHENTICATED_VARIABLE_HEADER *)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
} else {\r
Status = EFI_VOLUME_CORRUPTED;\r
- DEBUG((EFI_D_INFO, "Variable Store header is corrupted\n"));\r
+ DEBUG((EFI_D_ERROR, "Variable Store header is corrupted\n"));\r
}\r
\r
Done:\r
projects / mirror_edk2.git / blobdiff