]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add comments and DoxyGen format for these files.
[mirror_edk2.git] / MdeModulePkg / Universal / Variable / RuntimeDxe / Variable.c
1 /** @file
2
3 Implement all four UEFI Runtime Variable services for the nonvolatile
4 and volatile storage space and install variable architecture protocol.
5
6 Copyright (c) 2006 - 2008, Intel Corporation
7 All rights reserved. This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17
18 #include "Variable.h"
19
20 VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal;
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 BOOLEAN
156 IsValidVariableHeader (
157 IN VARIABLE_HEADER *Variable
158 )
159 /*++
160
161 Routine Description:
162
163 This code checks if variable header is valid or not.
164
165 Arguments:
166 Variable Pointer to the Variable Header.
167
168 Returns:
169 TRUE Variable header is valid.
170 FALSE Variable header is not valid.
171
172 --*/
173 {
174 if (Variable == NULL || Variable->StartId != VARIABLE_DATA) {
175 return FALSE;
176 }
177
178 return TRUE;
179 }
180
181
182 EFI_STATUS
183 UpdateVariableStore (
184 IN VARIABLE_GLOBAL *Global,
185 IN BOOLEAN Volatile,
186 IN BOOLEAN SetByIndex,
187 IN UINTN Instance,
188 IN UINTN DataPtrIndex,
189 IN UINT32 DataSize,
190 IN UINT8 *Buffer
191 )
192 /*++
193
194 Routine Description:
195
196 This function writes data to the FWH at the correct LBA even if the LBAs
197 are fragmented.
198
199 Arguments:
200
201 Global - Pointer to VARAIBLE_GLOBAL structure
202 Volatile - If the Variable is Volatile or Non-Volatile
203 SetByIndex - TRUE: Target pointer is given as index
204 FALSE: Target pointer is absolute
205 Instance - Instance of FV Block services
206 DataPtrIndex - Pointer to the Data from the end of VARIABLE_STORE_HEADER
207 structure
208 DataSize - Size of data to be written.
209 Buffer - Pointer to the buffer from which data is written
210
211 Returns:
212
213 EFI_INVALID_PARAMETER - Parameters not valid
214 EFI_SUCCESS - Variable store successfully updated
215
216 --*/
217 {
218 EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;
219 UINTN BlockIndex2;
220 UINTN LinearOffset;
221 UINTN CurrWriteSize;
222 UINTN CurrWritePtr;
223 UINT8 *CurrBuffer;
224 EFI_LBA LbaNumber;
225 UINTN Size;
226 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
227 VARIABLE_STORE_HEADER *VolatileBase;
228 EFI_PHYSICAL_ADDRESS FvVolHdr;
229 EFI_PHYSICAL_ADDRESS DataPtr;
230 EFI_STATUS Status;
231
232 FwVolHeader = NULL;
233 DataPtr = DataPtrIndex;
234
235 //
236 // Check if the Data is Volatile
237 //
238 if (!Volatile) {
239 EfiFvbGetPhysicalAddress (Instance, &FvVolHdr);
240 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
241 //
242 // Data Pointer should point to the actual Address where data is to be
243 // written
244 //
245 if (SetByIndex) {
246 DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;
247 }
248
249 if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {
250 return EFI_INVALID_PARAMETER;
251 }
252 } else {
253 //
254 // Data Pointer should point to the actual Address where data is to be
255 // written
256 //
257 VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
258 if (SetByIndex) {
259 DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;
260 }
261
262 if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {
263 return EFI_INVALID_PARAMETER;
264 }
265
266 //
267 // If Volatile Variable just do a simple mem copy.
268 //
269 CopyMem ((UINT8 *)(UINTN)DataPtr, Buffer, DataSize);
270 return EFI_SUCCESS;
271 }
272
273 //
274 // If we are here we are dealing with Non-Volatile Variables
275 //
276 LinearOffset = (UINTN) FwVolHeader;
277 CurrWritePtr = (UINTN) DataPtr;
278 CurrWriteSize = DataSize;
279 CurrBuffer = Buffer;
280 LbaNumber = 0;
281
282 if (CurrWritePtr < LinearOffset) {
283 return EFI_INVALID_PARAMETER;
284 }
285
286 for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {
287 for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {
288 //
289 // Check to see if the Variable Writes are spanning through multiple
290 // blocks.
291 //
292 if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->Length)) {
293 if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->Length)) {
294 Status = EfiFvbWriteBlock (
295 Instance,
296 LbaNumber,
297 (UINTN) (CurrWritePtr - LinearOffset),
298 &CurrWriteSize,
299 CurrBuffer
300 );
301 return Status;
302 } else {
303 Size = (UINT32) (LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);
304 Status = EfiFvbWriteBlock (
305 Instance,
306 LbaNumber,
307 (UINTN) (CurrWritePtr - LinearOffset),
308 &Size,
309 CurrBuffer
310 );
311 if (EFI_ERROR (Status)) {
312 return Status;
313 }
314
315 CurrWritePtr = LinearOffset + PtrBlockMapEntry->Length;
316 CurrBuffer = CurrBuffer + Size;
317 CurrWriteSize = CurrWriteSize - Size;
318 }
319 }
320
321 LinearOffset += PtrBlockMapEntry->Length;
322 LbaNumber++;
323 }
324 }
325
326 return EFI_SUCCESS;
327 }
328
329
330 VARIABLE_STORE_STATUS
331 GetVariableStoreStatus (
332 IN VARIABLE_STORE_HEADER *VarStoreHeader
333 )
334 /*++
335
336 Routine Description:
337
338 This code gets the current status of Variable Store.
339
340 Arguments:
341
342 VarStoreHeader Pointer to the Variable Store Header.
343
344 Returns:
345
346 EfiRaw Variable store status is raw
347 EfiValid Variable store status is valid
348 EfiInvalid Variable store status is invalid
349
350 --*/
351 {
352 if (VarStoreHeader->Signature == VARIABLE_STORE_SIGNATURE &&
353 VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
354 VarStoreHeader->State == VARIABLE_STORE_HEALTHY
355 ) {
356
357 return EfiValid;
358 } else if (VarStoreHeader->Signature == 0xffffffff &&
359 VarStoreHeader->Size == 0xffffffff &&
360 VarStoreHeader->Format == 0xff &&
361 VarStoreHeader->State == 0xff
362 ) {
363
364 return EfiRaw;
365 } else {
366 return EfiInvalid;
367 }
368 }
369
370
371 UINTN
372 NameSizeOfVariable (
373 IN VARIABLE_HEADER *Variable
374 )
375 /*++
376
377 Routine Description:
378
379 This code gets the size of name of variable.
380
381 Arguments:
382
383 Variable Pointer to the Variable Header.
384
385 Returns:
386
387 UINTN Size of variable in bytes
388
389 --*/
390 {
391 if (Variable->State == (UINT8) (-1) ||
392 Variable->DataSize == (UINT32) -1 ||
393 Variable->NameSize == (UINT32) -1 ||
394 Variable->Attributes == (UINT32) -1) {
395 return 0;
396 }
397 return (UINTN) Variable->NameSize;
398 }
399
400 UINTN
401 DataSizeOfVariable (
402 IN VARIABLE_HEADER *Variable
403 )
404 /*++
405
406 Routine Description:
407
408 This code gets the size of name of variable.
409
410 Arguments:
411
412 Variable Pointer to the Variable Header.
413
414 Returns:
415
416 UINTN Size of variable in bytes
417
418 --*/
419 {
420 if (Variable->State == (UINT8) -1 ||
421 Variable->DataSize == (UINT32) -1 ||
422 Variable->NameSize == (UINT32) -1 ||
423 Variable->Attributes == (UINT32) -1) {
424 return 0;
425 }
426 return (UINTN) Variable->DataSize;
427 }
428
429 CHAR16 *
430 GetVariableNamePtr (
431 IN VARIABLE_HEADER *Variable
432 )
433 /*++
434
435 Routine Description:
436
437 This code gets the pointer to the variable name.
438
439 Arguments:
440
441 Variable Pointer to the Variable Header.
442
443 Returns:
444
445 CHAR16* Pointer to Variable Name
446
447 --*/
448 {
449
450 return (CHAR16 *) (Variable + 1);
451 }
452
453 UINT8 *
454 GetVariableDataPtr (
455 IN VARIABLE_HEADER *Variable
456 )
457 /*++
458
459 Routine Description:
460
461 This code gets the pointer to the variable data.
462
463 Arguments:
464
465 Variable Pointer to the Variable Header.
466
467 Returns:
468
469 UINT8* Pointer to Variable Data
470
471 --*/
472 {
473 UINTN Value;
474
475 //
476 // Be careful about pad size for alignment
477 //
478 Value = (UINTN) GetVariableNamePtr (Variable);
479 Value += NameSizeOfVariable (Variable);
480 Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));
481
482 return (UINT8 *) Value;
483 }
484
485
486 VARIABLE_HEADER *
487 GetNextVariablePtr (
488 IN VARIABLE_HEADER *Variable
489 )
490 /*++
491
492 Routine Description:
493
494 This code gets the pointer to the next variable header.
495
496 Arguments:
497
498 Variable Pointer to the Variable Header.
499
500 Returns:
501
502 VARIABLE_HEADER* Pointer to next variable header.
503
504 --*/
505 {
506 UINTN Value;
507
508 if (!IsValidVariableHeader (Variable)) {
509 return NULL;
510 }
511
512 Value = (UINTN) GetVariableDataPtr (Variable);
513 Value += DataSizeOfVariable (Variable);
514 Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));
515
516 //
517 // Be careful about pad size for alignment
518 //
519 return (VARIABLE_HEADER *) HEADER_ALIGN (Value);
520 }
521
522 VARIABLE_HEADER *
523 GetStartPointer (
524 IN VARIABLE_STORE_HEADER *VarStoreHeader
525 )
526 /*++
527
528 Routine Description:
529
530 This code gets the pointer to the first variable memory pointer byte
531
532 Arguments:
533
534 VarStoreHeader Pointer to the Variable Store Header.
535
536 Returns:
537
538 VARIABLE_HEADER* Pointer to last unavailable Variable Header
539
540 --*/
541 {
542 //
543 // The end of variable store
544 //
545 return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);
546 }
547
548 VARIABLE_HEADER *
549 GetEndPointer (
550 IN VARIABLE_STORE_HEADER *VarStoreHeader
551 )
552 /*++
553
554 Routine Description:
555
556 This code gets the pointer to the last variable memory pointer byte
557
558 Arguments:
559
560 VarStoreHeader Pointer to the Variable Store Header.
561
562 Returns:
563
564 VARIABLE_HEADER* Pointer to last unavailable Variable Header
565
566 --*/
567 {
568 //
569 // The end of variable store
570 //
571 return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);
572 }
573
574
575 EFI_STATUS
576 Reclaim (
577 IN EFI_PHYSICAL_ADDRESS VariableBase,
578 OUT UINTN *LastVariableOffset,
579 IN BOOLEAN IsVolatile,
580 IN VARIABLE_HEADER *UpdatingVariable
581 )
582 /*++
583
584 Routine Description:
585
586 Variable store garbage collection and reclaim operation
587
588 Arguments:
589
590 VariableBase Base address of variable store
591 LastVariableOffset Offset of last variable
592 IsVolatile The variable store is volatile or not,
593 if it is non-volatile, need FTW
594
595 Returns:
596
597 EFI STATUS
598
599 --*/
600 {
601 VARIABLE_HEADER *Variable;
602 VARIABLE_HEADER *AddedVariable;
603 VARIABLE_HEADER *NextVariable;
604 VARIABLE_HEADER *NextAddedVariable;
605 VARIABLE_STORE_HEADER *VariableStoreHeader;
606 UINT8 *ValidBuffer;
607 UINTN MaximumBufferSize;
608 UINTN VariableSize;
609 UINTN NameSize;
610 UINT8 *CurrPtr;
611 VOID *Point0;
612 VOID *Point1;
613 BOOLEAN FoundAdded;
614 EFI_STATUS Status;
615
616 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);
617
618 //
619 // Start Pointers for the variable.
620 //
621 Variable = GetStartPointer (VariableStoreHeader);
622 MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);
623
624 while (IsValidVariableHeader (Variable)) {
625 NextVariable = GetNextVariablePtr (Variable);
626 if (Variable->State == VAR_ADDED ||
627 Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)
628 ) {
629 VariableSize = (UINTN) NextVariable - (UINTN) Variable;
630 MaximumBufferSize += VariableSize;
631 }
632
633 Variable = NextVariable;
634 }
635
636 //
637 // Reserve the 1 Bytes with Oxff to identify the
638 // end of the variable buffer.
639 //
640 MaximumBufferSize += 1;
641 ValidBuffer = AllocatePool (MaximumBufferSize);
642 if (ValidBuffer == NULL) {
643 return EFI_OUT_OF_RESOURCES;
644 }
645
646 SetMem (ValidBuffer, MaximumBufferSize, 0xff);
647
648 //
649 // Copy variable store header
650 //
651 CopyMem (ValidBuffer, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));
652 CurrPtr = (UINT8 *) GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);
653
654 //
655 // Start Pointers for the variable.
656 //
657
658 //
659 // Reinstall all ADDED variables
660 //
661 Variable = GetStartPointer (VariableStoreHeader);
662 while (IsValidVariableHeader (Variable)) {
663 NextVariable = GetNextVariablePtr (Variable);
664 if (Variable->State == VAR_ADDED) {
665 VariableSize = (UINTN) NextVariable - (UINTN) Variable;
666 CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
667 CurrPtr += VariableSize;
668 }
669
670 Variable = NextVariable;
671 }
672 //
673 // Reinstall all in delete transition variables
674 //
675 Variable = GetStartPointer (VariableStoreHeader);
676 while (IsValidVariableHeader (Variable)) {
677 NextVariable = GetNextVariablePtr (Variable);
678 if (Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
679
680 //
681 // Buffer has cached all ADDED variable.
682 // Per IN_DELETED variable, we have to guarantee that
683 // no ADDED one in previous buffer.
684 //
685
686 FoundAdded = FALSE;
687 AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);
688 while (IsValidVariableHeader (AddedVariable)) {
689 NextAddedVariable = GetNextVariablePtr (AddedVariable);
690 NameSize = NameSizeOfVariable (AddedVariable);
691 if (CompareGuid (&AddedVariable->VendorGuid, &Variable->VendorGuid) &&
692 NameSize == NameSizeOfVariable (Variable)
693 ) {
694 Point0 = (VOID *) GetVariableNamePtr (AddedVariable);
695 Point1 = (VOID *) GetVariableNamePtr (Variable);
696 if (!CompareMem (
697 Point0,
698 Point1,
699 NameSizeOfVariable (AddedVariable)
700 )
701 ) {
702 FoundAdded = TRUE;
703 break;
704 }
705 }
706 AddedVariable = NextAddedVariable;
707 }
708 if (!FoundAdded) {
709 VariableSize = (UINTN) NextVariable - (UINTN) Variable;
710 CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);
711 if (Variable != UpdatingVariable) {
712 ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;
713 }
714 CurrPtr += VariableSize;
715 }
716 }
717
718 Variable = NextVariable;
719 }
720
721 if (IsVolatile) {
722 //
723 // If volatile variable store, just copy valid buffer
724 //
725 SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);
726 CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, (UINTN) (CurrPtr - (UINT8 *) ValidBuffer));
727 Status = EFI_SUCCESS;
728 } else {
729 //
730 // If non-volatile variable store, perform FTW here.
731 //
732 Status = FtwVariableSpace (
733 VariableBase,
734 ValidBuffer,
735 (UINTN) (CurrPtr - (UINT8 *) ValidBuffer)
736 );
737 }
738 if (!EFI_ERROR (Status)) {
739 *LastVariableOffset = (UINTN) (CurrPtr - (UINT8 *) ValidBuffer);
740 } else {
741 *LastVariableOffset = 0;
742 }
743
744 FreePool (ValidBuffer);
745
746 return Status;
747 }
748
749
750 //
751 // The current Hii implementation accesses this variable a larg # of times on every boot.
752 // Other common variables are only accessed a single time. This is why this cache algorithm
753 // only targets a single variable. Probably to get an performance improvement out of
754 // a Cache you would need a cache that improves the search performance for a variable.
755 //
756 VARIABLE_CACHE_ENTRY mVariableCache[] = {
757 {
758 &gEfiGlobalVariableGuid,
759 L"Lang",
760 0x00000000,
761 0x00,
762 NULL
763 }
764 };
765
766
767 /**
768 Update the Cache with Variable information. These are the same
769 arguments as the EFI Variable services.
770
771 @param[in] VariableName Name of variable
772 @param[in] VendorGuid Guid of variable
773 @param[in] Attribute Attribue of the variable
774 @param[in] DataSize Size of data. 0 means delete
775 @param[in] Data Variable data
776
777 **/
778 VOID
779 UpdateVariableCache (
780 IN CHAR16 *VariableName,
781 IN EFI_GUID *VendorGuid,
782 IN UINT32 Attributes,
783 IN UINTN DataSize,
784 IN VOID *Data
785 )
786 {
787 VARIABLE_CACHE_ENTRY *Entry;
788 UINTN Index;
789
790 if (EfiAtRuntime ()) {
791 // Don't use the cache at runtime
792 return;
793 }
794
795 for (Index = 0, Entry = mVariableCache; Index < sizeof (mVariableCache)/sizeof (VARIABLE_CACHE_ENTRY); Index++, Entry++) {
796 if (CompareGuid (VendorGuid, Entry->Guid)) {
797 if (StrCmp (VariableName, Entry->Name) == 0) {
798 Entry->Attributes = Attributes;
799 if (DataSize == 0) {
800 // Delete Case
801 if (Entry->DataSize != 0) {
802 FreePool (Entry->Data);
803 }
804 Entry->DataSize = DataSize;
805 } else if (DataSize == Entry->DataSize) {
806 CopyMem (Entry->Data, Data, DataSize);
807 } else {
808 Entry->Data = AllocatePool (DataSize);
809 Entry->DataSize = DataSize;
810 CopyMem (Entry->Data, Data, DataSize);
811 }
812 }
813 }
814 }
815 }
816
817
818 /**
819 Search the cache to see if the variable is in the cache.
820
821 @param[in] VariableName Name of variable
822 @param[in] VendorGuid Guid of variable
823 @param[in] Attribute Attribue returned
824 @param[in] DataSize Size of data returned
825 @param[in] Data Variable data returned
826
827 @retval EFI_SUCCESS VariableGuid & VariableName data was returned.
828 @retval other Not found.
829
830 **/
831 EFI_STATUS
832 FindVariableInCache (
833 IN CHAR16 *VariableName,
834 IN EFI_GUID *VendorGuid,
835 OUT UINT32 *Attributes OPTIONAL,
836 IN OUT UINTN *DataSize,
837 OUT VOID *Data
838 )
839 {
840 VARIABLE_CACHE_ENTRY *Entry;
841 UINTN Index;
842
843 if (EfiAtRuntime ()) {
844 // Don't use the cache at runtime
845 return EFI_NOT_FOUND;
846 }
847
848 for (Index = 0, Entry = mVariableCache; Index < sizeof (mVariableCache)/sizeof (VARIABLE_CACHE_ENTRY); Index++, Entry++) {
849 if (CompareGuid (VendorGuid, Entry->Guid)) {
850 if (StrCmp (VariableName, Entry->Name) == 0) {
851 if (Entry->DataSize == 0) {
852 // Variable was deleted so return not found
853 return EFI_NOT_FOUND;
854 } else if (Entry->DataSize > *DataSize) {
855 // If the buffer is too small return correct size
856 *DataSize = Entry->DataSize;
857 return EFI_BUFFER_TOO_SMALL;
858 } else {
859 *DataSize = Entry->DataSize;
860 // Return the data
861 CopyMem (Data, Entry->Data, Entry->DataSize);
862 if (Attributes != NULL) {
863 *Attributes = Entry->Attributes;
864 }
865 return EFI_SUCCESS;
866 }
867 }
868 }
869 }
870
871 return EFI_NOT_FOUND;
872 }
873
874
875 EFI_STATUS
876 FindVariable (
877 IN CHAR16 *VariableName,
878 IN EFI_GUID *VendorGuid,
879 OUT VARIABLE_POINTER_TRACK *PtrTrack,
880 IN VARIABLE_GLOBAL *Global
881 )
882 /*++
883
884 Routine Description:
885
886 This code finds variable in storage blocks (Volatile or Non-Volatile)
887
888 Arguments:
889
890 VariableName Name of the variable to be found
891 VendorGuid Vendor GUID to be found.
892 PtrTrack Variable Track Pointer structure that contains
893 Variable Information.
894 Contains the pointer of Variable header.
895 Global VARIABLE_GLOBAL pointer
896
897 Returns:
898
899 EFI STATUS
900
901 --*/
902 {
903 VARIABLE_HEADER *Variable[2];
904 VARIABLE_HEADER *InDeletedVariable;
905 VARIABLE_STORE_HEADER *VariableStoreHeader[2];
906 UINTN InDeletedStorageIndex;
907 UINTN Index;
908 VOID *Point;
909
910 //
911 // 0: Volatile, 1: Non-Volatile
912 // The index and attributes mapping must be kept in this order as RuntimeServiceGetNextVariableName
913 // make use of this mapping to implement search algorithme.
914 //
915 VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
916 VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
917
918 //
919 // Start Pointers for the variable.
920 // Actual Data Pointer where data can be written.
921 //
922 Variable[0] = GetStartPointer (VariableStoreHeader[0]);
923 Variable[1] = GetStartPointer (VariableStoreHeader[1]);
924
925 if (VariableName[0] != 0 && VendorGuid == NULL) {
926 return EFI_INVALID_PARAMETER;
927 }
928
929 //
930 // Find the variable by walk through volatile and then non-volatile variable store
931 //
932 InDeletedVariable = NULL;
933 InDeletedStorageIndex = 0;
934 for (Index = 0; Index < 2; Index++) {
935 while (IsValidVariableHeader (Variable[Index]) && (Variable[Index] <= GetEndPointer (VariableStoreHeader[Index]))) {
936 if (Variable[Index]->State == VAR_ADDED ||
937 Variable[Index]->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)
938 ) {
939 if (!EfiAtRuntime () || (Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
940 if (VariableName[0] == 0) {
941 if (Variable[Index]->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
942 InDeletedVariable = Variable[Index];
943 InDeletedStorageIndex = Index;
944 } else {
945 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Index]);
946 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);
947 PtrTrack->CurrPtr = Variable[Index];
948 PtrTrack->Volatile = (BOOLEAN)(Index == 0);
949
950 return EFI_SUCCESS;
951 }
952 } else {
953 if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {
954 Point = (VOID *) GetVariableNamePtr (Variable[Index]);
955
956 ASSERT (NameSizeOfVariable (Variable[Index]) != 0);
957 if (!CompareMem (VariableName, Point, NameSizeOfVariable (Variable[Index]))) {
958 if (Variable[Index]->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
959 InDeletedVariable = Variable[Index];
960 InDeletedStorageIndex = Index;
961 } else {
962 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Index]);
963 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);
964 PtrTrack->CurrPtr = Variable[Index];
965 PtrTrack->Volatile = (BOOLEAN)(Index == 0);
966
967 return EFI_SUCCESS;
968 }
969 }
970 }
971 }
972 }
973 }
974
975 Variable[Index] = GetNextVariablePtr (Variable[Index]);
976 }
977 if (InDeletedVariable != NULL) {
978 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[InDeletedStorageIndex]);
979 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[InDeletedStorageIndex]);
980 PtrTrack->CurrPtr = InDeletedVariable;
981 PtrTrack->Volatile = (BOOLEAN)(InDeletedStorageIndex == 0);
982 return EFI_SUCCESS;
983 }
984 }
985 PtrTrack->CurrPtr = NULL;
986 return EFI_NOT_FOUND;
987 }
988
989
990
991 /*++
992
993 Routine Description:
994
995 This code finds variable in storage blocks (Volatile or Non-Volatile)
996
997 Arguments:
998
999 VariableName Name of Variable to be found
1000 VendorGuid Variable vendor GUID
1001 Attributes OPTIONAL Attribute value of the variable found
1002 DataSize Size of Data found. If size is less than the
1003 data, this value contains the required size.
1004 Data Data pointer
1005 Global Pointer to VARIABLE_GLOBAL structure
1006 Instance Instance of the Firmware Volume.
1007
1008 Returns:
1009
1010 EFI_INVALID_PARAMETER - Invalid parameter
1011 EFI_SUCCESS - Find the specified variable
1012 EFI_NOT_FOUND - Not found
1013 EFI_BUFFER_TO_SMALL - DataSize is too small for the result
1014
1015
1016 --*/
1017 EFI_STATUS
1018 EFIAPI
1019 RuntimeServiceGetVariable (
1020 IN CHAR16 *VariableName,
1021 IN EFI_GUID *VendorGuid,
1022 OUT UINT32 *Attributes OPTIONAL,
1023 IN OUT UINTN *DataSize,
1024 OUT VOID *Data
1025 )
1026 {
1027 EFI_STATUS Status;
1028 VARIABLE_POINTER_TRACK Variable;
1029 UINTN VarDataSize;
1030
1031 if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
1032 return EFI_INVALID_PARAMETER;
1033 }
1034
1035 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1036
1037 //
1038 // Find existing variable
1039 //
1040 Status = FindVariableInCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1041 if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_SUCCESS)){
1042 // Hit in the Cache
1043 UpdateVariableInfo (VariableName, VendorGuid, FALSE, TRUE, FALSE, FALSE, TRUE);
1044 goto Done;
1045 }
1046
1047 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
1048 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
1049 goto Done;
1050 }
1051
1052 //
1053 // Get data size
1054 //
1055 VarDataSize = DataSizeOfVariable (Variable.CurrPtr);
1056 ASSERT (VarDataSize != 0);
1057
1058 if (*DataSize >= VarDataSize) {
1059 if (Data == NULL) {
1060 Status = EFI_INVALID_PARAMETER;
1061 goto Done;
1062 }
1063
1064 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
1065 if (Attributes != NULL) {
1066 *Attributes = Variable.CurrPtr->Attributes;
1067 }
1068
1069 *DataSize = VarDataSize;
1070 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);
1071 UpdateVariableCache (VariableName, VendorGuid, Variable.CurrPtr->Attributes, VarDataSize, Data);
1072
1073 Status = EFI_SUCCESS;
1074 goto Done;
1075 } else {
1076 *DataSize = VarDataSize;
1077 Status = EFI_BUFFER_TOO_SMALL;
1078 goto Done;
1079 }
1080
1081 Done:
1082 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1083 return Status;
1084 }
1085
1086
1087
1088 /*++
1089
1090 Routine Description:
1091
1092 This code Finds the Next available variable
1093
1094 Arguments:
1095
1096 VariableNameSize Size of the variable
1097 VariableName Pointer to variable name
1098 VendorGuid Variable Vendor Guid
1099 Global VARIABLE_GLOBAL structure pointer.
1100 Instance FV instance
1101
1102 Returns:
1103
1104 EFI STATUS
1105
1106 --*/
1107 EFI_STATUS
1108 EFIAPI
1109 RuntimeServiceGetNextVariableName (
1110 IN OUT UINTN *VariableNameSize,
1111 IN OUT CHAR16 *VariableName,
1112 IN OUT EFI_GUID *VendorGuid
1113 )
1114 {
1115 VARIABLE_POINTER_TRACK Variable;
1116 UINTN VarNameSize;
1117 EFI_STATUS Status;
1118
1119 if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
1120 return EFI_INVALID_PARAMETER;
1121 }
1122
1123 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1124
1125 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
1126 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
1127 goto Done;
1128 }
1129
1130 if (VariableName[0] != 0) {
1131 //
1132 // If variable name is not NULL, get next variable
1133 //
1134 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
1135 }
1136
1137 while (TRUE) {
1138 //
1139 // If both volatile and non-volatile variable store are parsed,
1140 // return not found
1141 //
1142 if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
1143 Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));
1144 if (!Variable.Volatile) {
1145 Variable.StartPtr = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1146 Variable.EndPtr = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase));
1147 } else {
1148 Status = EFI_NOT_FOUND;
1149 goto Done;
1150 }
1151
1152 Variable.CurrPtr = Variable.StartPtr;
1153 if (!IsValidVariableHeader (Variable.CurrPtr)) {
1154 continue;
1155 }
1156 }
1157 //
1158 // Variable is found
1159 //
1160 if (IsValidVariableHeader (Variable.CurrPtr) && Variable.CurrPtr->State == VAR_ADDED) {
1161 if (!(EfiAtRuntime () && !(Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {
1162 VarNameSize = NameSizeOfVariable (Variable.CurrPtr);
1163 ASSERT (VarNameSize != 0);
1164
1165 if (VarNameSize <= *VariableNameSize) {
1166 CopyMem (
1167 VariableName,
1168 GetVariableNamePtr (Variable.CurrPtr),
1169 VarNameSize
1170 );
1171 CopyMem (
1172 VendorGuid,
1173 &Variable.CurrPtr->VendorGuid,
1174 sizeof (EFI_GUID)
1175 );
1176 Status = EFI_SUCCESS;
1177 } else {
1178 Status = EFI_BUFFER_TOO_SMALL;
1179 }
1180
1181 *VariableNameSize = VarNameSize;
1182 goto Done;
1183 }
1184 }
1185
1186 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
1187 }
1188
1189 Done:
1190 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1191 return Status;
1192 }
1193
1194
1195 /*++
1196
1197 Routine Description:
1198
1199 This code sets variable in storage blocks (Volatile or Non-Volatile)
1200
1201 Arguments:
1202
1203 VariableName Name of Variable to be found
1204 VendorGuid Variable vendor GUID
1205 Attributes Attribute value of the variable found
1206 DataSize Size of Data found. If size is less than the
1207 data, this value contains the required size.
1208 Data Data pointer
1209 Global Pointer to VARIABLE_GLOBAL structure
1210 VolatileOffset The offset of last volatile variable
1211 NonVolatileOffset The offset of last non-volatile variable
1212 Instance Instance of the Firmware Volume.
1213
1214 Returns:
1215
1216 EFI_INVALID_PARAMETER - Invalid parameter
1217 EFI_SUCCESS - Set successfully
1218 EFI_OUT_OF_RESOURCES - Resource not enough to set variable
1219 EFI_NOT_FOUND - Not found
1220 EFI_DEVICE_ERROR - Variable can not be saved due to hardware failure
1221 EFI_WRITE_PROTECTED - Variable is read-only
1222
1223 --*/
1224 EFI_STATUS
1225 EFIAPI
1226 RuntimeServiceSetVariable (
1227 IN CHAR16 *VariableName,
1228 IN EFI_GUID *VendorGuid,
1229 IN UINT32 Attributes,
1230 IN UINTN DataSize,
1231 IN VOID *Data
1232 )
1233 {
1234 VARIABLE_POINTER_TRACK Variable;
1235 EFI_STATUS Status;
1236 VARIABLE_HEADER *NextVariable;
1237 UINTN VarNameSize;
1238 UINTN VarNameOffset;
1239 UINTN VarDataOffset;
1240 UINTN VarSize;
1241 UINT8 State;
1242 BOOLEAN Reclaimed;
1243 UINTN *VolatileOffset;
1244 UINTN *NonVolatileOffset;
1245 UINT32 Instance;
1246 BOOLEAN Volatile;
1247 EFI_PHYSICAL_ADDRESS Point;
1248
1249 //
1250 // Check input parameters
1251 //
1252 if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
1253 return EFI_INVALID_PARAMETER;
1254 }
1255 //
1256 // Make sure if runtime bit is set, boot service bit is set also
1257 //
1258 if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1259 return EFI_INVALID_PARAMETER;
1260 }
1261
1262 //
1263 // The size of the VariableName, including the Unicode Null in bytes plus
1264 // the DataSize is limited to maximum size of MAX_HARDWARE_ERROR_VARIABLE_SIZE (32K)
1265 // bytes for HwErrRec, and MAX_VARIABLE_SIZE (1024) bytes for the others.
1266 //
1267 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1268 if ((DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE) ||
1269 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE)) {
1270 return EFI_INVALID_PARAMETER;
1271 }
1272 } else {
1273 //
1274 // The size of the VariableName, including the Unicode Null in bytes plus
1275 // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.
1276 //
1277 if ((DataSize > MAX_VARIABLE_SIZE) ||
1278 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_VARIABLE_SIZE)) {
1279 return EFI_INVALID_PARAMETER;
1280 }
1281 }
1282
1283 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1284
1285 Reclaimed = FALSE;
1286 Instance = mVariableModuleGlobal->FvbInstance;
1287 VolatileOffset = &mVariableModuleGlobal->VolatileLastVariableOffset;
1288
1289 //
1290 // Consider reentrant in MCA/INIT/NMI. It needs be reupdated;
1291 //
1292 if (1 < InterlockedIncrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState)) {
1293 Point = mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;;
1294 //
1295 // Parse non-volatile variable data and get last variable offset
1296 //
1297 NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point);
1298 while (IsValidVariableHeader (NextVariable)) {
1299 NextVariable = GetNextVariablePtr (NextVariable);
1300 }
1301 mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;
1302 }
1303
1304 NonVolatileOffset = &mVariableModuleGlobal->NonVolatileLastVariableOffset;
1305
1306
1307 //
1308 // Check whether the input variable is already existed
1309 //
1310
1311 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
1312 if (Status == EFI_SUCCESS && Variable.CurrPtr != NULL) {
1313 //
1314 // Update/Delete existing variable
1315 //
1316 Volatile = Variable.Volatile;
1317
1318 if (EfiAtRuntime ()) {
1319 //
1320 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
1321 // the volatile is ReadOnly, and SetVariable should be aborted and
1322 // return EFI_WRITE_PROTECTED.
1323 //
1324 if (Variable.Volatile) {
1325 Status = EFI_WRITE_PROTECTED;
1326 goto Done;
1327 }
1328 //
1329 // Only variable have NV attribute can be updated/deleted in Runtime
1330 //
1331 if (!(Variable.CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE)) {
1332 Status = EFI_INVALID_PARAMETER;
1333 goto Done;
1334 }
1335 }
1336 //
1337 // Setting a data variable with no access, or zero DataSize attributes
1338 // specified causes it to be deleted.
1339 //
1340 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1341 State = Variable.CurrPtr->State;
1342 State &= VAR_DELETED;
1343
1344 Status = UpdateVariableStore (
1345 &mVariableModuleGlobal->VariableGlobal,
1346 Variable.Volatile,
1347 FALSE,
1348 Instance,
1349 (UINTN) &Variable.CurrPtr->State,
1350 sizeof (UINT8),
1351 &State
1352 );
1353 if (!EFI_ERROR (Status)) {
1354 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, FALSE, TRUE, FALSE);
1355 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1356 }
1357 goto Done;
1358 }
1359 //
1360 // If the variable is marked valid and the same data has been passed in
1361 // then return to the caller immediately.
1362 //
1363 if (DataSizeOfVariable (Variable.CurrPtr) == DataSize &&
1364 (CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize) == 0)) {
1365
1366 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1367 Status = EFI_SUCCESS;
1368 goto Done;
1369 } else if ((Variable.CurrPtr->State == VAR_ADDED) ||
1370 (Variable.CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1371
1372 //
1373 // Mark the old variable as in delete transition
1374 //
1375 State = Variable.CurrPtr->State;
1376 State &= VAR_IN_DELETED_TRANSITION;
1377
1378 Status = UpdateVariableStore (
1379 &mVariableModuleGlobal->VariableGlobal,
1380 Variable.Volatile,
1381 FALSE,
1382 Instance,
1383 (UINTN) &Variable.CurrPtr->State,
1384 sizeof (UINT8),
1385 &State
1386 );
1387 if (EFI_ERROR (Status)) {
1388 goto Done;
1389 }
1390 }
1391 } else if (Status == EFI_NOT_FOUND) {
1392 //
1393 // Create a new variable
1394 //
1395
1396 //
1397 // Make sure we are trying to create a new variable.
1398 // Setting a data variable with no access, or zero DataSize attributes means to delete it.
1399 //
1400 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1401 Status = EFI_NOT_FOUND;
1402 goto Done;
1403 }
1404
1405 //
1406 // Only variable have NV|RT attribute can be created in Runtime
1407 //
1408 if (EfiAtRuntime () &&
1409 (!(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) || !(Attributes & EFI_VARIABLE_NON_VOLATILE))) {
1410 Status = EFI_INVALID_PARAMETER;
1411 goto Done;
1412 }
1413 } else {
1414 //
1415 // Status should be EFI_INVALID_PARAMETER here according to return status of FindVariable().
1416 //
1417 ASSERT (Status == EFI_INVALID_PARAMETER);
1418 goto Done;
1419 }
1420
1421 //
1422 // Function part - create a new variable and copy the data.
1423 // Both update a variable and create a variable will come here.
1424 //
1425 // Tricky part: Use scratch data area at the end of volatile variable store
1426 // as a temporary storage.
1427 //
1428 NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
1429
1430 SetMem (NextVariable, SCRATCH_SIZE, 0xff);
1431
1432 NextVariable->StartId = VARIABLE_DATA;
1433 NextVariable->Attributes = Attributes;
1434 //
1435 // NextVariable->State = VAR_ADDED;
1436 //
1437 NextVariable->Reserved = 0;
1438 VarNameOffset = sizeof (VARIABLE_HEADER);
1439 VarNameSize = StrSize (VariableName);
1440 CopyMem (
1441 (UINT8 *) ((UINTN) NextVariable + VarNameOffset),
1442 VariableName,
1443 VarNameSize
1444 );
1445 VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
1446 CopyMem (
1447 (UINT8 *) ((UINTN) NextVariable + VarDataOffset),
1448 Data,
1449 DataSize
1450 );
1451 CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
1452 //
1453 // There will be pad bytes after Data, the NextVariable->NameSize and
1454 // NextVariable->DataSize should not include pad size so that variable
1455 // service can get actual size in GetVariable
1456 //
1457 NextVariable->NameSize = (UINT32)VarNameSize;
1458 NextVariable->DataSize = (UINT32)DataSize;
1459
1460 //
1461 // The actual size of the variable that stores in storage should
1462 // include pad size.
1463 //
1464 VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
1465 if (Attributes & EFI_VARIABLE_NON_VOLATILE) {
1466 //
1467 // Create a nonvolatile variable
1468 //
1469 Volatile = FALSE;
1470
1471 if ((UINT32) (VarSize +*NonVolatileOffset) >
1472 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
1473 ) {
1474 if (EfiAtRuntime ()) {
1475 Status = EFI_OUT_OF_RESOURCES;
1476 goto Done;
1477 }
1478 //
1479 // Perform garbage collection & reclaim operation
1480 //
1481 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, NonVolatileOffset, FALSE, Variable.CurrPtr);
1482 if (EFI_ERROR (Status)) {
1483 goto Done;
1484 }
1485 //
1486 // If still no enough space, return out of resources
1487 //
1488 if ((UINT32) (VarSize +*NonVolatileOffset) >
1489 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
1490 ) {
1491 Status = EFI_OUT_OF_RESOURCES;
1492 goto Done;
1493 }
1494
1495 Reclaimed = TRUE;
1496 }
1497 //
1498 // Three steps
1499 // 1. Write variable header
1500 // 2. Set variable state to header valid
1501 // 3. Write variable data
1502 // 4. Set variable state to valid
1503 //
1504 //
1505 // Step 1:
1506 //
1507 Status = UpdateVariableStore (
1508 &mVariableModuleGlobal->VariableGlobal,
1509 FALSE,
1510 TRUE,
1511 Instance,
1512 *NonVolatileOffset,
1513 sizeof (VARIABLE_HEADER),
1514 (UINT8 *) NextVariable
1515 );
1516
1517 if (EFI_ERROR (Status)) {
1518 goto Done;
1519 }
1520
1521 //
1522 // Step 2:
1523 //
1524 NextVariable->State = VAR_HEADER_VALID_ONLY;
1525 Status = UpdateVariableStore (
1526 &mVariableModuleGlobal->VariableGlobal,
1527 FALSE,
1528 TRUE,
1529 Instance,
1530 *NonVolatileOffset,
1531 sizeof (VARIABLE_HEADER),
1532 (UINT8 *) NextVariable
1533 );
1534
1535 if (EFI_ERROR (Status)) {
1536 goto Done;
1537 }
1538 //
1539 // Step 3:
1540 //
1541 Status = UpdateVariableStore (
1542 &mVariableModuleGlobal->VariableGlobal,
1543 FALSE,
1544 TRUE,
1545 Instance,
1546 *NonVolatileOffset + sizeof (VARIABLE_HEADER),
1547 (UINT32) VarSize - sizeof (VARIABLE_HEADER),
1548 (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)
1549 );
1550
1551 if (EFI_ERROR (Status)) {
1552 goto Done;
1553 }
1554 //
1555 // Step 4:
1556 //
1557 NextVariable->State = VAR_ADDED;
1558 Status = UpdateVariableStore (
1559 &mVariableModuleGlobal->VariableGlobal,
1560 FALSE,
1561 TRUE,
1562 Instance,
1563 *NonVolatileOffset,
1564 sizeof (VARIABLE_HEADER),
1565 (UINT8 *) NextVariable
1566 );
1567
1568 if (EFI_ERROR (Status)) {
1569 goto Done;
1570 }
1571
1572 *NonVolatileOffset = HEADER_ALIGN (*NonVolatileOffset + VarSize);
1573
1574 } else {
1575 //
1576 // Create a volatile variable
1577 //
1578 Volatile = TRUE;
1579
1580 if ((UINT32) (VarSize +*VolatileOffset) >
1581 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {
1582 //
1583 // Perform garbage collection & reclaim operation
1584 //
1585 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, VolatileOffset, TRUE, Variable.CurrPtr);
1586 if (EFI_ERROR (Status)) {
1587 goto Done;
1588 }
1589 //
1590 // If still no enough space, return out of resources
1591 //
1592 if ((UINT32) (VarSize +*VolatileOffset) >
1593 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size
1594 ) {
1595 Status = EFI_OUT_OF_RESOURCES;
1596 goto Done;
1597 }
1598
1599 Reclaimed = TRUE;
1600 }
1601
1602 NextVariable->State = VAR_ADDED;
1603 Status = UpdateVariableStore (
1604 &mVariableModuleGlobal->VariableGlobal,
1605 TRUE,
1606 TRUE,
1607 Instance,
1608 *VolatileOffset,
1609 (UINT32) VarSize,
1610 (UINT8 *) NextVariable
1611 );
1612
1613 if (EFI_ERROR (Status)) {
1614 goto Done;
1615 }
1616
1617 *VolatileOffset = HEADER_ALIGN (*VolatileOffset + VarSize);
1618 }
1619 //
1620 // Mark the old variable as deleted
1621 //
1622 if (!Reclaimed && !EFI_ERROR (Status) && Variable.CurrPtr != NULL) {
1623 State = Variable.CurrPtr->State;
1624 State &= VAR_DELETED;
1625
1626 Status = UpdateVariableStore (
1627 &mVariableModuleGlobal->VariableGlobal,
1628 Variable.Volatile,
1629 FALSE,
1630 Instance,
1631 (UINTN) &Variable.CurrPtr->State,
1632 sizeof (UINT8),
1633 &State
1634 );
1635
1636 if (!EFI_ERROR (Status)) {
1637 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1638 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1639 }
1640 goto Done;
1641 }
1642
1643 Status = EFI_SUCCESS;
1644 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1645 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1646
1647 Done:
1648 InterlockedDecrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState);
1649 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1650
1651 return Status;
1652 }
1653
1654
1655 /*++
1656
1657 Routine Description:
1658
1659 This code returns information about the EFI variables.
1660
1661 Arguments:
1662
1663 Attributes Attributes bitmask to specify the type of variables
1664 on which to return information.
1665 MaximumVariableStorageSize Pointer to the maximum size of the storage space available
1666 for the EFI variables associated with the attributes specified.
1667 RemainingVariableStorageSize Pointer to the remaining size of the storage space available
1668 for EFI variables associated with the attributes specified.
1669 MaximumVariableSize Pointer to the maximum size of an individual EFI variables
1670 associated with the attributes specified.
1671 Global Pointer to VARIABLE_GLOBAL structure.
1672 Instance Instance of the Firmware Volume.
1673
1674 Returns:
1675
1676 EFI STATUS
1677 EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
1678 EFI_SUCCESS - Query successfully.
1679 EFI_UNSUPPORTED - The attribute is not supported on this platform.
1680
1681 --*/
1682 EFI_STATUS
1683 EFIAPI
1684 RuntimeServiceQueryVariableInfo (
1685 IN UINT32 Attributes,
1686 OUT UINT64 *MaximumVariableStorageSize,
1687 OUT UINT64 *RemainingVariableStorageSize,
1688 OUT UINT64 *MaximumVariableSize
1689 )
1690 {
1691 VARIABLE_HEADER *Variable;
1692 VARIABLE_HEADER *NextVariable;
1693 UINT64 VariableSize;
1694 VARIABLE_STORE_HEADER *VariableStoreHeader;
1695
1696 if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {
1697 return EFI_INVALID_PARAMETER;
1698 }
1699
1700 if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {
1701 //
1702 // Make sure the Attributes combination is supported by the platform.
1703 //
1704 return EFI_UNSUPPORTED;
1705 } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1706 //
1707 // Make sure if runtime bit is set, boot service bit is set also.
1708 //
1709 return EFI_INVALID_PARAMETER;
1710 } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1711 //
1712 // Make sure RT Attribute is set if we are in Runtime phase.
1713 //
1714 return EFI_INVALID_PARAMETER;
1715 }
1716
1717 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1718
1719 if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
1720 //
1721 // Query is Volatile related.
1722 //
1723 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
1724 } else {
1725 //
1726 // Query is Non-Volatile related.
1727 //
1728 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1729 }
1730
1731 //
1732 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1733 // with the storage size (excluding the storage header size).
1734 //
1735 *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1736 *RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1737
1738 //
1739 // Let *MaximumVariableSize be MAX_VARIABLE_SIZE with the exception of the variable header size.
1740 //
1741 *MaximumVariableSize = MAX_VARIABLE_SIZE - sizeof (VARIABLE_HEADER);
1742
1743 //
1744 // Harware error record variable needs larger size.
1745 //
1746 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1747 *MaximumVariableSize = MAX_HARDWARE_ERROR_VARIABLE_SIZE - sizeof (VARIABLE_HEADER);
1748 }
1749
1750 //
1751 // Point to the starting address of the variables.
1752 //
1753 Variable = GetStartPointer (VariableStoreHeader);
1754
1755 //
1756 // Now walk through the related variable store.
1757 //
1758 while (IsValidVariableHeader (Variable) && (Variable < GetEndPointer (VariableStoreHeader))) {
1759 NextVariable = GetNextVariablePtr (Variable);
1760 VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
1761
1762 if (EfiAtRuntime ()) {
1763 //
1764 // we don't take the state of the variables in mind
1765 // when calculating RemainingVariableStorageSize,
1766 // since the space occupied by variables not marked with
1767 // VAR_ADDED is not allowed to be reclaimed in Runtime.
1768 //
1769 *RemainingVariableStorageSize -= VariableSize;
1770 } else {
1771 //
1772 // Only care about Variables with State VAR_ADDED,because
1773 // the space not marked as VAR_ADDED is reclaimable now.
1774 //
1775 if (Variable->State == VAR_ADDED) {
1776 *RemainingVariableStorageSize -= VariableSize;
1777 }
1778 }
1779
1780 //
1781 // Go to the next one
1782 //
1783 Variable = NextVariable;
1784 }
1785
1786 if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {
1787 *MaximumVariableSize = 0;
1788 } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {
1789 *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);
1790 }
1791
1792 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1793 return EFI_SUCCESS;
1794 }
1795
1796 VOID
1797 EFIAPI
1798 ReclaimForOS(
1799 EFI_EVENT Event,
1800 VOID *Context
1801 )
1802 {
1803 UINT32 VarSize;
1804 EFI_STATUS Status;
1805
1806 VarSize = ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase))->Size;
1807 Status = EFI_SUCCESS;
1808
1809 //
1810 // Check if the free area is blow a threshold
1811 //
1812 if ((VarSize - mVariableModuleGlobal->NonVolatileLastVariableOffset) < VARIABLE_RECLAIM_THRESHOLD) {
1813 Status = Reclaim (
1814 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
1815 &mVariableModuleGlobal->NonVolatileLastVariableOffset,
1816 FALSE,
1817 NULL
1818 );
1819 ASSERT_EFI_ERROR (Status);
1820 }
1821 }
1822
1823 EFI_STATUS
1824 VariableCommonInitialize (
1825 IN EFI_HANDLE ImageHandle,
1826 IN EFI_SYSTEM_TABLE *SystemTable
1827 )
1828 /*++
1829
1830 Routine Description:
1831 This function does common initialization for variable services
1832
1833 Arguments:
1834
1835 ImageHandle - The firmware allocated handle for the EFI image.
1836 SystemTable - A pointer to the EFI System Table.
1837
1838 Returns:
1839
1840 Status code.
1841
1842 EFI_NOT_FOUND - Variable store area not found.
1843 EFI_UNSUPPORTED - Currently only one non-volatile variable store is supported.
1844 EFI_SUCCESS - Variable services successfully initialized.
1845
1846 --*/
1847 {
1848 EFI_STATUS Status;
1849 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
1850 CHAR8 *CurrPtr;
1851 VARIABLE_STORE_HEADER *VolatileVariableStore;
1852 VARIABLE_STORE_HEADER *VariableStoreHeader;
1853 VARIABLE_HEADER *NextVariable;
1854 UINT32 Instance;
1855 EFI_PHYSICAL_ADDRESS FvVolHdr;
1856 UINT64 TempVariableStoreHeader;
1857 EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
1858 UINT64 BaseAddress;
1859 UINT64 Length;
1860 UINTN Index;
1861 UINT8 Data;
1862 UINT64 VariableStoreBase;
1863 UINT64 VariableStoreLength;
1864 EFI_EVENT ReadyToBootEvent;
1865
1866 Status = EFI_SUCCESS;
1867 //
1868 // Allocate runtime memory for variable driver global structure.
1869 //
1870 mVariableModuleGlobal = AllocateRuntimePool (sizeof (VARIABLE_MODULE_GLOBAL));
1871 if (mVariableModuleGlobal == NULL) {
1872 return EFI_OUT_OF_RESOURCES;
1873 }
1874
1875 EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);
1876 mVariableModuleGlobal->VariableGlobal.ReentrantState = 0;
1877
1878 //
1879 // Allocate memory for volatile variable store
1880 //
1881 VolatileVariableStore = AllocateRuntimePool (VARIABLE_STORE_SIZE + SCRATCH_SIZE);
1882 if (VolatileVariableStore == NULL) {
1883 FreePool (mVariableModuleGlobal);
1884 return EFI_OUT_OF_RESOURCES;
1885 }
1886
1887 SetMem (VolatileVariableStore, VARIABLE_STORE_SIZE + SCRATCH_SIZE, 0xff);
1888
1889 //
1890 // Variable Specific Data
1891 //
1892 mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;
1893 mVariableModuleGlobal->VolatileLastVariableOffset = (UINTN) GetStartPointer (VolatileVariableStore) - (UINTN) VolatileVariableStore;
1894
1895 VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE;
1896 VolatileVariableStore->Size = VARIABLE_STORE_SIZE;
1897 VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;
1898 VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;
1899 VolatileVariableStore->Reserved = 0;
1900 VolatileVariableStore->Reserved1 = 0;
1901
1902 //
1903 // Get non volatile varaible store
1904 //
1905
1906 TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase);
1907 VariableStoreBase = TempVariableStoreHeader + \
1908 (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
1909 VariableStoreLength = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \
1910 (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
1911 //
1912 // Mark the variable storage region of the FLASH as RUNTIME
1913 //
1914 BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);
1915 Length = VariableStoreLength + (VariableStoreBase - BaseAddress);
1916 Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
1917
1918 Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
1919 if (EFI_ERROR (Status)) {
1920 goto Done;
1921 }
1922
1923 Status = gDS->SetMemorySpaceAttributes (
1924 BaseAddress,
1925 Length,
1926 GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME
1927 );
1928 if (EFI_ERROR (Status)) {
1929 goto Done;
1930 }
1931 //
1932 // Get address of non volatile variable store base
1933 //
1934 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
1935
1936 //
1937 // Check Integrity
1938 //
1939 //
1940 // Find the Correct Instance of the FV Block Service.
1941 //
1942 Instance = 0;
1943 CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1944 while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) {
1945 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
1946 if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) {
1947 mVariableModuleGlobal->FvbInstance = Instance;
1948 break;
1949 }
1950
1951 Instance++;
1952 }
1953
1954 VariableStoreHeader = (VARIABLE_STORE_HEADER *) CurrPtr;
1955 if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
1956 if (~VariableStoreHeader->Size == 0) {
1957 Status = UpdateVariableStore (
1958 &mVariableModuleGlobal->VariableGlobal,
1959 FALSE,
1960 FALSE,
1961 mVariableModuleGlobal->FvbInstance,
1962 (UINTN) &VariableStoreHeader->Size,
1963 sizeof (UINT32),
1964 (UINT8 *) &VariableStoreLength
1965 );
1966 //
1967 // As Variables are stored in NV storage, which are slow devices,such as flash.
1968 // Variable operation may skip checking variable program result to improve performance,
1969 // We can assume Variable program is OK through some check point.
1970 // Variable Store Size Setting should be the first Variable write operation,
1971 // We can assume all Read/Write is OK if we can set Variable store size successfully.
1972 // If write fail, we will assert here
1973 //
1974 ASSERT(VariableStoreHeader->Size == VariableStoreLength);
1975
1976 if (EFI_ERROR (Status)) {
1977 goto Done;
1978 }
1979 }
1980
1981 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) CurrPtr);
1982 //
1983 // Parse non-volatile variable data and get last variable offset
1984 //
1985 NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) CurrPtr);
1986 Status = EFI_SUCCESS;
1987
1988 while (IsValidVariableHeader (NextVariable)) {
1989 NextVariable = GetNextVariablePtr (NextVariable);
1990 }
1991
1992 mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) CurrPtr;
1993
1994 //
1995 // Check if the free area is really free.
1996 //
1997 for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) {
1998 Data = ((UINT8 *) (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)[Index];
1999 if (Data != 0xff) {
2000 //
2001 // There must be something wrong in variable store, do reclaim operation.
2002 //
2003 Status = Reclaim (
2004 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
2005 &mVariableModuleGlobal->NonVolatileLastVariableOffset,
2006 FALSE,
2007 NULL
2008 );
2009
2010 if (EFI_ERROR (Status)) {
2011 goto Done;
2012 }
2013
2014 break;
2015 }
2016 }
2017
2018 //
2019 // Register the event handling function to reclaim variable for OS usage.
2020 //
2021 Status = EfiCreateEventReadyToBootEx (
2022 TPL_NOTIFY,
2023 ReclaimForOS,
2024 NULL,
2025 &ReadyToBootEvent
2026 );
2027 }
2028
2029 Done:
2030 if (EFI_ERROR (Status)) {
2031 FreePool (mVariableModuleGlobal);
2032 FreePool (VolatileVariableStore);
2033 }
2034
2035 return Status;
2036 }
2037
2038 VOID
2039 EFIAPI
2040 VariableClassAddressChangeEvent (
2041 IN EFI_EVENT Event,
2042 IN VOID *Context
2043 )
2044 {
2045 EfiConvertPointer (
2046 0x0,
2047 (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase
2048 );
2049 EfiConvertPointer (
2050 0x0,
2051 (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase
2052 );
2053 EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
2054 }
2055
2056
2057 /**
2058 Variable Driver main entry point. The Variable driver places the 4 EFI
2059 runtime services in the EFI System Table and installs arch protocols
2060 for variable read and write services being availible.
2061
2062 @param[in] ImageHandle The firmware allocated handle for the EFI image.
2063 @param[in] SystemTable A pointer to the EFI System Table.
2064
2065 @retval EFI_SUCCESS The entry point is executed successfully.
2066 @retval other Some error occurs when executing this entry point.
2067
2068 **/
2069 EFI_STATUS
2070 EFIAPI
2071 VariableServiceInitialize (
2072 IN EFI_HANDLE ImageHandle,
2073 IN EFI_SYSTEM_TABLE *SystemTable
2074 )
2075 {
2076 EFI_STATUS Status;
2077
2078 Status = VariableCommonInitialize (ImageHandle, SystemTable);
2079 ASSERT_EFI_ERROR (Status);
2080
2081 SystemTable->RuntimeServices->GetVariable = RuntimeServiceGetVariable;
2082 SystemTable->RuntimeServices->GetNextVariableName = RuntimeServiceGetNextVariableName;
2083 SystemTable->RuntimeServices->SetVariable = RuntimeServiceSetVariable;
2084 SystemTable->RuntimeServices->QueryVariableInfo = RuntimeServiceQueryVariableInfo;
2085
2086 //
2087 // Now install the Variable Runtime Architectural Protocol on a new handle
2088 //
2089 Status = gBS->InstallMultipleProtocolInterfaces (
2090 &mHandle,
2091 &gEfiVariableArchProtocolGuid, NULL,
2092 &gEfiVariableWriteArchProtocolGuid, NULL,
2093 NULL
2094 );
2095 ASSERT_EFI_ERROR (Status);
2096
2097 Status = gBS->CreateEvent (
2098 EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
2099 TPL_NOTIFY,
2100 VariableClassAddressChangeEvent,
2101 NULL,
2102 &mVirtualAddressChangeEvent
2103 );
2104 ASSERT_EFI_ERROR (Status);
2105
2106 return EFI_SUCCESS;
2107 }
2108
EFI Development Kit II mirror for PVE