Lines Matching refs:Variable
4 All variable code, variable metadata, and variable data used by Duet platform are on
6 Duet trusts all meta data from disk. If variable code, variable metadata and variable
24 Provide support functions for variable services.
45 Update the variable region with Variable information. These are the same
46 arguments as the EFI Variable services.
48 @param[in] VariableName Name of variable
50 @param[in] VendorGuid Guid of variable
52 @param[in] Data Variable data
56 @param[in] Attributes Attribues of the variable
58 @param[in] Variable The variable information which is used to keep track of variable usage.
62 @retval EFI_OUT_OF_RESOURCES Variable region is full, can not write other data into this region.
73 IN VARIABLE_POINTER_TRACK *Variable
92 IN VARIABLE_HEADER *Variable
98 This code checks if variable header is valid or not.
101 Variable Pointer to the Variable Header.
104 TRUE Variable header is valid.
105 FALSE Variable header is not valid.
109 if (Variable == NULL || Variable->StartId != VARIABLE_DATA) {
124 This code gets the current status of Variable Store.
128 VarStoreHeader Pointer to the Variable Store Header.
132 EfiRaw Variable store status is raw
133 EfiValid Variable store status is valid
134 EfiInvalid Variable store status is invalid
160 IN VARIABLE_HEADER *Variable
166 This code gets the pointer to the variable data.
170 Variable Pointer to the Variable Header.
174 UINT8* Pointer to Variable Data
181 return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
186 IN VARIABLE_HEADER *Variable
192 This code gets the pointer to the next variable header.
196 Variable Pointer to the Variable Header.
200 VARIABLE_HEADER* Pointer to next variable header.
204 if (!IsValidVariableHeader (Variable)) {
210 return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
221 This code gets the pointer to the last variable memory pointer byte
225 VarStoreHeader Pointer to the Variable Store Header.
229 VARIABLE_HEADER* Pointer to last unavailable Variable Header
234 // The end of variable store
241 IN VARIABLE_HEADER *Variable
247 Check if exist newer variable when doing reclaim
251 Variable Pointer to start position
255 TRUE - Exists another variable, which is newer than the current one
264 VendorGuid = &Variable->VendorGuid;
265 VariableName = GET_VARIABLE_NAME_PTR(Variable);
267 NextVariable = GetNextVariablePtr (Variable);
293 Variable store garbage collection and reclaim operation
297 IsVolatile The variable store is volatile or not,
300 current variable for Reclaim.
308 VARIABLE_HEADER *Variable;
320 // Start Pointers for the variable.
322 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
348 // Copy variable store header
354 // Start Pointers for the variable.
356 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
360 while (IsValidVariableHeader (Variable)) {
361 NextVariable = GetNextVariablePtr (Variable);
366 if (Variable->State == VAR_ADDED) {
367 VariableSize = (UINTN) NextVariable - (UINTN) Variable;
368 CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
371 if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
373 } else if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
376 } else if (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)) {
381 if (!ExistNewerVariable(Variable)) {
382 VariableSize = (UINTN) NextVariable - (UINTN) Variable;
383 CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
385 // If CurrentVariable == Variable, mark as VAR_IN_DELETED_TRANSITION
387 if (Variable != CurrentVariable){
392 if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
394 } else if ((!StorageType) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
399 Variable = NextVariable;
419 // If error, then reset the last variable offset to zero.
439 This code finds variable in storage blocks (Volatile or Non-Volatile)
443 VariableName Name of the variable to be found
445 PtrTrack Variable Track Pointer structure that contains
446 Variable Information.
447 Contains the pointer of Variable header.
452 EFI_SUCCESS - Find the specified variable
457 VARIABLE_HEADER *Variable;
481 // Start Pointers for the variable.
484 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
487 // Find the variable by walk through non-volatile and volatile variable store
489 PtrTrack->StartPtr = Variable;
492 while ((Variable < PtrTrack->EndPtr) && IsValidVariableHeader (Variable)) {
493 if (Variable->State == VAR_ADDED) {
494 if (!EfiAtRuntime () || (Variable->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
496 PtrTrack->CurrPtr = Variable;
500 if (CompareGuid (VendorGuid, &Variable->VendorGuid)) {
501 if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable), StrSize (VariableName))) {
502 PtrTrack->CurrPtr = Variable;
509 } else if (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)) {
513 if (!EfiAtRuntime () || (Variable->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
515 InDeleteVariable = Variable;
520 if (CompareGuid (VendorGuid, &Variable->VendorGuid)) {
521 if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable), StrSize (VariableName))) {
522 InDeleteVariable = Variable;
532 Variable = GetNextVariablePtr (Variable);
728 supports a variable argument list that allows the caller to pass in a prioritized
739 @param[in] ... A variable argument list that contains pointers to
750 no matches are found, then the next variable argument
751 parameter is evaluated. The variable argument list
859 and are read-only. Therefore, in variable driver, only store the original value for other use.
861 @param[in] VariableName Name of variable
863 @param[in] Data Variable data
880 VARIABLE_POINTER_TRACK Variable;
894 // PlatformLangCodes is a volatile variable, so it can not be updated at runtime.
904 // Therefore, in variable driver, only store the original value for other use.
924 // LangCodes is a volatile variable, so it can not be updated at runtime.
934 // Therefore, in variable driver, only store the original value for other use.
950 Status = FindVariable (L"PlatformLang", &gEfiGlobalVariableGuid, &Variable);
956 Data = GetVariableDataPtr (Variable.CurrPtr);
957 DataSize = Variable.CurrPtr->DataSize;
959 Status = FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable);
965 Data = GetVariableDataPtr (Variable.CurrPtr);
966 DataSize = Variable.CurrPtr->DataSize;
1002 // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.
1004 FindVariable(L"Lang", &gEfiGlobalVariableGuid, &Variable);
1006 Status = UpdateVariable (L"Lang", &gEfiGlobalVariableGuid, BestLang, ISO_639_2_ENTRY_SIZE + 1, Attributes, &Variable);
1008 DEBUG ((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a\n", BestPlatformLang, BestLang));
1035 // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.
1037 FindVariable(L"PlatformLang", &gEfiGlobalVariableGuid, &Variable);
1040 AsciiStrSize (BestPlatformLang), Attributes, &Variable);
1042 DEBUG ((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a\n", BestLang, BestPlatformLang));
1050 Update the variable region with Variable information. These are the same
1051 arguments as the EFI Variable services.
1053 @param[in] VariableName Name of variable
1055 @param[in] VendorGuid Guid of variable
1057 @param[in] Data Variable data
1061 @param[in] Attributes Attribues of the variable
1063 @param[in] Variable The variable information which is used to keep track of variable usage.
1067 @retval EFI_OUT_OF_RESOURCES Variable region is full, can not write other data into this region.
1078 IN VARIABLE_POINTER_TRACK *Variable
1093 if (Variable->CurrPtr != NULL) {
1095 // Update/Delete existing variable
1100 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
1104 if (Variable->Type == Volatile) {
1108 // Only variable have NV attribute can be updated/deleted in Runtime
1110 if (!(Variable->CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE)) {
1116 // Setting a data variable with no access, or zero DataSize attributes
1121 // Found this variable in storage
1123 State = Variable->CurrPtr->State;
1126 Status = mGlobal->VariableStore[Variable->Type]->Write (
1127 mGlobal->VariableStore[Variable->Type],
1128 VARIABLE_MEMBER_OFFSET (State, (UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr),
1129 sizeof (Variable->CurrPtr->State),
1140 // Found this variable in storage
1141 // If the variable is marked valid and the same data has been passed in
1144 if ((Variable->CurrPtr->DataSize == DataSize) &&
1145 (CompareMem (Data, GetVariableDataPtr (Variable->CurrPtr), DataSize) == 0)
1148 } else if ((Variable->CurrPtr->State == VAR_ADDED) ||
1149 (Variable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1151 // Mark the old variable as in delete transition
1153 State = Variable->CurrPtr->State;
1156 Status = mGlobal->VariableStore[Variable->Type]->Write (
1157 mGlobal->VariableStore[Variable->Type],
1158 VARIABLE_MEMBER_OFFSET (State, (UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr),
1159 sizeof (Variable->CurrPtr->State),
1169 // Create a new variable
1173 // Make sure we are trying to create a new variable.
1174 // Setting a data variable with no access, or zero DataSize attributes means to delete it.
1180 // Only variable have NV|RT attribute can be created in Runtime
1190 // Function part - create a new variable and copy the data.
1191 // Both update a variable and create a variable will come here.
1218 // NextVariable->DataSize should not include pad size so that variable
1225 // The actual size of the variable that stores in storage should
1227 // VarDataOffset: offset from begin of current variable header
1242 Status = Reclaim (StorageType, Variable->CurrPtr);
1281 // Mark the old variable as deleted
1283 if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != NULL) {
1284 State = Variable->CurrPtr->State;
1289 VARIABLE_MEMBER_OFFSET (State, (UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr),
1290 sizeof (Variable->CurrPtr->State),
1314 This code finds variable in storage blocks (Volatile or Non-Volatile)
1318 VariableName Name of Variable to be found
1319 VendorGuid Variable vendor GUID
1320 Attributes OPTIONAL Attribute value of the variable found
1331 VARIABLE_POINTER_TRACK Variable;
1340 // Find existing variable
1342 Status = FindVariable (VariableName, VendorGuid, &Variable);
1344 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
1350 VarDataSize = Variable.CurrPtr->DataSize;
1355 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
1358 *Attributes = Variable.CurrPtr->Attributes;
1381 This code Finds the Next available variable
1385 VariableNameSize Size of the variable
1386 VariableName Pointer to variable name
1387 VendorGuid Variable Vendor Guid
1395 VARIABLE_POINTER_TRACK Variable;
1403 Status = FindVariable (VariableName, VendorGuid, &Variable);
1405 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
1411 // If variable name is not NULL, get next variable
1413 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
1418 // The order we find variable is: 1). NonVolatile; 2). Volatile
1419 // If both volatile and non-volatile variable store are parsed,
1422 if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
1423 if (Variable.Type == Volatile) {
1433 Variable.Type = Volatile;
1434 Variable.StartPtr = (VARIABLE_HEADER *) ((VARIABLE_STORE_HEADER *) mGlobal->VariableBase[Volatile] + 1);
1435 Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) mGlobal->VariableBase[Volatile]);
1437 Variable.CurrPtr = Variable.StartPtr;
1438 if (!IsValidVariableHeader (Variable.CurrPtr)) {
1443 // Variable is found
1445 if (IsValidVariableHeader (Variable.CurrPtr) &&
1446 ((Variable.CurrPtr->State == VAR_ADDED) ||
1447 (Variable.CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION)))) {
1448 if (!EfiAtRuntime () || (Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1449 VarNameSize = Variable.CurrPtr->NameSize;
1453 GET_VARIABLE_NAME_PTR (Variable.CurrPtr),
1458 &Variable.CurrPtr->VendorGuid,
1471 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
1488 This code sets variable in storage blocks (Volatile or Non-Volatile)
1492 VariableName Name of Variable to be found
1493 VendorGuid Variable vendor GUID
1494 Attributes Attribute value of the variable found
1503 EFI_OUT_OF_RESOURCES - Resource not enough to set variable
1505 EFI_DEVICE_ERROR - Variable can not be saved due to hardware failure
1506 EFI_WRITE_PROTECTED - Variable is read-only
1510 VARIABLE_POINTER_TRACK Variable;
1525 // Not support authenticated variable write yet.
1549 // According to UEFI spec, HARDWARE_ERROR_RECORD variable name convention should be L"HwErrRecXXXX"
1562 // Check whether the input variable is already existed
1564 Status = FindVariable (VariableName, VendorGuid, &Variable);
1571 Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, &Variable);
1610 VARIABLE_HEADER *Variable;
1646 // Not support authentiated variable write yet.
1661 // Harware error record variable needs larger size.
1673 // Let *MaximumVariableSize be PcdGet32(PcdMaxVariableSize) with the exception of the variable header size.
1681 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1684 // Now walk through the related variable store.
1686 while ((Variable < GetEndPointer (VariableStoreHeader)) && IsValidVariableHeader (Variable)) {
1687 NextVariable = GetNextVariablePtr (Variable);
1688 VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
1697 if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1707 if ((Variable->State == VAR_ADDED) || (Variable->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1708 if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1719 Variable = NextVariable;
1740 This function does initialization for variable services
1751 EFI_NOT_FOUND - Variable store area not found.
1752 EFI_SUCCESS - Variable services successfully initialized.
1760 VARIABLE_HEADER *Variable;
1791 DEBUG ((EFI_D_ERROR, "FSVariable: Could not find flash area for variable!\n"));
1803 // Mark the variable storage region of the FLASH as RUNTIME
1866 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1867 while (IsValidVariableHeader (Variable)) {
1869 NextVariable = GetNextVariablePtr (Variable);
1870 VariableSize = NextVariable - Variable;
1876 Variable = NextVariable;
1879 mGlobal->LastVariableOffset[NonVolatile] = (UINTN) Variable - (UINTN) VariableStoreHeader;
1923 // Now install the Variable Runtime Architectural Protocol on a new handle
