Change the TPL lock level to EFI_TPL_NOTIFY. Variable Service is called in ResetSyste...
[mirror_edk2.git] / EdkModulePkg / Universal / EmuVariable / RuntimeDxe / EmuVariable.c
1 /*++
2
3 Copyright (c) 2006 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 EmuVariable.c
15
16 Abstract:
17
18 Revision History
19
20 --*/
21
22 #include "Variable.h"
23
24 //
25 // Don't use module globals after the SetVirtualAddress map is signaled
26 //
27 ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
28
29 //
30 // This is a temperary function which will be removed
31 // when EfiAcquireLock in UefiLib can handle the
32 // the call in UEFI Runtimer driver in RT phase.
33 //
34 STATIC
35 VOID
36 AcquireLockOnlyAtBootTime (
37 IN EFI_LOCK *Lock
38 )
39 {
40 if (!EfiAtRuntime ()) {
41 EfiAcquireLock (Lock);
42 }
43 }
44
45 //
46 // This is a temperary function which will be removed
47 // when EfiAcquireLock in UefiLib can handle the
48 // the call in UEFI Runtimer driver in RT phase.
49 //
50 STATIC
51 VOID
52 ReleaseLockOnlyAtBootTime (
53 IN EFI_LOCK *Lock
54 )
55 {
56 if (!EfiAtRuntime ()) {
57 EfiReleaseLock (Lock);
58 }
59 }
60
61 STATIC
62 UINT8 *
63 EFIAPI
64 GetVariableDataPtr (
65 IN VARIABLE_HEADER *Variable
66 )
67 /*++
68
69 Routine Description:
70
71 This code gets the pointer to the variable data.
72
73 Arguments:
74
75 Variable Pointer to the Variable Header.
76
77 Returns:
78
79 UINT8* Pointer to Variable Data
80
81 --*/
82 {
83 if (Variable->StartId != VARIABLE_DATA) {
84 return NULL;
85 }
86 //
87 // Be careful about pad size for alignment
88 //
89 return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
90 }
91
92 STATIC
93 VARIABLE_HEADER *
94 EFIAPI
95 GetNextVariablePtr (
96 IN VARIABLE_HEADER *Variable
97 )
98 /*++
99
100 Routine Description:
101
102 This code gets the pointer to the next variable header.
103
104 Arguments:
105
106 Variable Pointer to the Variable Header.
107
108 Returns:
109
110 VARIABLE_HEADER* Pointer to next variable header.
111
112 --*/
113 {
114 VARIABLE_HEADER *VarHeader;
115
116 if (Variable->StartId != VARIABLE_DATA) {
117 return NULL;
118 }
119 //
120 // Be careful about pad size for alignment
121 //
122 VarHeader = (VARIABLE_HEADER *) (GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
123
124 if (VarHeader->StartId != VARIABLE_DATA ||
125 (sizeof (VARIABLE_HEADER) + VarHeader->DataSize + VarHeader->NameSize) > MAX_VARIABLE_SIZE
126 ) {
127 return NULL;
128 }
129
130 return VarHeader;
131 }
132
133 STATIC
134 VARIABLE_HEADER *
135 EFIAPI
136 GetEndPointer (
137 IN VARIABLE_STORE_HEADER *VolHeader
138 )
139 /*++
140
141 Routine Description:
142
143 This code gets the pointer to the last variable memory pointer byte
144
145 Arguments:
146
147 Variable Pointer to the Variable Header.
148
149 Returns:
150
151 VARIABLE_HEADER* Pointer to last unavailable Variable Header
152
153 --*/
154 {
155 //
156 // The end of variable store
157 //
158 return (VARIABLE_HEADER *) ((UINTN) VolHeader + VolHeader->Size);
159 }
160
161 STATIC
162 EFI_STATUS
163 EFIAPI
164 FindVariable (
165 IN CHAR16 *VariableName,
166 IN EFI_GUID *VendorGuid,
167 OUT VARIABLE_POINTER_TRACK *PtrTrack,
168 IN VARIABLE_GLOBAL *Global
169 )
170 /*++
171
172 Routine Description:
173
174 This code finds variable in storage blocks (Volatile or Non-Volatile)
175
176 Arguments:
177
178 VariableName Name of the variable to be found
179 VendorGuid Vendor GUID to be found.
180 PtrTrack Variable Track Pointer structure that contains
181 Variable Information.
182 Contains the pointer of Variable header.
183 Global VARIABLE_GLOBAL pointer
184
185 Returns:
186
187 EFI STATUS
188
189 --*/
190 {
191 VARIABLE_HEADER *Variable[2];
192 VARIABLE_STORE_HEADER *VariableStoreHeader[2];
193 UINTN Index;
194
195 //
196 // We aquire the lock at the entry of FindVariable as GetVariable, GetNextVariableName
197 // SetVariable all call FindVariable at entry point. Please move "Aquire Lock" to
198 // the correct places if this assumption does not hold TRUE anymore.
199 //
200 AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);
201
202 //
203 // 0: Non-Volatile, 1: Volatile
204 //
205 VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);
206 VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
207
208 //
209 // Start Pointers for the variable.
210 // Actual Data Pointer where data can be written.
211 //
212 Variable[0] = (VARIABLE_HEADER *) (VariableStoreHeader[0] + 1);
213 Variable[1] = (VARIABLE_HEADER *) (VariableStoreHeader[1] + 1);
214
215 if (VariableName[0] != 0 && VendorGuid == NULL) {
216 return EFI_INVALID_PARAMETER;
217 }
218 //
219 // Find the variable by walk through non-volatile and volatile variable store
220 //
221 for (Index = 0; Index < 2; Index++) {
222 PtrTrack->StartPtr = (VARIABLE_HEADER *) (VariableStoreHeader[Index] + 1);
223 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);
224
225 while ((Variable[Index] != NULL) && (Variable[Index] <= GetEndPointer (VariableStoreHeader[Index]))) {
226 if (Variable[Index]->StartId == VARIABLE_DATA && Variable[Index]->State == VAR_ADDED) {
227 if (!(EfiAtRuntime () && !(Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {
228 if (VariableName[0] == 0) {
229 PtrTrack->CurrPtr = Variable[Index];
230 PtrTrack->Volatile = (BOOLEAN) Index;
231 return EFI_SUCCESS;
232 } else {
233 if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {
234 if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize)) {
235 PtrTrack->CurrPtr = Variable[Index];
236 PtrTrack->Volatile = (BOOLEAN) Index;
237 return EFI_SUCCESS;
238 }
239 }
240 }
241 }
242 }
243
244 Variable[Index] = GetNextVariablePtr (Variable[Index]);
245 }
246 }
247 PtrTrack->CurrPtr = NULL;
248 return EFI_NOT_FOUND;
249 }
250
251 EFI_STATUS
252 EFIAPI
253 GetVariable (
254 IN CHAR16 *VariableName,
255 IN EFI_GUID * VendorGuid,
256 OUT UINT32 *Attributes OPTIONAL,
257 IN OUT UINTN *DataSize,
258 OUT VOID *Data,
259 IN VARIABLE_GLOBAL * Global,
260 IN UINT32 Instance
261 )
262 /*++
263
264 Routine Description:
265
266 This code finds variable in storage blocks (Volatile or Non-Volatile)
267
268 Arguments:
269
270 VariableName Name of Variable to be found
271 VendorGuid Variable vendor GUID
272 Attributes OPTIONAL Attribute value of the variable found
273 DataSize Size of Data found. If size is less than the
274 data, this value contains the required size.
275 Data Data pointer
276 Global Pointer to VARIABLE_GLOBAL structure
277 Instance Instance of the Firmware Volume.
278
279 Returns:
280
281 EFI STATUS
282
283 --*/
284 {
285 VARIABLE_POINTER_TRACK Variable;
286 UINTN VarDataSize;
287 EFI_STATUS Status;
288
289 if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
290 return EFI_INVALID_PARAMETER;
291 }
292 //
293 // Find existing variable
294 //
295 Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
296
297 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
298 goto Done;
299 }
300 //
301 // Get data size
302 //
303 VarDataSize = Variable.CurrPtr->DataSize;
304 if (*DataSize >= VarDataSize) {
305 if (Data == NULL) {
306 Status = EFI_INVALID_PARAMETER;
307 goto Done;
308 }
309
310 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
311 if (Attributes != NULL) {
312 *Attributes = Variable.CurrPtr->Attributes;
313 }
314
315 *DataSize = VarDataSize;
316 Status = EFI_SUCCESS;
317 goto Done;
318 } else {
319 *DataSize = VarDataSize;
320 Status = EFI_BUFFER_TOO_SMALL;
321 goto Done;
322 }
323
324 Done:
325 ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
326 return Status;
327 }
328
329 EFI_STATUS
330 EFIAPI
331 GetNextVariableName (
332 IN OUT UINTN *VariableNameSize,
333 IN OUT CHAR16 *VariableName,
334 IN OUT EFI_GUID *VendorGuid,
335 IN VARIABLE_GLOBAL *Global,
336 IN UINT32 Instance
337 )
338 /*++
339
340 Routine Description:
341
342 This code Finds the Next available variable
343
344 Arguments:
345
346 VariableNameSize Size of the variable
347 VariableName Pointer to variable name
348 VendorGuid Variable Vendor Guid
349 Global VARIABLE_GLOBAL structure pointer.
350 Instance FV instance
351
352 Returns:
353
354 EFI STATUS
355
356 --*/
357 {
358 VARIABLE_POINTER_TRACK Variable;
359 UINTN VarNameSize;
360 EFI_STATUS Status;
361
362 if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
363 return EFI_INVALID_PARAMETER;
364 }
365
366 Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
367
368 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
369 goto Done;
370 }
371
372 while (TRUE) {
373 if (VariableName[0] != 0) {
374 //
375 // If variable name is not NULL, get next variable
376 //
377 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
378 }
379 //
380 // If both volatile and non-volatile variable store are parsed,
381 // return not found
382 //
383 if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
384 Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));
385 if (Variable.Volatile) {
386 Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (Global->VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));
387 Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase));
388 } else {
389 Status = EFI_NOT_FOUND;
390 goto Done;
391 }
392
393 Variable.CurrPtr = Variable.StartPtr;
394 if (Variable.CurrPtr->StartId != VARIABLE_DATA) {
395 continue;
396 }
397 }
398 //
399 // Variable is found
400 //
401 if (Variable.CurrPtr->StartId == VARIABLE_DATA && Variable.CurrPtr->State == VAR_ADDED) {
402 if (!(EfiAtRuntime () && !(Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {
403 VarNameSize = Variable.CurrPtr->NameSize;
404 if (VarNameSize <= *VariableNameSize) {
405 CopyMem (
406 VariableName,
407 GET_VARIABLE_NAME_PTR (Variable.CurrPtr),
408 VarNameSize
409 );
410 CopyMem (
411 VendorGuid,
412 &Variable.CurrPtr->VendorGuid,
413 sizeof (EFI_GUID)
414 );
415 Status = EFI_SUCCESS;
416 } else {
417 Status = EFI_BUFFER_TOO_SMALL;
418 }
419
420 *VariableNameSize = VarNameSize;
421 goto Done;
422 }
423 }
424 }
425
426 Done:
427 ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
428 return Status;
429
430 }
431
432 EFI_STATUS
433 EFIAPI
434 SetVariable (
435 IN CHAR16 *VariableName,
436 IN EFI_GUID *VendorGuid,
437 IN UINT32 Attributes,
438 IN UINTN DataSize,
439 IN VOID *Data,
440 IN VARIABLE_GLOBAL *Global,
441 IN UINTN *VolatileOffset,
442 IN UINTN *NonVolatileOffset,
443 IN UINT32 Instance
444 )
445 /*++
446
447 Routine Description:
448
449 This code sets variable in storage blocks (Volatile or Non-Volatile)
450
451 Arguments:
452
453 VariableName Name of Variable to be found
454 VendorGuid Variable vendor GUID
455 Attributes Attribute value of the variable found
456 DataSize Size of Data found. If size is less than the
457 data, this value contains the required size.
458 Data Data pointer
459 Global Pointer to VARIABLE_GLOBAL structure
460 VolatileOffset The offset of last volatile variable
461 NonVolatileOffset The offset of last non-volatile variable
462 Instance Instance of the Firmware Volume.
463
464 Returns:
465
466 EFI STATUS
467
468 --*/
469 {
470 VARIABLE_POINTER_TRACK Variable;
471 EFI_STATUS Status;
472 VARIABLE_HEADER *NextVariable;
473 UINTN VarNameSize;
474 UINTN VarNameOffset;
475 UINTN VarDataOffset;
476 UINTN VarSize;
477
478 if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
479 return EFI_INVALID_PARAMETER;
480 }
481
482 Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
483
484 if (Status == EFI_INVALID_PARAMETER) {
485 goto Done;
486 } else if (!EFI_ERROR (Status) && Variable.Volatile && EfiAtRuntime()) {
487 //
488 // If EfiAtRuntime and the variable is Volatile and Runtime Access,
489 // the volatile is ReadOnly, and SetVariable should be aborted and
490 // return EFI_WRITE_PROTECTED.
491 //
492 Status = EFI_WRITE_PROTECTED;
493 goto Done;
494 } else if (sizeof (VARIABLE_HEADER) + (StrSize (VariableName) + DataSize) > MAX_VARIABLE_SIZE) {
495 //
496 // The size of the VariableName, including the Unicode Null in bytes plus
497 // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.
498 //
499 Status = EFI_INVALID_PARAMETER;
500 goto Done;
501 } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS
502 ) {
503 //
504 // Make sure if runtime bit is set, boot service bit is set also
505 //
506 Status = EFI_INVALID_PARAMETER;
507 goto Done;
508 } else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
509 //
510 // Runtime but Attribute is not Runtime
511 //
512 Status = EFI_INVALID_PARAMETER;
513 goto Done;
514 } else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_NON_VOLATILE)) {
515 //
516 // Cannot set volatile variable in Runtime
517 //
518 Status = EFI_INVALID_PARAMETER;
519 goto Done;
520 } else if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
521 //
522 // Setting a data variable with no access, or zero DataSize attributes
523 // specified causes it to be deleted.
524 //
525 if (!EFI_ERROR (Status)) {
526 Variable.CurrPtr->State &= VAR_DELETED;
527 Status = EFI_SUCCESS;
528 goto Done;
529 }
530
531 Status = EFI_NOT_FOUND;
532 goto Done;
533 } else {
534 if (!EFI_ERROR (Status)) {
535 //
536 // If the variable is marked valid and the same data has been passed in
537 // then return to the caller immediately.
538 //
539 if (Variable.CurrPtr->DataSize == DataSize &&
540 !CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize)
541 ) {
542 Status = EFI_SUCCESS;
543 goto Done;
544 } else if (Variable.CurrPtr->State == VAR_ADDED) {
545 //
546 // Mark the old variable as in delete transition
547 //
548 Variable.CurrPtr->State &= VAR_IN_DELETED_TRANSITION;
549 }
550 }
551 //
552 // Create a new variable and copy the data.
553 //
554 VarNameOffset = sizeof (VARIABLE_HEADER);
555 VarNameSize = StrSize (VariableName);
556 VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
557 VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
558
559 if (Attributes & EFI_VARIABLE_NON_VOLATILE) {
560 if ((UINT32) (VarSize +*NonVolatileOffset) >
561 ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size
562 ) {
563 Status = EFI_OUT_OF_RESOURCES;
564 goto Done;
565 }
566
567 NextVariable = (VARIABLE_HEADER *) (UINT8 *) (*NonVolatileOffset + (UINTN) Global->NonVolatileVariableBase);
568 *NonVolatileOffset = *NonVolatileOffset + VarSize;
569 } else {
570 if (EfiAtRuntime ()) {
571 Status = EFI_INVALID_PARAMETER;
572 goto Done;
573 }
574
575 if ((UINT32) (VarSize +*VolatileOffset) >
576 ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size
577 ) {
578 Status = EFI_OUT_OF_RESOURCES;
579 goto Done;
580 }
581
582 NextVariable = (VARIABLE_HEADER *) (UINT8 *) (*VolatileOffset + (UINTN) Global->VolatileVariableBase);
583 *VolatileOffset = *VolatileOffset + VarSize;
584 }
585
586 NextVariable->StartId = VARIABLE_DATA;
587 NextVariable->Attributes = Attributes;
588 NextVariable->State = VAR_ADDED;
589 NextVariable->Reserved = 0;
590
591 //
592 // There will be pad bytes after Data, the NextVariable->NameSize and
593 // NextVariable->NameSize should not include pad size so that variable
594 // service can get actual size in GetVariable
595 //
596 NextVariable->NameSize = (UINT32)VarNameSize;
597 NextVariable->DataSize = (UINT32)DataSize;
598
599 CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
600 CopyMem (
601 (UINT8 *) ((UINTN) NextVariable + VarNameOffset),
602 VariableName,
603 VarNameSize
604 );
605 CopyMem (
606 (UINT8 *) ((UINTN) NextVariable + VarDataOffset),
607 Data,
608 DataSize
609 );
610
611 //
612 // Mark the old variable as deleted
613 //
614 if (!EFI_ERROR (Status)) {
615 Variable.CurrPtr->State &= VAR_DELETED;
616 }
617 }
618
619 Status = EFI_SUCCESS;
620 Done:
621 ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
622 return Status;
623 }
624
625 #if (EFI_SPECIFICATION_VERSION >= 0x00020000)
626 EFI_STATUS
627 EFIAPI
628 QueryVariableInfo (
629 IN UINT32 Attributes,
630 OUT UINT64 *MaximumVariableStorageSize,
631 OUT UINT64 *RemainingVariableStorageSize,
632 OUT UINT64 *MaximumVariableSize,
633 IN VARIABLE_GLOBAL *Global,
634 IN UINT32 Instance
635 )
636 /*++
637
638 Routine Description:
639
640 This code returns information about the EFI variables.
641
642 Arguments:
643
644 Attributes Attributes bitmask to specify the type of variables
645 on which to return information.
646 MaximumVariableStorageSize Pointer to the maximum size of the storage space available
647 for the EFI variables associated with the attributes specified.
648 RemainingVariableStorageSize Pointer to the remaining size of the storage space available
649 for the EFI variables associated with the attributes specified.
650 MaximumVariableSize Pointer to the maximum size of the individual EFI variables
651 associated with the attributes specified.
652 Global Pointer to VARIABLE_GLOBAL structure.
653 Instance Instance of the Firmware Volume.
654
655 Returns:
656
657 EFI STATUS
658 EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
659 EFI_SUCCESS - Query successfully.
660 EFI_UNSUPPORTED - The attribute is not supported on this platform.
661
662 --*/
663 {
664 VARIABLE_HEADER *Variable;
665 VARIABLE_HEADER *NextVariable;
666 UINT64 VariableSize;
667 VARIABLE_STORE_HEADER *VariableStoreHeader;
668
669 if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL) {
670 return EFI_INVALID_PARAMETER;
671 }
672
673 if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)) == 0) {
674 //
675 // Make sure the Attributes combination is supported by the platform.
676 //
677 return EFI_UNSUPPORTED;
678 } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
679 //
680 // Make sure if runtime bit is set, boot service bit is set also.
681 //
682 return EFI_INVALID_PARAMETER;
683 } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
684 //
685 // Make sure RT Attribute is set if we are in Runtime phase.
686 //
687 return EFI_INVALID_PARAMETER;
688 } else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_NON_VOLATILE)) {
689 //
690 // Cannot Query volatile variable in Runtime
691 //
692 return EFI_INVALID_PARAMETER;
693 }
694
695 AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);
696
697 if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
698 //
699 // Query is Volatile related.
700 //
701 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
702 } else {
703 //
704 // Query is Non-Volatile related.
705 //
706 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);
707 }
708
709 //
710 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
711 // with the storage size (excluding the storage header size)
712 //
713 *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
714 *RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
715
716 //
717 // Let *MaximumVariableSize be MAX_VARIABLE_SIZE
718 //
719 *MaximumVariableSize = MAX_VARIABLE_SIZE;
720
721 //
722 // Point to the starting address of the variables.
723 //
724 Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
725
726 //
727 // Now walk through the related variable store.
728 //
729 while (Variable < GetEndPointer (VariableStoreHeader)) {
730 if (Variable->StartId != VARIABLE_DATA) {
731 break;
732 }
733
734 NextVariable = (VARIABLE_HEADER *) (GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
735 VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
736
737 if (Variable->State == VAR_ADDED) {
738 *RemainingVariableStorageSize -= VariableSize;
739 }
740
741 //
742 // Go to the next one.
743 //
744 Variable = NextVariable;
745 }
746
747 ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
748 return EFI_SUCCESS;
749 }
750 #endif
751
752 STATIC
753 EFI_STATUS
754 EFIAPI
755 InitializeVariableStore (
756 OUT EFI_PHYSICAL_ADDRESS *VariableBase,
757 OUT UINTN *LastVariableOffset
758 )
759 /*++
760
761 Routine Description:
762 This function initializes variable store
763
764 Arguments:
765
766 Returns:
767
768 --*/
769 {
770 VARIABLE_STORE_HEADER *VariableStore;
771
772 //
773 // Allocate memory for volatile variable store
774 //
775 VariableStore = (VARIABLE_STORE_HEADER *) AllocateRuntimePool (
776 VARIABLE_STORE_SIZE
777 );
778 if (NULL == VariableStore) {
779 return EFI_OUT_OF_RESOURCES;
780 }
781
782 SetMem (VariableStore, VARIABLE_STORE_SIZE, 0xff);
783
784 //
785 // Variable Specific Data
786 //
787 *VariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStore;
788 *LastVariableOffset = sizeof (VARIABLE_STORE_HEADER);
789
790 VariableStore->Signature = VARIABLE_STORE_SIGNATURE;
791 VariableStore->Size = VARIABLE_STORE_SIZE;
792 VariableStore->Format = VARIABLE_STORE_FORMATTED;
793 VariableStore->State = VARIABLE_STORE_HEALTHY;
794 VariableStore->Reserved = 0;
795 VariableStore->Reserved1 = 0;
796
797 return EFI_SUCCESS;
798 }
799
800 EFI_STATUS
801 EFIAPI
802 VariableCommonInitialize (
803 IN EFI_HANDLE ImageHandle,
804 IN EFI_SYSTEM_TABLE *SystemTable
805 )
806 /*++
807
808 Routine Description:
809 This function does common initialization for variable services
810
811 Arguments:
812
813 Returns:
814
815 --*/
816 {
817 EFI_STATUS Status;
818
819 //
820 // Allocate memory for mVariableModuleGlobal
821 //
822 mVariableModuleGlobal = (ESAL_VARIABLE_GLOBAL *) AllocateRuntimePool (
823 sizeof (ESAL_VARIABLE_GLOBAL)
824 );
825 if (NULL == mVariableModuleGlobal) {
826 return EFI_OUT_OF_RESOURCES;
827 }
828
829 EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal[Physical].VariableServicesLock, EFI_TPL_NOTIFY);
830
831 //
832 // Intialize volatile variable store
833 //
834 Status = InitializeVariableStore (
835 &mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase,
836 &mVariableModuleGlobal->VolatileLastVariableOffset
837 );
838
839 if (EFI_ERROR (Status)) {
840 return Status;
841 }
842 //
843 // Intialize non volatile variable store
844 //
845 Status = InitializeVariableStore (
846 &mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase,
847 &mVariableModuleGlobal->NonVolatileLastVariableOffset
848 );
849
850 return Status;
851 }