FALSE\r
);\r
if (!EFI_ERROR (Status)) {\r
- VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr);\r
+ VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
TempFlag = *VarErrFlag;\r
TempFlag &= Flag;\r
if (TempFlag == *VarErrFlag) {\r
FALSE\r
);\r
if (!EFI_ERROR (Status)) {\r
- VarErrFlag = *((VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr));\r
+ VarErrFlag = *((VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat));\r
if (VarErrFlag == Flag) {\r
return;\r
}\r
// then no need to check if the variable is user variable or not specially.\r
//\r
if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {\r
- if (VarCheckLibVariablePropertyGet (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &Property) == EFI_NOT_FOUND) {\r
+ if (VarCheckLibVariablePropertyGet (\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ &Property\r
+ ) == EFI_NOT_FOUND) {\r
return TRUE;\r
}\r
}\r
if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace != mVariableModuleGlobal->CommonVariableSpace)) {\r
Variable = GetStartPointer (mNvVariableCache);\r
while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
- if (VarCheckLibVariablePropertyGet (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &Property) == EFI_NOT_FOUND) {\r
+ if (VarCheckLibVariablePropertyGet (\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ &Property\r
+ ) == EFI_NOT_FOUND) {\r
//\r
// No property, it is user variable.\r
//\r
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
MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);\r
\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
if ((Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) &&\r
Variable != UpdatingVariable &&\r
Variable != UpdatingInDeletedTransition\r
//\r
Variable = GetStartPointer (VariableStoreHeader);\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
if (Variable != UpdatingVariable && Variable->State == VAR_ADDED) {\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
//\r
Variable = GetStartPointer (VariableStoreHeader);\r
while (IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
if (Variable != UpdatingVariable && Variable != UpdatingInDeletedTransition && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
\r
//\r
FoundAdded = FALSE;\r
AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);\r
while (IsValidVariableHeader (AddedVariable, GetEndPointer ((VARIABLE_STORE_HEADER *) ValidBuffer))) {\r
- NextAddedVariable = GetNextVariablePtr (AddedVariable);\r
- NameSize = NameSizeOfVariable (AddedVariable);\r
- if (CompareGuid (GetVendorGuidPtr (AddedVariable), GetVendorGuidPtr (Variable)) &&\r
- NameSize == NameSizeOfVariable (Variable)\r
- ) {\r
- Point0 = (VOID *) GetVariableNamePtr (AddedVariable);\r
- Point1 = (VOID *) GetVariableNamePtr (Variable);\r
+ NextAddedVariable = GetNextVariablePtr (AddedVariable, AuthFormat);\r
+ NameSize = NameSizeOfVariable (AddedVariable, AuthFormat);\r
+ if (CompareGuid (\r
+ GetVendorGuidPtr (AddedVariable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat)\r
+ ) && NameSize == NameSizeOfVariable (Variable, AuthFormat)) {\r
+ Point0 = (VOID *) GetVariableNamePtr (AddedVariable, AuthFormat);\r
+ Point1 = (VOID *) GetVariableNamePtr (Variable, AuthFormat);\r
if (CompareMem (Point0, Point1, NameSize) == 0) {\r
FoundAdded = TRUE;\r
break;\r
mVariableModuleGlobal->CommonUserVariableTotalSize = 0;\r
Variable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase);\r
while (IsValidVariableHeader (Variable, GetEndPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableBase))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, AuthFormat);\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Type]);\r
PtrTrack->Volatile = (BOOLEAN) (Type == VariableStoreTypeVolatile);\r
\r
- Status = FindVariableEx (VariableName, VendorGuid, IgnoreRtCheck, PtrTrack);\r
+ Status = FindVariableEx (\r
+ VariableName,\r
+ VendorGuid,\r
+ IgnoreRtCheck,\r
+ PtrTrack,\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
+ );\r
if (!EFI_ERROR (Status)) {\r
return Status;\r
}\r
VarNameSize += GET_PAD_SIZE (VarNameSize);\r
VarDataSize = VariableEntry->VariableSize;\r
VarDataSize += GET_PAD_SIZE (VarDataSize);\r
- VariableEntry->VariableSize = HEADER_ALIGN (GetVariableHeaderSize () + VarNameSize + VarDataSize);\r
+ VariableEntry->VariableSize = HEADER_ALIGN (\r
+ GetVariableHeaderSize (\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
+ ) + VarNameSize + VarDataSize\r
+ );\r
\r
TotalNeededSize += VariableEntry->VariableSize;\r
VariableEntry = VA_ARG (Args, VARIABLE_ENTRY_CONSISTENCY *);\r
VariableEntry->Name,\r
VariableEntry->Guid,\r
FALSE,\r
- &VariablePtrTrack\r
+ &VariablePtrTrack,\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
);\r
if (!EFI_ERROR (Status)) {\r
//\r
// Get size of Variable[Index].\r
//\r
- NextVariable = GetNextVariablePtr (VariablePtrTrack.CurrPtr);\r
+ NextVariable = GetNextVariablePtr (VariablePtrTrack.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
OriginalVarSize = (UINTN) NextVariable - (UINTN) VariablePtrTrack.CurrPtr;\r
//\r
// Add the original size of Variable[Index] to remaining variable storage size.\r
// 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
BOOLEAN IsCommonVariable;\r
BOOLEAN IsCommonUserVariable;\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
+ BOOLEAN AuthFormat;\r
\r
if (mVariableModuleGlobal->FvbInstance == NULL && !mVariableModuleGlobal->VariableGlobal.EmuNvMode) {\r
//\r
}\r
}\r
\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
+\r
//\r
// Check if CacheVariable points to the variable in variable HOB.\r
// If yes, let CacheVariable points to the variable in NV variable cache.\r
CacheVariable->StartPtr = GetStartPointer (mNvVariableCache);\r
CacheVariable->EndPtr = GetEndPointer (mNvVariableCache);\r
CacheVariable->Volatile = FALSE;\r
- Status = FindVariableEx (VariableName, VendorGuid, FALSE, CacheVariable);\r
+ Status = FindVariableEx (VariableName, VendorGuid, FALSE, CacheVariable, AuthFormat);\r
if (CacheVariable->CurrPtr == NULL || EFI_ERROR (Status)) {\r
//\r
// There is no matched variable in NV variable cache.\r
// If the variable is marked valid, and the same data has been passed in,\r
// then return to the caller immediately.\r
//\r
- if (DataSizeOfVariable (CacheVariable->CurrPtr) == DataSize &&\r
- (CompareMem (Data, GetVariableDataPtr (CacheVariable->CurrPtr), DataSize) == 0) &&\r
+ if (DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat) == DataSize &&\r
+ (CompareMem (Data, GetVariableDataPtr (CacheVariable->CurrPtr, AuthFormat), DataSize) == 0) &&\r
((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) &&\r
(TimeStamp == NULL)) {\r
//\r
// NOTE: From 0 to DataOffset of NextVariable is reserved for Variable Header and Name.\r
// From DataOffset of NextVariable is to save the existing variable data.\r
//\r
- DataOffset = GetVariableDataOffset (CacheVariable->CurrPtr);\r
+ DataOffset = GetVariableDataOffset (CacheVariable->CurrPtr, AuthFormat);\r
BufferForMerge = (UINT8 *) ((UINTN) NextVariable + DataOffset);\r
- CopyMem (BufferForMerge, (UINT8 *) ((UINTN) CacheVariable->CurrPtr + DataOffset), DataSizeOfVariable (CacheVariable->CurrPtr));\r
+ CopyMem (\r
+ BufferForMerge,\r
+ (UINT8 *) ((UINTN) CacheVariable->CurrPtr + DataOffset),\r
+ DataSizeOfVariable (CacheVariable->CurrPtr, AuthFormat)\r
+ );\r
\r
//\r
// Set Max 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
+ 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
NextVariable->Attributes = Attributes & (~EFI_VARIABLE_APPEND_WRITE);\r
\r
- VarNameOffset = GetVariableHeaderSize ();\r
+ VarNameOffset = GetVariableHeaderSize (AuthFormat);\r
VarNameSize = StrSize (VariableName);\r
CopyMem (\r
(UINT8 *) ((UINTN) NextVariable + VarNameOffset),\r
);\r
}\r
\r
- CopyMem (GetVendorGuidPtr (NextVariable), VendorGuid, sizeof (EFI_GUID));\r
+ CopyMem (\r
+ GetVendorGuidPtr (NextVariable, AuthFormat),\r
+ VendorGuid,\r
+ sizeof (EFI_GUID)\r
+ );\r
//\r
// There will be pad bytes after Data, the NextVariable->NameSize and\r
// NextVariable->DataSize should not include pad size so that variable\r
// service can get actual size in GetVariable.\r
//\r
- SetNameSizeOfVariable (NextVariable, VarNameSize);\r
- SetDataSizeOfVariable (NextVariable, DataSize);\r
+ SetNameSizeOfVariable (NextVariable, VarNameSize, AuthFormat);\r
+ SetDataSizeOfVariable (NextVariable, DataSize, AuthFormat);\r
\r
//\r
// The actual size of the variable that stores in storage should\r
TRUE,\r
Fvb,\r
mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
- (UINT32) GetVariableHeaderSize (),\r
+ (UINT32) GetVariableHeaderSize (AuthFormat),\r
(UINT8 *) NextVariable\r
);\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
//\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
+ CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat), VarDataSize);\r
if (Attributes != NULL) {\r
*Attributes = Variable.CurrPtr->Attributes;\r
}\r
EFI_STATUS Status;\r
UINTN MaxLen;\r
UINTN VarNameSize;\r
+ BOOLEAN AuthFormat;\r
VARIABLE_HEADER *VariablePtr;\r
VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];\r
\r
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
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
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
// bytes for HwErrRec#### variable.\r
//\r
if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
- if (StrSize (VariableName) + PayloadSize > PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize ()) {\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ PcdGet32 (PcdMaxHardwareErrorVariableSize) - GetVariableHeaderSize (AuthFormat)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
} else {\r
// the DataSize is limited to maximum size of Max(Auth|Volatile)VariableSize bytes.\r
//\r
if ((Attributes & VARIABLE_ATTRIBUTE_AT_AW) != 0) {\r
- if (StrSize (VariableName) + PayloadSize > mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ()) {\r
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxAuthVariableSize -\r
+ GetVariableHeaderSize (AuthFormat)) {\r
DEBUG ((DEBUG_ERROR,\r
"%a: Failed to set variable '%s' with Guid %g\n",\r
__FUNCTION__, VariableName, VendorGuid));\r
"MaxAuthVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
StrSize (VariableName), 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
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxVariableSize - GetVariableHeaderSize (AuthFormat)) {\r
DEBUG ((DEBUG_ERROR,\r
"%a: Failed to set variable '%s' with Guid %g\n",\r
__FUNCTION__, VariableName, VendorGuid));\r
"MaxVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
StrSize (VariableName), 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
+ if (StrSize (VariableName) + PayloadSize >\r
+ mVariableModuleGlobal->MaxVolatileVariableSize - GetVariableHeaderSize (AuthFormat)) {\r
DEBUG ((DEBUG_ERROR,\r
"%a: Failed to set variable '%s' with Guid %g\n",\r
__FUNCTION__, VariableName, VendorGuid));\r
"MaxVolatileVariableSize(0x%x) - HeaderSize(0x%x)\n",\r
StrSize (VariableName), PayloadSize,\r
mVariableModuleGlobal->MaxVolatileVariableSize,\r
- GetVariableHeaderSize ()\r
+ GetVariableHeaderSize (AuthFormat)\r
));\r
return EFI_INVALID_PARAMETER;\r
}\r
//\r
NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point);\r
while (IsValidVariableHeader (NextVariable, GetEndPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point))) {\r
- NextVariable = GetNextVariablePtr (NextVariable);\r
+ NextVariable = GetNextVariablePtr (NextVariable, AuthFormat);\r
}\r
mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;\r
}\r
//\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
+ NextVariable = GetNextVariablePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;\r
\r
if (AtRuntime ()) {\r
VariablePtrTrack.StartPtr = GetStartPointer (VariableStoreHeader);\r
VariablePtrTrack.EndPtr = GetEndPointer (VariableStoreHeader);\r
Status = FindVariableEx (\r
- GetVariableNamePtr (Variable),\r
- GetVendorGuidPtr (Variable),\r
+ GetVariableNamePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
+ GetVendorGuidPtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat),\r
FALSE,\r
- &VariablePtrTrack\r
+ &VariablePtrTrack,\r
+ mVariableModuleGlobal->VariableGlobal.AuthFormat\r
);\r
if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State != VAR_ADDED) {\r
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
}\r
}\r
\r
- if (*RemainingVariableStorageSize < GetVariableHeaderSize ()) {\r
+ if (*RemainingVariableStorageSize < GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat)) {\r
*MaximumVariableSize = 0;\r
- } else if ((*RemainingVariableStorageSize - GetVariableHeaderSize ()) < *MaximumVariableSize) {\r
- *MaximumVariableSize = *RemainingVariableStorageSize - GetVariableHeaderSize ();\r
+ } else if ((*RemainingVariableStorageSize - GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat)) <\r
+ *MaximumVariableSize\r
+ ) {\r
+ *MaximumVariableSize = *RemainingVariableStorageSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\r
\r
return EFI_SUCCESS;\r
//\r
Variable = GetStartPointer (mNvVariableCache);\r
while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
+ NextVariable = GetNextVariablePtr (Variable, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
if ((Variable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
VOID *VariableData;\r
VARIABLE_POINTER_TRACK VariablePtrTrack;\r
BOOLEAN ErrorFlag;\r
+ BOOLEAN AuthFormat;\r
\r
ErrorFlag = FALSE;\r
+ AuthFormat = mVariableModuleGlobal->VariableGlobal.AuthFormat;\r
\r
//\r
// Flush the HOB variable to flash.\r
mVariableModuleGlobal->VariableGlobal.HobVariableBase = 0;\r
for ( Variable = GetStartPointer (VariableStoreHeader)\r
; IsValidVariableHeader (Variable, GetEndPointer (VariableStoreHeader))\r
- ; Variable = GetNextVariablePtr (Variable)\r
+ ; Variable = GetNextVariablePtr (Variable, AuthFormat)\r
) {\r
if (Variable->State != VAR_ADDED) {\r
//\r
}\r
ASSERT ((Variable->Attributes & EFI_VARIABLE_NON_VOLATILE) != 0);\r
if (VendorGuid == NULL || VariableName == NULL ||\r
- !CompareGuid (VendorGuid, GetVendorGuidPtr (Variable)) ||\r
- StrCmp (VariableName, GetVariableNamePtr (Variable)) != 0) {\r
- VariableData = GetVariableDataPtr (Variable);\r
- FindVariable (GetVariableNamePtr (Variable), GetVendorGuidPtr (Variable), &VariablePtrTrack, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
+ !CompareGuid (VendorGuid, GetVendorGuidPtr (Variable, AuthFormat)) ||\r
+ StrCmp (VariableName, GetVariableNamePtr (Variable, AuthFormat)) != 0) {\r
+ VariableData = GetVariableDataPtr (Variable, AuthFormat);\r
+ FindVariable (\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ &VariablePtrTrack,\r
+ &mVariableModuleGlobal->VariableGlobal, FALSE\r
+ );\r
Status = UpdateVariable (\r
- GetVariableNamePtr (Variable),\r
- GetVendorGuidPtr (Variable),\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
VariableData,\r
- DataSizeOfVariable (Variable),\r
+ DataSizeOfVariable (Variable, AuthFormat),\r
Variable->Attributes,\r
0,\r
0,\r
&VariablePtrTrack,\r
NULL\r
);\r
- DEBUG ((EFI_D_INFO, "Variable driver flush the HOB variable to flash: %g %s %r\n", GetVendorGuidPtr (Variable), GetVariableNamePtr (Variable), Status));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "Variable driver flush the HOB variable to flash: %g %s %r\n",\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ GetVariableNamePtr (Variable, AuthFormat),\r
+ Status\r
+ ));\r
} else {\r
//\r
// The updated or deleted variable is matched with this HOB variable.\r
// If set variable successful, or the updated or deleted variable is matched with the HOB variable,\r
// set the HOB variable to DELETED state in local.\r
//\r
- DEBUG ((EFI_D_INFO, "Variable driver set the HOB variable to DELETED state in local: %g %s\n", GetVendorGuidPtr (Variable), GetVariableNamePtr (Variable)));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "Variable driver set the HOB variable to DELETED state in local: %g %s\n",\r
+ GetVendorGuidPtr (Variable, AuthFormat),\r
+ GetVariableNamePtr (Variable, AuthFormat)\r
+ ));\r
Variable->State &= VAR_DELETED;\r
} else {\r
ErrorFlag = TRUE;\r
// Authenticated variable initialize.\r
//\r
mAuthContextIn.StructSize = sizeof (AUTH_VAR_LIB_CONTEXT_IN);\r
- mAuthContextIn.MaxAuthVariableSize = mVariableModuleGlobal->MaxAuthVariableSize - GetVariableHeaderSize ();\r
+ mAuthContextIn.MaxAuthVariableSize = mVariableModuleGlobal->MaxAuthVariableSize -\r
+ GetVariableHeaderSize (mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
Status = AuthVariableLibInitialize (&mAuthContextIn, &mAuthContextOut);\r
if (!EFI_ERROR (Status)) {\r
DEBUG ((EFI_D_INFO, "Variable driver will work with auth variable support!\n"));\r
AuthVarStroageSize += StartPtr->NameSize + GET_PAD_SIZE (StartPtr->NameSize);\r
AuthVarStroageSize += StartPtr->DataSize + GET_PAD_SIZE (StartPtr->DataSize);\r
}\r
- StartPtr = GetNextVariablePtr (StartPtr);\r
+ StartPtr = GetNextVariablePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\r
\r
//\r
// Copy Variable Name\r
//\r
NextPtr = (UINT8 *) (AuthStartPtr + 1);\r
- CopyMem (NextPtr, GetVariableNamePtr (StartPtr), AuthStartPtr->NameSize);\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
}\r
- StartPtr = GetNextVariablePtr (StartPtr);\r
+ StartPtr = GetNextVariablePtr (StartPtr, mVariableModuleGlobal->VariableGlobal.AuthFormat);\r
}\r
//\r
// Update Auth Storage Header\r
/**\r
This code gets the size of variable header.\r
\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
+\r
@return Size of variable header in bytes in type UINTN.\r
\r
**/\r
UINTN\r
GetVariableHeaderSize (\r
- VOID\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
UINTN Value;\r
\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
+ if (AuthFormat) {\r
Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);\r
} else {\r
Value = sizeof (VARIABLE_HEADER);\r
\r
This code gets the size of name of variable.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the variable header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return UINTN Size of variable in bytes.\r
\r
**/\r
UINTN\r
NameSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
\r
AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
+ if (AuthFormat) {\r
if (AuthVariable->State == (UINT8) (-1) ||\r
AuthVariable->DataSize == (UINT32) (-1) ||\r
AuthVariable->NameSize == (UINT32) (-1) ||\r
/**\r
This code sets the size of name of variable.\r
\r
- @param[in] Variable Pointer to the Variable Header.\r
- @param[in] NameSize Name size to set.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] NameSize Name size to set.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
**/\r
VOID\r
SetNameSizeOfVariable (\r
IN VARIABLE_HEADER *Variable,\r
- IN UINTN NameSize\r
+ IN UINTN NameSize,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
\r
AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
+ if (AuthFormat) {\r
AuthVariable->NameSize = (UINT32) NameSize;\r
} else {\r
Variable->NameSize = (UINT32) NameSize;\r
\r
This code gets the size of variable data.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Size of variable in bytes.\r
\r
**/\r
UINTN\r
DataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
\r
AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
+ if (AuthFormat) {\r
if (AuthVariable->State == (UINT8) (-1) ||\r
AuthVariable->DataSize == (UINT32) (-1) ||\r
AuthVariable->NameSize == (UINT32) (-1) ||\r
\r
@param[in] Variable Pointer to the Variable Header.\r
@param[in] DataSize Data size to set.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
**/\r
VOID\r
SetDataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable,\r
- IN UINTN DataSize\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN UINTN DataSize,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
\r
AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
+ if (AuthFormat) {\r
AuthVariable->DataSize = (UINT32) DataSize;\r
} else {\r
Variable->DataSize = (UINT32) DataSize;\r
\r
This code gets the pointer to the variable name.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Pointer to Variable Name which is Unicode encoding.\r
\r
**/\r
CHAR16 *\r
GetVariableNamePtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
- return (CHAR16 *) ((UINTN) Variable + GetVariableHeaderSize ());\r
+ return (CHAR16 *) ((UINTN) Variable + GetVariableHeaderSize (AuthFormat));\r
}\r
\r
/**\r
This code gets the pointer to the variable guid.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return A EFI_GUID* pointer to Vendor Guid.\r
\r
**/\r
EFI_GUID *\r
GetVendorGuidPtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
AUTHENTICATED_VARIABLE_HEADER *AuthVariable;\r
\r
AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *) Variable;\r
- if (mVariableModuleGlobal->VariableGlobal.AuthFormat) {\r
+ if (AuthFormat) {\r
return &AuthVariable->VendorGuid;\r
} else {\r
return &Variable->VendorGuid;\r
\r
This code gets the pointer to the variable data.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Pointer to Variable Data.\r
\r
**/\r
UINT8 *\r
GetVariableDataPtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
UINTN Value;\r
//\r
// Be careful about pad size for alignment.\r
//\r
- Value = (UINTN) GetVariableNamePtr (Variable);\r
- Value += NameSizeOfVariable (Variable);\r
- Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));\r
+ Value = (UINTN) GetVariableNamePtr (Variable, AuthFormat);\r
+ Value += NameSizeOfVariable (Variable, AuthFormat);\r
+ Value += GET_PAD_SIZE (NameSizeOfVariable (Variable, AuthFormat));\r
\r
return (UINT8 *) Value;\r
}\r
/**\r
This code gets the variable data offset related to variable header.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Variable Data offset.\r
\r
**/\r
UINTN\r
GetVariableDataOffset (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
UINTN Value;\r
//\r
// Be careful about pad size for alignment\r
//\r
- Value = GetVariableHeaderSize ();\r
- Value += NameSizeOfVariable (Variable);\r
- Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));\r
+ Value = GetVariableHeaderSize (AuthFormat);\r
+ Value += NameSizeOfVariable (Variable, AuthFormat);\r
+ Value += GET_PAD_SIZE (NameSizeOfVariable (Variable, AuthFormat));\r
\r
return Value;\r
}\r
\r
This code gets the pointer to the next variable header.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Pointer to next variable header.\r
\r
**/\r
VARIABLE_HEADER *\r
GetNextVariablePtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
UINTN Value;\r
\r
- Value = (UINTN) GetVariableDataPtr (Variable);\r
- Value += DataSizeOfVariable (Variable);\r
- Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));\r
+ Value = (UINTN) GetVariableDataPtr (Variable, AuthFormat);\r
+ Value += DataSizeOfVariable (Variable, AuthFormat);\r
+ Value += GET_PAD_SIZE (DataSizeOfVariable (Variable, AuthFormat));\r
\r
//\r
// Be careful about pad size for alignment.\r
@param[in] IgnoreRtCheck Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute\r
check at runtime when searching variable.\r
@param[in, out] PtrTrack Variable Track Pointer structure that contains Variable Information.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@retval EFI_SUCCESS Variable found successfully\r
@retval EFI_NOT_FOUND Variable not found\r
IN CHAR16 *VariableName,\r
IN EFI_GUID *VendorGuid,\r
IN BOOLEAN IgnoreRtCheck,\r
- IN OUT VARIABLE_POINTER_TRACK *PtrTrack\r
+ IN OUT VARIABLE_POINTER_TRACK *PtrTrack,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
VARIABLE_HEADER *InDeletedVariable;\r
\r
for ( PtrTrack->CurrPtr = PtrTrack->StartPtr\r
; IsValidVariableHeader (PtrTrack->CurrPtr, PtrTrack->EndPtr)\r
- ; PtrTrack->CurrPtr = GetNextVariablePtr (PtrTrack->CurrPtr)\r
+ ; PtrTrack->CurrPtr = GetNextVariablePtr (PtrTrack->CurrPtr, AuthFormat)\r
) {\r
if (PtrTrack->CurrPtr->State == VAR_ADDED ||\r
PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)\r
return EFI_SUCCESS;\r
}\r
} else {\r
- if (CompareGuid (VendorGuid, GetVendorGuidPtr (PtrTrack->CurrPtr))) {\r
- Point = (VOID *) GetVariableNamePtr (PtrTrack->CurrPtr);\r
+ if (CompareGuid (VendorGuid, GetVendorGuidPtr (PtrTrack->CurrPtr, AuthFormat))) {\r
+ Point = (VOID *) GetVariableNamePtr (PtrTrack->CurrPtr, AuthFormat);\r
\r
- ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr) != 0);\r
- if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr)) == 0) {\r
+ ASSERT (NameSizeOfVariable (PtrTrack->CurrPtr, AuthFormat) != 0);\r
+ if (CompareMem (VariableName, Point, NameSizeOfVariable (PtrTrack->CurrPtr, AuthFormat)) == 0) {\r
if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
InDeletedVariable = PtrTrack->CurrPtr;\r
} else {\r
@param[in] VariableStoreList A list of variable stores that should be used to get the next variable.\r
The maximum number of entries is the max value of VARIABLE_STORE_TYPE.\r
@param[out] VariablePtr Pointer to variable header address.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@retval EFI_SUCCESS The function completed successfully.\r
@retval EFI_NOT_FOUND The next variable was not found.\r
IN CHAR16 *VariableName,\r
IN EFI_GUID *VendorGuid,\r
IN VARIABLE_STORE_HEADER **VariableStoreList,\r
- OUT VARIABLE_HEADER **VariablePtr\r
+ OUT VARIABLE_HEADER **VariablePtr,\r
+ IN BOOLEAN AuthFormat\r
)\r
{\r
EFI_STATUS Status;\r
Variable.EndPtr = GetEndPointer (VariableStoreList[StoreType]);\r
Variable.Volatile = (BOOLEAN) (StoreType == VariableStoreTypeVolatile);\r
\r
- Status = FindVariableEx (VariableName, VendorGuid, FALSE, &Variable);\r
+ Status = FindVariableEx (VariableName, VendorGuid, FALSE, &Variable, AuthFormat);\r
if (!EFI_ERROR (Status)) {\r
break;\r
}\r
//\r
// If variable name is not empty, get next variable.\r
//\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
+ Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);\r
}\r
\r
while (TRUE) {\r
VariablePtrTrack.StartPtr = Variable.StartPtr;\r
VariablePtrTrack.EndPtr = Variable.EndPtr;\r
Status = FindVariableEx (\r
- GetVariableNamePtr (Variable.CurrPtr),\r
- GetVendorGuidPtr (Variable.CurrPtr),\r
+ GetVariableNamePtr (Variable.CurrPtr, AuthFormat),\r
+ GetVendorGuidPtr (Variable.CurrPtr, AuthFormat),\r
FALSE,\r
- &VariablePtrTrack\r
+ &VariablePtrTrack,\r
+ AuthFormat\r
);\r
if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
+ Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);\r
continue;\r
}\r
}\r
VariableInHob.StartPtr = GetStartPointer (VariableStoreList[VariableStoreTypeHob]);\r
VariableInHob.EndPtr = GetEndPointer (VariableStoreList[VariableStoreTypeHob]);\r
Status = FindVariableEx (\r
- GetVariableNamePtr (Variable.CurrPtr),\r
- GetVendorGuidPtr (Variable.CurrPtr),\r
+ GetVariableNamePtr (Variable.CurrPtr, AuthFormat),\r
+ GetVendorGuidPtr (Variable.CurrPtr, AuthFormat),\r
FALSE,\r
- &VariableInHob\r
+ &VariableInHob,\r
+ AuthFormat\r
);\r
if (!EFI_ERROR (Status)) {\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
+ Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);\r
continue;\r
}\r
}\r
}\r
}\r
\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
+ Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr, AuthFormat);\r
}\r
\r
Done:\r
/**\r
This code gets the size of variable header.\r
\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
+\r
@return Size of variable header in bytes in type UINTN.\r
\r
**/\r
UINTN\r
GetVariableHeaderSize (\r
- VOID\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
\r
This code gets the size of name of variable.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the variable header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return UINTN Size of variable in bytes.\r
\r
**/\r
UINTN\r
NameSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
This code sets the size of name of variable.\r
\r
- @param[in] Variable Pointer to the Variable Header.\r
- @param[in] NameSize Name size to set.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] NameSize Name size to set.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
**/\r
VOID\r
SetNameSizeOfVariable (\r
IN VARIABLE_HEADER *Variable,\r
- IN UINTN NameSize\r
+ IN UINTN NameSize,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
\r
This code gets the size of variable data.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Size of variable in bytes.\r
\r
**/\r
UINTN\r
DataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
\r
@param[in] Variable Pointer to the Variable Header.\r
@param[in] DataSize Data size to set.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
**/\r
VOID\r
SetDataSizeOfVariable (\r
- IN VARIABLE_HEADER *Variable,\r
- IN UINTN DataSize\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN UINTN DataSize,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
\r
This code gets the pointer to the variable name.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Pointer to Variable Name which is Unicode encoding.\r
\r
**/\r
CHAR16 *\r
GetVariableNamePtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
This code gets the pointer to the variable guid.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return A EFI_GUID* pointer to Vendor Guid.\r
\r
**/\r
EFI_GUID *\r
GetVendorGuidPtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
\r
This code gets the pointer to the variable data.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Pointer to Variable Data.\r
\r
**/\r
UINT8 *\r
GetVariableDataPtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
This code gets the variable data offset related to variable header.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Variable Data offset.\r
\r
**/\r
UINTN\r
GetVariableDataOffset (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
\r
This code gets the pointer to the next variable header.\r
\r
- @param Variable Pointer to the Variable Header.\r
+ @param[in] Variable Pointer to the Variable Header.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@return Pointer to next variable header.\r
\r
**/\r
VARIABLE_HEADER *\r
GetNextVariablePtr (\r
- IN VARIABLE_HEADER *Variable\r
+ IN VARIABLE_HEADER *Variable,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
@param[in] IgnoreRtCheck Ignore EFI_VARIABLE_RUNTIME_ACCESS attribute\r
check at runtime when searching variable.\r
@param[in, out] PtrTrack Variable Track Pointer structure that contains Variable Information.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@retval EFI_SUCCESS Variable found successfully\r
@retval EFI_NOT_FOUND Variable not found\r
IN CHAR16 *VariableName,\r
IN EFI_GUID *VendorGuid,\r
IN BOOLEAN IgnoreRtCheck,\r
- IN OUT VARIABLE_POINTER_TRACK *PtrTrack\r
+ IN OUT VARIABLE_POINTER_TRACK *PtrTrack,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
@param[in] VariableStoreList A list of variable stores that should be used to get the next variable.\r
The maximum number of entries is the max value of VARIABLE_STORE_TYPE.\r
@param[out] VariablePtr Pointer to variable header address.\r
+ @param[in] AuthFormat TRUE indicates authenticated variables are used.\r
+ FALSE indicates authenticated variables are not used.\r
\r
@retval EFI_SUCCESS The function completed successfully.\r
@retval EFI_NOT_FOUND The next variable was not found.\r
- @retval EFI_INVALID_PARAMETER If VariableName is nt an empty string, while VendorGuid is NULL.\r
+ @retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while VendorGuid is NULL.\r
@retval EFI_INVALID_PARAMETER The input values of VariableName and VendorGuid are not a name and\r
GUID of an existing variable.\r
\r
IN CHAR16 *VariableName,\r
IN EFI_GUID *VendorGuid,\r
IN VARIABLE_STORE_HEADER **VariableStoreList,\r
- OUT VARIABLE_HEADER **VariablePtr\r
+ OUT VARIABLE_HEADER **VariablePtr,\r
+ IN BOOLEAN AuthFormat\r
);\r
\r
/**\r
projects / mirror_edk2.git / commitdiff