]> 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
Fix a bug. FindVariable now search volatile variable first (previously NV variable...
[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 // The index and attributes mapping must be kept in this order as RuntimeServiceGetNextVariableName
741 // make use of this mapping to implement search algorithme.
742 //
743 VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
744 VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
745
746 //
747 // Start Pointers for the variable.
748 // Actual Data Pointer where data can be written.
749 //
750 Variable[0] = (VARIABLE_HEADER *) (VariableStoreHeader[0] + 1);
751 Variable[1] = (VARIABLE_HEADER *) (VariableStoreHeader[1] + 1);
752
753 if (VariableName[0] != 0 && VendorGuid == NULL) {
754 return EFI_INVALID_PARAMETER;
755 }
756 //
757 // Find the variable by walk through volatile and then non-volatile variable store
758 //
759 for (Index = 0; Index < 2; Index++) {
760 PtrTrack->StartPtr = (VARIABLE_HEADER *) (VariableStoreHeader[Index] + 1);
761 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);
762
763 while (IsValidVariableHeader (Variable[Index]) && (Variable[Index] <= GetEndPointer (VariableStoreHeader[Index]))) {
764 if (Variable[Index]->State == VAR_ADDED) {
765 if (!EfiAtRuntime () || (Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
766 if (VariableName[0] == 0) {
767 PtrTrack->CurrPtr = Variable[Index];
768 PtrTrack->Volatile = (BOOLEAN)(Index == 0);
769 return EFI_SUCCESS;
770 } else {
771 if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {
772 if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize)) {
773 PtrTrack->CurrPtr = Variable[Index];
774 PtrTrack->Volatile = (BOOLEAN)(Index == 0);
775 return EFI_SUCCESS;
776 }
777 }
778 }
779 }
780 }
781
782 Variable[Index] = GetNextVariablePtr (Variable[Index]);
783 }
784 }
785 PtrTrack->CurrPtr = NULL;
786 return EFI_NOT_FOUND;
787 }
788
789
790
791 /*++
792
793 Routine Description:
794
795 This code finds variable in storage blocks (Volatile or Non-Volatile)
796
797 Arguments:
798
799 VariableName Name of Variable to be found
800 VendorGuid Variable vendor GUID
801 Attributes OPTIONAL Attribute value of the variable found
802 DataSize Size of Data found. If size is less than the
803 data, this value contains the required size.
804 Data Data pointer
805 Global Pointer to VARIABLE_GLOBAL structure
806 Instance Instance of the Firmware Volume.
807
808 Returns:
809
810 EFI_INVALID_PARAMETER - Invalid parameter
811 EFI_SUCCESS - Find the specified variable
812 EFI_NOT_FOUND - Not found
813 EFI_BUFFER_TO_SMALL - DataSize is too small for the result
814
815
816 --*/
817 EFI_STATUS
818 EFIAPI
819 RuntimeServiceGetVariable (
820 IN CHAR16 *VariableName,
821 IN EFI_GUID *VendorGuid,
822 OUT UINT32 *Attributes OPTIONAL,
823 IN OUT UINTN *DataSize,
824 OUT VOID *Data
825 )
826 {
827 EFI_STATUS Status;
828 VARIABLE_POINTER_TRACK Variable;
829 UINTN VarDataSize;
830
831 if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
832 return EFI_INVALID_PARAMETER;
833 }
834
835 //
836 // Find existing variable
837 //
838 Status = FindVariableInCache (VariableName, VendorGuid, Attributes, DataSize, Data);
839 if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_SUCCESS)){
840 // Hit in the Cache
841 UpdateVariableInfo (VariableName, VendorGuid, FALSE, TRUE, FALSE, FALSE, TRUE);
842 return Status;
843 }
844
845 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
846 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
847 goto Done;
848 }
849
850 //
851 // Get data size
852 //
853 VarDataSize = Variable.CurrPtr->DataSize;
854 if (*DataSize >= VarDataSize) {
855 if (Data == NULL) {
856 Status = EFI_INVALID_PARAMETER;
857 goto Done;
858 }
859
860 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
861 if (Attributes != NULL) {
862 *Attributes = Variable.CurrPtr->Attributes;
863 }
864
865 *DataSize = VarDataSize;
866 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);
867 UpdateVariableCache (VariableName, VendorGuid, Variable.CurrPtr->Attributes, VarDataSize, Data);
868
869 Status = EFI_SUCCESS;
870 goto Done;
871 } else {
872 *DataSize = VarDataSize;
873 Status = EFI_BUFFER_TOO_SMALL;
874 goto Done;
875 }
876
877 Done:
878 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
879 return Status;
880 }
881
882
883
884 /*++
885
886 Routine Description:
887
888 This code Finds the Next available variable
889
890 Arguments:
891
892 VariableNameSize Size of the variable
893 VariableName Pointer to variable name
894 VendorGuid Variable Vendor Guid
895 Global VARIABLE_GLOBAL structure pointer.
896 Instance FV instance
897
898 Returns:
899
900 EFI STATUS
901
902 --*/
903 EFI_STATUS
904 EFIAPI
905 RuntimeServiceGetNextVariableName (
906 IN OUT UINTN *VariableNameSize,
907 IN OUT CHAR16 *VariableName,
908 IN OUT EFI_GUID *VendorGuid
909 )
910 {
911 VARIABLE_POINTER_TRACK Variable;
912 UINTN VarNameSize;
913 EFI_STATUS Status;
914
915 if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
916 return EFI_INVALID_PARAMETER;
917 }
918
919 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
920 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
921 goto Done;
922 }
923
924 if (VariableName[0] != 0) {
925 //
926 // If variable name is not NULL, get next variable
927 //
928 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
929 }
930
931 while (TRUE) {
932 //
933 // If both volatile and non-volatile variable store are parsed,
934 // return not found
935 //
936 if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
937 Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));
938 if (!Variable.Volatile) {
939 Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));
940 Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase));
941 } else {
942 Status = EFI_NOT_FOUND;
943 goto Done;
944 }
945
946 Variable.CurrPtr = Variable.StartPtr;
947 if (!IsValidVariableHeader (Variable.CurrPtr)) {
948 continue;
949 }
950 }
951 //
952 // Variable is found
953 //
954 if (IsValidVariableHeader (Variable.CurrPtr) && Variable.CurrPtr->State == VAR_ADDED) {
955 if (!(EfiAtRuntime () && !(Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {
956 VarNameSize = Variable.CurrPtr->NameSize;
957 if (VarNameSize <= *VariableNameSize) {
958 CopyMem (
959 VariableName,
960 GET_VARIABLE_NAME_PTR (Variable.CurrPtr),
961 VarNameSize
962 );
963 CopyMem (
964 VendorGuid,
965 &Variable.CurrPtr->VendorGuid,
966 sizeof (EFI_GUID)
967 );
968 Status = EFI_SUCCESS;
969 } else {
970 Status = EFI_BUFFER_TOO_SMALL;
971 }
972
973 *VariableNameSize = VarNameSize;
974 goto Done;
975 }
976 }
977
978 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
979 }
980
981 Done:
982 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
983 return Status;
984 }
985
986
987 /*++
988
989 Routine Description:
990
991 This code sets variable in storage blocks (Volatile or Non-Volatile)
992
993 Arguments:
994
995 VariableName Name of Variable to be found
996 VendorGuid Variable vendor GUID
997 Attributes Attribute value of the variable found
998 DataSize Size of Data found. If size is less than the
999 data, this value contains the required size.
1000 Data Data pointer
1001 Global Pointer to VARIABLE_GLOBAL structure
1002 VolatileOffset The offset of last volatile variable
1003 NonVolatileOffset The offset of last non-volatile variable
1004 Instance Instance of the Firmware Volume.
1005
1006 Returns:
1007
1008 EFI_INVALID_PARAMETER - Invalid parameter
1009 EFI_SUCCESS - Set successfully
1010 EFI_OUT_OF_RESOURCES - Resource not enough to set variable
1011 EFI_NOT_FOUND - Not found
1012 EFI_DEVICE_ERROR - Variable can not be saved due to hardware failure
1013 EFI_WRITE_PROTECTED - Variable is read-only
1014
1015 --*/
1016 EFI_STATUS
1017 EFIAPI
1018 RuntimeServiceSetVariable (
1019 IN CHAR16 *VariableName,
1020 IN EFI_GUID *VendorGuid,
1021 IN UINT32 Attributes,
1022 IN UINTN DataSize,
1023 IN VOID *Data
1024 )
1025 {
1026 VARIABLE_POINTER_TRACK Variable;
1027 EFI_STATUS Status;
1028 VARIABLE_HEADER *NextVariable;
1029 UINTN VarNameSize;
1030 UINTN VarNameOffset;
1031 UINTN VarDataOffset;
1032 UINTN VarSize;
1033 UINT8 State;
1034 BOOLEAN Reclaimed;
1035 UINTN *VolatileOffset;
1036 UINTN *NonVolatileOffset;
1037 UINT32 Instance;
1038 BOOLEAN Volatile;
1039
1040 Reclaimed = FALSE;
1041 VolatileOffset = &mVariableModuleGlobal->VolatileLastVariableOffset;
1042 NonVolatileOffset = &mVariableModuleGlobal->NonVolatileLastVariableOffset;
1043 Instance = mVariableModuleGlobal->FvbInstance;
1044
1045 //
1046 // Check input parameters
1047 //
1048 if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
1049 return EFI_INVALID_PARAMETER;
1050 }
1051 //
1052 // Make sure if runtime bit is set, boot service bit is set also
1053 //
1054 if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1055 return EFI_INVALID_PARAMETER;
1056 }
1057 //
1058 // The size of the VariableName, including the Unicode Null in bytes plus
1059 // the DataSize is limited to maximum size of MAX_HARDWARE_ERROR_VARIABLE_SIZE (32K)
1060 // bytes for HwErrRec, and MAX_VARIABLE_SIZE (1024) bytes for the others.
1061 //
1062 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1063 if ((DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE) ||
1064 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE)) {
1065 return EFI_INVALID_PARAMETER;
1066 }
1067 } else {
1068 //
1069 // The size of the VariableName, including the Unicode Null in bytes plus
1070 // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.
1071 //
1072 if ((DataSize > MAX_VARIABLE_SIZE) ||
1073 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_VARIABLE_SIZE)) {
1074 return EFI_INVALID_PARAMETER;
1075 }
1076 }
1077 //
1078 // Check whether the input variable is already existed
1079 //
1080
1081 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
1082 if (Status == EFI_SUCCESS && Variable.CurrPtr != NULL) {
1083 //
1084 // Update/Delete existing variable
1085 //
1086 Volatile = Variable.Volatile;
1087
1088 if (EfiAtRuntime ()) {
1089 //
1090 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
1091 // the volatile is ReadOnly, and SetVariable should be aborted and
1092 // return EFI_WRITE_PROTECTED.
1093 //
1094 if (Variable.Volatile) {
1095 Status = EFI_WRITE_PROTECTED;
1096 goto Done;
1097 }
1098 //
1099 // Only variable have NV attribute can be updated/deleted in Runtime
1100 //
1101 if (!(Variable.CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE)) {
1102 Status = EFI_INVALID_PARAMETER;
1103 goto Done;
1104 }
1105 }
1106 //
1107 // Setting a data variable with no access, or zero DataSize attributes
1108 // specified causes it to be deleted.
1109 //
1110 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1111 State = Variable.CurrPtr->State;
1112 State &= VAR_DELETED;
1113
1114 Status = UpdateVariableStore (
1115 &mVariableModuleGlobal->VariableGlobal,
1116 Variable.Volatile,
1117 FALSE,
1118 Instance,
1119 (UINTN) &Variable.CurrPtr->State,
1120 sizeof (UINT8),
1121 &State
1122 );
1123 if (!EFI_ERROR (Status)) {
1124 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, FALSE, TRUE, FALSE);
1125 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1126 }
1127 goto Done;
1128 }
1129 //
1130 // If the variable is marked valid and the same data has been passed in
1131 // then return to the caller immediately.
1132 //
1133 if (Variable.CurrPtr->DataSize == DataSize &&
1134 (CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize) == 0)) {
1135
1136 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1137 Status = EFI_SUCCESS;
1138 goto Done;
1139 } else if ((Variable.CurrPtr->State == VAR_ADDED) ||
1140 (Variable.CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {
1141 //
1142 // Mark the old variable as in delete transition
1143 //
1144 State = Variable.CurrPtr->State;
1145 State &= VAR_IN_DELETED_TRANSITION;
1146
1147 Status = UpdateVariableStore (
1148 &mVariableModuleGlobal->VariableGlobal,
1149 Variable.Volatile,
1150 FALSE,
1151 Instance,
1152 (UINTN) &Variable.CurrPtr->State,
1153 sizeof (UINT8),
1154 &State
1155 );
1156 if (EFI_ERROR (Status)) {
1157 goto Done;
1158 }
1159 }
1160 } else if (Status == EFI_NOT_FOUND) {
1161 //
1162 // Create a new variable
1163 //
1164
1165 //
1166 // Make sure we are trying to create a new variable.
1167 // Setting a data variable with no access, or zero DataSize attributes means to delete it.
1168 //
1169 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
1170 Status = EFI_NOT_FOUND;
1171 goto Done;
1172 }
1173
1174 //
1175 // Only variable have NV|RT attribute can be created in Runtime
1176 //
1177 if (EfiAtRuntime () &&
1178 (!(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) || !(Attributes & EFI_VARIABLE_NON_VOLATILE))) {
1179 Status = EFI_INVALID_PARAMETER;
1180 goto Done;
1181 }
1182 } else {
1183 //
1184 // Status should be EFI_INVALID_PARAMETER here according to return status of FindVariable().
1185 //
1186 ASSERT (Status == EFI_INVALID_PARAMETER);
1187 goto Done;
1188 }
1189
1190 //
1191 // Function part - create a new variable and copy the data.
1192 // Both update a variable and create a variable will come here.
1193 //
1194 // Tricky part: Use scratch data area at the end of volatile variable store
1195 // as a temporary storage.
1196 //
1197 NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
1198
1199 SetMem (NextVariable, SCRATCH_SIZE, 0xff);
1200
1201 NextVariable->StartId = VARIABLE_DATA;
1202 NextVariable->Attributes = Attributes;
1203 //
1204 // NextVariable->State = VAR_ADDED;
1205 //
1206 NextVariable->Reserved = 0;
1207 VarNameOffset = sizeof (VARIABLE_HEADER);
1208 VarNameSize = StrSize (VariableName);
1209 CopyMem (
1210 (UINT8 *) ((UINTN) NextVariable + VarNameOffset),
1211 VariableName,
1212 VarNameSize
1213 );
1214 VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
1215 CopyMem (
1216 (UINT8 *) ((UINTN) NextVariable + VarDataOffset),
1217 Data,
1218 DataSize
1219 );
1220 CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
1221 //
1222 // There will be pad bytes after Data, the NextVariable->NameSize and
1223 // NextVariable->DataSize should not include pad size so that variable
1224 // service can get actual size in GetVariable
1225 //
1226 NextVariable->NameSize = (UINT32)VarNameSize;
1227 NextVariable->DataSize = (UINT32)DataSize;
1228
1229 //
1230 // The actual size of the variable that stores in storage should
1231 // include pad size.
1232 //
1233 VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
1234 if (Attributes & EFI_VARIABLE_NON_VOLATILE) {
1235 //
1236 // Create a nonvolatile variable
1237 //
1238 Volatile = FALSE;
1239
1240 if ((UINT32) (VarSize +*NonVolatileOffset) >
1241 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
1242 ) {
1243 if (EfiAtRuntime ()) {
1244 Status = EFI_OUT_OF_RESOURCES;
1245 goto Done;
1246 }
1247 //
1248 // Perform garbage collection & reclaim operation
1249 //
1250 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, NonVolatileOffset, FALSE);
1251 if (EFI_ERROR (Status)) {
1252 goto Done;
1253 }
1254 //
1255 // If still no enough space, return out of resources
1256 //
1257 if ((UINT32) (VarSize +*NonVolatileOffset) >
1258 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
1259 ) {
1260 Status = EFI_OUT_OF_RESOURCES;
1261 goto Done;
1262 }
1263
1264 Reclaimed = TRUE;
1265 }
1266 //
1267 // Three steps
1268 // 1. Write variable header
1269 // 2. Write variable data
1270 // 3. Set variable state to valid
1271 //
1272 //
1273 // Step 1:
1274 //
1275 Status = UpdateVariableStore (
1276 &mVariableModuleGlobal->VariableGlobal,
1277 FALSE,
1278 TRUE,
1279 Instance,
1280 *NonVolatileOffset,
1281 sizeof (VARIABLE_HEADER),
1282 (UINT8 *) NextVariable
1283 );
1284
1285 if (EFI_ERROR (Status)) {
1286 goto Done;
1287 }
1288 //
1289 // Step 2:
1290 //
1291 Status = UpdateVariableStore (
1292 &mVariableModuleGlobal->VariableGlobal,
1293 FALSE,
1294 TRUE,
1295 Instance,
1296 *NonVolatileOffset + sizeof (VARIABLE_HEADER),
1297 (UINT32) VarSize - sizeof (VARIABLE_HEADER),
1298 (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)
1299 );
1300
1301 if (EFI_ERROR (Status)) {
1302 goto Done;
1303 }
1304 //
1305 // Step 3:
1306 //
1307 NextVariable->State = VAR_ADDED;
1308 Status = UpdateVariableStore (
1309 &mVariableModuleGlobal->VariableGlobal,
1310 FALSE,
1311 TRUE,
1312 Instance,
1313 *NonVolatileOffset,
1314 sizeof (VARIABLE_HEADER),
1315 (UINT8 *) NextVariable
1316 );
1317
1318 if (EFI_ERROR (Status)) {
1319 goto Done;
1320 }
1321
1322 *NonVolatileOffset = *NonVolatileOffset + VarSize;
1323
1324 } else {
1325 //
1326 // Create a volatile variable
1327 //
1328 Volatile = TRUE;
1329
1330 if ((UINT32) (VarSize +*VolatileOffset) >
1331 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {
1332 //
1333 // Perform garbage collection & reclaim operation
1334 //
1335 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, VolatileOffset, TRUE);
1336 if (EFI_ERROR (Status)) {
1337 goto Done;
1338 }
1339 //
1340 // If still no enough space, return out of resources
1341 //
1342 if ((UINT32) (VarSize +*VolatileOffset) >
1343 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size
1344 ) {
1345 Status = EFI_OUT_OF_RESOURCES;
1346 goto Done;
1347 }
1348
1349 Reclaimed = TRUE;
1350 }
1351
1352 NextVariable->State = VAR_ADDED;
1353 Status = UpdateVariableStore (
1354 &mVariableModuleGlobal->VariableGlobal,
1355 TRUE,
1356 TRUE,
1357 Instance,
1358 *VolatileOffset,
1359 (UINT32) VarSize,
1360 (UINT8 *) NextVariable
1361 );
1362
1363 if (EFI_ERROR (Status)) {
1364 goto Done;
1365 }
1366
1367 *VolatileOffset = *VolatileOffset + VarSize;
1368 }
1369 //
1370 // Mark the old variable as deleted
1371 //
1372 if (!Reclaimed && !EFI_ERROR (Status) && Variable.CurrPtr != NULL) {
1373 State = Variable.CurrPtr->State;
1374 State &= VAR_DELETED;
1375
1376 Status = UpdateVariableStore (
1377 &mVariableModuleGlobal->VariableGlobal,
1378 Variable.Volatile,
1379 FALSE,
1380 Instance,
1381 (UINTN) &Variable.CurrPtr->State,
1382 sizeof (UINT8),
1383 &State
1384 );
1385
1386 if (!EFI_ERROR (Status)) {
1387 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1388 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1389 }
1390 goto Done;
1391 }
1392
1393 Status = EFI_SUCCESS;
1394 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);
1395 UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
1396
1397 Done:
1398 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1399 return Status;
1400 }
1401
1402
1403 /*++
1404
1405 Routine Description:
1406
1407 This code returns information about the EFI variables.
1408
1409 Arguments:
1410
1411 Attributes Attributes bitmask to specify the type of variables
1412 on which to return information.
1413 MaximumVariableStorageSize Pointer to the maximum size of the storage space available
1414 for the EFI variables associated with the attributes specified.
1415 RemainingVariableStorageSize Pointer to the remaining size of the storage space available
1416 for EFI variables associated with the attributes specified.
1417 MaximumVariableSize Pointer to the maximum size of an individual EFI variables
1418 associated with the attributes specified.
1419 Global Pointer to VARIABLE_GLOBAL structure.
1420 Instance Instance of the Firmware Volume.
1421
1422 Returns:
1423
1424 EFI STATUS
1425 EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
1426 EFI_SUCCESS - Query successfully.
1427 EFI_UNSUPPORTED - The attribute is not supported on this platform.
1428
1429 --*/
1430 EFI_STATUS
1431 EFIAPI
1432 RuntimeServiceQueryVariableInfo (
1433 IN UINT32 Attributes,
1434 OUT UINT64 *MaximumVariableStorageSize,
1435 OUT UINT64 *RemainingVariableStorageSize,
1436 OUT UINT64 *MaximumVariableSize
1437 )
1438 {
1439 VARIABLE_HEADER *Variable;
1440 VARIABLE_HEADER *NextVariable;
1441 UINT64 VariableSize;
1442 VARIABLE_STORE_HEADER *VariableStoreHeader;
1443
1444 if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {
1445 return EFI_INVALID_PARAMETER;
1446 }
1447
1448 if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {
1449 //
1450 // Make sure the Attributes combination is supported by the platform.
1451 //
1452 return EFI_UNSUPPORTED;
1453 } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
1454 //
1455 // Make sure if runtime bit is set, boot service bit is set also.
1456 //
1457 return EFI_INVALID_PARAMETER;
1458 } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
1459 //
1460 // Make sure RT Attribute is set if we are in Runtime phase.
1461 //
1462 return EFI_INVALID_PARAMETER;
1463 }
1464
1465 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1466
1467 if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
1468 //
1469 // Query is Volatile related.
1470 //
1471 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
1472 } else {
1473 //
1474 // Query is Non-Volatile related.
1475 //
1476 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1477 }
1478
1479 //
1480 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
1481 // with the storage size (excluding the storage header size).
1482 //
1483 *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1484 *RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
1485
1486 //
1487 // Let *MaximumVariableSize be MAX_VARIABLE_SIZE with the exception of the variable header size.
1488 //
1489 *MaximumVariableSize = MAX_VARIABLE_SIZE - sizeof (VARIABLE_HEADER);
1490
1491 //
1492 // Harware error record variable needs larger size.
1493 //
1494 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
1495 *MaximumVariableSize = MAX_HARDWARE_ERROR_VARIABLE_SIZE - sizeof (VARIABLE_HEADER);
1496 }
1497
1498 //
1499 // Point to the starting address of the variables.
1500 //
1501 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
1502
1503 //
1504 // Now walk through the related variable store.
1505 //
1506 while (IsValidVariableHeader (Variable) && (Variable < GetEndPointer (VariableStoreHeader))) {
1507 NextVariable = GetNextVariablePtr (Variable);
1508 VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
1509
1510 if (EfiAtRuntime ()) {
1511 //
1512 // we don't take the state of the variables in mind
1513 // when calculating RemainingVariableStorageSize,
1514 // since the space occupied by variables not marked with
1515 // VAR_ADDED is not allowed to be reclaimed in Runtime.
1516 //
1517 *RemainingVariableStorageSize -= VariableSize;
1518 } else {
1519 //
1520 // Only care about Variables with State VAR_ADDED,because
1521 // the space not marked as VAR_ADDED is reclaimable now.
1522 //
1523 if (Variable->State == VAR_ADDED) {
1524 *RemainingVariableStorageSize -= VariableSize;
1525 }
1526 }
1527
1528 //
1529 // Go to the next one
1530 //
1531 Variable = NextVariable;
1532 }
1533
1534 if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {
1535 *MaximumVariableSize = 0;
1536 } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {
1537 *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);
1538 }
1539
1540 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
1541 return EFI_SUCCESS;
1542 }
1543
1544 EFI_STATUS
1545 VariableCommonInitialize (
1546 IN EFI_HANDLE ImageHandle,
1547 IN EFI_SYSTEM_TABLE *SystemTable
1548 )
1549 /*++
1550
1551 Routine Description:
1552 This function does common initialization for variable services
1553
1554 Arguments:
1555
1556 ImageHandle - The firmware allocated handle for the EFI image.
1557 SystemTable - A pointer to the EFI System Table.
1558
1559 Returns:
1560
1561 Status code.
1562
1563 EFI_NOT_FOUND - Variable store area not found.
1564 EFI_UNSUPPORTED - Currently only one non-volatile variable store is supported.
1565 EFI_SUCCESS - Variable services successfully initialized.
1566
1567 --*/
1568 {
1569 EFI_STATUS Status;
1570 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
1571 CHAR8 *CurrPtr;
1572 VARIABLE_STORE_HEADER *VolatileVariableStore;
1573 VARIABLE_STORE_HEADER *VariableStoreHeader;
1574 VARIABLE_HEADER *NextVariable;
1575 UINT32 Instance;
1576 EFI_PHYSICAL_ADDRESS FvVolHdr;
1577 UINT64 TempVariableStoreHeader;
1578 EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
1579 UINT64 BaseAddress;
1580 UINT64 Length;
1581 UINTN Index;
1582 UINT8 Data;
1583 UINT64 VariableStoreBase;
1584 UINT64 VariableStoreLength;
1585
1586
1587 EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);
1588
1589 //
1590 // Allocate memory for volatile variable store
1591 //
1592 VolatileVariableStore = AllocateRuntimePool (VARIABLE_STORE_SIZE + SCRATCH_SIZE);
1593 if (VolatileVariableStore == NULL) {
1594 FreePool (mVariableModuleGlobal);
1595 return EFI_OUT_OF_RESOURCES;
1596 }
1597
1598 SetMem (VolatileVariableStore, VARIABLE_STORE_SIZE + SCRATCH_SIZE, 0xff);
1599
1600 //
1601 // Variable Specific Data
1602 //
1603 mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;
1604 mVariableModuleGlobal->VolatileLastVariableOffset = sizeof (VARIABLE_STORE_HEADER);
1605
1606 VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE;
1607 VolatileVariableStore->Size = VARIABLE_STORE_SIZE;
1608 VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;
1609 VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;
1610 VolatileVariableStore->Reserved = 0;
1611 VolatileVariableStore->Reserved1 = 0;
1612
1613 //
1614 // Get non volatile varaible store
1615 //
1616
1617 TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase);
1618 VariableStoreBase = TempVariableStoreHeader + \
1619 (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
1620 VariableStoreLength = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \
1621 (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
1622 //
1623 // Mark the variable storage region of the FLASH as RUNTIME
1624 //
1625 BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);
1626 Length = VariableStoreLength + (VariableStoreBase - BaseAddress);
1627 Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
1628
1629 Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
1630 if (EFI_ERROR (Status)) {
1631 FreePool (mVariableModuleGlobal);
1632 FreePool (VolatileVariableStore);
1633 return EFI_UNSUPPORTED;
1634 }
1635
1636 Status = gDS->SetMemorySpaceAttributes (
1637 BaseAddress,
1638 Length,
1639 GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME
1640 );
1641 if (EFI_ERROR (Status)) {
1642 FreePool (mVariableModuleGlobal);
1643 FreePool (VolatileVariableStore);
1644 return EFI_UNSUPPORTED;
1645 }
1646 //
1647 // Get address of non volatile variable store base
1648 //
1649 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
1650
1651 //
1652 // Check Integrity
1653 //
1654 //
1655 // Find the Correct Instance of the FV Block Service.
1656 //
1657 Instance = 0;
1658 CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
1659 while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) {
1660 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
1661 if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) {
1662 mVariableModuleGlobal->FvbInstance = Instance;
1663 break;
1664 }
1665
1666 Instance++;
1667 }
1668
1669 VariableStoreHeader = (VARIABLE_STORE_HEADER *) CurrPtr;
1670 if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
1671 if (~VariableStoreHeader->Size == 0) {
1672 Status = UpdateVariableStore (
1673 &mVariableModuleGlobal->VariableGlobal,
1674 FALSE,
1675 FALSE,
1676 mVariableModuleGlobal->FvbInstance,
1677 (UINTN) &VariableStoreHeader->Size,
1678 sizeof (UINT32),
1679 (UINT8 *) &VariableStoreLength
1680 );
1681 //
1682 // As Variables are stored in NV storage, which are slow devices,such as flash.
1683 // Variable operation may skip checking variable program result to improve performance,
1684 // We can assume Variable program is OK through some check point.
1685 // Variable Store Size Setting should be the first Variable write operation,
1686 // We can assume all Read/Write is OK if we can set Variable store size successfully.
1687 // If write fail, we will assert here
1688 //
1689 ASSERT(VariableStoreHeader->Size == VariableStoreLength);
1690
1691 if (EFI_ERROR (Status)) {
1692 return Status;
1693 }
1694 }
1695
1696 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) CurrPtr);
1697 //
1698 // Parse non-volatile variable data and get last variable offset
1699 //
1700 NextVariable = (VARIABLE_HEADER *) (CurrPtr + sizeof (VARIABLE_STORE_HEADER));
1701 Status = EFI_SUCCESS;
1702
1703 while (IsValidVariableHeader (NextVariable)) {
1704 NextVariable = GetNextVariablePtr (NextVariable);
1705 }
1706
1707 mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) CurrPtr;
1708
1709 //
1710 // Check if the free area is blow a threshold
1711 //
1712 if ((((VARIABLE_STORE_HEADER *)((UINTN) CurrPtr))->Size - mVariableModuleGlobal->NonVolatileLastVariableOffset) < VARIABLE_RECLAIM_THRESHOLD) {
1713 Status = Reclaim (
1714 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
1715 &mVariableModuleGlobal->NonVolatileLastVariableOffset,
1716 FALSE
1717 );
1718 }
1719
1720 if (EFI_ERROR (Status)) {
1721 FreePool (mVariableModuleGlobal);
1722 FreePool (VolatileVariableStore);
1723 return Status;
1724 }
1725
1726 //
1727 // Check if the free area is really free.
1728 //
1729 for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) {
1730 Data = ((UINT8 *) (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)[Index];
1731 if (Data != 0xff) {
1732 //
1733 // There must be something wrong in variable store, do reclaim operation.
1734 //
1735 Status = Reclaim (
1736 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
1737 &mVariableModuleGlobal->NonVolatileLastVariableOffset,
1738 FALSE
1739 );
1740 break;
1741 }
1742 }
1743 }
1744
1745 if (EFI_ERROR (Status)) {
1746 FreePool (mVariableModuleGlobal);
1747 FreePool (VolatileVariableStore);
1748 }
1749
1750 return Status;
1751 }
1752
1753
1754
1755
1756 VOID
1757 EFIAPI
1758 VariableClassAddressChangeEvent (
1759 IN EFI_EVENT Event,
1760 IN VOID *Context
1761 )
1762 {
1763 EfiConvertPointer (
1764 0x0,
1765 (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase
1766 );
1767 EfiConvertPointer (
1768 0x0,
1769 (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase
1770 );
1771 EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
1772 }
1773
1774
1775 /**
1776 Variable Driver main entry point. The Variable driver places the 4 EFI
1777 runtime services in the EFI System Table and installs arch protocols
1778 for variable read and write services being availible.
1779
1780 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1781 @param[in] SystemTable A pointer to the EFI System Table.
1782
1783 @retval EFI_SUCCESS The entry point is executed successfully.
1784 @retval other Some error occurs when executing this entry point.
1785
1786 **/
1787 EFI_STATUS
1788 EFIAPI
1789 VariableServiceInitialize (
1790 IN EFI_HANDLE ImageHandle,
1791 IN EFI_SYSTEM_TABLE *SystemTable
1792 )
1793 {
1794 EFI_STATUS Status;
1795
1796 Status = VariableCommonInitialize (ImageHandle, SystemTable);
1797 ASSERT_EFI_ERROR (Status);
1798
1799 SystemTable->RuntimeServices->GetVariable = RuntimeServiceGetVariable;
1800 SystemTable->RuntimeServices->GetNextVariableName = RuntimeServiceGetNextVariableName;
1801 SystemTable->RuntimeServices->SetVariable = RuntimeServiceSetVariable;
1802 SystemTable->RuntimeServices->QueryVariableInfo = RuntimeServiceQueryVariableInfo;
1803
1804 //
1805 // Now install the Variable Runtime Architectural Protocol on a new handle
1806 //
1807 Status = gBS->InstallMultipleProtocolInterfaces (
1808 &mHandle,
1809 &gEfiVariableArchProtocolGuid, NULL,
1810 &gEfiVariableWriteArchProtocolGuid, NULL,
1811 NULL
1812 );
1813 ASSERT_EFI_ERROR (Status);
1814
1815 Status = gBS->CreateEvent (
1816 EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
1817 TPL_NOTIFY,
1818 VariableClassAddressChangeEvent,
1819 NULL,
1820 &mVirtualAddressChangeEvent
1821 );
1822 ASSERT_EFI_ERROR (Status);
1823
1824 return EFI_SUCCESS;
1825 }
1826
EFI Development Kit II mirror for PVE