2 EFI Runtime Variable services.
4 Copyright (c) 2006 - 2007, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 VARIABLE_MODULE_GLOBAL mRuntimeData
;
20 VARIABLE_MODULE_GLOBAL
*mVariableModuleGlobal
= &mRuntimeData
;
21 EFI_EVENT mVirtualAddressChangeEvent
= NULL
;
22 EFI_HANDLE mHandle
= NULL
;
26 // This is a temperary function which will be removed
27 // when EfiAcquireLock in UefiLib can handle the
28 // the call in UEFI Runtimer driver in RT phase.
31 AcquireLockOnlyAtBootTime (
35 if (!EfiAtRuntime ()) {
36 EfiAcquireLock (Lock
);
41 // This is a temperary function which will be removed
42 // when EfiAcquireLock in UefiLib can handle the
43 // the call in UEFI Runtimer driver in RT phase.
46 ReleaseLockOnlyAtBootTime (
50 if (!EfiAtRuntime ()) {
51 EfiReleaseLock (Lock
);
56 GLOBAL_REMOVE_IF_UNREFERENCED VARIABLE_INFO_ENTRY
*gVariableInfo
= NULL
;
60 Routine used to track statistical information about variable usage.
61 The data is stored in the EFI system table so it can be accessed later.
62 VariableInfo.efi can dump out the table. Only Boot Services variable
63 accesses are tracked by this code. The PcdVariableCollectStatistics
64 build flag controls if this feature is enabled.
66 A read that hits in the cache will have Read and Cache true for
67 the transaction. Data is allocated by this routine, but never
70 @param[in] VariableName Name of the Variable to track
71 @param[in] VendorGuid Guid of the Variable to track
72 @param[in] Volatile TRUE if volatile FALSE if non-volatile
73 @param[in] Read TRUE if GetVariable() was called
74 @param[in] Write TRUE if SetVariable() was called
75 @param[in] Delete TRUE if deleted via SetVariable()
76 @param[in] Cache TRUE for a cache hit.
81 IN CHAR16
*VariableName
,
82 IN EFI_GUID
*VendorGuid
,
90 VARIABLE_INFO_ENTRY
*Entry
;
92 if (FeaturePcdGet (PcdVariableCollectStatistics
)) {
94 if (EfiAtRuntime ()) {
95 // Don't collect statistics at runtime
99 if (gVariableInfo
== NULL
) {
101 // on the first call allocate a entry and place a pointer to it in
102 // the EFI System Table
104 gVariableInfo
= AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY
));
105 ASSERT (gVariableInfo
!= NULL
);
107 CopyGuid (&gVariableInfo
->VendorGuid
, VendorGuid
);
108 gVariableInfo
->Name
= AllocatePool (StrLen (VariableName
));
109 StrCpy (gVariableInfo
->Name
, VariableName
);
110 gVariableInfo
->Volatile
= Volatile
;
112 gBS
->InstallConfigurationTable (&gEfiVariableInfoGuid
, gVariableInfo
);
116 for (Entry
= gVariableInfo
; Entry
!= NULL
; Entry
= Entry
->Next
) {
117 if (CompareGuid (VendorGuid
, &Entry
->VendorGuid
)) {
118 if (StrCmp (VariableName
, Entry
->Name
) == 0) {
126 Entry
->DeleteCount
++;
136 if (Entry
->Next
== NULL
) {
138 // If the entry is not in the table add it.
139 // Next iteration of the loop will fill in the data
141 Entry
->Next
= AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY
));
142 ASSERT (Entry
->Next
!= NULL
);
144 CopyGuid (&Entry
->Next
->VendorGuid
, VendorGuid
);
145 Entry
->Next
->Name
= AllocatePool (StrLen (VariableName
));
146 StrCpy (Entry
->Next
->Name
, VariableName
);
147 Entry
->Next
->Volatile
= Volatile
;
157 IsValidVariableHeader (
158 IN VARIABLE_HEADER
*Variable
164 This code checks if variable header is valid or not.
167 Variable Pointer to the Variable Header.
170 TRUE Variable header is valid.
171 FALSE Variable header is not valid.
175 if (Variable
== NULL
||
176 Variable
->StartId
!= VARIABLE_DATA
||
177 (sizeof (VARIABLE_HEADER
) + Variable
->NameSize
+ Variable
->DataSize
) > MAX_VARIABLE_SIZE
187 UpdateVariableStore (
188 IN VARIABLE_GLOBAL
*Global
,
190 IN BOOLEAN SetByIndex
,
192 IN UINTN DataPtrIndex
,
200 This function writes data to the FWH at the correct LBA even if the LBAs
205 Global - Pointer to VARAIBLE_GLOBAL structure
206 Volatile - If the Variable is Volatile or Non-Volatile
207 SetByIndex - TRUE: Target pointer is given as index
208 FALSE: Target pointer is absolute
209 Instance - Instance of FV Block services
210 DataPtrIndex - Pointer to the Data from the end of VARIABLE_STORE_HEADER
212 DataSize - Size of data to be written.
213 Buffer - Pointer to the buffer from which data is written
217 EFI_INVALID_PARAMETER - Parameters not valid
218 EFI_SUCCESS - Variable store successfully updated
222 EFI_FV_BLOCK_MAP_ENTRY
*PtrBlockMapEntry
;
230 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
231 VARIABLE_STORE_HEADER
*VolatileBase
;
232 EFI_PHYSICAL_ADDRESS FvVolHdr
;
233 EFI_PHYSICAL_ADDRESS DataPtr
;
237 DataPtr
= DataPtrIndex
;
240 // Check if the Data is Volatile
243 EfiFvbGetPhysicalAddress (Instance
, &FvVolHdr
);
244 FwVolHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) ((UINTN
) FvVolHdr
);
246 // Data Pointer should point to the actual Address where data is to be
250 DataPtr
+= mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
;
253 if ((DataPtr
+ DataSize
) >= ((EFI_PHYSICAL_ADDRESS
) (UINTN
) ((UINT8
*) FwVolHeader
+ FwVolHeader
->FvLength
))) {
254 return EFI_INVALID_PARAMETER
;
258 // Data Pointer should point to the actual Address where data is to be
261 VolatileBase
= (VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
);
263 DataPtr
+= mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
;
266 if ((DataPtr
+ DataSize
) >= ((UINTN
) ((UINT8
*) VolatileBase
+ VolatileBase
->Size
))) {
267 return EFI_INVALID_PARAMETER
;
271 // If Volatile Variable just do a simple mem copy.
273 CopyMem ((UINT8
*)(UINTN
)DataPtr
, Buffer
, DataSize
);
278 // If we are here we are dealing with Non-Volatile Variables
280 LinearOffset
= (UINTN
) FwVolHeader
;
281 CurrWritePtr
= (UINTN
) DataPtr
;
282 CurrWriteSize
= DataSize
;
286 if (CurrWritePtr
< LinearOffset
) {
287 return EFI_INVALID_PARAMETER
;
290 for (PtrBlockMapEntry
= FwVolHeader
->BlockMap
; PtrBlockMapEntry
->NumBlocks
!= 0; PtrBlockMapEntry
++) {
291 for (BlockIndex2
= 0; BlockIndex2
< PtrBlockMapEntry
->NumBlocks
; BlockIndex2
++) {
293 // Check to see if the Variable Writes are spanning through multiple
296 if ((CurrWritePtr
>= LinearOffset
) && (CurrWritePtr
< LinearOffset
+ PtrBlockMapEntry
->Length
)) {
297 if ((CurrWritePtr
+ CurrWriteSize
) <= (LinearOffset
+ PtrBlockMapEntry
->Length
)) {
298 Status
= EfiFvbWriteBlock (
301 (UINTN
) (CurrWritePtr
- LinearOffset
),
307 Size
= (UINT32
) (LinearOffset
+ PtrBlockMapEntry
->Length
- CurrWritePtr
);
308 Status
= EfiFvbWriteBlock (
311 (UINTN
) (CurrWritePtr
- LinearOffset
),
315 if (EFI_ERROR (Status
)) {
319 CurrWritePtr
= LinearOffset
+ PtrBlockMapEntry
->Length
;
320 CurrBuffer
= CurrBuffer
+ Size
;
321 CurrWriteSize
= CurrWriteSize
- Size
;
325 LinearOffset
+= PtrBlockMapEntry
->Length
;
334 VARIABLE_STORE_STATUS
335 GetVariableStoreStatus (
336 IN VARIABLE_STORE_HEADER
*VarStoreHeader
342 This code gets the current status of Variable Store.
346 VarStoreHeader Pointer to the Variable Store Header.
350 EfiRaw Variable store status is raw
351 EfiValid Variable store status is valid
352 EfiInvalid Variable store status is invalid
356 if (VarStoreHeader
->Signature
== VARIABLE_STORE_SIGNATURE
&&
357 VarStoreHeader
->Format
== VARIABLE_STORE_FORMATTED
&&
358 VarStoreHeader
->State
== VARIABLE_STORE_HEALTHY
362 } else if (VarStoreHeader
->Signature
== 0xffffffff &&
363 VarStoreHeader
->Size
== 0xffffffff &&
364 VarStoreHeader
->Format
== 0xff &&
365 VarStoreHeader
->State
== 0xff
377 IN VARIABLE_HEADER
*Variable
383 This code gets the pointer to the variable data.
387 Variable Pointer to the Variable Header.
391 UINT8* Pointer to Variable Data
396 // Be careful about pad size for alignment
398 return (UINT8
*) ((UINTN
) GET_VARIABLE_NAME_PTR (Variable
) + Variable
->NameSize
+ GET_PAD_SIZE (Variable
->NameSize
));
404 IN VARIABLE_HEADER
*Variable
410 This code gets the pointer to the next variable header.
414 Variable Pointer to the Variable Header.
418 VARIABLE_HEADER* Pointer to next variable header.
422 if (!IsValidVariableHeader (Variable
)) {
426 // Be careful about pad size for alignment
428 return (VARIABLE_HEADER
*) ((UINTN
) GetVariableDataPtr (Variable
) + Variable
->DataSize
+ GET_PAD_SIZE (Variable
->DataSize
));
434 IN VARIABLE_STORE_HEADER
*VarStoreHeader
440 This code gets the pointer to the last variable memory pointer byte
444 VarStoreHeader Pointer to the Variable Store Header.
448 VARIABLE_HEADER* Pointer to last unavailable Variable Header
453 // The end of variable store
455 return (VARIABLE_HEADER
*) ((UINTN
) VarStoreHeader
+ VarStoreHeader
->Size
);
461 IN EFI_PHYSICAL_ADDRESS VariableBase
,
462 OUT UINTN
*LastVariableOffset
,
463 IN BOOLEAN IsVolatile
469 Variable store garbage collection and reclaim operation
473 VariableBase Base address of variable store
474 LastVariableOffset Offset of last variable
475 IsVolatile The variable store is volatile or not,
476 if it is non-volatile, need FTW
484 VARIABLE_HEADER
*Variable
;
485 VARIABLE_HEADER
*NextVariable
;
486 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
488 UINTN ValidBufferSize
;
493 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) ((UINTN
) VariableBase
);
496 // Start Pointers for the variable.
498 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
500 ValidBufferSize
= sizeof (VARIABLE_STORE_HEADER
);
502 while (IsValidVariableHeader (Variable
)) {
503 NextVariable
= GetNextVariablePtr (Variable
);
504 if (Variable
->State
== VAR_ADDED
) {
505 VariableSize
= (UINTN
) NextVariable
- (UINTN
) Variable
;
506 ValidBufferSize
+= VariableSize
;
509 Variable
= NextVariable
;
512 ValidBuffer
= AllocatePool (ValidBufferSize
);
513 if (ValidBuffer
== NULL
) {
514 return EFI_OUT_OF_RESOURCES
;
517 SetMem (ValidBuffer
, ValidBufferSize
, 0xff);
519 CurrPtr
= ValidBuffer
;
522 // Copy variable store header
524 CopyMem (CurrPtr
, VariableStoreHeader
, sizeof (VARIABLE_STORE_HEADER
));
525 CurrPtr
+= sizeof (VARIABLE_STORE_HEADER
);
528 // Start Pointers for the variable.
530 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
532 while (IsValidVariableHeader (Variable
)) {
533 NextVariable
= GetNextVariablePtr (Variable
);
534 if (Variable
->State
== VAR_ADDED
) {
535 VariableSize
= (UINTN
) NextVariable
- (UINTN
) Variable
;
536 CopyMem (CurrPtr
, (UINT8
*) Variable
, VariableSize
);
537 CurrPtr
+= VariableSize
;
540 Variable
= NextVariable
;
545 // If volatile variable store, just copy valid buffer
547 SetMem ((UINT8
*) (UINTN
) VariableBase
, VariableStoreHeader
->Size
, 0xff);
548 CopyMem ((UINT8
*) (UINTN
) VariableBase
, ValidBuffer
, ValidBufferSize
);
549 *LastVariableOffset
= ValidBufferSize
;
550 Status
= EFI_SUCCESS
;
553 // If non-volatile variable store, perform FTW here.
555 Status
= FtwVariableSpace (
560 if (!EFI_ERROR (Status
)) {
561 *LastVariableOffset
= ValidBufferSize
;
565 FreePool (ValidBuffer
);
567 if (EFI_ERROR (Status
)) {
568 *LastVariableOffset
= 0;
576 // The current Hii implementation accesses this variable a larg # of times on every boot.
577 // Other common variables are only accessed a single time. This is why this cache algorithm
578 // only targets a single variable. Probably to get an performance improvement out of
579 // a Cache you would need a cache that improves the search performance for a variable.
581 VARIABLE_CACHE_ENTRY mVariableCache
[] = {
583 &gEfiGlobalVariableGuid
,
593 Update the Cache with Variable information. These are the same
594 arguments as the EFI Variable services.
596 @param[in] VariableName Name of variable
597 @param[in] VendorGuid Guid of variable
598 @param[in] Attribute Attribue of the variable
599 @param[in] DataSize Size of data. 0 means delete
600 @param[in] Data Variable data
604 UpdateVariableCache (
605 IN CHAR16
*VariableName
,
606 IN EFI_GUID
*VendorGuid
,
607 IN UINT32 Attributes
,
612 VARIABLE_CACHE_ENTRY
*Entry
;
615 if (EfiAtRuntime ()) {
616 // Don't use the cache at runtime
620 for (Index
= 0, Entry
= mVariableCache
; Index
< sizeof (mVariableCache
)/sizeof (VARIABLE_CACHE_ENTRY
); Index
++, Entry
++) {
621 if (CompareGuid (VendorGuid
, Entry
->Guid
)) {
622 if (StrCmp (VariableName
, Entry
->Name
) == 0) {
623 Entry
->Attributes
= Attributes
;
626 if (Entry
->DataSize
!= 0) {
627 FreePool (Entry
->Data
);
629 Entry
->DataSize
= DataSize
;
630 } else if (DataSize
== Entry
->DataSize
) {
631 CopyMem (Entry
->Data
, Data
, DataSize
);
633 Entry
->Data
= AllocatePool (DataSize
);
634 Entry
->DataSize
= DataSize
;
635 CopyMem (Entry
->Data
, Data
, DataSize
);
644 Search the cache to see if the variable is in the cache.
646 @param[in] VariableName Name of variable
647 @param[in] VendorGuid Guid of variable
648 @param[in] Attribute Attribue returned
649 @param[in] DataSize Size of data returned
650 @param[in] Data Variable data returned
652 @retval EFI_SUCCESS VariableGuid & VariableName data was returned.
653 @retval other Not found.
657 FindVariableInCache (
658 IN CHAR16
*VariableName
,
659 IN EFI_GUID
*VendorGuid
,
660 OUT UINT32
*Attributes OPTIONAL
,
661 IN OUT UINTN
*DataSize
,
665 VARIABLE_CACHE_ENTRY
*Entry
;
668 if (EfiAtRuntime ()) {
669 // Don't use the cache at runtime
670 return EFI_NOT_FOUND
;
673 for (Index
= 0, Entry
= mVariableCache
; Index
< sizeof (mVariableCache
)/sizeof (VARIABLE_CACHE_ENTRY
); Index
++, Entry
++) {
674 if (CompareGuid (VendorGuid
, Entry
->Guid
)) {
675 if (StrCmp (VariableName
, Entry
->Name
) == 0) {
676 if (Entry
->DataSize
== 0) {
677 // Variable was deleted so return not found
678 return EFI_NOT_FOUND
;
679 } else if (Entry
->DataSize
!= *DataSize
) {
680 // If the buffer is too small return correct size
681 *DataSize
= Entry
->DataSize
;
682 return EFI_BUFFER_TOO_SMALL
;
685 CopyMem (Data
, Entry
->Data
, Entry
->DataSize
);
686 if (Attributes
!= NULL
) {
687 *Attributes
= Entry
->Attributes
;
695 return EFI_NOT_FOUND
;
701 IN CHAR16
*VariableName
,
702 IN EFI_GUID
*VendorGuid
,
703 OUT VARIABLE_POINTER_TRACK
*PtrTrack
,
704 IN VARIABLE_GLOBAL
*Global
710 This code finds variable in storage blocks (Volatile or Non-Volatile)
714 VariableName Name of the variable to be found
715 VendorGuid Vendor GUID to be found.
716 PtrTrack Variable Track Pointer structure that contains
717 Variable Information.
718 Contains the pointer of Variable header.
719 Global VARIABLE_GLOBAL pointer
727 VARIABLE_HEADER
*Variable
[2];
728 VARIABLE_STORE_HEADER
*VariableStoreHeader
[2];
732 // We aquire the lock at the entry of FindVariable as GetVariable, GetNextVariableName
733 // SetVariable all call FindVariable at entry point. Please move "Aquire Lock" to
734 // the correct places if this assumption does not hold TRUE anymore.
736 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
);
739 // 0: Volatile, 1: Non-Volatile
741 VariableStoreHeader
[0] = (VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
);
742 VariableStoreHeader
[1] = (VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
);
745 // Start Pointers for the variable.
746 // Actual Data Pointer where data can be written.
748 Variable
[0] = (VARIABLE_HEADER
*) (VariableStoreHeader
[0] + 1);
749 Variable
[1] = (VARIABLE_HEADER
*) (VariableStoreHeader
[1] + 1);
751 if (VariableName
[0] != 0 && VendorGuid
== NULL
) {
752 return EFI_INVALID_PARAMETER
;
755 // Find the variable by walk through volatile and then non-volatile variable store
757 for (Index
= 0; Index
< 2; Index
++) {
758 PtrTrack
->StartPtr
= (VARIABLE_HEADER
*) (VariableStoreHeader
[Index
] + 1);
759 PtrTrack
->EndPtr
= GetEndPointer (VariableStoreHeader
[Index
]);
761 while (IsValidVariableHeader (Variable
[Index
]) && (Variable
[Index
] <= GetEndPointer (VariableStoreHeader
[Index
]))) {
762 if (Variable
[Index
]->State
== VAR_ADDED
) {
763 if (!EfiAtRuntime () || (Variable
[Index
]->Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)) {
764 if (VariableName
[0] == 0) {
765 PtrTrack
->CurrPtr
= Variable
[Index
];
766 PtrTrack
->Volatile
= (BOOLEAN
)(Index
== 0);
769 if (CompareGuid (VendorGuid
, &Variable
[Index
]->VendorGuid
)) {
770 if (!CompareMem (VariableName
, GET_VARIABLE_NAME_PTR (Variable
[Index
]), Variable
[Index
]->NameSize
)) {
771 PtrTrack
->CurrPtr
= Variable
[Index
];
772 PtrTrack
->Volatile
= (BOOLEAN
)(Index
== 0);
780 Variable
[Index
] = GetNextVariablePtr (Variable
[Index
]);
783 PtrTrack
->CurrPtr
= NULL
;
784 return EFI_NOT_FOUND
;
793 This code finds variable in storage blocks (Volatile or Non-Volatile)
797 VariableName Name of Variable to be found
798 VendorGuid Variable vendor GUID
799 Attributes OPTIONAL Attribute value of the variable found
800 DataSize Size of Data found. If size is less than the
801 data, this value contains the required size.
803 Global Pointer to VARIABLE_GLOBAL structure
804 Instance Instance of the Firmware Volume.
808 EFI_INVALID_PARAMETER - Invalid parameter
809 EFI_SUCCESS - Find the specified variable
810 EFI_NOT_FOUND - Not found
811 EFI_BUFFER_TO_SMALL - DataSize is too small for the result
817 RuntimeServiceGetVariable (
818 IN CHAR16
*VariableName
,
819 IN EFI_GUID
*VendorGuid
,
820 OUT UINT32
*Attributes OPTIONAL
,
821 IN OUT UINTN
*DataSize
,
826 VARIABLE_POINTER_TRACK Variable
;
829 if (VariableName
== NULL
|| VendorGuid
== NULL
|| DataSize
== NULL
) {
830 return EFI_INVALID_PARAMETER
;
834 // Find existing variable
836 Status
= FindVariableInCache (VariableName
, VendorGuid
, Attributes
, DataSize
, Data
);
837 if ((Status
== EFI_BUFFER_TOO_SMALL
) || (Status
== EFI_SUCCESS
)){
839 UpdateVariableInfo (VariableName
, VendorGuid
, FALSE
, TRUE
, FALSE
, FALSE
, TRUE
);
843 Status
= FindVariable (VariableName
, VendorGuid
, &Variable
, &mVariableModuleGlobal
->VariableGlobal
);
844 if (Variable
.CurrPtr
== NULL
|| EFI_ERROR (Status
)) {
851 VarDataSize
= Variable
.CurrPtr
->DataSize
;
852 if (*DataSize
>= VarDataSize
) {
854 Status
= EFI_INVALID_PARAMETER
;
858 CopyMem (Data
, GetVariableDataPtr (Variable
.CurrPtr
), VarDataSize
);
859 if (Attributes
!= NULL
) {
860 *Attributes
= Variable
.CurrPtr
->Attributes
;
863 *DataSize
= VarDataSize
;
864 UpdateVariableInfo (VariableName
, VendorGuid
, Variable
.Volatile
, TRUE
, FALSE
, FALSE
, FALSE
);
865 UpdateVariableCache (VariableName
, VendorGuid
, Variable
.CurrPtr
->Attributes
, VarDataSize
, Data
);
867 Status
= EFI_SUCCESS
;
870 *DataSize
= VarDataSize
;
871 Status
= EFI_BUFFER_TOO_SMALL
;
876 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
);
886 This code Finds the Next available variable
890 VariableNameSize Size of the variable
891 VariableName Pointer to variable name
892 VendorGuid Variable Vendor Guid
893 Global VARIABLE_GLOBAL structure pointer.
903 RuntimeServiceGetNextVariableName (
904 IN OUT UINTN
*VariableNameSize
,
905 IN OUT CHAR16
*VariableName
,
906 IN OUT EFI_GUID
*VendorGuid
909 VARIABLE_POINTER_TRACK Variable
;
913 if (VariableNameSize
== NULL
|| VariableName
== NULL
|| VendorGuid
== NULL
) {
914 return EFI_INVALID_PARAMETER
;
917 Status
= FindVariable (VariableName
, VendorGuid
, &Variable
, &mVariableModuleGlobal
->VariableGlobal
);
918 if (Variable
.CurrPtr
== NULL
|| EFI_ERROR (Status
)) {
922 if (VariableName
[0] != 0) {
924 // If variable name is not NULL, get next variable
926 Variable
.CurrPtr
= GetNextVariablePtr (Variable
.CurrPtr
);
931 // If both volatile and non-volatile variable store are parsed,
934 if (Variable
.CurrPtr
>= Variable
.EndPtr
|| Variable
.CurrPtr
== NULL
) {
935 Variable
.Volatile
= (BOOLEAN
) (Variable
.Volatile
^ ((BOOLEAN
) 0x1));
936 if (Variable
.Volatile
) {
937 Variable
.StartPtr
= (VARIABLE_HEADER
*) ((UINTN
) (mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
+ sizeof (VARIABLE_STORE_HEADER
)));
938 Variable
.EndPtr
= (VARIABLE_HEADER
*) GetEndPointer ((VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
));
940 Status
= EFI_NOT_FOUND
;
944 Variable
.CurrPtr
= Variable
.StartPtr
;
945 if (!IsValidVariableHeader (Variable
.CurrPtr
)) {
952 if (IsValidVariableHeader (Variable
.CurrPtr
) && Variable
.CurrPtr
->State
== VAR_ADDED
) {
953 if (!(EfiAtRuntime () && !(Variable
.CurrPtr
->Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
))) {
954 VarNameSize
= Variable
.CurrPtr
->NameSize
;
955 if (VarNameSize
<= *VariableNameSize
) {
958 GET_VARIABLE_NAME_PTR (Variable
.CurrPtr
),
963 &Variable
.CurrPtr
->VendorGuid
,
966 Status
= EFI_SUCCESS
;
968 Status
= EFI_BUFFER_TOO_SMALL
;
971 *VariableNameSize
= VarNameSize
;
976 Variable
.CurrPtr
= GetNextVariablePtr (Variable
.CurrPtr
);
980 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
);
989 This code sets variable in storage blocks (Volatile or Non-Volatile)
993 VariableName Name of Variable to be found
994 VendorGuid Variable vendor GUID
995 Attributes Attribute value of the variable found
996 DataSize Size of Data found. If size is less than the
997 data, this value contains the required size.
999 Global Pointer to VARIABLE_GLOBAL structure
1000 VolatileOffset The offset of last volatile variable
1001 NonVolatileOffset The offset of last non-volatile variable
1002 Instance Instance of the Firmware Volume.
1006 EFI_INVALID_PARAMETER - Invalid parameter
1007 EFI_SUCCESS - Set successfully
1008 EFI_OUT_OF_RESOURCES - Resource not enough to set variable
1009 EFI_NOT_FOUND - Not found
1010 EFI_DEVICE_ERROR - Variable can not be saved due to hardware failure
1011 EFI_WRITE_PROTECTED - Variable is read-only
1016 RuntimeServiceSetVariable (
1017 IN CHAR16
*VariableName
,
1018 IN EFI_GUID
*VendorGuid
,
1019 IN UINT32 Attributes
,
1024 VARIABLE_POINTER_TRACK Variable
;
1026 VARIABLE_HEADER
*NextVariable
;
1028 UINTN VarNameOffset
;
1029 UINTN VarDataOffset
;
1033 UINTN
*VolatileOffset
;
1034 UINTN
*NonVolatileOffset
;
1039 VolatileOffset
= &mVariableModuleGlobal
->VolatileLastVariableOffset
;
1040 NonVolatileOffset
= &mVariableModuleGlobal
->NonVolatileLastVariableOffset
;
1041 Instance
= mVariableModuleGlobal
->FvbInstance
;
1044 // Check input parameters
1046 if (VariableName
== NULL
|| VariableName
[0] == 0 || VendorGuid
== NULL
) {
1047 return EFI_INVALID_PARAMETER
;
1050 // Make sure if runtime bit is set, boot service bit is set also
1052 if ((Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == EFI_VARIABLE_RUNTIME_ACCESS
) {
1053 return EFI_INVALID_PARAMETER
;
1056 // The size of the VariableName, including the Unicode Null in bytes plus
1057 // the DataSize is limited to maximum size of MAX_HARDWARE_ERROR_VARIABLE_SIZE (32K)
1058 // bytes for HwErrRec, and MAX_VARIABLE_SIZE (1024) bytes for the others.
1060 if ((Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
) {
1061 if ((DataSize
> MAX_HARDWARE_ERROR_VARIABLE_SIZE
) ||
1062 (sizeof (VARIABLE_HEADER
) + StrSize (VariableName
) + DataSize
> MAX_HARDWARE_ERROR_VARIABLE_SIZE
)) {
1063 return EFI_INVALID_PARAMETER
;
1067 // The size of the VariableName, including the Unicode Null in bytes plus
1068 // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.
1070 if ((DataSize
> MAX_VARIABLE_SIZE
) ||
1071 (sizeof (VARIABLE_HEADER
) + StrSize (VariableName
) + DataSize
> MAX_VARIABLE_SIZE
)) {
1072 return EFI_INVALID_PARAMETER
;
1076 // Check whether the input variable is already existed
1079 Status
= FindVariable (VariableName
, VendorGuid
, &Variable
, &mVariableModuleGlobal
->VariableGlobal
);
1080 if (Status
== EFI_SUCCESS
&& Variable
.CurrPtr
!= NULL
) {
1082 // Update/Delete existing variable
1084 Volatile
= Variable
.Volatile
;
1086 if (EfiAtRuntime ()) {
1088 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
1089 // the volatile is ReadOnly, and SetVariable should be aborted and
1090 // return EFI_WRITE_PROTECTED.
1092 if (Variable
.Volatile
) {
1093 Status
= EFI_WRITE_PROTECTED
;
1097 // Only variable have NV attribute can be updated/deleted in Runtime
1099 if (!(Variable
.CurrPtr
->Attributes
& EFI_VARIABLE_NON_VOLATILE
)) {
1100 Status
= EFI_INVALID_PARAMETER
;
1105 // Setting a data variable with no access, or zero DataSize attributes
1106 // specified causes it to be deleted.
1108 if (DataSize
== 0 || (Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == 0) {
1109 State
= Variable
.CurrPtr
->State
;
1110 State
&= VAR_DELETED
;
1112 Status
= UpdateVariableStore (
1113 &mVariableModuleGlobal
->VariableGlobal
,
1117 (UINTN
) &Variable
.CurrPtr
->State
,
1121 if (!EFI_ERROR (Status
)) {
1122 UpdateVariableInfo (VariableName
, VendorGuid
, Volatile
, FALSE
, FALSE
, TRUE
, FALSE
);
1123 UpdateVariableCache (VariableName
, VendorGuid
, Attributes
, DataSize
, Data
);
1128 // If the variable is marked valid and the same data has been passed in
1129 // then return to the caller immediately.
1131 if (Variable
.CurrPtr
->DataSize
== DataSize
&&
1132 (CompareMem (Data
, GetVariableDataPtr (Variable
.CurrPtr
), DataSize
) == 0)) {
1134 UpdateVariableInfo (VariableName
, VendorGuid
, Volatile
, FALSE
, TRUE
, FALSE
, FALSE
);
1135 Status
= EFI_SUCCESS
;
1137 } else if ((Variable
.CurrPtr
->State
== VAR_ADDED
) ||
1138 (Variable
.CurrPtr
->State
== (VAR_ADDED
& VAR_IN_DELETED_TRANSITION
))) {
1140 // Mark the old variable as in delete transition
1142 State
= Variable
.CurrPtr
->State
;
1143 State
&= VAR_IN_DELETED_TRANSITION
;
1145 Status
= UpdateVariableStore (
1146 &mVariableModuleGlobal
->VariableGlobal
,
1150 (UINTN
) &Variable
.CurrPtr
->State
,
1154 if (EFI_ERROR (Status
)) {
1158 } else if (Status
== EFI_NOT_FOUND
) {
1160 // Create a new variable
1164 // Make sure we are trying to create a new variable.
1165 // Setting a data variable with no access, or zero DataSize attributes means to delete it.
1167 if (DataSize
== 0 || (Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == 0) {
1168 Status
= EFI_NOT_FOUND
;
1173 // Only variable have NV|RT attribute can be created in Runtime
1175 if (EfiAtRuntime () &&
1176 (!(Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
) || !(Attributes
& EFI_VARIABLE_NON_VOLATILE
))) {
1177 Status
= EFI_INVALID_PARAMETER
;
1182 // Status should be EFI_INVALID_PARAMETER here according to return status of FindVariable().
1184 ASSERT (Status
== EFI_INVALID_PARAMETER
);
1189 // Function part - create a new variable and copy the data.
1190 // Both update a variable and create a variable will come here.
1192 // Tricky part: Use scratch data area at the end of volatile variable store
1193 // as a temporary storage.
1195 NextVariable
= GetEndPointer ((VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
));
1197 SetMem (NextVariable
, SCRATCH_SIZE
, 0xff);
1199 NextVariable
->StartId
= VARIABLE_DATA
;
1200 NextVariable
->Attributes
= Attributes
;
1202 // NextVariable->State = VAR_ADDED;
1204 NextVariable
->Reserved
= 0;
1205 VarNameOffset
= sizeof (VARIABLE_HEADER
);
1206 VarNameSize
= StrSize (VariableName
);
1208 (UINT8
*) ((UINTN
) NextVariable
+ VarNameOffset
),
1212 VarDataOffset
= VarNameOffset
+ VarNameSize
+ GET_PAD_SIZE (VarNameSize
);
1214 (UINT8
*) ((UINTN
) NextVariable
+ VarDataOffset
),
1218 CopyMem (&NextVariable
->VendorGuid
, VendorGuid
, sizeof (EFI_GUID
));
1220 // There will be pad bytes after Data, the NextVariable->NameSize and
1221 // NextVariable->DataSize should not include pad size so that variable
1222 // service can get actual size in GetVariable
1224 NextVariable
->NameSize
= (UINT32
)VarNameSize
;
1225 NextVariable
->DataSize
= (UINT32
)DataSize
;
1228 // The actual size of the variable that stores in storage should
1229 // include pad size.
1231 VarSize
= VarDataOffset
+ DataSize
+ GET_PAD_SIZE (DataSize
);
1232 if (Attributes
& EFI_VARIABLE_NON_VOLATILE
) {
1234 // Create a nonvolatile variable
1238 if ((UINT32
) (VarSize
+*NonVolatileOffset
) >
1239 ((VARIABLE_STORE_HEADER
*) ((UINTN
) (mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
)))->Size
1241 if (EfiAtRuntime ()) {
1242 Status
= EFI_OUT_OF_RESOURCES
;
1246 // Perform garbage collection & reclaim operation
1248 Status
= Reclaim (mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
, NonVolatileOffset
, FALSE
);
1249 if (EFI_ERROR (Status
)) {
1253 // If still no enough space, return out of resources
1255 if ((UINT32
) (VarSize
+*NonVolatileOffset
) >
1256 ((VARIABLE_STORE_HEADER
*) ((UINTN
) (mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
)))->Size
1258 Status
= EFI_OUT_OF_RESOURCES
;
1266 // 1. Write variable header
1267 // 2. Write variable data
1268 // 3. Set variable state to valid
1273 Status
= UpdateVariableStore (
1274 &mVariableModuleGlobal
->VariableGlobal
,
1279 sizeof (VARIABLE_HEADER
),
1280 (UINT8
*) NextVariable
1283 if (EFI_ERROR (Status
)) {
1289 Status
= UpdateVariableStore (
1290 &mVariableModuleGlobal
->VariableGlobal
,
1294 *NonVolatileOffset
+ sizeof (VARIABLE_HEADER
),
1295 (UINT32
) VarSize
- sizeof (VARIABLE_HEADER
),
1296 (UINT8
*) NextVariable
+ sizeof (VARIABLE_HEADER
)
1299 if (EFI_ERROR (Status
)) {
1305 NextVariable
->State
= VAR_ADDED
;
1306 Status
= UpdateVariableStore (
1307 &mVariableModuleGlobal
->VariableGlobal
,
1312 sizeof (VARIABLE_HEADER
),
1313 (UINT8
*) NextVariable
1316 if (EFI_ERROR (Status
)) {
1320 *NonVolatileOffset
= *NonVolatileOffset
+ VarSize
;
1324 // Create a volatile variable
1328 if ((UINT32
) (VarSize
+*VolatileOffset
) >
1329 ((VARIABLE_STORE_HEADER
*) ((UINTN
) (mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
)))->Size
) {
1331 // Perform garbage collection & reclaim operation
1333 Status
= Reclaim (mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
, VolatileOffset
, TRUE
);
1334 if (EFI_ERROR (Status
)) {
1338 // If still no enough space, return out of resources
1340 if ((UINT32
) (VarSize
+*VolatileOffset
) >
1341 ((VARIABLE_STORE_HEADER
*) ((UINTN
) (mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
)))->Size
1343 Status
= EFI_OUT_OF_RESOURCES
;
1350 NextVariable
->State
= VAR_ADDED
;
1351 Status
= UpdateVariableStore (
1352 &mVariableModuleGlobal
->VariableGlobal
,
1358 (UINT8
*) NextVariable
1361 if (EFI_ERROR (Status
)) {
1365 *VolatileOffset
= *VolatileOffset
+ VarSize
;
1368 // Mark the old variable as deleted
1370 if (!Reclaimed
&& !EFI_ERROR (Status
) && Variable
.CurrPtr
!= NULL
) {
1371 State
= Variable
.CurrPtr
->State
;
1372 State
&= VAR_DELETED
;
1374 Status
= UpdateVariableStore (
1375 &mVariableModuleGlobal
->VariableGlobal
,
1379 (UINTN
) &Variable
.CurrPtr
->State
,
1384 if (!EFI_ERROR (Status
)) {
1385 UpdateVariableInfo (VariableName
, VendorGuid
, Volatile
, FALSE
, TRUE
, FALSE
, FALSE
);
1386 UpdateVariableCache (VariableName
, VendorGuid
, Attributes
, DataSize
, Data
);
1391 Status
= EFI_SUCCESS
;
1392 UpdateVariableInfo (VariableName
, VendorGuid
, Volatile
, FALSE
, TRUE
, FALSE
, FALSE
);
1393 UpdateVariableCache (VariableName
, VendorGuid
, Attributes
, DataSize
, Data
);
1396 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
);
1403 Routine Description:
1405 This code returns information about the EFI variables.
1409 Attributes Attributes bitmask to specify the type of variables
1410 on which to return information.
1411 MaximumVariableStorageSize Pointer to the maximum size of the storage space available
1412 for the EFI variables associated with the attributes specified.
1413 RemainingVariableStorageSize Pointer to the remaining size of the storage space available
1414 for EFI variables associated with the attributes specified.
1415 MaximumVariableSize Pointer to the maximum size of an individual EFI variables
1416 associated with the attributes specified.
1417 Global Pointer to VARIABLE_GLOBAL structure.
1418 Instance Instance of the Firmware Volume.
1423 EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
1424 EFI_SUCCESS - Query successfully.
1425 EFI_UNSUPPORTED - The attribute is not supported on this platform.
1430 RuntimeServiceQueryVariableInfo (
1431 IN UINT32 Attributes
,
1432 OUT UINT64
*MaximumVariableStorageSize
,
1433 OUT UINT64
*RemainingVariableStorageSize
,
1434 OUT UINT64
*MaximumVariableSize
1437 VARIABLE_HEADER
*Variable
;
1438 VARIABLE_HEADER
*NextVariable
;
1439 UINT64 VariableSize
;
1440 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
1442 if(MaximumVariableStorageSize
== NULL
|| RemainingVariableStorageSize
== NULL
|| MaximumVariableSize
== NULL
|| Attributes
== 0) {
1443 return EFI_INVALID_PARAMETER
;
1446 if((Attributes
& (EFI_VARIABLE_NON_VOLATILE
| EFI_VARIABLE_BOOTSERVICE_ACCESS
| EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_HARDWARE_ERROR_RECORD
)) == 0) {
1448 // Make sure the Attributes combination is supported by the platform.
1450 return EFI_UNSUPPORTED
;
1451 } else if ((Attributes
& (EFI_VARIABLE_RUNTIME_ACCESS
| EFI_VARIABLE_BOOTSERVICE_ACCESS
)) == EFI_VARIABLE_RUNTIME_ACCESS
) {
1453 // Make sure if runtime bit is set, boot service bit is set also.
1455 return EFI_INVALID_PARAMETER
;
1456 } else if (EfiAtRuntime () && !(Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)) {
1458 // Make sure RT Attribute is set if we are in Runtime phase.
1460 return EFI_INVALID_PARAMETER
;
1463 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
);
1465 if((Attributes
& EFI_VARIABLE_NON_VOLATILE
) == 0) {
1467 // Query is Volatile related.
1469 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
);
1472 // Query is Non-Volatile related.
1474 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
);
1478 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1479 // with the storage size (excluding the storage header size).
1481 *MaximumVariableStorageSize
= VariableStoreHeader
->Size
- sizeof (VARIABLE_STORE_HEADER
);
1482 *RemainingVariableStorageSize
= VariableStoreHeader
->Size
- sizeof (VARIABLE_STORE_HEADER
);
1485 // Let *MaximumVariableSize be MAX_VARIABLE_SIZE with the exception of the variable header size.
1487 *MaximumVariableSize
= MAX_VARIABLE_SIZE
- sizeof (VARIABLE_HEADER
);
1490 // Harware error record variable needs larger size.
1492 if ((Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
) == EFI_VARIABLE_HARDWARE_ERROR_RECORD
) {
1493 *MaximumVariableSize
= MAX_HARDWARE_ERROR_VARIABLE_SIZE
- sizeof (VARIABLE_HEADER
);
1497 // Point to the starting address of the variables.
1499 Variable
= (VARIABLE_HEADER
*) (VariableStoreHeader
+ 1);
1502 // Now walk through the related variable store.
1504 while (IsValidVariableHeader (Variable
) && (Variable
< GetEndPointer (VariableStoreHeader
))) {
1505 NextVariable
= GetNextVariablePtr (Variable
);
1506 VariableSize
= (UINT64
) (UINTN
) NextVariable
- (UINT64
) (UINTN
) Variable
;
1508 if (EfiAtRuntime ()) {
1510 // we don't take the state of the variables in mind
1511 // when calculating RemainingVariableStorageSize,
1512 // since the space occupied by variables not marked with
1513 // VAR_ADDED is not allowed to be reclaimed in Runtime.
1515 *RemainingVariableStorageSize
-= VariableSize
;
1518 // Only care about Variables with State VAR_ADDED,because
1519 // the space not marked as VAR_ADDED is reclaimable now.
1521 if (Variable
->State
== VAR_ADDED
) {
1522 *RemainingVariableStorageSize
-= VariableSize
;
1527 // Go to the next one
1529 Variable
= NextVariable
;
1532 if (*RemainingVariableStorageSize
< sizeof (VARIABLE_HEADER
)) {
1533 *MaximumVariableSize
= 0;
1534 } else if ((*RemainingVariableStorageSize
- sizeof (VARIABLE_HEADER
)) < *MaximumVariableSize
) {
1535 *MaximumVariableSize
= *RemainingVariableStorageSize
- sizeof (VARIABLE_HEADER
);
1538 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
);
1543 VariableCommonInitialize (
1544 IN EFI_HANDLE ImageHandle
,
1545 IN EFI_SYSTEM_TABLE
*SystemTable
1549 Routine Description:
1550 This function does common initialization for variable services
1554 ImageHandle - The firmware allocated handle for the EFI image.
1555 SystemTable - A pointer to the EFI System Table.
1561 EFI_NOT_FOUND - Variable store area not found.
1562 EFI_UNSUPPORTED - Currently only one non-volatile variable store is supported.
1563 EFI_SUCCESS - Variable services successfully initialized.
1568 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
1570 VARIABLE_STORE_HEADER
*VolatileVariableStore
;
1571 VARIABLE_STORE_HEADER
*VariableStoreHeader
;
1572 VARIABLE_HEADER
*NextVariable
;
1574 EFI_PHYSICAL_ADDRESS FvVolHdr
;
1575 UINT64 TempVariableStoreHeader
;
1576 EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor
;
1581 UINT64 VariableStoreBase
;
1582 UINT64 VariableStoreLength
;
1585 EfiInitializeLock(&mVariableModuleGlobal
->VariableGlobal
.VariableServicesLock
, TPL_NOTIFY
);
1588 // Allocate memory for volatile variable store
1590 VolatileVariableStore
= AllocateRuntimePool (VARIABLE_STORE_SIZE
+ SCRATCH_SIZE
);
1591 if (VolatileVariableStore
== NULL
) {
1592 FreePool (mVariableModuleGlobal
);
1593 return EFI_OUT_OF_RESOURCES
;
1596 SetMem (VolatileVariableStore
, VARIABLE_STORE_SIZE
+ SCRATCH_SIZE
, 0xff);
1599 // Variable Specific Data
1601 mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) VolatileVariableStore
;
1602 mVariableModuleGlobal
->VolatileLastVariableOffset
= sizeof (VARIABLE_STORE_HEADER
);
1604 VolatileVariableStore
->Signature
= VARIABLE_STORE_SIGNATURE
;
1605 VolatileVariableStore
->Size
= VARIABLE_STORE_SIZE
;
1606 VolatileVariableStore
->Format
= VARIABLE_STORE_FORMATTED
;
1607 VolatileVariableStore
->State
= VARIABLE_STORE_HEALTHY
;
1608 VolatileVariableStore
->Reserved
= 0;
1609 VolatileVariableStore
->Reserved1
= 0;
1612 // Get non volatile varaible store
1615 TempVariableStoreHeader
= (UINT64
) PcdGet32 (PcdFlashNvStorageVariableBase
);
1616 VariableStoreBase
= TempVariableStoreHeader
+ \
1617 (((EFI_FIRMWARE_VOLUME_HEADER
*) (UINTN
) (TempVariableStoreHeader
)) -> HeaderLength
);
1618 VariableStoreLength
= (UINT64
) PcdGet32 (PcdFlashNvStorageVariableSize
) - \
1619 (((EFI_FIRMWARE_VOLUME_HEADER
*) (UINTN
) (TempVariableStoreHeader
)) -> HeaderLength
);
1621 // Mark the variable storage region of the FLASH as RUNTIME
1623 BaseAddress
= VariableStoreBase
& (~EFI_PAGE_MASK
);
1624 Length
= VariableStoreLength
+ (VariableStoreBase
- BaseAddress
);
1625 Length
= (Length
+ EFI_PAGE_SIZE
- 1) & (~EFI_PAGE_MASK
);
1627 Status
= gDS
->GetMemorySpaceDescriptor (BaseAddress
, &GcdDescriptor
);
1628 if (EFI_ERROR (Status
)) {
1629 FreePool (mVariableModuleGlobal
);
1630 FreePool (VolatileVariableStore
);
1631 return EFI_UNSUPPORTED
;
1634 Status
= gDS
->SetMemorySpaceAttributes (
1637 GcdDescriptor
.Attributes
| EFI_MEMORY_RUNTIME
1639 if (EFI_ERROR (Status
)) {
1640 FreePool (mVariableModuleGlobal
);
1641 FreePool (VolatileVariableStore
);
1642 return EFI_UNSUPPORTED
;
1645 // Get address of non volatile variable store base
1647 mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
= VariableStoreBase
;
1653 // Find the Correct Instance of the FV Block Service.
1656 CurrPtr
= (CHAR8
*) ((UINTN
) mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
);
1657 while (EfiFvbGetPhysicalAddress (Instance
, &FvVolHdr
) == EFI_SUCCESS
) {
1658 FwVolHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*) ((UINTN
) FvVolHdr
);
1659 if (CurrPtr
>= (CHAR8
*) FwVolHeader
&& CurrPtr
< (((CHAR8
*) FwVolHeader
) + FwVolHeader
->FvLength
)) {
1660 mVariableModuleGlobal
->FvbInstance
= Instance
;
1667 VariableStoreHeader
= (VARIABLE_STORE_HEADER
*) CurrPtr
;
1668 if (GetVariableStoreStatus (VariableStoreHeader
) == EfiValid
) {
1669 if (~VariableStoreHeader
->Size
== 0) {
1670 Status
= UpdateVariableStore (
1671 &mVariableModuleGlobal
->VariableGlobal
,
1674 mVariableModuleGlobal
->FvbInstance
,
1675 (UINTN
) &VariableStoreHeader
->Size
,
1677 (UINT8
*) &VariableStoreLength
1680 // As Variables are stored in NV storage, which are slow devices,such as flash.
1681 // Variable operation may skip checking variable program result to improve performance,
1682 // We can assume Variable program is OK through some check point.
1683 // Variable Store Size Setting should be the first Variable write operation,
1684 // We can assume all Read/Write is OK if we can set Variable store size successfully.
1685 // If write fail, we will assert here
1687 ASSERT(VariableStoreHeader
->Size
== VariableStoreLength
);
1689 if (EFI_ERROR (Status
)) {
1694 mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
= (EFI_PHYSICAL_ADDRESS
) ((UINTN
) CurrPtr
);
1696 // Parse non-volatile variable data and get last variable offset
1698 NextVariable
= (VARIABLE_HEADER
*) (CurrPtr
+ sizeof (VARIABLE_STORE_HEADER
));
1699 Status
= EFI_SUCCESS
;
1701 while (IsValidVariableHeader (NextVariable
)) {
1702 NextVariable
= GetNextVariablePtr (NextVariable
);
1705 mVariableModuleGlobal
->NonVolatileLastVariableOffset
= (UINTN
) NextVariable
- (UINTN
) CurrPtr
;
1708 // Check if the free area is blow a threshold
1710 if ((((VARIABLE_STORE_HEADER
*)((UINTN
) CurrPtr
))->Size
- mVariableModuleGlobal
->NonVolatileLastVariableOffset
) < VARIABLE_RECLAIM_THRESHOLD
) {
1712 mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
,
1713 &mVariableModuleGlobal
->NonVolatileLastVariableOffset
,
1718 if (EFI_ERROR (Status
)) {
1719 FreePool (mVariableModuleGlobal
);
1720 FreePool (VolatileVariableStore
);
1725 // Check if the free area is really free.
1727 for (Index
= mVariableModuleGlobal
->NonVolatileLastVariableOffset
; Index
< VariableStoreHeader
->Size
; Index
++) {
1728 Data
= ((UINT8
*) (UINTN
) mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
)[Index
];
1731 // There must be something wrong in variable store, do reclaim operation.
1734 mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
,
1735 &mVariableModuleGlobal
->NonVolatileLastVariableOffset
,
1743 if (EFI_ERROR (Status
)) {
1744 FreePool (mVariableModuleGlobal
);
1745 FreePool (VolatileVariableStore
);
1756 VariableClassAddressChangeEvent (
1763 (VOID
**) &mVariableModuleGlobal
->VariableGlobal
.NonVolatileVariableBase
1767 (VOID
**) &mVariableModuleGlobal
->VariableGlobal
.VolatileVariableBase
1769 EfiConvertPointer (0x0, (VOID
**) &mVariableModuleGlobal
);
1774 Variable Driver main entry point. The Variable driver places the 4 EFI
1775 runtime services in the EFI System Table and installs arch protocols
1776 for variable read and write services being availible.
1778 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1779 @param[in] SystemTable A pointer to the EFI System Table.
1781 @retval EFI_SUCCESS The entry point is executed successfully.
1782 @retval other Some error occurs when executing this entry point.
1787 VariableServiceInitialize (
1788 IN EFI_HANDLE ImageHandle
,
1789 IN EFI_SYSTEM_TABLE
*SystemTable
1794 Status
= VariableCommonInitialize (ImageHandle
, SystemTable
);
1795 ASSERT_EFI_ERROR (Status
);
1797 SystemTable
->RuntimeServices
->GetVariable
= RuntimeServiceGetVariable
;
1798 SystemTable
->RuntimeServices
->GetNextVariableName
= RuntimeServiceGetNextVariableName
;
1799 SystemTable
->RuntimeServices
->SetVariable
= RuntimeServiceSetVariable
;
1800 SystemTable
->RuntimeServices
->QueryVariableInfo
= RuntimeServiceQueryVariableInfo
;
1803 // Now install the Variable Runtime Architectural Protocol on a new handle
1805 Status
= gBS
->InstallMultipleProtocolInterfaces (
1807 &gEfiVariableArchProtocolGuid
, NULL
,
1808 &gEfiVariableWriteArchProtocolGuid
, NULL
,
1811 ASSERT_EFI_ERROR (Status
);
1813 Status
= gBS
->CreateEvent (
1814 EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
,
1816 VariableClassAddressChangeEvent
,
1818 &mVirtualAddressChangeEvent
1820 ASSERT_EFI_ERROR (Status
);