]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
projects / mirror_edk2.git / blob
? search:


767fafce1f1c339f6c288c63387a9d1b24990001
[mirror_edk2.git] / MdeModulePkg / Universal / Variable / RuntimeDxe / Variable.c
1 /** @file
2 EFI Runtime Variable services.
3
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
9
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.
12
13 **/
14
15
16 #include "Variable.h"
17
18
19 VARIABLE_MODULE_GLOBAL mRuntimeData;
20 VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal = &mRuntimeData;
21 EFI_EVENT mVirtualAddressChangeEvent = NULL;
22 EFI_HANDLE mHandle = NULL;
23
24
25 //
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.
29 //
30 VOID
31 AcquireLockOnlyAtBootTime (
32 IN EFI_LOCK *Lock
33 )
34 {
35 if (!EfiAtRuntime ()) {
36 EfiAcquireLock (Lock);
37 }
38 }
39
40 //
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.
44 //
45 VOID
46 ReleaseLockOnlyAtBootTime (
47 IN EFI_LOCK *Lock
48 )
49 {
50 if (!EfiAtRuntime ()) {
51 EfiReleaseLock (Lock);
52 }
53 }
54
55
56 GLOBAL_REMOVE_IF_UNREFERENCED VARIABLE_INFO_ENTRY *gVariableInfo = NULL;
57
58
59 /**
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.
65
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
68 freed.
69
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.
77
78 **/
79 VOID
80 UpdateVariableInfo (
81 IN CHAR16 *VariableName,
82 IN EFI_GUID *VendorGuid,
83 IN BOOLEAN Volatile,
84 IN BOOLEAN Read,
85 IN BOOLEAN Write,
86 IN BOOLEAN Delete,
87 IN BOOLEAN Cache
88 )
89 {
90 VARIABLE_INFO_ENTRY *Entry;
91
92 if (FeaturePcdGet (PcdVariableCollectStatistics)) {
93
94 if (EfiAtRuntime ()) {
95 // Don't collect statistics at runtime
96 return;
97 }
98
99 if (gVariableInfo == NULL) {
100 //
101 // on the first call allocate a entry and place a pointer to it in
102 // the EFI System Table
103 //
104 gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
105 ASSERT (gVariableInfo != NULL);
106
107 CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);
108 gVariableInfo->Name = AllocatePool (StrLen (VariableName));
109 StrCpy (gVariableInfo->Name, VariableName);
110 gVariableInfo->Volatile = Volatile;
111
112 gBS->InstallConfigurationTable (&gEfiVariableInfoGuid, gVariableInfo);
113 }
114
115
116 for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) {
117 if (CompareGuid (VendorGuid, &Entry->VendorGuid)) {
118 if (StrCmp (VariableName, Entry->Name) == 0) {
119 if (Read) {
120 Entry->ReadCount++;
121 }
122 if (Write) {
123 Entry->WriteCount++;
124 }
125 if (Delete) {
126 Entry->DeleteCount++;
127 }
128 if (Cache) {
129 Entry->CacheCount++;
130 }
131
132 return;
133 }
134 }
135
136 if (Entry->Next == NULL) {
137 //
138 // If the entry is not in the table add it.
139 // Next iteration of the loop will fill in the data
140 //
141 Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
142 ASSERT (Entry->Next != NULL);
143
144 CopyGuid (&Entry->Next->VendorGuid, VendorGuid);
145 Entry->Next->Name = AllocatePool (StrLen (VariableName));
146 StrCpy (Entry->Next->Name, VariableName);
147 Entry->Next->Volatile = Volatile;
148 }
149
150 }
151 }
152 }
153
154
155
156 BOOLEAN
157 IsValidVariableHeader (
158 IN VARIABLE_HEADER *Variable
159 )
160 /*++
161
162 Routine Description:
163
164 This code checks if variable header is valid or not.
165
166 Arguments:
167 Variable Pointer to the Variable Header.
168
169 Returns:
170 TRUE Variable header is valid.
171 FALSE Variable header is not valid.
172
173 --*/
174 {
175 if (Variable == NULL ||
176 Variable->StartId != VARIABLE_DATA ||
177 (sizeof (VARIABLE_HEADER) + Variable->NameSize + Variable->DataSize) > MAX_VARIABLE_SIZE
178 ) {
179 return FALSE;
180 }
181
182 return TRUE;
183 }
184
185
186 EFI_STATUS
187 UpdateVariableStore (
188 IN VARIABLE_GLOBAL *Global,
189 IN BOOLEAN Volatile,
190 IN BOOLEAN SetByIndex,
191 IN UINTN Instance,
192 IN UINTN DataPtrIndex,
193 IN UINT32 DataSize,
194 IN UINT8 *Buffer
195 )
196 /*++
197
198 Routine Description:
199
200 This function writes data to the FWH at the correct LBA even if the LBAs
201 are fragmented.
202
203 Arguments:
204
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
211 structure
212 DataSize - Size of data to be written.
213 Buffer - Pointer to the buffer from which data is written
214
215 Returns:
216
217 EFI_INVALID_PARAMETER - Parameters not valid
218 EFI_SUCCESS - Variable store successfully updated
219
220 --*/
221 {
222 EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;
223 UINTN BlockIndex2;
224 UINTN LinearOffset;
225 UINTN CurrWriteSize;
226 UINTN CurrWritePtr;
227 UINT8 *CurrBuffer;
228 EFI_LBA LbaNumber;
229 UINTN Size;
230 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
231 VARIABLE_STORE_HEADER *VolatileBase;
232 EFI_PHYSICAL_ADDRESS FvVolHdr;
233 EFI_PHYSICAL_ADDRESS DataPtr;
234 EFI_STATUS Status;
235
236 FwVolHeader = NULL;
237 DataPtr = DataPtrIndex;
238
239 //
240 // Check if the Data is Volatile
241 //
242 if (!Volatile) {
243 EfiFvbGetPhysicalAddress (Instance, &FvVolHdr);
244 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
245 //
246 // Data Pointer should point to the actual Address where data is to be
247 // written
248 //
249 if (SetByIndex) {
250 DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;
251 }
252
253 if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {
254 return EFI_INVALID_PARAMETER;
255 }
256 } else {
257 //
258 // Data Pointer should point to the actual Address where data is to be
259 // written
260 //
261 VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
262 if (SetByIndex) {
263 DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;
264 }
265
266 if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {
267 return EFI_INVALID_PARAMETER;
268 }
269
270 //
271 // If Volatile Variable just do a simple mem copy.
272 //
273 CopyMem ((UINT8 *)(UINTN)DataPtr, Buffer, DataSize);
274 return EFI_SUCCESS;
275 }
276
277 //
278 // If we are here we are dealing with Non-Volatile Variables
279 //
280 LinearOffset = (UINTN) FwVolHeader;
281 CurrWritePtr = (UINTN) DataPtr;
282 CurrWriteSize = DataSize;
283 CurrBuffer = Buffer;
284 LbaNumber = 0;
285
286 if (CurrWritePtr < LinearOffset) {
287 return EFI_INVALID_PARAMETER;
288 }
289
290 for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {
291 for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {
292 //
293 // Check to see if the Variable Writes are spanning through multiple
294 // blocks.
295 //
296 if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->Length)) {
297 if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->Length)) {
298 Status = EfiFvbWriteBlock (
299 Instance,
300 LbaNumber,
301 (UINTN) (CurrWritePtr - LinearOffset),
302 &CurrWriteSize,
303 CurrBuffer
304 );
305 return Status;
306 } else {
307 Size = (UINT32) (LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);
308 Status = EfiFvbWriteBlock (
309 Instance,
310 LbaNumber,
311 (UINTN) (CurrWritePtr - LinearOffset),
312 &Size,
313 CurrBuffer
314 );
315 if (EFI_ERROR (Status)) {
316 return Status;
317 }
318
319 CurrWritePtr = LinearOffset + PtrBlockMapEntry->Length;
320 CurrBuffer = CurrBuffer + Size;
321 CurrWriteSize = CurrWriteSize - Size;
322 }
323 }
324
325 LinearOffset += PtrBlockMapEntry->Length;
326 LbaNumber++;
327 }
328 }
329
330 return EFI_SUCCESS;
331 }
332
333
334 VARIABLE_STORE_STATUS
335 GetVariableStoreStatus (
336 IN VARIABLE_STORE_HEADER *VarStoreHeader
337 )
338 /*++
339
340 Routine Description:
341
342 This code gets the current status of Variable Store.
343
344 Arguments:
345
346 VarStoreHeader Pointer to the Variable Store Header.
347
348 Returns:
349
350 EfiRaw Variable store status is raw
351 EfiValid Variable store status is valid
352 EfiInvalid Variable store status is invalid
353
354 --*/
355 {
356 if (VarStoreHeader->Signature == VARIABLE_STORE_SIGNATURE &&
357 VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
358 VarStoreHeader->State == VARIABLE_STORE_HEALTHY
359 ) {
360
361 return EfiValid;
362 } else if (VarStoreHeader->Signature == 0xffffffff &&
363 VarStoreHeader->Size == 0xffffffff &&
364 VarStoreHeader->Format == 0xff &&
365 VarStoreHeader->State == 0xff
366 ) {
367
368 return EfiRaw;
369 } else {
370 return EfiInvalid;
371 }
372 }
373
374
375 UINT8 *
376 GetVariableDataPtr (
377 IN VARIABLE_HEADER *Variable
378 )
379 /*++
380
381 Routine Description:
382
383 This code gets the pointer to the variable data.
384
385 Arguments:
386
387 Variable Pointer to the Variable Header.
388
389 Returns:
390
391 UINT8* Pointer to Variable Data
392
393 --*/
394 {
395 //
396 // Be careful about pad size for alignment
397 //
398 return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
399 }
400
401
402 VARIABLE_HEADER *
403 GetNextVariablePtr (
404 IN VARIABLE_HEADER *Variable
405 )
406 /*++
407
408 Routine Description:
409
410 This code gets the pointer to the next variable header.
411
412 Arguments:
413
414 Variable Pointer to the Variable Header.
415
416 Returns:
417
418 VARIABLE_HEADER* Pointer to next variable header.
419
420 --*/
421 {
422 if (!IsValidVariableHeader (Variable)) {
423 return NULL;
424 }
425 //
426 // Be careful about pad size for alignment
427 //
428 return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
429 }
430
431
432 VARIABLE_HEADER *
433 GetEndPointer (
434 IN VARIABLE_STORE_HEADER *VarStoreHeader
435 )
436 /*++
437
438 Routine Description:
439
440 This code gets the pointer to the last variable memory pointer byte
441
442 Arguments:
443
444 VarStoreHeader Pointer to the Variable Store Header.
445
446 Returns:
447
448 VARIABLE_HEADER* Pointer to last unavailable Variable Header
449
450 --*/
451 {
452 //
453 // The end of variable store
454 //
455 return (VARIABLE_HEADER *) ((UINTN) VarStoreHeader + VarStoreHeader->Size);
456 }
457
458
459 EFI_STATUS
460 Reclaim (
461 IN EFI_PHYSICAL_ADDRESS VariableBase,
462 OUT UINTN *LastVariableOffset,
463 IN BOOLEAN IsVolatile
464 )
465 /*++
466
467 Routine Description:
468
469 Variable store garbage collection and reclaim operation
470
471 Arguments:
472
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
477
478 Returns:
479
480 EFI STATUS
481
482 --*/
483 {
484 VARIABLE_HEADER *Variable;
485 VARIABLE_HEADER *NextVariable;
486 VARIABLE_STORE_HEADER *VariableStoreHeader;
487 UINT8 *ValidBuffer;
488 UINTN ValidBufferSize;
489 UINTN VariableSize;
490 UINT8 *CurrPtr;
491 EFI_STATUS Status;
492
493 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);
494
495 //
496 // Start Pointers for the variable.
497 //
498 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
499
500 ValidBufferSize = sizeof (VARIABLE_STORE_HEADER);
501
502 while (IsValidVariableHeader (Variable)) {
503 NextVariable = GetNextVariablePtr (Variable);
504 if (Variable->State == VAR_ADDED) {
505 VariableSize = (UINTN) NextVariable - (UINTN) Variable;
506 ValidBufferSize += VariableSize;
507 }
508
509 Variable = NextVariable;
510 }
511
512 ValidBuffer = AllocatePool (ValidBufferSize);
513 if (ValidBuffer == NULL) {
514 return EFI_OUT_OF_RESOURCES;
515 }
516
517 SetMem (ValidBuffer, ValidBufferSize, 0xff);
518
519 CurrPtr = ValidBuffer;
520
521 //
522 // Copy variable store header
523 //
524 CopyMem (CurrPtr, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));
525 CurrPtr += sizeof (VARIABLE_STORE_HEADER);
526
527 //
528 // Start Pointers for the variable.
529 //
530 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
531
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;
538 }
539
540 Variable = NextVariable;
541 }
542
543 if (IsVolatile) {
544 //
545 // If volatile variable store, just copy valid buffer
546 //
547 SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);
548 CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, ValidBufferSize);
549 *LastVariableOffset = ValidBufferSize;
550 Status = EFI_SUCCESS;
551 } else {
552 //
553 // If non-volatile variable store, perform FTW here.
554 //
555 Status = FtwVariableSpace (
556 VariableBase,
557 ValidBuffer,
558 ValidBufferSize
559 );
560 if (!EFI_ERROR (Status)) {
561 *LastVariableOffset = ValidBufferSize;
562 }
563 }
564
565 FreePool (ValidBuffer);
566
567 if (EFI_ERROR (Status)) {
568 *LastVariableOffset = 0;
569 }
570
571 return Status;
572 }
573
574
575 //
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.
580 //
581 VARIABLE_CACHE_ENTRY mVariableCache[] = {
582 {
583 &gEfiGlobalVariableGuid,
584 L"Lang",
585 0x00000000,
586 0x00,
587 NULL
588 }
589 };
590
591
592 /**
593 Update the Cache with Variable information. These are the same
594 arguments as the EFI Variable services.
595
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
601
602 **/
603 VOID
604 UpdateVariableCache (
605 IN CHAR16 *VariableName,
606 IN EFI_GUID *VendorGuid,
607 IN UINT32 Attributes,
608 IN UINTN DataSize,
609 IN VOID *Data
610 )
611 {
612 VARIABLE_CACHE_ENTRY *Entry;
613 UINTN Index;
614
615 if (EfiAtRuntime ()) {
616 // Don't use the cache at runtime
617 return;
618 }
619
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;
624 if (DataSize == 0) {
625 // Delete Case
626 if (Entry->DataSize != 0) {
627 FreePool (Entry->Data);
628 }
629 Entry->DataSize = DataSize;
630 } else if (DataSize == Entry->DataSize) {
631 CopyMem (Entry->Data, Data, DataSize);
632 } else {
633 Entry->Data = AllocatePool (DataSize);
634 Entry->DataSize = DataSize;
635 CopyMem (Entry->Data, Data, DataSize);
636 }
637 }
638 }
639 }
640 }
641
642
643 /**
644 Search the cache to see if the variable is in the cache.
645
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
651
652 @retval EFI_SUCCESS VariableGuid & VariableName data was returned.
653 @retval other Not found.
654
655 **/
656 EFI_STATUS
657 FindVariableInCache (
658 IN CHAR16 *VariableName,
659 IN EFI_GUID *VendorGuid,
660 OUT UINT32 *Attributes OPTIONAL,
661 IN OUT UINTN *DataSize,
662 OUT VOID *Data
663 )
664 {
665 VARIABLE_CACHE_ENTRY *Entry;
666 UINTN Index;
667
668 if (EfiAtRuntime ()) {
669 // Don't use the cache at runtime
670 return EFI_NOT_FOUND;
671 }
672
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;
683 } else {
684 // Return the data
685 CopyMem (Data, Entry->Data, Entry->DataSize);
686 if (Attributes != NULL) {
687 *Attributes = Entry->Attributes;
688 }
689 return EFI_SUCCESS;
690 }
691 }
692 }
693 }
694
695 return EFI_NOT_FOUND;
696 }
697
698
699 EFI_STATUS
700 FindVariable (
701 IN CHAR16 *VariableName,
702 IN EFI_GUID *VendorGuid,
703 OUT VARIABLE_POINTER_TRACK *PtrTrack,
704 IN VARIABLE_GLOBAL *Global
705 )
706 /*++
707
708 Routine Description:
709
710 This code finds variable in storage blocks (Volatile or Non-Volatile)
711
712 Arguments:
713
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
720
721 Returns:
722
723 EFI STATUS
724
725 --*/
726 {
727 VARIABLE_HEADER *Variable[2];
728 VARIABLE_STORE_HEADER *VariableStoreHeader[2];
729 UINTN Index;
730
731 //
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.
735 //
736 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
737
738 //
739 // 0: Volatile, 1: Non-Volatile
740 //
741 VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
742 VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
743
744 //
745 // Start Pointers for the variable.
746 // Actual Data Pointer where data can be written.
747 //
748 Variable[0] = (VARIABLE_HEADER *) (VariableStoreHeader[0] + 1);
749 Variable[1] = (VARIABLE_HEADER *) (VariableStoreHeader[1] + 1);
750
751 if (VariableName[0] != 0 && VendorGuid == NULL) {
752 return EFI_INVALID_PARAMETER;
753 }
754 //
755 // Find the variable by walk through volatile and then non-volatile variable store
756 //
757 for (Index = 0; Index < 2; Index++) {
758 PtrTrack->StartPtr = (VARIABLE_HEADER *) (VariableStoreHeader[Index] + 1);
759 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);
760
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);
767 return EFI_SUCCESS;
768 } else {
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);
773 return EFI_SUCCESS;
774 }
775 }
776 }
777 }
778 }
779
780 Variable[Index] = GetNextVariablePtr (Variable[Index]);
781 }
782 }
783 PtrTrack->CurrPtr = NULL;
784 return EFI_NOT_FOUND;
785 }
786
787
788
789 /*++
790
791 Routine Description:
792
793 This code finds variable in storage blocks (Volatile or Non-Volatile)
794
795 Arguments:
796
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.
802 Data Data pointer
803 Global Pointer to VARIABLE_GLOBAL structure
804 Instance Instance of the Firmware Volume.
805
806 Returns:
807
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
812
813
814 --*/
815 EFI_STATUS
816 EFIAPI
817 RuntimeServiceGetVariable (
818 IN CHAR16 *VariableName,
819 IN EFI_GUID *VendorGuid,
820 OUT UINT32 *Attributes OPTIONAL,
821 IN OUT UINTN *DataSize,
822 OUT VOID *Data
823 )
824 {
825 EFI_STATUS Status;
826 VARIABLE_POINTER_TRACK Variable;
827 UINTN VarDataSize;
828
829 if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
830 return EFI_INVALID_PARAMETER;
831 }
832
833 //
834 // Find existing variable
835 //
836 Status = FindVariableInCache (VariableName, VendorGuid, Attributes, DataSize, Data);
837 if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_SUCCESS)){
838 // Hit in the Cache
839 UpdateVariableInfo (VariableName, VendorGuid, FALSE, TRUE, FALSE, FALSE, TRUE);
840 return Status;
841 }
842
843 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
844 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
845 goto Done;
846 }
847
848 //
849 // Get data size
850 //
851 VarDataSize = Variable.CurrPtr->DataSize;
852 if (*DataSize >= VarDataSize) {
853 if (Data == NULL) {
854 Status = EFI_INVALID_PARAMETER;
855 goto Done;
856 }
857
858 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
859 if (Attributes != NULL) {
860 *Attributes = Variable.CurrPtr->Attributes;
861 }
862
863 *DataSize = VarDataSize;
864 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);
865 UpdateVariableCache (VariableName, VendorGuid, Variable.CurrPtr->Attributes, VarDataSize, Data);
866
867 Status = EFI_SUCCESS;
868 goto Done;
869 } else {
870 *DataSize = VarDataSize;
871 Status = EFI_BUFFER_TOO_SMALL;
872 goto Done;
873 }
874
875 Done:
876 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
877 return Status;
878 }
879
880
881
882 /*++
883
884 Routine Description:
885
886 This code Finds the Next available variable
887
888 Arguments:
889
890 VariableNameSize Size of the variable
891 VariableName Pointer to variable name
892 VendorGuid Variable Vendor Guid
893 Global VARIABLE_GLOBAL structure pointer.
894 Instance FV instance
895
896 Returns:
897
898 EFI STATUS
899
900 --*/
901 EFI_STATUS
902 EFIAPI
903 RuntimeServiceGetNextVariableName (
904 IN OUT UINTN *VariableNameSize,
905 IN OUT CHAR16 *VariableName,
906 IN OUT EFI_GUID *VendorGuid
907 )
908 {
909 VARIABLE_POINTER_TRACK Variable;
910 UINTN VarNameSize;
911 EFI_STATUS Status;
912
913 if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
914 return EFI_INVALID_PARAMETER;
915 }
916
917 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
918 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
919 goto Done;
920 }
921
922 if (VariableName[0] != 0) {
923 //
924 // If variable name is not NULL, get next variable
925 //
926 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
927 }
928
929 while (TRUE) {
930 //
931 // If both volatile and non-volatile variable store are parsed,
932 // return not found
933 //
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));
939 } else {
940 Status = EFI_NOT_FOUND;
941 goto Done;
942 }
943
944 Variable.CurrPtr = Variable.StartPtr;
945 if (!IsValidVariableHeader (Variable.CurrPtr)) {
946 continue;
947 }
948 }
949 //
950 // Variable is found
951 //
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) {
956 CopyMem (
957 VariableName,
958 GET_VARIABLE_NAME_PTR (Variable.CurrPtr),
959 VarNameSize
960 );
961 CopyMem (
962 VendorGuid,
963 &Variable.CurrPtr->VendorGuid,
964 sizeof (EFI_GUID)
965 );
966 Status = EFI_SUCCESS;
967 } else {
968 Status = EFI_BUFFER_TOO_SMALL;
969 }
970
971 *VariableNameSize = VarNameSize;
972 goto Done;
973 }
974 }
975
976 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
977 }
978
979 Done:
980 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
981 return Status;
982 }
983
984
985 /*++
986
987 Routine Description:
988
989 This code sets variable in storage blocks (Volatile or Non-Volatile)
990
991 Arguments:
992
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.
998 Data Data pointer
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.
1003
1004 Returns:
1005
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
1012
1013 --*/
1014 EFI_STATUS
1015 EFIAPI
1016 RuntimeServiceSetVariable (
1017 IN CHAR16 *VariableName,
1018 IN EFI_GUID *VendorGuid,
1019 IN UINT32 Attributes,
1020 IN UINTN DataSize,
1021 IN VOID *Data
1022 )
1023 {
1024 VARIABLE_POINTER_TRACK Variable;
1025 EFI_STATUS Status;
1026 VARIABLE_HEADER *NextVariable;
1027 UINTN VarNameSize;
1028 UINTN VarNameOffset;
1029 UINTN VarDataOffset;
1030 UINTN VarSize;
1031 UINT8 State;
1032 BOOLEAN Reclaimed;
1033 UINTN *VolatileOffset;
1034 UINTN *NonVolatileOffset;
1035 UINT32 Instance;
1036
1037 Reclaimed = FALSE;
1038 VolatileOffset = &mVariableModuleGlobal->VolatileLastVariableOffset;
1039 NonVolatileOffset = &mVariableModuleGlobal->NonVolatileLastVariableOffset;
1040 Instance = mVariableModuleGlobal->FvbInstance;
1041
1042 //
1043 // Check input parameters
1044 //
1045 if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
1046 return EFI_INVALID_PARAMETER;
1047 }
1048 //
1049 // Make sure if runtime bit is set, boot service bit is set also
1050 //
1051 if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1052 return EFI_INVALID_PARAMETER;
1053 }
1054 //
1055 // The size of the VariableName, including the Unicode Null in bytes plus
1056 // the DataSize is limited to maximum size of MAX_HARDWARE_ERROR_VARIABLE_SIZE (32K)
1057 // bytes for HwErrRec, and MAX_VARIABLE_SIZE (1024) bytes for the others.
1058 //
1059 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1060 if ((DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE) ||
1061 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE)) {
1062 return EFI_INVALID_PARAMETER;
1063 }
1064 } else {
1065 //
1066 // The size of the VariableName, including the Unicode Null in bytes plus
1067 // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.
1068 //
1069 if ((DataSize > MAX_VARIABLE_SIZE) ||
1070 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_VARIABLE_SIZE)) {
1071 return EFI_INVALID_PARAMETER;
1072 }
1073 }
1074 //
1075 // Check whether the input variable is already existed
1076 //
1077
1078 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
1079
1080 if (Status == EFI_SUCCESS && Variable.CurrPtr != NULL) {
1081 //
1082 // Update/Delete existing variable
1083 //
1084
1085 if (EfiAtRuntime ()) {
1086 //
1087 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
1088 // the volatile is ReadOnly, and SetVariable should be aborted and
1089 // return EFI_WRITE_PROTECTED.
1090 //
1091 if (Variable.Volatile) {
1092 Status = EFI_WRITE_PROTECTED;
1093 goto Done;
1094 }
1095 //
1096 // Only variable have NV attribute can be updated/deleted in Runtime
1097 //
1098 if (!(Variable.CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE)) {
1099 Status = EFI_INVALID_PARAMETER;
1100 goto Done;
1101 }
1102 }
1103 //
1104 // Setting a data variable with no access, or zero DataSize attributes
1105 // specified causes it to be deleted.
1106 //
1107 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1108 State = Variable.CurrPtr->State;
1109 State &= VAR_DELETED;
1110
1111 Status = UpdateVariableStore (
1112 &mVariableModuleGlobal->VariableGlobal,
1113 Variable.Volatile,
1114 FALSE,
1115 Instance,
1116 (UINTN) &Variable.CurrPtr->State,
1117 sizeof (UINT8),
1118 &State
1119 );
1120 if (!EFI_ERROR (Status)) {
1121 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, FALSE, FALSE, TRUE, FALSE);
1122 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1123 }
1124 goto Done;
1125 }
1126 //
1127 // If the variable is marked valid and the same data has been passed in
1128 // then return to the caller immediately.
1129 //
1130 if (Variable.CurrPtr->DataSize == DataSize &&
1131 (CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize) == 0)) {
1132
1133 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, FALSE, TRUE, FALSE, FALSE);
1134 Status = EFI_SUCCESS;
1135 goto Done;
1136 } else if ((Variable.CurrPtr->State == VAR_ADDED) ||
1137 (Variable.CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1138 //
1139 // Mark the old variable as in delete transition
1140 //
1141 State = Variable.CurrPtr->State;
1142 State &= VAR_IN_DELETED_TRANSITION;
1143
1144 Status = UpdateVariableStore (
1145 &mVariableModuleGlobal->VariableGlobal,
1146 Variable.Volatile,
1147 FALSE,
1148 Instance,
1149 (UINTN) &Variable.CurrPtr->State,
1150 sizeof (UINT8),
1151 &State
1152 );
1153 if (EFI_ERROR (Status)) {
1154 goto Done;
1155 }
1156 }
1157 } else if (Status == EFI_NOT_FOUND) {
1158 //
1159 // Create a new variable
1160 //
1161
1162 //
1163 // Make sure we are trying to create a new variable.
1164 // Setting a data variable with no access, or zero DataSize attributes means to delete it.
1165 //
1166 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1167 Status = EFI_NOT_FOUND;
1168 goto Done;
1169 }
1170
1171 //
1172 // Only variable have NV|RT attribute can be created in Runtime
1173 //
1174 if (EfiAtRuntime () &&
1175 (!(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) || !(Attributes & EFI_VARIABLE_NON_VOLATILE))) {
1176 Status = EFI_INVALID_PARAMETER;
1177 goto Done;
1178 }
1179 } else {
1180 //
1181 // Status should be EFI_INVALID_PARAMETER here according to return status of FindVariable().
1182 //
1183 ASSERT (Status == EFI_INVALID_PARAMETER);
1184 goto Done;
1185 }
1186
1187 //
1188 // Function part - create a new variable and copy the data.
1189 // Both update a variable and create a variable will come here.
1190 //
1191 // Tricky part: Use scratch data area at the end of volatile variable store
1192 // as a temporary storage.
1193 //
1194 NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
1195
1196 SetMem (NextVariable, SCRATCH_SIZE, 0xff);
1197
1198 NextVariable->StartId = VARIABLE_DATA;
1199 NextVariable->Attributes = Attributes;
1200 //
1201 // NextVariable->State = VAR_ADDED;
1202 //
1203 NextVariable->Reserved = 0;
1204 VarNameOffset = sizeof (VARIABLE_HEADER);
1205 VarNameSize = StrSize (VariableName);
1206 CopyMem (
1207 (UINT8 *) ((UINTN) NextVariable + VarNameOffset),
1208 VariableName,
1209 VarNameSize
1210 );
1211 VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
1212 CopyMem (
1213 (UINT8 *) ((UINTN) NextVariable + VarDataOffset),
1214 Data,
1215 DataSize
1216 );
1217 CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
1218 //
1219 // There will be pad bytes after Data, the NextVariable->NameSize and
1220 // NextVariable->DataSize should not include pad size so that variable
1221 // service can get actual size in GetVariable
1222 //
1223 NextVariable->NameSize = (UINT32)VarNameSize;
1224 NextVariable->DataSize = (UINT32)DataSize;
1225
1226 //
1227 // The actual size of the variable that stores in storage should
1228 // include pad size.
1229 //
1230 VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
1231 if (Attributes & EFI_VARIABLE_NON_VOLATILE) {
1232 //
1233 // Create a nonvolatile variable
1234 //
1235 Variable.Volatile = FALSE;
1236
1237 if ((UINT32) (VarSize +*NonVolatileOffset) >
1238 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
1239 ) {
1240 if (EfiAtRuntime ()) {
1241 Status = EFI_OUT_OF_RESOURCES;
1242 goto Done;
1243 }
1244 //
1245 // Perform garbage collection & reclaim operation
1246 //
1247 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, NonVolatileOffset, FALSE);
1248 if (EFI_ERROR (Status)) {
1249 goto Done;
1250 }
1251 //
1252 // If still no enough space, return out of resources
1253 //
1254 if ((UINT32) (VarSize +*NonVolatileOffset) >
1255 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
1256 ) {
1257 Status = EFI_OUT_OF_RESOURCES;
1258 goto Done;
1259 }
1260
1261 Reclaimed = TRUE;
1262 }
1263 //
1264 // Three steps
1265 // 1. Write variable header
1266 // 2. Write variable data
1267 // 3. Set variable state to valid
1268 //
1269 //
1270 // Step 1:
1271 //
1272 Status = UpdateVariableStore (
1273 &mVariableModuleGlobal->VariableGlobal,
1274 FALSE,
1275 TRUE,
1276 Instance,
1277 *NonVolatileOffset,
1278 sizeof (VARIABLE_HEADER),
1279 (UINT8 *) NextVariable
1280 );
1281
1282 if (EFI_ERROR (Status)) {
1283 goto Done;
1284 }
1285 //
1286 // Step 2:
1287 //
1288 Status = UpdateVariableStore (
1289 &mVariableModuleGlobal->VariableGlobal,
1290 FALSE,
1291 TRUE,
1292 Instance,
1293 *NonVolatileOffset + sizeof (VARIABLE_HEADER),
1294 (UINT32) VarSize - sizeof (VARIABLE_HEADER),
1295 (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)
1296 );
1297
1298 if (EFI_ERROR (Status)) {
1299 goto Done;
1300 }
1301 //
1302 // Step 3:
1303 //
1304 NextVariable->State = VAR_ADDED;
1305 Status = UpdateVariableStore (
1306 &mVariableModuleGlobal->VariableGlobal,
1307 FALSE,
1308 TRUE,
1309 Instance,
1310 *NonVolatileOffset,
1311 sizeof (VARIABLE_HEADER),
1312 (UINT8 *) NextVariable
1313 );
1314
1315 if (EFI_ERROR (Status)) {
1316 goto Done;
1317 }
1318
1319 *NonVolatileOffset = *NonVolatileOffset + VarSize;
1320
1321 } else {
1322 //
1323 // Create a volatile variable
1324 //
1325 Variable.Volatile = TRUE;
1326
1327 if ((UINT32) (VarSize +*VolatileOffset) >
1328 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {
1329 //
1330 // Perform garbage collection & reclaim operation
1331 //
1332 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, VolatileOffset, TRUE);
1333 if (EFI_ERROR (Status)) {
1334 goto Done;
1335 }
1336 //
1337 // If still no enough space, return out of resources
1338 //
1339 if ((UINT32) (VarSize +*VolatileOffset) >
1340 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size
1341 ) {
1342 Status = EFI_OUT_OF_RESOURCES;
1343 goto Done;
1344 }
1345
1346 Reclaimed = TRUE;
1347 }
1348
1349 NextVariable->State = VAR_ADDED;
1350 Status = UpdateVariableStore (
1351 &mVariableModuleGlobal->VariableGlobal,
1352 TRUE,
1353 TRUE,
1354 Instance,
1355 *VolatileOffset,
1356 (UINT32) VarSize,
1357 (UINT8 *) NextVariable
1358 );
1359
1360 if (EFI_ERROR (Status)) {
1361 goto Done;
1362 }
1363
1364 *VolatileOffset = *VolatileOffset + VarSize;
1365 }
1366 //
1367 // Mark the old variable as deleted
1368 //
1369 if (!Reclaimed && !EFI_ERROR (Status) && Variable.CurrPtr != NULL) {
1370 State = Variable.CurrPtr->State;
1371 State &= VAR_DELETED;
1372
1373 Status = UpdateVariableStore (
1374 &mVariableModuleGlobal->VariableGlobal,
1375 Variable.Volatile,
1376 FALSE,
1377 Instance,
1378 (UINTN) &Variable.CurrPtr->State,
1379 sizeof (UINT8),
1380 &State
1381 );
1382
1383 if (!EFI_ERROR (Status)) {
1384 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, FALSE, TRUE, FALSE, FALSE);
1385 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1386 }
1387 goto Done;
1388 }
1389
1390 Status = EFI_SUCCESS;
1391 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, FALSE, TRUE, FALSE, FALSE);
1392 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1393
1394 Done:
1395 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1396 return Status;
1397 }
1398
1399
1400 /*++
1401
1402 Routine Description:
1403
1404 This code returns information about the EFI variables.
1405
1406 Arguments:
1407
1408 Attributes Attributes bitmask to specify the type of variables
1409 on which to return information.
1410 MaximumVariableStorageSize Pointer to the maximum size of the storage space available
1411 for the EFI variables associated with the attributes specified.
1412 RemainingVariableStorageSize Pointer to the remaining size of the storage space available
1413 for EFI variables associated with the attributes specified.
1414 MaximumVariableSize Pointer to the maximum size of an individual EFI variables
1415 associated with the attributes specified.
1416 Global Pointer to VARIABLE_GLOBAL structure.
1417 Instance Instance of the Firmware Volume.
1418
1419 Returns:
1420
1421 EFI STATUS
1422 EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
1423 EFI_SUCCESS - Query successfully.
1424 EFI_UNSUPPORTED - The attribute is not supported on this platform.
1425
1426 --*/
1427 EFI_STATUS
1428 EFIAPI
1429 RuntimeServiceQueryVariableInfo (
1430 IN UINT32 Attributes,
1431 OUT UINT64 *MaximumVariableStorageSize,
1432 OUT UINT64 *RemainingVariableStorageSize,
1433 OUT UINT64 *MaximumVariableSize
1434 )
1435 {
1436 VARIABLE_HEADER *Variable;
1437 VARIABLE_HEADER *NextVariable;
1438 UINT64 VariableSize;
1439 VARIABLE_STORE_HEADER *VariableStoreHeader;
1440
1441 if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {
1442 return EFI_INVALID_PARAMETER;
1443 }
1444
1445 if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {
1446 //
1447 // Make sure the Attributes combination is supported by the platform.
1448 //
1449 return EFI_UNSUPPORTED;
1450 } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1451 //
1452 // Make sure if runtime bit is set, boot service bit is set also.
1453 //
1454 return EFI_INVALID_PARAMETER;
1455 } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1456 //
1457 // Make sure RT Attribute is set if we are in Runtime phase.
1458 //
1459 return EFI_INVALID_PARAMETER;
1460 }
1461
1462 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1463
1464 if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
1465 //
1466 // Query is Volatile related.
1467 //
1468 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
1469 } else {
1470 //
1471 // Query is Non-Volatile related.
1472 //
1473 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1474 }
1475
1476 //
1477 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1478 // with the storage size (excluding the storage header size).
1479 //
1480 *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1481 *RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1482
1483 //
1484 // Let *MaximumVariableSize be MAX_VARIABLE_SIZE with the exception of the variable header size.
1485 //
1486 *MaximumVariableSize = MAX_VARIABLE_SIZE - sizeof (VARIABLE_HEADER);
1487
1488 //
1489 // Harware error record variable needs larger size.
1490 //
1491 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1492 *MaximumVariableSize = MAX_HARDWARE_ERROR_VARIABLE_SIZE - sizeof (VARIABLE_HEADER);
1493 }
1494
1495 //
1496 // Point to the starting address of the variables.
1497 //
1498 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1499
1500 //
1501 // Now walk through the related variable store.
1502 //
1503 while (IsValidVariableHeader (Variable) && (Variable < GetEndPointer (VariableStoreHeader))) {
1504 NextVariable = GetNextVariablePtr (Variable);
1505 VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
1506
1507 if (EfiAtRuntime ()) {
1508 //
1509 // we don't take the state of the variables in mind
1510 // when calculating RemainingVariableStorageSize,
1511 // since the space occupied by variables not marked with
1512 // VAR_ADDED is not allowed to be reclaimed in Runtime.
1513 //
1514 *RemainingVariableStorageSize -= VariableSize;
1515 } else {
1516 //
1517 // Only care about Variables with State VAR_ADDED,because
1518 // the space not marked as VAR_ADDED is reclaimable now.
1519 //
1520 if (Variable->State == VAR_ADDED) {
1521 *RemainingVariableStorageSize -= VariableSize;
1522 }
1523 }
1524
1525 //
1526 // Go to the next one
1527 //
1528 Variable = NextVariable;
1529 }
1530
1531 if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {
1532 *MaximumVariableSize = 0;
1533 } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {
1534 *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);
1535 }
1536
1537 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1538 return EFI_SUCCESS;
1539 }
1540
1541 EFI_STATUS
1542 VariableCommonInitialize (
1543 IN EFI_HANDLE ImageHandle,
1544 IN EFI_SYSTEM_TABLE *SystemTable
1545 )
1546 /*++
1547
1548 Routine Description:
1549 This function does common initialization for variable services
1550
1551 Arguments:
1552
1553 ImageHandle - The firmware allocated handle for the EFI image.
1554 SystemTable - A pointer to the EFI System Table.
1555
1556 Returns:
1557
1558 Status code.
1559
1560 EFI_NOT_FOUND - Variable store area not found.
1561 EFI_UNSUPPORTED - Currently only one non-volatile variable store is supported.
1562 EFI_SUCCESS - Variable services successfully initialized.
1563
1564 --*/
1565 {
1566 EFI_STATUS Status;
1567 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
1568 CHAR8 *CurrPtr;
1569 VARIABLE_STORE_HEADER *VolatileVariableStore;
1570 VARIABLE_STORE_HEADER *VariableStoreHeader;
1571 VARIABLE_HEADER *NextVariable;
1572 UINT32 Instance;
1573 EFI_PHYSICAL_ADDRESS FvVolHdr;
1574 UINT64 TempVariableStoreHeader;
1575 EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
1576 UINT64 BaseAddress;
1577 UINT64 Length;
1578 UINTN Index;
1579 UINT8 Data;
1580 UINT64 VariableStoreBase;
1581 UINT64 VariableStoreLength;
1582
1583
1584 EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);
1585
1586 //
1587 // Allocate memory for volatile variable store
1588 //
1589 VolatileVariableStore = AllocateRuntimePool (VARIABLE_STORE_SIZE + SCRATCH_SIZE);
1590 if (VolatileVariableStore == NULL) {
1591 FreePool (mVariableModuleGlobal);
1592 return EFI_OUT_OF_RESOURCES;
1593 }
1594
1595 SetMem (VolatileVariableStore, VARIABLE_STORE_SIZE + SCRATCH_SIZE, 0xff);
1596
1597 //
1598 // Variable Specific Data
1599 //
1600 mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;
1601 mVariableModuleGlobal->VolatileLastVariableOffset = sizeof (VARIABLE_STORE_HEADER);
1602
1603 VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE;
1604 VolatileVariableStore->Size = VARIABLE_STORE_SIZE;
1605 VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;
1606 VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;
1607 VolatileVariableStore->Reserved = 0;
1608 VolatileVariableStore->Reserved1 = 0;
1609
1610 //
1611 // Get non volatile varaible store
1612 //
1613
1614 TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase);
1615 VariableStoreBase = TempVariableStoreHeader + \
1616 (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
1617 VariableStoreLength = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \
1618 (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
1619 //
1620 // Mark the variable storage region of the FLASH as RUNTIME
1621 //
1622 BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);
1623 Length = VariableStoreLength + (VariableStoreBase - BaseAddress);
1624 Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
1625
1626 Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
1627 if (EFI_ERROR (Status)) {
1628 FreePool (mVariableModuleGlobal);
1629 FreePool (VolatileVariableStore);
1630 return EFI_UNSUPPORTED;
1631 }
1632
1633 Status = gDS->SetMemorySpaceAttributes (
1634 BaseAddress,
1635 Length,
1636 GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME
1637 );
1638 if (EFI_ERROR (Status)) {
1639 FreePool (mVariableModuleGlobal);
1640 FreePool (VolatileVariableStore);
1641 return EFI_UNSUPPORTED;
1642 }
1643 //
1644 // Get address of non volatile variable store base
1645 //
1646 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
1647
1648 //
1649 // Check Integrity
1650 //
1651 //
1652 // Find the Correct Instance of the FV Block Service.
1653 //
1654 Instance = 0;
1655 CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1656 while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) {
1657 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
1658 if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) {
1659 mVariableModuleGlobal->FvbInstance = Instance;
1660 break;
1661 }
1662
1663 Instance++;
1664 }
1665
1666 VariableStoreHeader = (VARIABLE_STORE_HEADER *) CurrPtr;
1667 if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
1668 if (~VariableStoreHeader->Size == 0) {
1669 Status = UpdateVariableStore (
1670 &mVariableModuleGlobal->VariableGlobal,
1671 FALSE,
1672 FALSE,
1673 mVariableModuleGlobal->FvbInstance,
1674 (UINTN) &VariableStoreHeader->Size,
1675 sizeof (UINT32),
1676 (UINT8 *) &VariableStoreLength
1677 );
1678 //
1679 // As Variables are stored in NV storage, which are slow devices,such as flash.
1680 // Variable operation may skip checking variable program result to improve performance,
1681 // We can assume Variable program is OK through some check point.
1682 // Variable Store Size Setting should be the first Variable write operation,
1683 // We can assume all Read/Write is OK if we can set Variable store size successfully.
1684 // If write fail, we will assert here
1685 //
1686 ASSERT(VariableStoreHeader->Size == VariableStoreLength);
1687
1688 if (EFI_ERROR (Status)) {
1689 return Status;
1690 }
1691 }
1692
1693 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) CurrPtr);
1694 //
1695 // Parse non-volatile variable data and get last variable offset
1696 //
1697 NextVariable = (VARIABLE_HEADER *) (CurrPtr + sizeof (VARIABLE_STORE_HEADER));
1698 Status = EFI_SUCCESS;
1699
1700 while (IsValidVariableHeader (NextVariable)) {
1701 NextVariable = GetNextVariablePtr (NextVariable);
1702 }
1703
1704 mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) CurrPtr;
1705
1706 //
1707 // Check if the free area is blow a threshold
1708 //
1709 if ((((VARIABLE_STORE_HEADER *)((UINTN) CurrPtr))->Size - mVariableModuleGlobal->NonVolatileLastVariableOffset) < VARIABLE_RECLAIM_THRESHOLD) {
1710 Status = Reclaim (
1711 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
1712 &mVariableModuleGlobal->NonVolatileLastVariableOffset,
1713 FALSE
1714 );
1715 }
1716
1717 if (EFI_ERROR (Status)) {
1718 FreePool (mVariableModuleGlobal);
1719 FreePool (VolatileVariableStore);
1720 return Status;
1721 }
1722
1723 //
1724 // Check if the free area is really free.
1725 //
1726 for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) {
1727 Data = ((UINT8 *) (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)[Index];
1728 if (Data != 0xff) {
1729 //
1730 // There must be something wrong in variable store, do reclaim operation.
1731 //
1732 Status = Reclaim (
1733 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
1734 &mVariableModuleGlobal->NonVolatileLastVariableOffset,
1735 FALSE
1736 );
1737 break;
1738 }
1739 }
1740 }
1741
1742 if (EFI_ERROR (Status)) {
1743 FreePool (mVariableModuleGlobal);
1744 FreePool (VolatileVariableStore);
1745 }
1746
1747 return Status;
1748 }
1749
1750
1751
1752
1753 VOID
1754 EFIAPI
1755 VariableClassAddressChangeEvent (
1756 IN EFI_EVENT Event,
1757 IN VOID *Context
1758 )
1759 {
1760 EfiConvertPointer (
1761 0x0,
1762 (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase
1763 );
1764 EfiConvertPointer (
1765 0x0,
1766 (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase
1767 );
1768 EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
1769 }
1770
1771
1772 /**
1773 Variable Driver main entry point. The Variable driver places the 4 EFI
1774 runtime services in the EFI System Table and installs arch protocols
1775 for variable read and write services being availible.
1776
1777 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1778 @param[in] SystemTable A pointer to the EFI System Table.
1779
1780 @retval EFI_SUCCESS The entry point is executed successfully.
1781 @retval other Some error occurs when executing this entry point.
1782
1783 **/
1784 EFI_STATUS
1785 EFIAPI
1786 VariableServiceInitialize (
1787 IN EFI_HANDLE ImageHandle,
1788 IN EFI_SYSTEM_TABLE *SystemTable
1789 )
1790 {
1791 EFI_STATUS Status;
1792
1793 Status = VariableCommonInitialize (ImageHandle, SystemTable);
1794 ASSERT_EFI_ERROR (Status);
1795
1796 SystemTable->RuntimeServices->GetVariable = RuntimeServiceGetVariable;
1797 SystemTable->RuntimeServices->GetNextVariableName = RuntimeServiceGetNextVariableName;
1798 SystemTable->RuntimeServices->SetVariable = RuntimeServiceSetVariable;
1799 SystemTable->RuntimeServices->QueryVariableInfo = RuntimeServiceQueryVariableInfo;
1800
1801 //
1802 // Now install the Variable Runtime Architectural Protocol on a new handle
1803 //
1804 Status = gBS->InstallMultipleProtocolInterfaces (
1805 &mHandle,
1806 &gEfiVariableArchProtocolGuid, NULL,
1807 &gEfiVariableWriteArchProtocolGuid, NULL,
1808 NULL
1809 );
1810 ASSERT_EFI_ERROR (Status);
1811
1812 Status = gBS->CreateEvent (
1813 EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
1814 TPL_NOTIFY,
1815 VariableClassAddressChangeEvent,
1816 NULL,
1817 &mVirtualAddressChangeEvent
1818 );
1819 ASSERT_EFI_ERROR (Status);
1820
1821 return EFI_SUCCESS;
1822 }
1823
EFI Development Kit II mirror for PVE