]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Variable/Pei/Variable.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm
[mirror_edk2.git] / MdeModulePkg / Universal / Variable / Pei / Variable.c
1 /** @file
2 Implement ReadOnly Variable Services required by PEIM and install
3 PEI ReadOnly Varaiable2 PPI. These services operates the non volatile storage space.
4
5 Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
6 Copyright (c) Microsoft Corporation.<BR>
7 SPDX-License-Identifier: BSD-2-Clause-Patent
8
9 **/
10
11 #include "Variable.h"
12
13 //
14 // Module globals
15 //
16 EFI_PEI_READ_ONLY_VARIABLE2_PPI mVariablePpi = {
17 PeiGetVariable,
18 PeiGetNextVariableName
19 };
20
21 EFI_PEI_PPI_DESCRIPTOR mPpiListVariable = {
22 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
23 &gEfiPeiReadOnlyVariable2PpiGuid,
24 &mVariablePpi
25 };
26
27 /**
28 Provide the functionality of the variable services.
29
30 @param FileHandle Handle of the file being invoked.
31 Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().
32 @param PeiServices General purpose services available to every PEIM.
33
34 @retval EFI_SUCCESS If the interface could be successfully installed
35 @retval Others Returned from PeiServicesInstallPpi()
36 **/
37 EFI_STATUS
38 EFIAPI
39 PeimInitializeVariableServices (
40 IN EFI_PEI_FILE_HANDLE FileHandle,
41 IN CONST EFI_PEI_SERVICES **PeiServices
42 )
43 {
44 return PeiServicesInstallPpi (&mPpiListVariable);
45 }
46
47 /**
48
49 Gets the pointer to the first variable header in given variable store area.
50
51 @param VarStoreHeader Pointer to the Variable Store Header.
52
53 @return Pointer to the first variable header.
54
55 **/
56 VARIABLE_HEADER *
57 GetStartPointer (
58 IN VARIABLE_STORE_HEADER *VarStoreHeader
59 )
60 {
61 //
62 // The start of variable store
63 //
64 return (VARIABLE_HEADER *)HEADER_ALIGN (VarStoreHeader + 1);
65 }
66
67 /**
68
69 Gets the pointer to the end of the variable storage area.
70
71 This function gets pointer to the end of the variable storage
72 area, according to the input variable store header.
73
74 @param VarStoreHeader Pointer to the Variable Store Header.
75
76 @return Pointer to the end of the variable storage area.
77
78 **/
79 VARIABLE_HEADER *
80 GetEndPointer (
81 IN VARIABLE_STORE_HEADER *VarStoreHeader
82 )
83 {
84 //
85 // The end of variable store
86 //
87 return (VARIABLE_HEADER *)HEADER_ALIGN ((UINTN)VarStoreHeader + VarStoreHeader->Size);
88 }
89
90 /**
91 This code checks if variable header is valid or not.
92
93 @param Variable Pointer to the Variable Header.
94
95 @retval TRUE Variable header is valid.
96 @retval FALSE Variable header is not valid.
97
98 **/
99 BOOLEAN
100 IsValidVariableHeader (
101 IN VARIABLE_HEADER *Variable
102 )
103 {
104 if ((Variable == NULL) || (Variable->StartId != VARIABLE_DATA)) {
105 return FALSE;
106 }
107
108 return TRUE;
109 }
110
111 /**
112 This code gets the size of variable header.
113
114 @param AuthFlag Authenticated variable flag.
115
116 @return Size of variable header in bytes in type UINTN.
117
118 **/
119 UINTN
120 GetVariableHeaderSize (
121 IN BOOLEAN AuthFlag
122 )
123 {
124 UINTN Value;
125
126 if (AuthFlag) {
127 Value = sizeof (AUTHENTICATED_VARIABLE_HEADER);
128 } else {
129 Value = sizeof (VARIABLE_HEADER);
130 }
131
132 return Value;
133 }
134
135 /**
136 This code gets the size of name of variable.
137
138 @param Variable Pointer to the Variable Header.
139 @param AuthFlag Authenticated variable flag.
140
141 @return Size of variable in bytes in type UINTN.
142
143 **/
144 UINTN
145 NameSizeOfVariable (
146 IN VARIABLE_HEADER *Variable,
147 IN BOOLEAN AuthFlag
148 )
149 {
150 AUTHENTICATED_VARIABLE_HEADER *AuthVariable;
151
152 AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
153 if (AuthFlag) {
154 if ((AuthVariable->State == (UINT8)(-1)) ||
155 (AuthVariable->DataSize == (UINT32)(-1)) ||
156 (AuthVariable->NameSize == (UINT32)(-1)) ||
157 (AuthVariable->Attributes == (UINT32)(-1)))
158 {
159 return 0;
160 }
161
162 return (UINTN)AuthVariable->NameSize;
163 } else {
164 if ((Variable->State == (UINT8)(-1)) ||
165 (Variable->DataSize == (UINT32)(-1)) ||
166 (Variable->NameSize == (UINT32)(-1)) ||
167 (Variable->Attributes == (UINT32)(-1)))
168 {
169 return 0;
170 }
171
172 return (UINTN)Variable->NameSize;
173 }
174 }
175
176 /**
177 This code gets the size of data of variable.
178
179 @param Variable Pointer to the Variable Header.
180 @param AuthFlag Authenticated variable flag.
181
182 @return Size of variable in bytes in type UINTN.
183
184 **/
185 UINTN
186 DataSizeOfVariable (
187 IN VARIABLE_HEADER *Variable,
188 IN BOOLEAN AuthFlag
189 )
190 {
191 AUTHENTICATED_VARIABLE_HEADER *AuthVariable;
192
193 AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
194 if (AuthFlag) {
195 if ((AuthVariable->State == (UINT8)(-1)) ||
196 (AuthVariable->DataSize == (UINT32)(-1)) ||
197 (AuthVariable->NameSize == (UINT32)(-1)) ||
198 (AuthVariable->Attributes == (UINT32)(-1)))
199 {
200 return 0;
201 }
202
203 return (UINTN)AuthVariable->DataSize;
204 } else {
205 if ((Variable->State == (UINT8)(-1)) ||
206 (Variable->DataSize == (UINT32)(-1)) ||
207 (Variable->NameSize == (UINT32)(-1)) ||
208 (Variable->Attributes == (UINT32)(-1)))
209 {
210 return 0;
211 }
212
213 return (UINTN)Variable->DataSize;
214 }
215 }
216
217 /**
218 This code gets the pointer to the variable name.
219
220 @param Variable Pointer to the Variable Header.
221 @param AuthFlag Authenticated variable flag.
222
223 @return A CHAR16* pointer to Variable Name.
224
225 **/
226 CHAR16 *
227 GetVariableNamePtr (
228 IN VARIABLE_HEADER *Variable,
229 IN BOOLEAN AuthFlag
230 )
231 {
232 return (CHAR16 *)((UINTN)Variable + GetVariableHeaderSize (AuthFlag));
233 }
234
235 /**
236 This code gets the pointer to the variable guid.
237
238 @param Variable Pointer to the Variable Header.
239 @param AuthFlag Authenticated variable flag.
240
241 @return A EFI_GUID* pointer to Vendor Guid.
242
243 **/
244 EFI_GUID *
245 GetVendorGuidPtr (
246 IN VARIABLE_HEADER *Variable,
247 IN BOOLEAN AuthFlag
248 )
249 {
250 AUTHENTICATED_VARIABLE_HEADER *AuthVariable;
251
252 AuthVariable = (AUTHENTICATED_VARIABLE_HEADER *)Variable;
253 if (AuthFlag) {
254 return &AuthVariable->VendorGuid;
255 } else {
256 return &Variable->VendorGuid;
257 }
258 }
259
260 /**
261 This code gets the pointer to the variable data.
262
263 @param Variable Pointer to the Variable Header.
264 @param VariableHeader Pointer to the Variable Header that has consecutive content.
265 @param AuthFlag Authenticated variable flag.
266
267 @return A UINT8* pointer to Variable Data.
268
269 **/
270 UINT8 *
271 GetVariableDataPtr (
272 IN VARIABLE_HEADER *Variable,
273 IN VARIABLE_HEADER *VariableHeader,
274 IN BOOLEAN AuthFlag
275 )
276 {
277 UINTN Value;
278
279 //
280 // Be careful about pad size for alignment
281 //
282 Value = (UINTN)GetVariableNamePtr (Variable, AuthFlag);
283 Value += NameSizeOfVariable (VariableHeader, AuthFlag);
284 Value += GET_PAD_SIZE (NameSizeOfVariable (VariableHeader, AuthFlag));
285
286 return (UINT8 *)Value;
287 }
288
289 /**
290 This code gets the pointer to the next variable header.
291
292 @param StoreInfo Pointer to variable store info structure.
293 @param Variable Pointer to the Variable Header.
294 @param VariableHeader Pointer to the Variable Header that has consecutive content.
295
296 @return A VARIABLE_HEADER* pointer to next variable header.
297
298 **/
299 VARIABLE_HEADER *
300 GetNextVariablePtr (
301 IN VARIABLE_STORE_INFO *StoreInfo,
302 IN VARIABLE_HEADER *Variable,
303 IN VARIABLE_HEADER *VariableHeader
304 )
305 {
306 EFI_PHYSICAL_ADDRESS TargetAddress;
307 EFI_PHYSICAL_ADDRESS SpareAddress;
308 UINTN Value;
309
310 Value = (UINTN)GetVariableDataPtr (Variable, VariableHeader, StoreInfo->AuthFlag);
311 Value += DataSizeOfVariable (VariableHeader, StoreInfo->AuthFlag);
312 Value += GET_PAD_SIZE (DataSizeOfVariable (VariableHeader, StoreInfo->AuthFlag));
313 //
314 // Be careful about pad size for alignment
315 //
316 Value = HEADER_ALIGN (Value);
317
318 if (StoreInfo->FtwLastWriteData != NULL) {
319 TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;
320 SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;
321 if (((UINTN)Variable < (UINTN)TargetAddress) && (Value >= (UINTN)TargetAddress)) {
322 //
323 // Next variable is in spare block.
324 //
325 Value = (UINTN)SpareAddress + (Value - (UINTN)TargetAddress);
326 }
327 }
328
329 return (VARIABLE_HEADER *)Value;
330 }
331
332 /**
333 Get variable store status.
334
335 @param VarStoreHeader Pointer to the Variable Store Header.
336
337 @retval EfiRaw Variable store is raw
338 @retval EfiValid Variable store is valid
339 @retval EfiInvalid Variable store is invalid
340
341 **/
342 VARIABLE_STORE_STATUS
343 GetVariableStoreStatus (
344 IN VARIABLE_STORE_HEADER *VarStoreHeader
345 )
346 {
347 if ((CompareGuid (&VarStoreHeader->Signature, &gEfiAuthenticatedVariableGuid) ||
348 CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid)) &&
349 (VarStoreHeader->Format == VARIABLE_STORE_FORMATTED) &&
350 (VarStoreHeader->State == VARIABLE_STORE_HEALTHY)
351 )
352 {
353 return EfiValid;
354 }
355
356 if ((((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff) &&
357 (((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff) &&
358 (((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff) &&
359 (((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff) &&
360 (VarStoreHeader->Size == 0xffffffff) &&
361 (VarStoreHeader->Format == 0xff) &&
362 (VarStoreHeader->State == 0xff)
363 )
364 {
365 return EfiRaw;
366 } else {
367 return EfiInvalid;
368 }
369 }
370
371 /**
372 Compare two variable names, one of them may be inconsecutive.
373
374 @param StoreInfo Pointer to variable store info structure.
375 @param Name1 Pointer to one variable name.
376 @param Name2 Pointer to another variable name.
377 @param NameSize Variable name size.
378
379 @retval TRUE Name1 and Name2 are identical.
380 @retval FALSE Name1 and Name2 are not identical.
381
382 **/
383 BOOLEAN
384 CompareVariableName (
385 IN VARIABLE_STORE_INFO *StoreInfo,
386 IN CONST CHAR16 *Name1,
387 IN CONST CHAR16 *Name2,
388 IN UINTN NameSize
389 )
390 {
391 EFI_PHYSICAL_ADDRESS TargetAddress;
392 EFI_PHYSICAL_ADDRESS SpareAddress;
393 UINTN PartialNameSize;
394
395 if (StoreInfo->FtwLastWriteData != NULL) {
396 TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;
397 SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;
398 if (((UINTN)Name1 < (UINTN)TargetAddress) && (((UINTN)Name1 + NameSize) > (UINTN)TargetAddress)) {
399 //
400 // Name1 is inconsecutive.
401 //
402 PartialNameSize = (UINTN)TargetAddress - (UINTN)Name1;
403 //
404 // Partial content is in NV storage.
405 //
406 if (CompareMem ((UINT8 *)Name1, (UINT8 *)Name2, PartialNameSize) == 0) {
407 //
408 // Another partial content is in spare block.
409 //
410 if (CompareMem ((UINT8 *)(UINTN)SpareAddress, (UINT8 *)Name2 + PartialNameSize, NameSize - PartialNameSize) == 0) {
411 return TRUE;
412 }
413 }
414
415 return FALSE;
416 } else if (((UINTN)Name2 < (UINTN)TargetAddress) && (((UINTN)Name2 + NameSize) > (UINTN)TargetAddress)) {
417 //
418 // Name2 is inconsecutive.
419 //
420 PartialNameSize = (UINTN)TargetAddress - (UINTN)Name2;
421 //
422 // Partial content is in NV storage.
423 //
424 if (CompareMem ((UINT8 *)Name2, (UINT8 *)Name1, PartialNameSize) == 0) {
425 //
426 // Another partial content is in spare block.
427 //
428 if (CompareMem ((UINT8 *)(UINTN)SpareAddress, (UINT8 *)Name1 + PartialNameSize, NameSize - PartialNameSize) == 0) {
429 return TRUE;
430 }
431 }
432
433 return FALSE;
434 }
435 }
436
437 //
438 // Both Name1 and Name2 are consecutive.
439 //
440 if (CompareMem ((UINT8 *)Name1, (UINT8 *)Name2, NameSize) == 0) {
441 return TRUE;
442 }
443
444 return FALSE;
445 }
446
447 /**
448 This function compares a variable with variable entries in database.
449
450 @param StoreInfo Pointer to variable store info structure.
451 @param Variable Pointer to the variable in our database
452 @param VariableHeader Pointer to the Variable Header that has consecutive content.
453 @param VariableName Name of the variable to compare to 'Variable'
454 @param VendorGuid GUID of the variable to compare to 'Variable'
455 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
456
457 @retval EFI_SUCCESS Found match variable
458 @retval EFI_NOT_FOUND Variable not found
459
460 **/
461 EFI_STATUS
462 CompareWithValidVariable (
463 IN VARIABLE_STORE_INFO *StoreInfo,
464 IN VARIABLE_HEADER *Variable,
465 IN VARIABLE_HEADER *VariableHeader,
466 IN CONST CHAR16 *VariableName,
467 IN CONST EFI_GUID *VendorGuid,
468 OUT VARIABLE_POINTER_TRACK *PtrTrack
469 )
470 {
471 VOID *Point;
472 EFI_GUID *TempVendorGuid;
473
474 TempVendorGuid = GetVendorGuidPtr (VariableHeader, StoreInfo->AuthFlag);
475
476 if (VariableName[0] == 0) {
477 PtrTrack->CurrPtr = Variable;
478 return EFI_SUCCESS;
479 } else {
480 //
481 // Don't use CompareGuid function here for performance reasons.
482 // Instead we compare the GUID a UINT32 at a time and branch
483 // on the first failed comparison.
484 //
485 if ((((INT32 *)VendorGuid)[0] == ((INT32 *)TempVendorGuid)[0]) &&
486 (((INT32 *)VendorGuid)[1] == ((INT32 *)TempVendorGuid)[1]) &&
487 (((INT32 *)VendorGuid)[2] == ((INT32 *)TempVendorGuid)[2]) &&
488 (((INT32 *)VendorGuid)[3] == ((INT32 *)TempVendorGuid)[3])
489 )
490 {
491 ASSERT (NameSizeOfVariable (VariableHeader, StoreInfo->AuthFlag) != 0);
492 Point = (VOID *)GetVariableNamePtr (Variable, StoreInfo->AuthFlag);
493 if (CompareVariableName (StoreInfo, VariableName, Point, NameSizeOfVariable (VariableHeader, StoreInfo->AuthFlag))) {
494 PtrTrack->CurrPtr = Variable;
495 return EFI_SUCCESS;
496 }
497 }
498 }
499
500 return EFI_NOT_FOUND;
501 }
502
503 /**
504 Get HOB variable store.
505
506 @param[out] StoreInfo Return the store info.
507 @param[out] VariableStoreHeader Return variable store header.
508
509 **/
510 VOID
511 GetHobVariableStore (
512 OUT VARIABLE_STORE_INFO *StoreInfo,
513 OUT VARIABLE_STORE_HEADER **VariableStoreHeader
514 )
515 {
516 EFI_HOB_GUID_TYPE *GuidHob;
517
518 //
519 // Make sure there is no more than one Variable HOB.
520 //
521 DEBUG_CODE_BEGIN ();
522 GuidHob = GetFirstGuidHob (&gEfiAuthenticatedVariableGuid);
523 if (GuidHob != NULL) {
524 if ((GetNextGuidHob (&gEfiAuthenticatedVariableGuid, GET_NEXT_HOB (GuidHob)) != NULL)) {
525 DEBUG ((DEBUG_ERROR, "ERROR: Found two Auth Variable HOBs\n"));
526 ASSERT (FALSE);
527 } else if (GetFirstGuidHob (&gEfiVariableGuid) != NULL) {
528 DEBUG ((DEBUG_ERROR, "ERROR: Found one Auth + one Normal Variable HOBs\n"));
529 ASSERT (FALSE);
530 }
531 } else {
532 GuidHob = GetFirstGuidHob (&gEfiVariableGuid);
533 if (GuidHob != NULL) {
534 if ((GetNextGuidHob (&gEfiVariableGuid, GET_NEXT_HOB (GuidHob)) != NULL)) {
535 DEBUG ((DEBUG_ERROR, "ERROR: Found two Normal Variable HOBs\n"));
536 ASSERT (FALSE);
537 }
538 }
539 }
540
541 DEBUG_CODE_END ();
542
543 GuidHob = GetFirstGuidHob (&gEfiAuthenticatedVariableGuid);
544 if (GuidHob != NULL) {
545 *VariableStoreHeader = (VARIABLE_STORE_HEADER *)GET_GUID_HOB_DATA (GuidHob);
546 StoreInfo->AuthFlag = TRUE;
547 } else {
548 GuidHob = GetFirstGuidHob (&gEfiVariableGuid);
549 if (GuidHob != NULL) {
550 *VariableStoreHeader = (VARIABLE_STORE_HEADER *)GET_GUID_HOB_DATA (GuidHob);
551 StoreInfo->AuthFlag = FALSE;
552 }
553 }
554 }
555
556 /**
557 Return the variable store header and the store info based on the Index.
558
559 @param Type The type of the variable store.
560 @param StoreInfo Return the store info.
561
562 @return Pointer to the variable store header.
563 **/
564 VARIABLE_STORE_HEADER *
565 GetVariableStore (
566 IN VARIABLE_STORE_TYPE Type,
567 OUT VARIABLE_STORE_INFO *StoreInfo
568 )
569 {
570 EFI_STATUS Status;
571 EFI_HOB_GUID_TYPE *GuidHob;
572 EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
573 VARIABLE_STORE_HEADER *VariableStoreHeader;
574 EFI_PHYSICAL_ADDRESS NvStorageBase;
575 UINT32 NvStorageSize;
576 UINT64 NvStorageSize64;
577 FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *FtwLastWriteData;
578 UINT32 BackUpOffset;
579
580 StoreInfo->IndexTable = NULL;
581 StoreInfo->FtwLastWriteData = NULL;
582 StoreInfo->AuthFlag = FALSE;
583 VariableStoreHeader = NULL;
584 switch (Type) {
585 case VariableStoreTypeHob:
586 GetHobVariableStore (StoreInfo, &VariableStoreHeader);
587
588 break;
589
590 case VariableStoreTypeNv:
591 if (!PcdGetBool (PcdEmuVariableNvModeEnable)) {
592 //
593 // Emulated non-volatile variable mode is not enabled.
594 //
595
596 Status = GetVariableFlashNvStorageInfo (&NvStorageBase, &NvStorageSize64);
597 ASSERT_EFI_ERROR (Status);
598
599 Status = SafeUint64ToUint32 (NvStorageSize64, &NvStorageSize);
600 // This driver currently assumes the size will be UINT32 so assert the value is safe for now.
601 ASSERT_EFI_ERROR (Status);
602
603 ASSERT (NvStorageBase != 0);
604
605 //
606 // First let FvHeader point to NV storage base.
607 //
608 FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)NvStorageBase;
609
610 //
611 // Check the FTW last write data hob.
612 //
613 BackUpOffset = 0;
614 GuidHob = GetFirstGuidHob (&gEdkiiFaultTolerantWriteGuid);
615 if (GuidHob != NULL) {
616 FtwLastWriteData = (FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *)GET_GUID_HOB_DATA (GuidHob);
617 if (FtwLastWriteData->TargetAddress == NvStorageBase) {
618 //
619 // Let FvHeader point to spare block.
620 //
621 FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)FtwLastWriteData->SpareAddress;
622 DEBUG ((DEBUG_INFO, "PeiVariable: NV storage is backed up in spare block: 0x%x\n", (UINTN)FtwLastWriteData->SpareAddress));
623 } else if ((FtwLastWriteData->TargetAddress > NvStorageBase) && (FtwLastWriteData->TargetAddress < (NvStorageBase + NvStorageSize))) {
624 StoreInfo->FtwLastWriteData = FtwLastWriteData;
625 //
626 // Flash NV storage from the offset is backed up in spare block.
627 //
628 BackUpOffset = (UINT32)(FtwLastWriteData->TargetAddress - NvStorageBase);
629 DEBUG ((DEBUG_INFO, "PeiVariable: High partial NV storage from offset: %x is backed up in spare block: 0x%x\n", BackUpOffset, (UINTN)FtwLastWriteData->SpareAddress));
630 //
631 // At least one block data in flash NV storage is still valid, so still leave FvHeader point to NV storage base.
632 //
633 }
634 }
635
636 //
637 // Check if the Firmware Volume is not corrupted
638 //
639 if ((FvHeader->Signature != EFI_FVH_SIGNATURE) || (!CompareGuid (&gEfiSystemNvDataFvGuid, &FvHeader->FileSystemGuid))) {
640 DEBUG ((DEBUG_ERROR, "Firmware Volume for Variable Store is corrupted\n"));
641 break;
642 }
643
644 VariableStoreHeader = (VARIABLE_STORE_HEADER *)((UINT8 *)FvHeader + FvHeader->HeaderLength);
645
646 StoreInfo->AuthFlag = (BOOLEAN)(CompareGuid (&VariableStoreHeader->Signature, &gEfiAuthenticatedVariableGuid));
647
648 GuidHob = GetFirstGuidHob (&gEfiVariableIndexTableGuid);
649 if (GuidHob != NULL) {
650 StoreInfo->IndexTable = GET_GUID_HOB_DATA (GuidHob);
651 } else {
652 //
653 // If it's the first time to access variable region in flash, create a guid hob to record
654 // VAR_ADDED type variable info.
655 // Note that as the resource of PEI phase is limited, only store the limited number of
656 // VAR_ADDED type variables to reduce access time.
657 //
658 StoreInfo->IndexTable = (VARIABLE_INDEX_TABLE *)BuildGuidHob (&gEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));
659 StoreInfo->IndexTable->Length = 0;
660 StoreInfo->IndexTable->StartPtr = GetStartPointer (VariableStoreHeader);
661 StoreInfo->IndexTable->EndPtr = GetEndPointer (VariableStoreHeader);
662 StoreInfo->IndexTable->GoneThrough = 0;
663 }
664 }
665
666 break;
667
668 default:
669 ASSERT (FALSE);
670 break;
671 }
672
673 StoreInfo->VariableStoreHeader = VariableStoreHeader;
674 return VariableStoreHeader;
675 }
676
677 /**
678 Get variable header that has consecutive content.
679
680 @param StoreInfo Pointer to variable store info structure.
681 @param Variable Pointer to the Variable Header.
682 @param VariableHeader Pointer to Pointer to the Variable Header that has consecutive content.
683
684 @retval TRUE Variable header is valid.
685 @retval FALSE Variable header is not valid.
686
687 **/
688 BOOLEAN
689 GetVariableHeader (
690 IN VARIABLE_STORE_INFO *StoreInfo,
691 IN VARIABLE_HEADER *Variable,
692 OUT VARIABLE_HEADER **VariableHeader
693 )
694 {
695 EFI_PHYSICAL_ADDRESS TargetAddress;
696 EFI_PHYSICAL_ADDRESS SpareAddress;
697 EFI_HOB_GUID_TYPE *GuidHob;
698 UINTN PartialHeaderSize;
699
700 if (Variable == NULL) {
701 return FALSE;
702 }
703
704 //
705 // First assume variable header pointed by Variable is consecutive.
706 //
707 *VariableHeader = Variable;
708
709 if (StoreInfo->FtwLastWriteData != NULL) {
710 TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;
711 SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;
712 if (((UINTN)Variable > (UINTN)SpareAddress) &&
713 (((UINTN)Variable - (UINTN)SpareAddress + (UINTN)TargetAddress) >= (UINTN)GetEndPointer (StoreInfo->VariableStoreHeader)))
714 {
715 //
716 // Reach the end of variable store.
717 //
718 return FALSE;
719 }
720
721 if (((UINTN)Variable < (UINTN)TargetAddress) && (((UINTN)Variable + GetVariableHeaderSize (StoreInfo->AuthFlag)) > (UINTN)TargetAddress)) {
722 //
723 // Variable header pointed by Variable is inconsecutive,
724 // create a guid hob to combine the two partial variable header content together.
725 //
726 GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);
727 if (GuidHob != NULL) {
728 *VariableHeader = (VARIABLE_HEADER *)GET_GUID_HOB_DATA (GuidHob);
729 } else {
730 *VariableHeader = (VARIABLE_HEADER *)BuildGuidHob (&gEfiCallerIdGuid, GetVariableHeaderSize (StoreInfo->AuthFlag));
731 PartialHeaderSize = (UINTN)TargetAddress - (UINTN)Variable;
732 //
733 // Partial content is in NV storage.
734 //
735 CopyMem ((UINT8 *)*VariableHeader, (UINT8 *)Variable, PartialHeaderSize);
736 //
737 // Another partial content is in spare block.
738 //
739 CopyMem ((UINT8 *)*VariableHeader + PartialHeaderSize, (UINT8 *)(UINTN)SpareAddress, GetVariableHeaderSize (StoreInfo->AuthFlag) - PartialHeaderSize);
740 }
741 }
742 } else {
743 if (Variable >= GetEndPointer (StoreInfo->VariableStoreHeader)) {
744 //
745 // Reach the end of variable store.
746 //
747 return FALSE;
748 }
749 }
750
751 return IsValidVariableHeader (*VariableHeader);
752 }
753
754 /**
755 Get variable name or data to output buffer.
756
757 @param StoreInfo Pointer to variable store info structure.
758 @param NameOrData Pointer to the variable name/data that may be inconsecutive.
759 @param Size Variable name/data size.
760 @param Buffer Pointer to output buffer to hold the variable name/data.
761
762 **/
763 VOID
764 GetVariableNameOrData (
765 IN VARIABLE_STORE_INFO *StoreInfo,
766 IN UINT8 *NameOrData,
767 IN UINTN Size,
768 OUT UINT8 *Buffer
769 )
770 {
771 EFI_PHYSICAL_ADDRESS TargetAddress;
772 EFI_PHYSICAL_ADDRESS SpareAddress;
773 UINTN PartialSize;
774
775 if (StoreInfo->FtwLastWriteData != NULL) {
776 TargetAddress = StoreInfo->FtwLastWriteData->TargetAddress;
777 SpareAddress = StoreInfo->FtwLastWriteData->SpareAddress;
778 if (((UINTN)NameOrData < (UINTN)TargetAddress) && (((UINTN)NameOrData + Size) > (UINTN)TargetAddress)) {
779 //
780 // Variable name/data is inconsecutive.
781 //
782 PartialSize = (UINTN)TargetAddress - (UINTN)NameOrData;
783 //
784 // Partial content is in NV storage.
785 //
786 CopyMem (Buffer, NameOrData, PartialSize);
787 //
788 // Another partial content is in spare block.
789 //
790 CopyMem (Buffer + PartialSize, (UINT8 *)(UINTN)SpareAddress, Size - PartialSize);
791 return;
792 }
793 }
794
795 //
796 // Variable name/data is consecutive.
797 //
798 CopyMem (Buffer, NameOrData, Size);
799 }
800
801 /**
802 Find the variable in the specified variable store.
803
804 @param StoreInfo Pointer to the store info structure.
805 @param VariableName Name of the variable to be found
806 @param VendorGuid Vendor GUID to be found.
807 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
808
809 @retval EFI_SUCCESS Variable found successfully
810 @retval EFI_NOT_FOUND Variable not found
811 @retval EFI_INVALID_PARAMETER Invalid variable name
812
813 **/
814 EFI_STATUS
815 FindVariableEx (
816 IN VARIABLE_STORE_INFO *StoreInfo,
817 IN CONST CHAR16 *VariableName,
818 IN CONST EFI_GUID *VendorGuid,
819 OUT VARIABLE_POINTER_TRACK *PtrTrack
820 )
821 {
822 VARIABLE_HEADER *Variable;
823 VARIABLE_HEADER *LastVariable;
824 VARIABLE_HEADER *MaxIndex;
825 UINTN Index;
826 UINTN Offset;
827 BOOLEAN StopRecord;
828 VARIABLE_HEADER *InDeletedVariable;
829 VARIABLE_STORE_HEADER *VariableStoreHeader;
830 VARIABLE_INDEX_TABLE *IndexTable;
831 VARIABLE_HEADER *VariableHeader;
832
833 VariableStoreHeader = StoreInfo->VariableStoreHeader;
834
835 if (VariableStoreHeader == NULL) {
836 return EFI_INVALID_PARAMETER;
837 }
838
839 if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {
840 return EFI_UNSUPPORTED;
841 }
842
843 if (~VariableStoreHeader->Size == 0) {
844 return EFI_NOT_FOUND;
845 }
846
847 IndexTable = StoreInfo->IndexTable;
848 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader);
849 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader);
850
851 InDeletedVariable = NULL;
852
853 //
854 // No Variable Address equals zero, so 0 as initial value is safe.
855 //
856 MaxIndex = NULL;
857 VariableHeader = NULL;
858
859 if (IndexTable != NULL) {
860 //
861 // traverse the variable index table to look for varible.
862 // The IndexTable->Index[Index] records the distance of two neighbouring VAR_ADDED type variables.
863 //
864 for (Offset = 0, Index = 0; Index < IndexTable->Length; Index++) {
865 ASSERT (Index < sizeof (IndexTable->Index) / sizeof (IndexTable->Index[0]));
866 Offset += IndexTable->Index[Index];
867 MaxIndex = (VARIABLE_HEADER *)((UINT8 *)IndexTable->StartPtr + Offset);
868 GetVariableHeader (StoreInfo, MaxIndex, &VariableHeader);
869 if (CompareWithValidVariable (StoreInfo, MaxIndex, VariableHeader, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
870 if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
871 InDeletedVariable = PtrTrack->CurrPtr;
872 } else {
873 return EFI_SUCCESS;
874 }
875 }
876 }
877
878 if (IndexTable->GoneThrough != 0) {
879 //
880 // If the table has all the existing variables indexed, return.
881 //
882 PtrTrack->CurrPtr = InDeletedVariable;
883 return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;
884 }
885 }
886
887 if (MaxIndex != NULL) {
888 //
889 // HOB exists but the variable cannot be found in HOB
890 // If not found in HOB, then let's start from the MaxIndex we've found.
891 //
892 Variable = GetNextVariablePtr (StoreInfo, MaxIndex, VariableHeader);
893 LastVariable = MaxIndex;
894 } else {
895 //
896 // Start Pointers for the variable.
897 // Actual Data Pointer where data can be written.
898 //
899 Variable = PtrTrack->StartPtr;
900 LastVariable = PtrTrack->StartPtr;
901 }
902
903 //
904 // Find the variable by walk through variable store
905 //
906 StopRecord = FALSE;
907 while (GetVariableHeader (StoreInfo, Variable, &VariableHeader)) {
908 if ((VariableHeader->State == VAR_ADDED) || (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED))) {
909 //
910 // Record Variable in VariableIndex HOB
911 //
912 if ((IndexTable != NULL) && !StopRecord) {
913 Offset = (UINTN)Variable - (UINTN)LastVariable;
914 if ((Offset > 0x0FFFF) || (IndexTable->Length >= sizeof (IndexTable->Index) / sizeof (IndexTable->Index[0]))) {
915 //
916 // Stop to record if the distance of two neighbouring VAR_ADDED variable is larger than the allowable scope(UINT16),
917 // or the record buffer is full.
918 //
919 StopRecord = TRUE;
920 } else {
921 IndexTable->Index[IndexTable->Length++] = (UINT16)Offset;
922 LastVariable = Variable;
923 }
924 }
925
926 if (CompareWithValidVariable (StoreInfo, Variable, VariableHeader, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
927 if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
928 InDeletedVariable = PtrTrack->CurrPtr;
929 } else {
930 return EFI_SUCCESS;
931 }
932 }
933 }
934
935 Variable = GetNextVariablePtr (StoreInfo, Variable, VariableHeader);
936 }
937
938 //
939 // If gone through the VariableStore, that means we never find in Firmware any more.
940 //
941 if ((IndexTable != NULL) && !StopRecord) {
942 IndexTable->GoneThrough = 1;
943 }
944
945 PtrTrack->CurrPtr = InDeletedVariable;
946
947 return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;
948 }
949
950 /**
951 Find the variable in HOB and Non-Volatile variable storages.
952
953 @param VariableName Name of the variable to be found
954 @param VendorGuid Vendor GUID to be found.
955 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
956 @param StoreInfo Return the store info.
957
958 @retval EFI_SUCCESS Variable found successfully
959 @retval EFI_NOT_FOUND Variable not found
960 @retval EFI_INVALID_PARAMETER Invalid variable name
961 **/
962 EFI_STATUS
963 FindVariable (
964 IN CONST CHAR16 *VariableName,
965 IN CONST EFI_GUID *VendorGuid,
966 OUT VARIABLE_POINTER_TRACK *PtrTrack,
967 OUT VARIABLE_STORE_INFO *StoreInfo
968 )
969 {
970 EFI_STATUS Status;
971 VARIABLE_STORE_TYPE Type;
972
973 if ((VariableName[0] != 0) && (VendorGuid == NULL)) {
974 return EFI_INVALID_PARAMETER;
975 }
976
977 for (Type = (VARIABLE_STORE_TYPE)0; Type < VariableStoreTypeMax; Type++) {
978 GetVariableStore (Type, StoreInfo);
979 Status = FindVariableEx (
980 StoreInfo,
981 VariableName,
982 VendorGuid,
983 PtrTrack
984 );
985 if (!EFI_ERROR (Status)) {
986 return Status;
987 }
988 }
989
990 return EFI_NOT_FOUND;
991 }
992
993 /**
994 This service retrieves a variable's value using its name and GUID.
995
996 Read the specified variable from the UEFI variable store. If the Data
997 buffer is too small to hold the contents of the variable, the error
998 EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer
999 size to obtain the data.
1000
1001 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
1002 @param VariableName A pointer to a null-terminated string that is the variable's name.
1003 @param VariableGuid A pointer to an EFI_GUID that is the variable's GUID. The combination of
1004 VariableGuid and VariableName must be unique.
1005 @param Attributes If non-NULL, on return, points to the variable's attributes.
1006 @param DataSize On entry, points to the size in bytes of the Data buffer.
1007 On return, points to the size of the data returned in Data.
1008 @param Data Points to the buffer which will hold the returned variable value.
1009 May be NULL with a zero DataSize in order to determine the size of the buffer needed.
1010
1011 @retval EFI_SUCCESS The variable was read successfully.
1012 @retval EFI_NOT_FOUND The variable was be found.
1013 @retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the resulting data.
1014 DataSize is updated with the size required for
1015 the specified variable.
1016 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.
1017 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
1018
1019 **/
1020 EFI_STATUS
1021 EFIAPI
1022 PeiGetVariable (
1023 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
1024 IN CONST CHAR16 *VariableName,
1025 IN CONST EFI_GUID *VariableGuid,
1026 OUT UINT32 *Attributes,
1027 IN OUT UINTN *DataSize,
1028 OUT VOID *Data OPTIONAL
1029 )
1030 {
1031 VARIABLE_POINTER_TRACK Variable;
1032 UINTN VarDataSize;
1033 EFI_STATUS Status;
1034 VARIABLE_STORE_INFO StoreInfo;
1035 VARIABLE_HEADER *VariableHeader;
1036
1037 if ((VariableName == NULL) || (VariableGuid == NULL) || (DataSize == NULL)) {
1038 return EFI_INVALID_PARAMETER;
1039 }
1040
1041 if (VariableName[0] == 0) {
1042 return EFI_NOT_FOUND;
1043 }
1044
1045 VariableHeader = NULL;
1046
1047 //
1048 // Find existing variable
1049 //
1050 Status = FindVariable (VariableName, VariableGuid, &Variable, &StoreInfo);
1051 if (EFI_ERROR (Status)) {
1052 return Status;
1053 }
1054
1055 GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader);
1056
1057 //
1058 // Get data size
1059 //
1060 VarDataSize = DataSizeOfVariable (VariableHeader, StoreInfo.AuthFlag);
1061 if (*DataSize >= VarDataSize) {
1062 if (Data == NULL) {
1063 return EFI_INVALID_PARAMETER;
1064 }
1065
1066 GetVariableNameOrData (&StoreInfo, GetVariableDataPtr (Variable.CurrPtr, VariableHeader, StoreInfo.AuthFlag), VarDataSize, Data);
1067 Status = EFI_SUCCESS;
1068 } else {
1069 Status = EFI_BUFFER_TOO_SMALL;
1070 }
1071
1072 if (Attributes != NULL) {
1073 *Attributes = VariableHeader->Attributes;
1074 }
1075
1076 *DataSize = VarDataSize;
1077
1078 return Status;
1079 }
1080
1081 /**
1082 Return the next variable name and GUID.
1083
1084 This function is called multiple times to retrieve the VariableName
1085 and VariableGuid of all variables currently available in the system.
1086 On each call, the previous results are passed into the interface,
1087 and, on return, the interface returns the data for the next
1088 interface. When the entire variable list has been returned,
1089 EFI_NOT_FOUND is returned.
1090
1091 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
1092
1093 @param VariableNameSize On entry, points to the size of the buffer pointed to by VariableName.
1094 On return, the size of the variable name buffer.
1095 @param VariableName On entry, a pointer to a null-terminated string that is the variable's name.
1096 On return, points to the next variable's null-terminated name string.
1097 @param VariableGuid On entry, a pointer to an EFI_GUID that is the variable's GUID.
1098 On return, a pointer to the next variable's GUID.
1099
1100 @retval EFI_SUCCESS The variable was read successfully.
1101 @retval EFI_NOT_FOUND The variable could not be found.
1102 @retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the resulting
1103 data. VariableNameSize is updated with the size
1104 required for the specified variable.
1105 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or
1106 VariableNameSize is NULL.
1107 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
1108
1109 **/
1110 EFI_STATUS
1111 EFIAPI
1112 PeiGetNextVariableName (
1113 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
1114 IN OUT UINTN *VariableNameSize,
1115 IN OUT CHAR16 *VariableName,
1116 IN OUT EFI_GUID *VariableGuid
1117 )
1118 {
1119 VARIABLE_STORE_TYPE Type;
1120 VARIABLE_POINTER_TRACK Variable;
1121 VARIABLE_POINTER_TRACK VariableInHob;
1122 VARIABLE_POINTER_TRACK VariablePtrTrack;
1123 UINTN VarNameSize;
1124 EFI_STATUS Status;
1125 VARIABLE_STORE_HEADER *VariableStoreHeader[VariableStoreTypeMax];
1126 VARIABLE_HEADER *VariableHeader;
1127 VARIABLE_STORE_INFO StoreInfo;
1128 VARIABLE_STORE_INFO StoreInfoForNv;
1129 VARIABLE_STORE_INFO StoreInfoForHob;
1130
1131 if ((VariableName == NULL) || (VariableGuid == NULL) || (VariableNameSize == NULL)) {
1132 return EFI_INVALID_PARAMETER;
1133 }
1134
1135 VariableHeader = NULL;
1136
1137 Status = FindVariable (VariableName, VariableGuid, &Variable, &StoreInfo);
1138 if ((Variable.CurrPtr == NULL) || (Status != EFI_SUCCESS)) {
1139 return Status;
1140 }
1141
1142 if (VariableName[0] != 0) {
1143 //
1144 // If variable name is not NULL, get next variable
1145 //
1146 GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader);
1147 Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);
1148 }
1149
1150 VariableStoreHeader[VariableStoreTypeHob] = GetVariableStore (VariableStoreTypeHob, &StoreInfoForHob);
1151 VariableStoreHeader[VariableStoreTypeNv] = GetVariableStore (VariableStoreTypeNv, &StoreInfoForNv);
1152
1153 while (TRUE) {
1154 //
1155 // Switch from HOB to Non-Volatile.
1156 //
1157 while (!GetVariableHeader (&StoreInfo, Variable.CurrPtr, &VariableHeader)) {
1158 //
1159 // Find current storage index
1160 //
1161 for (Type = (VARIABLE_STORE_TYPE)0; Type < VariableStoreTypeMax; Type++) {
1162 if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {
1163 break;
1164 }
1165 }
1166
1167 ASSERT (Type < VariableStoreTypeMax);
1168 //
1169 // Switch to next storage
1170 //
1171 for (Type++; Type < VariableStoreTypeMax; Type++) {
1172 if (VariableStoreHeader[Type] != NULL) {
1173 break;
1174 }
1175 }
1176
1177 //
1178 // Capture the case that
1179 // 1. current storage is the last one, or
1180 // 2. no further storage
1181 //
1182 if (Type == VariableStoreTypeMax) {
1183 return EFI_NOT_FOUND;
1184 }
1185
1186 Variable.StartPtr = GetStartPointer (VariableStoreHeader[Type]);
1187 Variable.EndPtr = GetEndPointer (VariableStoreHeader[Type]);
1188 Variable.CurrPtr = Variable.StartPtr;
1189 GetVariableStore (Type, &StoreInfo);
1190 }
1191
1192 if ((VariableHeader->State == VAR_ADDED) || (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED))) {
1193 if (VariableHeader->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {
1194 //
1195 // If it is a IN_DELETED_TRANSITION variable,
1196 // and there is also a same ADDED one at the same time,
1197 // don't return it.
1198 //
1199 Status = FindVariableEx (
1200 &StoreInfo,
1201 GetVariableNamePtr (Variable.CurrPtr, StoreInfo.AuthFlag),
1202 GetVendorGuidPtr (VariableHeader, StoreInfo.AuthFlag),
1203 &VariablePtrTrack
1204 );
1205 if (!EFI_ERROR (Status) && (VariablePtrTrack.CurrPtr != Variable.CurrPtr)) {
1206 Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);
1207 continue;
1208 }
1209 }
1210
1211 //
1212 // Don't return NV variable when HOB overrides it
1213 //
1214 if ((VariableStoreHeader[VariableStoreTypeHob] != NULL) && (VariableStoreHeader[VariableStoreTypeNv] != NULL) &&
1215 (Variable.StartPtr == GetStartPointer (VariableStoreHeader[VariableStoreTypeNv]))
1216 )
1217 {
1218 Status = FindVariableEx (
1219 &StoreInfoForHob,
1220 GetVariableNamePtr (Variable.CurrPtr, StoreInfo.AuthFlag),
1221 GetVendorGuidPtr (VariableHeader, StoreInfo.AuthFlag),
1222 &VariableInHob
1223 );
1224 if (!EFI_ERROR (Status)) {
1225 Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);
1226 continue;
1227 }
1228 }
1229
1230 VarNameSize = NameSizeOfVariable (VariableHeader, StoreInfo.AuthFlag);
1231 ASSERT (VarNameSize != 0);
1232
1233 if (VarNameSize <= *VariableNameSize) {
1234 GetVariableNameOrData (&StoreInfo, (UINT8 *)GetVariableNamePtr (Variable.CurrPtr, StoreInfo.AuthFlag), VarNameSize, (UINT8 *)VariableName);
1235
1236 CopyMem (VariableGuid, GetVendorGuidPtr (VariableHeader, StoreInfo.AuthFlag), sizeof (EFI_GUID));
1237
1238 Status = EFI_SUCCESS;
1239 } else {
1240 Status = EFI_BUFFER_TOO_SMALL;
1241 }
1242
1243 *VariableNameSize = VarNameSize;
1244 //
1245 // Variable is found
1246 //
1247 return Status;
1248 } else {
1249 Variable.CurrPtr = GetNextVariablePtr (&StoreInfo, Variable.CurrPtr, VariableHeader);
1250 }
1251 }
1252 }
EFI Development Kit II mirror for PVE