3 Caution: This file is used for Duet platform only, do not use them in real platform.
4 All variable code, variable metadata, and variable data used by Duet platform are on
5 disk. They can be changed by user. BIOS is not able to protoect those.
6 Duet trusts all meta data from disk. If variable code, variable metadata and variable
7 data is modified in inproper way, the behavior is undefined.
9 Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
10 This program and the accompanying materials
11 are licensed and made available under the terms and conditions of the BSD License
12 which accompanies this distribution. The full text of the license may be found at
13 http://opensource.org/licenses/bsd-license.php
15 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
16 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
24 Provide support functions for variable services.
28 #include "FSVariable.h"
30 VARIABLE_STORE_HEADER mStoreHeaderTemplate
= {
31 VARIABLE_STORE_SIGNATURE
,
32 VOLATILE_VARIABLE_STORE_SIZE
,
33 VARIABLE_STORE_FORMATTED
,
34 VARIABLE_STORE_HEALTHY
,
40 // Don't use module globals after the SetVirtualAddress map is signaled
42 VARIABLE_GLOBAL
*mGlobal
;
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
54 @param[in] DataSize Size of data. 0 means delete
56 @param[in] Attributes Attribues of the variable
58 @param[in] Variable The variable information which is used to keep track of variable usage.
60 @retval EFI_SUCCESS The update operation is success.
62 @retval EFI_OUT_OF_RESOURCES Variable region is full, can not write other data into this region.
68 IN CHAR16
*VariableName
,
69 IN EFI_GUID
*VendorGuid
,
72 IN UINT32 Attributes OPTIONAL
,
73 IN VARIABLE_POINTER_TRACK
*Variable
78 OnVirtualAddressChangeFsv (
85 OnSimpleFileSystemInstall (
91 IsValidVariableHeader (
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
) {
116 VARIABLE_STORE_STATUS
117 GetVariableStoreStatus (
118 IN VARIABLE_STORE_HEADER
*VarStoreHeader
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
138 if (CompareGuid (&VarStoreHeader
->Signature
, &mStoreHeaderTemplate
.Signature
) &&
139 (VarStoreHeader
->Format
== mStoreHeaderTemplate
.Format
) &&
140 (VarStoreHeader
->State
== mStoreHeaderTemplate
.State
)
143 } else if (((UINT32
*)(&VarStoreHeader
->Signature
))[0] == VAR_DEFAULT_VALUE_32
&&
144 ((UINT32
*)(&VarStoreHeader
->Signature
))[1] == VAR_DEFAULT_VALUE_32
&&
145 ((UINT32
*)(&VarStoreHeader
->Signature
))[2] == VAR_DEFAULT_VALUE_32
&&
146 ((UINT32
*)(&VarStoreHeader
->Signature
))[3] == VAR_DEFAULT_VALUE_32
&&
147 VarStoreHeader
->Size
== VAR_DEFAULT_VALUE_32
&&
148 VarStoreHeader
->Format
== VAR_DEFAULT_VALUE
&&
149 VarStoreHeader
->State
== VAR_DEFAULT_VALUE
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
179 // Be careful about pad size for alignment
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
)) {
208 // Be careful about pad size for alignment
210 return (VARIABLE_HEADER
*) ((UINTN
) GetVariableDataPtr (Variable
) + Variable
->DataSize
+ GET_PAD_SIZE (Variable
->DataSize
));
215 IN VARIABLE_STORE_HEADER
*VarStoreHeader
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
236 return (VARIABLE_HEADER
*) ((UINTN
) VarStoreHeader
+ VarStoreHeader
->Size
);
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
256 FALSE - Doesn't exist another vairable which is newer than the current one
260 VARIABLE_HEADER
*NextVariable
;
261 CHAR16
*VariableName
;
262 EFI_GUID
*VendorGuid
;
264 VendorGuid
= &Variable
->VendorGuid
;
265 VariableName
= GET_VARIABLE_NAME_PTR(Variable
);
267 NextVariable
= GetNextVariablePtr (Variable
);
268 while (IsValidVariableHeader (NextVariable
)) {
269 if ((NextVariable
->State
== VAR_ADDED
) || (NextVariable
->State
== (VAR_ADDED
& VAR_IN_DELETED_TRANSITION
))) {
271 // If match Guid and Name
273 if (CompareGuid (VendorGuid
, &NextVariable
->VendorGuid
)) {
274 if (CompareMem (VariableName
, GET_VARIABLE_NAME_PTR (NextVariable
), StrSize (VariableName
)) == 0) {
279 NextVariable
= GetNextVariablePtr (NextVariable
);
286 IN VARIABLE_STORAGE_TYPE StorageType
,
287 IN VARIABLE_HEADER
*CurrentVariable OPTIONAL
293 Variable store garbage collection and reclaim operation
297 IsVolatile The variable store is volatile or not,
298 if it is non-volatile, need FTW
299 CurrentVairable If it is not NULL, it means not to process
300 current variable for Reclaim.
308 VARIABLE_HEADER
*Variable
;
309 VARIABLE_HEADER
*NextVariable
;
310 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
312 UINTN ValidBufferSize
;
317 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[StorageType
];
320 // Start Pointers for the variable.
322 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
325 // recaluate the total size of Common/HwErr type variables in non-volatile area.
328 mGlobal
->CommonVariableTotalSize
= 0;
329 mGlobal
->HwErrVariableTotalSize
= 0;
332 // To make the reclaim, here we just allocate a memory that equal to the original memory
334 ValidBufferSize
= sizeof (VARIABLE_STORE_HEADER
) + VariableStoreHeader
->Size
;
336 Status
= gBS
->AllocatePool (
339 (VOID
**) &ValidBuffer
341 if (EFI_ERROR (Status
)) {
345 CurrPtr
= ValidBuffer
;
348 // Copy variable store header
350 CopyMem (CurrPtr
, VariableStoreHeader
, sizeof (VARIABLE_STORE_HEADER
));
351 CurrPtr
+= sizeof (VARIABLE_STORE_HEADER
);
354 // Start Pointers for the variable.
356 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
359 ValidBufferSize
= sizeof (VARIABLE_STORE_HEADER
);
360 while (IsValidVariableHeader (Variable
)) {
361 NextVariable
= GetNextVariablePtr (Variable
);
363 // State VAR_ADDED or VAR_IN_DELETED_TRANSITION are to kept,
364 // The CurrentVariable, is also saved, as SetVariable may fail due to lack of space
366 if (Variable
->State
== VAR_ADDED
) {
367 VariableSize
= (UINTN
) NextVariable
- (UINTN
) Variable
;
368 CopyMem (CurrPtr
, (UINT8
*) Variable
, VariableSize
);
369 ValidBufferSize
+= VariableSize
;
370 CurrPtr
+= VariableSize
;
371 if ((!StorageType
) && ((Variable
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) {
372 mGlobal
->HwErrVariableTotalSize
+= VariableSize
;
373 } else if ((!StorageType
) && ((Variable
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) != EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) {
374 mGlobal
->CommonVariableTotalSize
+= VariableSize
;
376 } else if (Variable
->State
== (VAR_ADDED
& VAR_IN_DELETED_TRANSITION
)) {
378 // As variables that with the same guid and name may exist in NV due to power failure during SetVariable,
379 // we will only save the latest valid one
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
){
388 ((VARIABLE_HEADER
*)CurrPtr
)->State
= VAR_ADDED
;
390 CurrPtr
+= VariableSize
;
391 ValidBufferSize
+= VariableSize
;
392 if ((!StorageType
) && ((Variable
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) {
393 mGlobal
->HwErrVariableTotalSize
+= VariableSize
;
394 } else if ((!StorageType
) && ((Variable
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) != EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) {
395 mGlobal
->CommonVariableTotalSize
+= VariableSize
;
399 Variable
= NextVariable
;
402 mGlobal
->LastVariableOffset
[StorageType
] = ValidBufferSize
;
405 // TODO: cannot restore to original state, basic FTW needed
407 Status
= mGlobal
->VariableStore
[StorageType
]->Erase (
408 mGlobal
->VariableStore
[StorageType
]
410 Status
= mGlobal
->VariableStore
[StorageType
]->Write (
411 mGlobal
->VariableStore
[StorageType
],
417 if (EFI_ERROR (Status
)) {
419 // If error, then reset the last variable offset to zero.
421 mGlobal
->LastVariableOffset
[StorageType
] = 0;
424 gBS
->FreePool (ValidBuffer
);
431 IN CHAR16
*VariableName
,
432 IN EFI_GUID
*VendorGuid
,
433 OUT VARIABLE_POINTER_TRACK
*PtrTrack
439 This code finds variable in storage blocks (Volatile or Non-Volatile)
443 VariableName Name of the variable to be found
444 VendorGuid Vendor GUID to be found.
445 PtrTrack Variable Track Pointer structure that contains
446 Variable Information.
447 Contains the pointer of Variable header.
451 EFI_INVALID_PARAMETER - Invalid parameter
452 EFI_SUCCESS - Find the specified variable
453 EFI_NOT_FOUND - Not found
457 VARIABLE_HEADER
*Variable
;
458 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
460 VARIABLE_HEADER
*InDeleteVariable
;
462 VARIABLE_HEADER
*InDeleteStartPtr
;
463 VARIABLE_HEADER
*InDeleteEndPtr
;
465 if (VariableName
[0] != 0 && VendorGuid
== NULL
) {
466 return EFI_INVALID_PARAMETER
;
469 InDeleteVariable
= NULL
;
470 InDeleteIndex
= (UINTN
)-1;
471 InDeleteStartPtr
= NULL
;
472 InDeleteEndPtr
= NULL
;
474 for (Index
= 0; Index
< MaxType
; Index
++) {
476 // 0: Non-Volatile, 1: Volatile
478 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[Index
];
481 // Start Pointers for the variable.
482 // Actual Data Pointer where data can be written.
484 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
487 // Find the variable by walk through non-volatile and volatile variable store
489 PtrTrack
->StartPtr
= Variable
;
490 PtrTrack
->EndPtr
= GetEndPointer (VariableStoreHeader
);
492 while ((Variable
< PtrTrack
->EndPtr
) && IsValidVariableHeader (Variable
)) {
493 if (Variable
->State
== VAR_ADDED
) {
494 if (!EfiAtRuntime () || (Variable
->Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)) {
495 if (VariableName
[0] == 0) {
496 PtrTrack
->CurrPtr
= Variable
;
497 PtrTrack
->Type
= (VARIABLE_STORAGE_TYPE
) Index
;
500 if (CompareGuid (VendorGuid
, &Variable
->VendorGuid
)) {
501 if (!CompareMem (VariableName
, GET_VARIABLE_NAME_PTR (Variable
), StrSize (VariableName
))) {
502 PtrTrack
->CurrPtr
= Variable
;
503 PtrTrack
->Type
= (VARIABLE_STORAGE_TYPE
) Index
;
509 } else if (Variable
->State
== (VAR_ADDED
& VAR_IN_DELETED_TRANSITION
)) {
511 // VAR_IN_DELETED_TRANSITION should also be checked.
513 if (!EfiAtRuntime () || (Variable
->Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)) {
514 if (VariableName
[0] == 0) {
515 InDeleteVariable
= Variable
;
516 InDeleteIndex
= Index
;
517 InDeleteStartPtr
= PtrTrack
->StartPtr
;
518 InDeleteEndPtr
= PtrTrack
->EndPtr
;
520 if (CompareGuid (VendorGuid
, &Variable
->VendorGuid
)) {
521 if (!CompareMem (VariableName
, GET_VARIABLE_NAME_PTR (Variable
), StrSize (VariableName
))) {
522 InDeleteVariable
= Variable
;
523 InDeleteIndex
= Index
;
524 InDeleteStartPtr
= PtrTrack
->StartPtr
;
525 InDeleteEndPtr
= PtrTrack
->EndPtr
;
532 Variable
= GetNextVariablePtr (Variable
);
543 // if VAR_IN_DELETED_TRANSITION found, and VAR_ADDED not found,
546 if (InDeleteVariable
!= NULL
) {
547 PtrTrack
->CurrPtr
= InDeleteVariable
;
548 PtrTrack
->Type
= (VARIABLE_STORAGE_TYPE
) InDeleteIndex
;
549 PtrTrack
->StartPtr
= InDeleteStartPtr
;
550 PtrTrack
->EndPtr
= InDeleteEndPtr
;
554 PtrTrack
->CurrPtr
= NULL
;
555 return EFI_NOT_FOUND
;
559 Get index from supported language codes according to language string.
561 This code is used to get corresponding index in supported language codes. It can handle
562 RFC4646 and ISO639 language tags.
563 In ISO639 language tags, take 3-characters as a delimitation to find matched string and calculate the index.
564 In RFC4646 language tags, take semicolon as a delimitation to find matched string and calculate the index.
567 SupportedLang = "engfraengfra"
569 Iso639Language = TRUE
570 The return value is "0".
572 SupportedLang = "en;fr;en-US;fr-FR"
574 Iso639Language = FALSE
575 The return value is "3".
577 @param SupportedLang Platform supported language codes.
578 @param Lang Configured language.
579 @param Iso639Language A bool value to signify if the handler is operated on ISO639 or RFC4646.
581 @retval the index of language in the language codes.
585 GetIndexFromSupportedLangCodes(
586 IN CHAR8
*SupportedLang
,
588 IN BOOLEAN Iso639Language
593 UINTN LanguageLength
;
595 if (Iso639Language
) {
596 CompareLength
= ISO_639_2_ENTRY_SIZE
;
597 for (Index
= 0; Index
< AsciiStrLen (SupportedLang
); Index
+= CompareLength
) {
598 if (AsciiStrnCmp (Lang
, SupportedLang
+ Index
, CompareLength
) == 0) {
600 // Successfully find the index of Lang string in SupportedLang string.
602 Index
= Index
/ CompareLength
;
610 // Compare RFC4646 language code
613 for (LanguageLength
= 0; Lang
[LanguageLength
] != '\0'; LanguageLength
++);
615 for (Index
= 0; *SupportedLang
!= '\0'; Index
++, SupportedLang
+= CompareLength
) {
617 // Skip ';' characters in SupportedLang
619 for (; *SupportedLang
!= '\0' && *SupportedLang
== ';'; SupportedLang
++);
621 // Determine the length of the next language code in SupportedLang
623 for (CompareLength
= 0; SupportedLang
[CompareLength
] != '\0' && SupportedLang
[CompareLength
] != ';'; CompareLength
++);
625 if ((CompareLength
== LanguageLength
) &&
626 (AsciiStrnCmp (Lang
, SupportedLang
, CompareLength
) == 0)) {
628 // Successfully find the index of Lang string in SupportedLang string.
639 Get language string from supported language codes according to index.
641 This code is used to get corresponding language string in supported language codes. It can handle
642 RFC4646 and ISO639 language tags.
643 In ISO639 language tags, take 3-characters as a delimitation. Find language string according to the index.
644 In RFC4646 language tags, take semicolon as a delimitation. Find language string according to the index.
647 SupportedLang = "engfraengfra"
649 Iso639Language = TRUE
650 The return value is "fra".
652 SupportedLang = "en;fr;en-US;fr-FR"
654 Iso639Language = FALSE
655 The return value is "fr".
657 @param SupportedLang Platform supported language codes.
658 @param Index the index in supported language codes.
659 @param Iso639Language A bool value to signify if the handler is operated on ISO639 or RFC4646.
661 @retval the language string in the language codes.
665 GetLangFromSupportedLangCodes (
666 IN CHAR8
*SupportedLang
,
668 IN BOOLEAN Iso639Language
676 Supported
= SupportedLang
;
677 if (Iso639Language
) {
679 // according to the index of Lang string in SupportedLang string to get the language.
680 // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.
681 // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.
683 CompareLength
= ISO_639_2_ENTRY_SIZE
;
684 mGlobal
->Lang
[CompareLength
] = '\0';
685 return CopyMem (mGlobal
->Lang
, SupportedLang
+ Index
* CompareLength
, CompareLength
);
690 // take semicolon as delimitation, sequentially traverse supported language codes.
692 for (CompareLength
= 0; *Supported
!= ';' && *Supported
!= '\0'; CompareLength
++) {
695 if ((*Supported
== '\0') && (SubIndex
!= Index
)) {
697 // Have completed the traverse, but not find corrsponding string.
698 // This case is not allowed to happen.
703 if (SubIndex
== Index
) {
705 // according to the index of Lang string in SupportedLang string to get the language.
706 // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.
707 // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.
709 mGlobal
->PlatformLang
[CompareLength
] = '\0';
710 return CopyMem (mGlobal
->PlatformLang
, Supported
- CompareLength
, CompareLength
);
715 // Skip ';' characters in Supported
717 for (; *Supported
!= '\0' && *Supported
== ';'; Supported
++);
723 Returns a pointer to an allocated buffer that contains the best matching language
724 from a set of supported languages.
726 This function supports both ISO 639-2 and RFC 4646 language codes, but language
727 code types may not be mixed in a single call to this function. This function
728 supports a variable argument list that allows the caller to pass in a prioritized
729 list of language codes to test against all the language codes in SupportedLanguages.
731 If SupportedLanguages is NULL, then ASSERT().
733 @param[in] SupportedLanguages A pointer to a Null-terminated ASCII string that
734 contains a set of language codes in the format
735 specified by Iso639Language.
736 @param[in] Iso639Language If TRUE, then all language codes are assumed to be
737 in ISO 639-2 format. If FALSE, then all language
738 codes are assumed to be in RFC 4646 language format
739 @param[in] ... A variable argument list that contains pointers to
740 Null-terminated ASCII strings that contain one or more
741 language codes in the format specified by Iso639Language.
742 The first language code from each of these language
743 code lists is used to determine if it is an exact or
744 close match to any of the language codes in
745 SupportedLanguages. Close matches only apply to RFC 4646
746 language codes, and the matching algorithm from RFC 4647
747 is used to determine if a close match is present. If
748 an exact or close match is found, then the matching
749 language code from SupportedLanguages is returned. If
750 no matches are found, then the next variable argument
751 parameter is evaluated. The variable argument list
752 is terminated by a NULL.
754 @retval NULL The best matching language could not be found in SupportedLanguages.
755 @retval NULL There are not enough resources available to return the best matching
757 @retval Other A pointer to a Null-terminated ASCII string that is the best matching
758 language in SupportedLanguages.
763 VariableGetBestLanguage (
764 IN CONST CHAR8
*SupportedLanguages
,
765 IN BOOLEAN Iso639Language
,
772 UINTN LanguageLength
;
773 CONST CHAR8
*Supported
;
776 ASSERT (SupportedLanguages
!= NULL
);
778 VA_START (Args
, Iso639Language
);
779 while ((Language
= VA_ARG (Args
, CHAR8
*)) != NULL
) {
781 // Default to ISO 639-2 mode
784 LanguageLength
= MIN (3, AsciiStrLen (Language
));
787 // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language
789 if (!Iso639Language
) {
790 for (LanguageLength
= 0; Language
[LanguageLength
] != 0 && Language
[LanguageLength
] != ';'; LanguageLength
++);
794 // Trim back the length of Language used until it is empty
796 while (LanguageLength
> 0) {
798 // Loop through all language codes in SupportedLanguages
800 for (Supported
= SupportedLanguages
; *Supported
!= '\0'; Supported
+= CompareLength
) {
802 // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages
804 if (!Iso639Language
) {
806 // Skip ';' characters in Supported
808 for (; *Supported
!= '\0' && *Supported
== ';'; Supported
++);
810 // Determine the length of the next language code in Supported
812 for (CompareLength
= 0; Supported
[CompareLength
] != 0 && Supported
[CompareLength
] != ';'; CompareLength
++);
814 // If Language is longer than the Supported, then skip to the next language
816 if (LanguageLength
> CompareLength
) {
821 // See if the first LanguageLength characters in Supported match Language
823 if (AsciiStrnCmp (Supported
, Language
, LanguageLength
) == 0) {
826 Buffer
= Iso639Language
? mGlobal
->Lang
: mGlobal
->PlatformLang
;
827 Buffer
[CompareLength
] = '\0';
828 return CopyMem (Buffer
, Supported
, CompareLength
);
832 if (Iso639Language
) {
834 // If ISO 639 mode, then each language can only be tested once
839 // If RFC 4646 mode, then trim Language from the right to the next '-' character
841 for (LanguageLength
--; LanguageLength
> 0 && Language
[LanguageLength
] != '-'; LanguageLength
--);
848 // No matches were found
854 Hook the operations in PlatformLangCodes, LangCodes, PlatformLang and Lang.
856 When setting Lang/LangCodes, simultaneously update PlatformLang/PlatformLangCodes.
858 According to UEFI spec, PlatformLangCodes/LangCodes are only set once in firmware initialization,
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
865 @param[in] DataSize Size of data. 0 means delete
869 AutoUpdateLangVariable(
870 IN CHAR16
*VariableName
,
876 CHAR8
*BestPlatformLang
;
880 VARIABLE_POINTER_TRACK Variable
;
881 BOOLEAN SetLanguageCodes
;
884 // Don't do updates for delete operation
890 SetLanguageCodes
= FALSE
;
892 if (StrCmp (VariableName
, L
"PlatformLangCodes") == 0) {
894 // PlatformLangCodes is a volatile variable, so it can not be updated at runtime.
896 if (EfiAtRuntime ()) {
900 SetLanguageCodes
= TRUE
;
903 // According to UEFI spec, PlatformLangCodes is only set once in firmware initialization, and is read-only
904 // Therefore, in variable driver, only store the original value for other use.
906 if (mGlobal
->PlatformLangCodes
!= NULL
) {
907 FreePool (mGlobal
->PlatformLangCodes
);
909 mGlobal
->PlatformLangCodes
= AllocateRuntimeCopyPool (DataSize
, Data
);
910 ASSERT (mGlobal
->PlatformLangCodes
!= NULL
);
913 // PlatformLang holds a single language from PlatformLangCodes,
914 // so the size of PlatformLangCodes is enough for the PlatformLang.
916 if (mGlobal
->PlatformLang
!= NULL
) {
917 FreePool (mGlobal
->PlatformLang
);
919 mGlobal
->PlatformLang
= AllocateRuntimePool (DataSize
);
920 ASSERT (mGlobal
->PlatformLang
!= NULL
);
922 } else if (StrCmp (VariableName
, L
"LangCodes") == 0) {
924 // LangCodes is a volatile variable, so it can not be updated at runtime.
926 if (EfiAtRuntime ()) {
930 SetLanguageCodes
= TRUE
;
933 // According to UEFI spec, LangCodes is only set once in firmware initialization, and is read-only
934 // Therefore, in variable driver, only store the original value for other use.
936 if (mGlobal
->LangCodes
!= NULL
) {
937 FreePool (mGlobal
->LangCodes
);
939 mGlobal
->LangCodes
= AllocateRuntimeCopyPool (DataSize
, Data
);
940 ASSERT (mGlobal
->LangCodes
!= NULL
);
944 && (mGlobal
->PlatformLangCodes
!= NULL
)
945 && (mGlobal
->LangCodes
!= NULL
)) {
947 // Update Lang if PlatformLang is already set
948 // Update PlatformLang if Lang is already set
950 Status
= FindVariable (L
"PlatformLang", &gEfiGlobalVariableGuid
, &Variable
);
951 if (!EFI_ERROR (Status
)) {
955 VariableName
= L
"PlatformLang";
956 Data
= GetVariableDataPtr (Variable
.CurrPtr
);
957 DataSize
= Variable
.CurrPtr
->DataSize
;
959 Status
= FindVariable (L
"Lang", &gEfiGlobalVariableGuid
, &Variable
);
960 if (!EFI_ERROR (Status
)) {
962 // Update PlatformLang
964 VariableName
= L
"Lang";
965 Data
= GetVariableDataPtr (Variable
.CurrPtr
);
966 DataSize
= Variable
.CurrPtr
->DataSize
;
969 // Neither PlatformLang nor Lang is set, directly return
977 // According to UEFI spec, "Lang" and "PlatformLang" is NV|BS|RT attributions.
979 Attributes
= EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
;
981 if (StrCmp (VariableName
, L
"PlatformLang") == 0) {
983 // Update Lang when PlatformLangCodes/LangCodes were set.
985 if ((mGlobal
->PlatformLangCodes
!= NULL
) && (mGlobal
->LangCodes
!= NULL
)) {
987 // When setting PlatformLang, firstly get most matched language string from supported language codes.
989 BestPlatformLang
= VariableGetBestLanguage (mGlobal
->PlatformLangCodes
, FALSE
, Data
, NULL
);
990 if (BestPlatformLang
!= NULL
) {
992 // Get the corresponding index in language codes.
994 Index
= GetIndexFromSupportedLangCodes (mGlobal
->PlatformLangCodes
, BestPlatformLang
, FALSE
);
997 // Get the corresponding ISO639 language tag according to RFC4646 language tag.
999 BestLang
= GetLangFromSupportedLangCodes (mGlobal
->LangCodes
, Index
, TRUE
);
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
));
1010 ASSERT_EFI_ERROR(Status
);
1014 } else if (StrCmp (VariableName
, L
"Lang") == 0) {
1016 // Update PlatformLang when PlatformLangCodes/LangCodes were set.
1018 if ((mGlobal
->PlatformLangCodes
!= NULL
) && (mGlobal
->LangCodes
!= NULL
)) {
1020 // When setting Lang, firstly get most matched language string from supported language codes.
1022 BestLang
= VariableGetBestLanguage (mGlobal
->LangCodes
, TRUE
, Data
, NULL
);
1023 if (BestLang
!= NULL
) {
1025 // Get the corresponding index in language codes.
1027 Index
= GetIndexFromSupportedLangCodes (mGlobal
->LangCodes
, BestLang
, TRUE
);
1030 // Get the corresponding RFC4646 language tag according to ISO639 language tag.
1032 BestPlatformLang
= GetLangFromSupportedLangCodes (mGlobal
->PlatformLangCodes
, Index
, FALSE
);
1035 // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.
1037 FindVariable(L
"PlatformLang", &gEfiGlobalVariableGuid
, &Variable
);
1039 Status
= UpdateVariable (L
"PlatformLang", &gEfiGlobalVariableGuid
, BestPlatformLang
,
1040 AsciiStrSize (BestPlatformLang
), Attributes
, &Variable
);
1042 DEBUG ((EFI_D_INFO
, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a\n", BestLang
, BestPlatformLang
));
1043 ASSERT_EFI_ERROR (Status
);
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
1059 @param[in] DataSize Size of data. 0 means delete
1061 @param[in] Attributes Attribues of the variable
1063 @param[in] Variable The variable information which is used to keep track of variable usage.
1065 @retval EFI_SUCCESS The update operation is success.
1067 @retval EFI_OUT_OF_RESOURCES Variable region is full, can not write other data into this region.
1073 IN CHAR16
*VariableName
,
1074 IN EFI_GUID
*VendorGuid
,
1077 IN UINT32 Attributes OPTIONAL
,
1078 IN VARIABLE_POINTER_TRACK
*Variable
1082 VARIABLE_HEADER
*NextVariable
;
1083 UINTN VarNameOffset
;
1084 UINTN VarDataOffset
;
1089 VARIABLE_STORAGE_TYPE StorageType
;
1093 if (Variable
->CurrPtr
!= NULL
) {
1095 // Update/Delete existing variable
1098 if (EfiAtRuntime ()) {
1100 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
1101 // the volatile is ReadOnly, and SetVariable should be aborted and
1102 // return EFI_WRITE_PROTECTED.
1104 if (Variable
->Type
== Volatile
) {
1105 return EFI_WRITE_PROTECTED
;
1108 // Only variable have NV attribute can be updated/deleted in Runtime
1110 if (!(Variable
->CurrPtr
->Attributes
& EFI_VARIABLE_NON_VOLATILE
)) {
1111 return EFI_INVALID_PARAMETER
;
1116 // Setting a data variable with no access, or zero DataSize attributes
1117 // specified causes it to be deleted.
1119 if (DataSize
== 0 || (Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == 0) {
1121 // Found this variable in storage
1123 State
= Variable
->CurrPtr
->State
;
1124 State
&= VAR_DELETED
;
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
),
1133 // NOTE: Write operation at least can write data to memory cache
1134 // Discard file writing failure here.
1140 // Found this variable in storage
1141 // If the variable is marked valid and the same data has been passed in
1142 // then return to the caller immediately.
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
;
1154 State
&= VAR_IN_DELETED_TRANSITION
;
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
),
1163 // NOTE: Write operation at least can write data to memory cache
1164 // Discard file writing failure here.
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.
1176 if (DataSize
== 0 || (Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == 0) {
1177 return EFI_NOT_FOUND
;
1180 // Only variable have NV|RT attribute can be created in Runtime
1182 if (EfiAtRuntime () &&
1183 (!(Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
) || !(Attributes
& EFI_VARIABLE_NON_VOLATILE
))) {
1184 return EFI_INVALID_PARAMETER
;
1190 // Function part - create a new variable and copy the data.
1191 // Both update a variable and create a variable will come here.
1192 // We can firstly write all the data in memory, then write them to file
1193 // This can reduce the times of write operation
1196 NextVariable
= (VARIABLE_HEADER
*) mGlobal
->Scratch
;
1198 NextVariable
->StartId
= VARIABLE_DATA
;
1199 NextVariable
->Attributes
= Attributes
;
1200 NextVariable
->State
= VAR_ADDED
;
1201 NextVariable
->Reserved
= 0;
1202 VarNameOffset
= sizeof (VARIABLE_HEADER
);
1203 VarNameSize
= StrSize (VariableName
);
1205 (UINT8
*) ((UINTN
) NextVariable
+ VarNameOffset
),
1209 VarDataOffset
= VarNameOffset
+ VarNameSize
+ GET_PAD_SIZE (VarNameSize
);
1211 (UINT8
*) ((UINTN
) NextVariable
+ VarDataOffset
),
1215 CopyMem (&NextVariable
->VendorGuid
, VendorGuid
, sizeof (EFI_GUID
));
1217 // There will be pad bytes after Data, the NextVariable->NameSize and
1218 // NextVariable->DataSize should not include pad size so that variable
1219 // service can get actual size in GetVariable
1221 NextVariable
->NameSize
= (UINT32
)VarNameSize
;
1222 NextVariable
->DataSize
= (UINT32
)DataSize
;
1225 // The actual size of the variable that stores in storage should
1226 // include pad size.
1227 // VarDataOffset: offset from begin of current variable header
1229 VarSize
= VarDataOffset
+ DataSize
+ GET_PAD_SIZE (DataSize
);
1231 StorageType
= (Attributes
& EFI_VARIABLE_NON_VOLATILE
) ? NonVolatile
: Volatile
;
1233 if ((UINT32
) (VarSize
+ mGlobal
->LastVariableOffset
[StorageType
]) >
1234 ((VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[StorageType
])->Size
1236 if ((StorageType
== NonVolatile
) && EfiAtRuntime ()) {
1237 return EFI_OUT_OF_RESOURCES
;
1240 // Perform garbage collection & reclaim operation
1242 Status
= Reclaim (StorageType
, Variable
->CurrPtr
);
1243 if (EFI_ERROR (Status
)) {
1246 // we cannot restore to original state, fetal error, report to user
1248 DEBUG ((EFI_D_ERROR
, "FSVariable: Recalim error (fetal error) - %r\n", Status
));
1252 // If still no enough space, return out of resources
1254 if ((UINT32
) (VarSize
+ mGlobal
->LastVariableOffset
[StorageType
]) >
1255 ((VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[StorageType
])->Size
1257 return EFI_OUT_OF_RESOURCES
;
1262 Status
= mGlobal
->VariableStore
[StorageType
]->Write (
1263 mGlobal
->VariableStore
[StorageType
],
1264 mGlobal
->LastVariableOffset
[StorageType
],
1269 // NOTE: Write operation at least can write data to memory cache
1270 // Discard file writing failure here.
1272 mGlobal
->LastVariableOffset
[StorageType
] += VarSize
;
1274 if ((Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) != 0) {
1275 mGlobal
->HwErrVariableTotalSize
+= VarSize
;
1277 mGlobal
->CommonVariableTotalSize
+= VarSize
;
1281 // Mark the old variable as deleted
1283 if (!Reclaimed
&& !EFI_ERROR (Status
) && Variable
->CurrPtr
!= NULL
) {
1284 State
= Variable
->CurrPtr
->State
;
1285 State
&= VAR_DELETED
;
1287 Status
= mGlobal
->VariableStore
[StorageType
]->Write (
1288 mGlobal
->VariableStore
[StorageType
],
1289 VARIABLE_MEMBER_OFFSET (State
, (UINTN
) Variable
->CurrPtr
- (UINTN
) Variable
->StartPtr
),
1290 sizeof (Variable
->CurrPtr
->State
),
1294 // NOTE: Write operation at least can write data to memory cache
1295 // Discard file writing failure here.
1304 IN CHAR16
*VariableName
,
1305 IN EFI_GUID
*VendorGuid
,
1306 OUT UINT32
*Attributes OPTIONAL
,
1307 IN OUT UINTN
*DataSize
,
1308 OUT VOID
*Data OPTIONAL
1312 Routine Description:
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
1321 DataSize Size of Data found. If size is less than the
1322 data, this value contains the required size.
1323 Data The buffer to return the contents of the variable. May be NULL
1324 with a zero DataSize in order to determine the size buffer needed.
1332 VARIABLE_POINTER_TRACK Variable
;
1336 if (VariableName
== NULL
|| VendorGuid
== NULL
|| DataSize
== NULL
) {
1337 return EFI_INVALID_PARAMETER
;
1341 // Find existing variable
1343 Status
= FindVariable (VariableName
, VendorGuid
, &Variable
);
1345 if (Variable
.CurrPtr
== NULL
|| EFI_ERROR (Status
)) {
1351 VarDataSize
= Variable
.CurrPtr
->DataSize
;
1352 if (*DataSize
>= VarDataSize
) {
1354 return EFI_INVALID_PARAMETER
;
1356 CopyMem (Data
, GetVariableDataPtr (Variable
.CurrPtr
), VarDataSize
);
1358 if (Attributes
!= NULL
) {
1359 *Attributes
= Variable
.CurrPtr
->Attributes
;
1362 *DataSize
= VarDataSize
;
1366 *DataSize
= VarDataSize
;
1367 return EFI_BUFFER_TOO_SMALL
;
1373 GetNextVariableName (
1374 IN OUT UINTN
*VariableNameSize
,
1375 IN OUT CHAR16
*VariableName
,
1376 IN OUT EFI_GUID
*VendorGuid
1380 Routine Description:
1382 This code Finds the Next available variable
1386 VariableNameSize Size of the variable
1387 VariableName Pointer to variable name
1388 VendorGuid Variable Vendor Guid
1396 VARIABLE_POINTER_TRACK Variable
;
1400 if (VariableNameSize
== NULL
|| VariableName
== NULL
|| VendorGuid
== NULL
) {
1401 return EFI_INVALID_PARAMETER
;
1404 Status
= FindVariable (VariableName
, VendorGuid
, &Variable
);
1406 if (Variable
.CurrPtr
== NULL
|| EFI_ERROR (Status
)) {
1410 if (VariableName
[0] != 0) {
1412 // If variable name is not NULL, get next variable
1414 Variable
.CurrPtr
= GetNextVariablePtr (Variable
.CurrPtr
);
1419 // The order we find variable is: 1). NonVolatile; 2). Volatile
1420 // If both volatile and non-volatile variable store are parsed,
1423 if (Variable
.CurrPtr
>= Variable
.EndPtr
|| Variable
.CurrPtr
== NULL
) {
1424 if (Variable
.Type
== Volatile
) {
1426 // Since we met the end of Volatile storage, we have parsed all the stores.
1428 return EFI_NOT_FOUND
;
1432 // End of NonVolatile, continue to parse Volatile
1434 Variable
.Type
= Volatile
;
1435 Variable
.StartPtr
= (VARIABLE_HEADER
*) ((VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[Volatile
] + 1);
1436 Variable
.EndPtr
= (VARIABLE_HEADER
*) GetEndPointer ((VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[Volatile
]);
1438 Variable
.CurrPtr
= Variable
.StartPtr
;
1439 if (!IsValidVariableHeader (Variable
.CurrPtr
)) {
1444 // Variable is found
1446 if (IsValidVariableHeader (Variable
.CurrPtr
) &&
1447 ((Variable
.CurrPtr
->State
== VAR_ADDED
) ||
1448 (Variable
.CurrPtr
->State
== (VAR_ADDED
& VAR_IN_DELETED_TRANSITION
)))) {
1449 if (!EfiAtRuntime () || (Variable
.CurrPtr
->Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)) {
1450 VarNameSize
= Variable
.CurrPtr
->NameSize
;
1451 if (VarNameSize
<= *VariableNameSize
) {
1454 GET_VARIABLE_NAME_PTR (Variable
.CurrPtr
),
1459 &Variable
.CurrPtr
->VendorGuid
,
1462 Status
= EFI_SUCCESS
;
1464 Status
= EFI_BUFFER_TOO_SMALL
;
1467 *VariableNameSize
= VarNameSize
;
1472 Variable
.CurrPtr
= GetNextVariablePtr (Variable
.CurrPtr
);
1479 IN CHAR16
*VariableName
,
1480 IN EFI_GUID
*VendorGuid
,
1481 IN UINT32 Attributes
,
1487 Routine Description:
1489 This code sets variable in storage blocks (Volatile or Non-Volatile)
1493 VariableName Name of Variable to be found
1494 VendorGuid Variable vendor GUID
1495 Attributes Attribute value of the variable found
1496 DataSize Size of Data found. If size is less than the
1497 data, this value contains the required size.
1502 EFI_INVALID_PARAMETER - Invalid parameter
1503 EFI_SUCCESS - Set successfully
1504 EFI_OUT_OF_RESOURCES - Resource not enough to set variable
1505 EFI_NOT_FOUND - Not found
1506 EFI_DEVICE_ERROR - Variable can not be saved due to hardware failure
1507 EFI_WRITE_PROTECTED - Variable is read-only
1511 VARIABLE_POINTER_TRACK Variable
;
1515 // Check input parameters
1517 if (VariableName
== NULL
|| VariableName
[0] == 0 || VendorGuid
== NULL
) {
1518 return EFI_INVALID_PARAMETER
;
1521 if (DataSize
!= 0 && Data
== NULL
) {
1522 return EFI_INVALID_PARAMETER
;
1526 // Not support authenticated variable write yet.
1528 if ((Attributes
& EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS
) != 0) {
1529 return EFI_INVALID_PARAMETER
;
1533 // Make sure if runtime bit is set, boot service bit is set also
1535 if ((Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == EFI_VARIABLE_RUNTIME_ACCESS
) {
1536 return EFI_INVALID_PARAMETER
;
1540 // The size of the VariableName, including the Unicode Null in bytes plus
1541 // the DataSize is limited to maximum size of PcdGet32 (PcdMaxHardwareErrorVariableSize)
1542 // bytes for HwErrRec, and PcdGet32 (PcdMaxVariableSize) bytes for the others.
1544 if ((Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
) {
1545 if ((DataSize
> PcdGet32(PcdMaxHardwareErrorVariableSize
)) ||
1546 (sizeof (VARIABLE_HEADER
) + StrSize (VariableName
) + DataSize
> PcdGet32(PcdMaxHardwareErrorVariableSize
))) {
1547 return EFI_INVALID_PARAMETER
;
1550 // According to UEFI spec, HARDWARE_ERROR_RECORD variable name convention should be L"HwErrRecXXXX"
1552 if (StrnCmp(VariableName
, L
"HwErrRec", StrLen(L
"HwErrRec")) != 0) {
1553 return EFI_INVALID_PARAMETER
;
1556 if ((DataSize
> PcdGet32(PcdMaxVariableSize
)) ||
1557 (sizeof (VARIABLE_HEADER
) + StrSize (VariableName
) + DataSize
> PcdGet32(PcdMaxVariableSize
))) {
1558 return EFI_INVALID_PARAMETER
;
1563 // Check whether the input variable is already existed
1565 Status
= FindVariable (VariableName
, VendorGuid
, &Variable
);
1568 // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang
1570 AutoUpdateLangVariable (VariableName
, Data
, DataSize
);
1572 Status
= UpdateVariable (VariableName
, VendorGuid
, Data
, DataSize
, Attributes
, &Variable
);
1580 IN UINT32 Attributes
,
1581 OUT UINT64
*MaximumVariableStorageSize
,
1582 OUT UINT64
*RemainingVariableStorageSize
,
1583 OUT UINT64
*MaximumVariableSize
1587 Routine Description:
1589 This code returns information about the EFI variables.
1593 Attributes Attributes bitmask to specify the type of variables
1594 on which to return information.
1595 MaximumVariableStorageSize Pointer to the maximum size of the storage space available
1596 for the EFI variables associated with the attributes specified.
1597 RemainingVariableStorageSize Pointer to the remaining size of the storage space available
1598 for the EFI variables associated with the attributes specified.
1599 MaximumVariableSize Pointer to the maximum size of the individual EFI variables
1600 associated with the attributes specified.
1605 EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
1606 EFI_SUCCESS - Query successfully.
1607 EFI_UNSUPPORTED - The attribute is not supported on this platform.
1611 VARIABLE_HEADER
*Variable
;
1612 VARIABLE_HEADER
*NextVariable
;
1613 UINT64 VariableSize
;
1614 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
1615 UINT64 CommonVariableTotalSize
;
1616 UINT64 HwErrVariableTotalSize
;
1618 CommonVariableTotalSize
= 0;
1619 HwErrVariableTotalSize
= 0;
1621 if(MaximumVariableStorageSize
== NULL
|| RemainingVariableStorageSize
== NULL
|| MaximumVariableSize
== NULL
|| Attributes
== 0) {
1622 return EFI_INVALID_PARAMETER
;
1625 if((Attributes
& (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) == 0) {
1627 // Make sure the Attributes combination is supported by the platform.
1629 return EFI_UNSUPPORTED
;
1630 } else if ((Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == EFI_VARIABLE_RUNTIME_ACCESS
) {
1632 // Make sure if runtime bit is set, boot service bit is set also.
1634 return EFI_INVALID_PARAMETER
;
1635 } else if (EfiAtRuntime () && !(Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)) {
1637 // Make sure RT Attribute is set if we are in Runtime phase.
1639 return EFI_INVALID_PARAMETER
;
1640 } else if ((Attributes
& (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
) {
1642 // Make sure Hw Attribute is set with NV.
1644 return EFI_INVALID_PARAMETER
;
1645 } else if ((Attributes
& EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS
) != 0) {
1647 // Not support authentiated variable write yet.
1649 return EFI_UNSUPPORTED
;
1652 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) mGlobal
->VariableBase
[
1653 (Attributes
& EFI_VARIABLE_NON_VOLATILE
) ? NonVolatile
: Volatile
1656 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1657 // with the storage size (excluding the storage header size).
1659 *MaximumVariableStorageSize
= VariableStoreHeader
->Size
- sizeof (VARIABLE_STORE_HEADER
);
1662 // Harware error record variable needs larger size.
1664 if ((Attributes
& (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) == (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) {
1665 *MaximumVariableStorageSize
= PcdGet32(PcdHwErrStorageSize
);
1666 *MaximumVariableSize
= PcdGet32(PcdMaxHardwareErrorVariableSize
) - sizeof (VARIABLE_HEADER
);
1668 if ((Attributes
& EFI_VARIABLE_NON_VOLATILE
) != 0) {
1669 ASSERT (PcdGet32(PcdHwErrStorageSize
) < VariableStoreHeader
->Size
);
1670 *MaximumVariableStorageSize
= VariableStoreHeader
->Size
- sizeof (VARIABLE_STORE_HEADER
) - PcdGet32(PcdHwErrStorageSize
);
1674 // Let *MaximumVariableSize be PcdGet32(PcdMaxVariableSize) with the exception of the variable header size.
1676 *MaximumVariableSize
= PcdGet32(PcdMaxVariableSize
) - sizeof (VARIABLE_HEADER
);
1680 // Point to the starting address of the variables.
1682 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
1685 // Now walk through the related variable store.
1687 while ((Variable
< GetEndPointer (VariableStoreHeader
)) && IsValidVariableHeader (Variable
)) {
1688 NextVariable
= GetNextVariablePtr (Variable
);
1689 VariableSize
= (UINT64
) (UINTN
) NextVariable
- (UINT64
) (UINTN
) Variable
;
1691 if (EfiAtRuntime ()) {
1693 // we don't take the state of the variables in mind
1694 // when calculating RemainingVariableStorageSize,
1695 // since the space occupied by variables not marked with
1696 // VAR_ADDED is not allowed to be reclaimed in Runtime.
1698 if ((Variable
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
) {
1699 HwErrVariableTotalSize
+= VariableSize
;
1701 CommonVariableTotalSize
+= VariableSize
;
1705 // Only care about Variables with State VAR_ADDED,because
1706 // the space not marked as VAR_ADDED is reclaimable now.
1708 if ((Variable
->State
== VAR_ADDED
) || (Variable
->State
== (VAR_ADDED
& VAR_IN_DELETED_TRANSITION
))) {
1709 if ((Variable
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
) {
1710 HwErrVariableTotalSize
+= VariableSize
;
1712 CommonVariableTotalSize
+= VariableSize
;
1718 // Go to the next one
1720 Variable
= NextVariable
;
1723 if ((Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
){
1724 *RemainingVariableStorageSize
= *MaximumVariableStorageSize
- HwErrVariableTotalSize
;
1726 *RemainingVariableStorageSize
= *MaximumVariableStorageSize
- CommonVariableTotalSize
;
1734 VariableServiceInitialize (
1735 IN EFI_HANDLE ImageHandle
,
1736 IN EFI_SYSTEM_TABLE
*SystemTable
1740 Routine Description:
1741 This function does initialization for variable services
1745 ImageHandle - The firmware allocated handle for the EFI image.
1746 SystemTable - A pointer to the EFI System Table.
1752 EFI_NOT_FOUND - Variable store area not found.
1753 EFI_SUCCESS - Variable services successfully initialized.
1758 EFI_HANDLE NewHandle
;
1760 EFI_PEI_HOB_POINTERS GuidHob
;
1761 VARIABLE_HEADER
*Variable
;
1762 VARIABLE_HEADER
*NextVariable
;
1763 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
1764 EFI_FLASH_MAP_FS_ENTRY_DATA
*FlashMapEntryData
;
1765 EFI_FLASH_SUBAREA_ENTRY VariableStoreEntry
;
1768 EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor
;
1770 Status
= gBS
->AllocatePool (
1771 EfiRuntimeServicesData
,
1772 (UINTN
) sizeof (VARIABLE_GLOBAL
),
1775 if (EFI_ERROR (Status
)) {
1779 ZeroMem (mGlobal
, (UINTN
) sizeof (VARIABLE_GLOBAL
));
1781 GuidHob
.Raw
= GetHobList ();
1782 FlashMapEntryData
= NULL
;
1783 while ((GuidHob
.Raw
= GetNextGuidHob (&gEfiFlashMapHobGuid
, GuidHob
.Raw
)) != NULL
) {
1784 FlashMapEntryData
= (EFI_FLASH_MAP_FS_ENTRY_DATA
*) GET_GUID_HOB_DATA (GuidHob
.Guid
);
1785 if (FlashMapEntryData
->AreaType
== EFI_FLASH_AREA_EFI_VARIABLES
) {
1788 GuidHob
.Raw
= GET_NEXT_HOB (GuidHob
);
1791 if (FlashMapEntryData
== NULL
) {
1792 DEBUG ((EFI_D_ERROR
, "FSVariable: Could not find flash area for variable!\n"));
1793 Status
= EFI_NOT_FOUND
;
1798 (VOID
*)&VariableStoreEntry
,
1799 (VOID
*)&FlashMapEntryData
->Entries
[0],
1800 sizeof(EFI_FLASH_SUBAREA_ENTRY
)
1804 // Mark the variable storage region of the FLASH as RUNTIME
1806 BaseAddress
= VariableStoreEntry
.Base
& (~EFI_PAGE_MASK
);
1807 Length
= VariableStoreEntry
.Length
+ (VariableStoreEntry
.Base
- BaseAddress
);
1808 Length
= (Length
+ EFI_PAGE_SIZE
- 1) & (~EFI_PAGE_MASK
);
1809 Status
= gDS
->GetMemorySpaceDescriptor (BaseAddress
, &GcdDescriptor
);
1810 if (EFI_ERROR (Status
)) {
1811 Status
= EFI_UNSUPPORTED
;
1814 Status
= gDS
->SetMemorySpaceAttributes (
1817 GcdDescriptor
.Attributes
| EFI_MEMORY_RUNTIME
1819 if (EFI_ERROR (Status
)) {
1820 Status
= EFI_UNSUPPORTED
;
1824 Status
= FileStorageConstructor (
1825 &mGlobal
->VariableStore
[NonVolatile
],
1826 &mGlobal
->GoVirtualChildEvent
[NonVolatile
],
1827 VariableStoreEntry
.Base
,
1828 (UINT32
) VariableStoreEntry
.Length
,
1829 FlashMapEntryData
->VolumeId
,
1830 FlashMapEntryData
->FilePath
1832 ASSERT_EFI_ERROR (Status
);
1837 Status
= MemStorageConstructor (
1838 &mGlobal
->VariableStore
[Volatile
],
1839 &mGlobal
->GoVirtualChildEvent
[Volatile
],
1840 VOLATILE_VARIABLE_STORE_SIZE
1842 ASSERT_EFI_ERROR (Status
);
1847 Status
= gBS
->AllocatePool (
1848 EfiRuntimeServicesData
,
1849 VARIABLE_SCRATCH_SIZE
,
1852 ASSERT_EFI_ERROR (Status
);
1857 Dev
= DEV_FROM_THIS (mGlobal
->VariableStore
[NonVolatile
]);
1858 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) VAR_DATA_PTR (Dev
);
1859 if (GetVariableStoreStatus (VariableStoreHeader
) == EfiValid
) {
1860 if (~VariableStoreHeader
->Size
== 0) {
1861 VariableStoreHeader
->Size
= (UINT32
) VariableStoreEntry
.Length
;
1865 // Calculate LastVariableOffset
1867 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
1868 while (IsValidVariableHeader (Variable
)) {
1869 UINTN VariableSize
= 0;
1870 NextVariable
= GetNextVariablePtr (Variable
);
1871 VariableSize
= NextVariable
- Variable
;
1872 if ((NextVariable
->Attributes
& (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) == (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) {
1873 mGlobal
->HwErrVariableTotalSize
+= HEADER_ALIGN (VariableSize
);
1875 mGlobal
->CommonVariableTotalSize
+= HEADER_ALIGN (VariableSize
);
1877 Variable
= NextVariable
;
1880 mGlobal
->LastVariableOffset
[NonVolatile
] = (UINTN
) Variable
- (UINTN
) VariableStoreHeader
;
1881 mGlobal
->VariableBase
[NonVolatile
] = VariableStoreHeader
;
1884 // Reclaim if remaining space is too small
1886 if ((VariableStoreHeader
->Size
- mGlobal
->LastVariableOffset
[NonVolatile
]) < VARIABLE_RECLAIM_THRESHOLD
) {
1887 Status
= Reclaim (NonVolatile
, NULL
);
1888 if (EFI_ERROR (Status
)) {
1891 // we cannot restore to original state
1893 DEBUG ((EFI_D_ERROR
, "FSVariable: Reclaim error (fatal error) - %r\n", Status
));
1894 ASSERT_EFI_ERROR (Status
);
1899 // 2. Volatile Storage
1901 Dev
= DEV_FROM_THIS (mGlobal
->VariableStore
[Volatile
]);
1902 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) VAR_DATA_PTR (Dev
);
1903 mGlobal
->VariableBase
[Volatile
] = VAR_DATA_PTR (Dev
);
1904 mGlobal
->LastVariableOffset
[Volatile
] = sizeof (VARIABLE_STORE_HEADER
);
1906 // init store_header & body in memory.
1908 mGlobal
->VariableStore
[Volatile
]->Erase (mGlobal
->VariableStore
[Volatile
]);
1909 mGlobal
->VariableStore
[Volatile
]->Write (
1910 mGlobal
->VariableStore
[Volatile
],
1912 sizeof (VARIABLE_STORE_HEADER
),
1913 &mStoreHeaderTemplate
1917 SystemTable
->RuntimeServices
->GetVariable
= DuetGetVariable
;
1918 SystemTable
->RuntimeServices
->GetNextVariableName
= GetNextVariableName
;
1919 SystemTable
->RuntimeServices
->SetVariable
= SetVariable
;
1921 SystemTable
->RuntimeServices
->QueryVariableInfo
= QueryVariableInfo
;
1924 // Now install the Variable Runtime Architectural Protocol on a new handle
1927 Status
= gBS
->InstallMultipleProtocolInterfaces (
1929 &gEfiVariableArchProtocolGuid
,
1931 &gEfiVariableWriteArchProtocolGuid
,
1935 ASSERT_EFI_ERROR (Status
);
1944 OnVirtualAddressChangeFsv (
1951 for (Index
= 0; Index
< MaxType
; Index
++) {
1952 mGlobal
->GoVirtualChildEvent
[Index
] (Event
, mGlobal
->VariableStore
[Index
]);
1953 EfiConvertPointer (0, (VOID
**) &mGlobal
->VariableStore
[Index
]);
1954 EfiConvertPointer (0, &mGlobal
->VariableBase
[Index
]);
1956 EfiConvertPointer (0, (VOID
**) &mGlobal
->PlatformLangCodes
);
1957 EfiConvertPointer (0, (VOID
**) &mGlobal
->LangCodes
);
1958 EfiConvertPointer (0, (VOID
**) &mGlobal
->PlatformLang
);
1959 EfiConvertPointer (0, &mGlobal
->Scratch
);
1960 EfiConvertPointer (0, (VOID
**) &mGlobal
);