]> 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
Fix some coding style issues in MdeModulePkg.
[mirror_edk2.git] / MdeModulePkg / Universal / Variable / Pei / Variable.c
1 /** @file
2
3 Implement ReadOnly Variable Services required by PEIM and install
4 PEI ReadOnly Varaiable2 PPI. These services operates the non volatile storage space.
5
6 Copyright (c) 2006 - 2009 Intel Corporation. <BR>
7 All rights reserved. This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14 Module Name:
15
16 **/
17
18
19 #include "Variable.h"
20
21 //
22 // Module globals
23 //
24 EFI_PEI_READ_ONLY_VARIABLE2_PPI mVariablePpi = {
25 PeiGetVariable,
26 PeiGetNextVariableName
27 };
28
29 EFI_PEI_PPI_DESCRIPTOR mPpiListVariable = {
30 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
31 &gEfiPeiReadOnlyVariable2PpiGuid,
32 &mVariablePpi
33 };
34
35 EFI_GUID mEfiVariableIndexTableGuid = EFI_VARIABLE_INDEX_TABLE_GUID;
36
37
38 /**
39 Provide the functionality of the variable services.
40
41 @param FileHandle Handle of the file being invoked.
42 Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().
43 @param PeiServices General purpose services available to every PEIM.
44
45 @retval EFI_SUCCESS If the interface could be successfully installed
46 @retval Others Returned from PeiServicesInstallPpi()
47
48 **/
49 EFI_STATUS
50 EFIAPI
51 PeimInitializeVariableServices (
52 IN EFI_PEI_FILE_HANDLE FileHandle,
53 IN CONST EFI_PEI_SERVICES **PeiServices
54 )
55 {
56 EFI_BOOT_MODE BootMode;
57 EFI_STATUS Status;
58
59 //
60 // Check if this is recovery boot path. If no, publish the variable access capability
61 // to other modules. If yes, the content of variable area is not reliable. Therefore,
62 // in this case we should not provide variable service to other pei modules.
63 //
64 Status = (*PeiServices)->GetBootMode (PeiServices, &BootMode);
65 ASSERT_EFI_ERROR (Status);
66
67 if (BootMode == BOOT_IN_RECOVERY_MODE) {
68 return EFI_UNSUPPORTED;
69 }
70
71 return PeiServicesInstallPpi (&mPpiListVariable);
72
73 }
74
75 /**
76
77 Gets the pointer to the first variable header in given variable store area.
78
79 @param VarStoreHeader Pointer to the Variable Store Header.
80
81 @return Pointer to the first variable header
82
83 **/
84 VARIABLE_HEADER *
85 GetStartPointer (
86 IN VARIABLE_STORE_HEADER *VarStoreHeader
87 )
88 {
89 //
90 // The end of variable store
91 //
92 return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);
93 }
94
95
96 /**
97 This code gets the pointer to the last variable memory pointer byte.
98
99 @param VarStoreHeader Pointer to the Variable Store Header.
100
101 @return VARIABLE_HEADER* pointer to last unavailable Variable Header.
102
103 **/
104 VARIABLE_HEADER *
105 GetEndPointer (
106 IN VARIABLE_STORE_HEADER *VarStoreHeader
107 )
108 {
109 //
110 // The end of variable store
111 //
112 return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);
113 }
114
115
116 /**
117 This code checks if variable header is valid or not.
118
119 @param Variable Pointer to the Variable Header.
120
121 @retval TRUE Variable header is valid.
122 @retval FALSE Variable header is not valid.
123
124 **/
125 BOOLEAN
126 IsValidVariableHeader (
127 IN VARIABLE_HEADER *Variable
128 )
129 {
130 if (Variable == NULL || Variable->StartId != VARIABLE_DATA ) {
131 return FALSE;
132 }
133
134 return TRUE;
135 }
136
137
138 /**
139 This code gets the size of name of variable.
140
141 @param Variable Pointer to the Variable Header.
142
143 @return Size of variable in bytes in type UINTN.
144
145 **/
146 UINTN
147 NameSizeOfVariable (
148 IN VARIABLE_HEADER *Variable
149 )
150 {
151 if (Variable->State == (UINT8) (-1) ||
152 Variable->DataSize == (UINT32) (-1) ||
153 Variable->NameSize == (UINT32) (-1) ||
154 Variable->Attributes == (UINT32) (-1)) {
155 return 0;
156 }
157 return (UINTN) Variable->NameSize;
158 }
159
160
161 /**
162 This code gets the size of data of variable.
163
164 @param Variable Pointer to the Variable Header.
165
166 @return Size of variable in bytes in type UINTN.
167
168 **/
169 UINTN
170 DataSizeOfVariable (
171 IN VARIABLE_HEADER *Variable
172 )
173 {
174 if (Variable->State == (UINT8) (-1) ||
175 Variable->DataSize == (UINT32) (-1) ||
176 Variable->NameSize == (UINT32) (-1) ||
177 Variable->Attributes == (UINT32) (-1)) {
178 return 0;
179 }
180 return (UINTN) Variable->DataSize;
181 }
182
183 /**
184 This code gets the pointer to the variable name.
185
186 @param Variable Pointer to the Variable Header.
187
188 @return A CHAR16* pointer to Variable Name.
189
190 **/
191 CHAR16 *
192 GetVariableNamePtr (
193 IN VARIABLE_HEADER *Variable
194 )
195 {
196
197 return (CHAR16 *) (Variable + 1);
198 }
199
200
201 /**
202 This code gets the pointer to the variable data.
203
204 @param Variable Pointer to the Variable Header.
205
206 @return A UINT8* pointer to Variable Data.
207
208 **/
209 UINT8 *
210 GetVariableDataPtr (
211 IN VARIABLE_HEADER *Variable
212 )
213 {
214 UINTN Value;
215
216 //
217 // Be careful about pad size for alignment
218 //
219 Value = (UINTN) GetVariableNamePtr (Variable);
220 Value += NameSizeOfVariable (Variable);
221 Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));
222
223 return (UINT8 *) Value;
224 }
225
226
227 /**
228 This code gets the pointer to the next variable header.
229
230 @param Variable Pointer to the Variable Header.
231
232 @return A VARIABLE_HEADER* pointer to next variable header.
233
234 **/
235 VARIABLE_HEADER *
236 GetNextVariablePtr (
237 IN VARIABLE_HEADER *Variable
238 )
239 {
240 UINTN Value;
241
242 if (!IsValidVariableHeader (Variable)) {
243 return NULL;
244 }
245
246 Value = (UINTN) GetVariableDataPtr (Variable);
247 Value += DataSizeOfVariable (Variable);
248 Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));
249
250 //
251 // Be careful about pad size for alignment
252 //
253 return (VARIABLE_HEADER *) HEADER_ALIGN (Value);
254 }
255
256 /**
257 This code gets the pointer to the variable name.
258
259 @param VarStoreHeader Pointer to the Variable Store Header.
260
261 @retval EfiRaw Variable store is raw
262 @retval EfiValid Variable store is valid
263 @retval EfiInvalid Variable store is invalid
264
265 **/
266 VARIABLE_STORE_STATUS
267 GetVariableStoreStatus (
268 IN VARIABLE_STORE_HEADER *VarStoreHeader
269 )
270 {
271
272 if (CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid) &&
273 VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
274 VarStoreHeader->State == VARIABLE_STORE_HEALTHY
275 ) {
276
277 return EfiValid;
278 }
279
280 if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&
281 ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&
282 ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&
283 ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&
284 VarStoreHeader->Size == 0xffffffff &&
285 VarStoreHeader->Format == 0xff &&
286 VarStoreHeader->State == 0xff
287 ) {
288
289 return EfiRaw;
290 } else {
291 return EfiInvalid;
292 }
293 }
294
295
296 /**
297 This function compares a variable with variable entries in database.
298
299 @param Variable Pointer to the variable in our database
300 @param VariableName Name of the variable to compare to 'Variable'
301 @param VendorGuid GUID of the variable to compare to 'Variable'
302 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
303
304 @retval EFI_SUCCESS Found match variable
305 @retval EFI_NOT_FOUND Variable not found
306
307 **/
308 EFI_STATUS
309 CompareWithValidVariable (
310 IN VARIABLE_HEADER *Variable,
311 IN CONST CHAR16 *VariableName,
312 IN CONST EFI_GUID *VendorGuid,
313 OUT VARIABLE_POINTER_TRACK *PtrTrack
314 )
315 {
316 VOID *Point;
317
318 if (VariableName[0] == 0) {
319 PtrTrack->CurrPtr = Variable;
320 return EFI_SUCCESS;
321 } else {
322 //
323 // Don't use CompareGuid function here for performance reasons.
324 // Instead we compare the GUID a UINT32 at a time and branch
325 // on the first failed comparison.
326 //
327 if ((((INT32 *) VendorGuid)[0] == ((INT32 *) &Variable->VendorGuid)[0]) &&
328 (((INT32 *) VendorGuid)[1] == ((INT32 *) &Variable->VendorGuid)[1]) &&
329 (((INT32 *) VendorGuid)[2] == ((INT32 *) &Variable->VendorGuid)[2]) &&
330 (((INT32 *) VendorGuid)[3] == ((INT32 *) &Variable->VendorGuid)[3])
331 ) {
332 ASSERT (NameSizeOfVariable (Variable) != 0);
333 Point = (VOID *) GetVariableNamePtr (Variable);
334 if (CompareMem (VariableName, Point, NameSizeOfVariable (Variable)) == 0) {
335 PtrTrack->CurrPtr = Variable;
336 return EFI_SUCCESS;
337 }
338 }
339 }
340
341 return EFI_NOT_FOUND;
342 }
343
344
345 /**
346 This code finds variable in storage blocks (Non-Volatile).
347
348 @param PeiServices General purpose services available to every PEIM.
349 @param VariableName Name of the variable to be found
350 @param VendorGuid Vendor GUID to be found.
351 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
352
353 @retval EFI_SUCCESS Variable found successfully
354 @retval EFI_NOT_FOUND Variable not found
355 @retval EFI_INVALID_PARAMETER Invalid variable name
356
357 **/
358 EFI_STATUS
359 FindVariable (
360 IN CONST EFI_PEI_SERVICES **PeiServices,
361 IN CONST CHAR16 *VariableName,
362 IN CONST EFI_GUID *VendorGuid,
363 OUT VARIABLE_POINTER_TRACK *PtrTrack
364 )
365 {
366 EFI_HOB_GUID_TYPE *GuidHob;
367 VARIABLE_STORE_HEADER *VariableStoreHeader;
368 VARIABLE_HEADER *Variable;
369 VARIABLE_HEADER *LastVariable;
370 VARIABLE_HEADER *MaxIndex;
371 VARIABLE_INDEX_TABLE *IndexTable;
372 UINT32 Count;
373 UINT32 Offset;
374 UINT8 *VariableBase;
375 BOOLEAN StopRecord;
376
377 if (VariableName[0] != 0 && VendorGuid == NULL) {
378 return EFI_INVALID_PARAMETER;
379 }
380 //
381 // No Variable Address equals zero, so 0 as initial value is safe.
382 //
383 MaxIndex = 0;
384 StopRecord = FALSE;
385
386 GuidHob = GetFirstGuidHob (&mEfiVariableIndexTableGuid);
387 if (GuidHob == NULL) {
388 //
389 // If it's the first time to access variable region in flash, create a guid hob to record
390 // VAR_ADDED type variable info.
391 // Note that as the resource of PEI phase is limited, only store the number of
392 // VARIABLE_INDEX_TABLE_VOLUME of VAR_ADDED type variables to reduce access time.
393 //
394 IndexTable = BuildGuidHob (&mEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));
395 IndexTable->Length = 0;
396 IndexTable->StartPtr = NULL;
397 IndexTable->EndPtr = NULL;
398 IndexTable->GoneThrough = 0;
399 } else {
400 IndexTable = GET_GUID_HOB_DATA (GuidHob);
401 for (Offset = 0, Count = 0; Count < IndexTable->Length; Count++) {
402 //
403 // traverse the variable info list to look for varible.
404 // The IndexTable->Index[Count] records the distance of two neighbouring VAR_ADDED type variables.
405 //
406 ASSERT (Count < VARIABLE_INDEX_TABLE_VOLUME);
407 Offset += IndexTable->Index[Count];
408 MaxIndex = (VARIABLE_HEADER *)((CHAR8 *)(IndexTable->StartPtr) + Offset);
409 if (CompareWithValidVariable (MaxIndex, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
410 PtrTrack->StartPtr = IndexTable->StartPtr;
411 PtrTrack->EndPtr = IndexTable->EndPtr;
412
413 return EFI_SUCCESS;
414 }
415 }
416
417 if (IndexTable->GoneThrough != 0) {
418 return EFI_NOT_FOUND;
419 }
420 }
421 //
422 // If not found in HOB, then let's start from the MaxIndex we've found.
423 //
424 if (MaxIndex != NULL) {
425 Variable = GetNextVariablePtr (MaxIndex);
426 LastVariable = MaxIndex;
427 } else {
428 if ((IndexTable->StartPtr != NULL) || (IndexTable->EndPtr != NULL)) {
429 Variable = IndexTable->StartPtr;
430 } else {
431 VariableBase = (UINT8 *) (UINTN) PcdGet32 (PcdFlashNvStorageVariableBase);
432 VariableStoreHeader = (VARIABLE_STORE_HEADER *) (VariableBase + \
433 ((EFI_FIRMWARE_VOLUME_HEADER *) (VariableBase)) -> HeaderLength);
434
435 if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {
436 return EFI_UNSUPPORTED;
437 }
438
439 if (~VariableStoreHeader->Size == 0) {
440 return EFI_NOT_FOUND;
441 }
442 //
443 // Find the variable by walk through non-volatile variable store
444 //
445 IndexTable->StartPtr = GetStartPointer (VariableStoreHeader);
446 IndexTable->EndPtr = GetEndPointer (VariableStoreHeader);
447
448 //
449 // Start Pointers for the variable.
450 // Actual Data Pointer where data can be written.
451 //
452 Variable = IndexTable->StartPtr;
453 }
454
455 LastVariable = IndexTable->StartPtr;
456 }
457 //
458 // Find the variable by walk through non-volatile variable store
459 //
460 PtrTrack->StartPtr = IndexTable->StartPtr;
461 PtrTrack->EndPtr = IndexTable->EndPtr;
462
463 while ((Variable < IndexTable->EndPtr) && IsValidVariableHeader (Variable)) {
464 if (Variable->State == VAR_ADDED) {
465 //
466 // Record Variable in VariableIndex HOB
467 //
468 if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME && !StopRecord) {
469 Offset = (UINT32)((UINTN)Variable - (UINTN)LastVariable);
470 //
471 // The distance of two neighbouring VAR_ADDED variable is larger than 2^16,
472 // which is beyond the allowable scope(UINT16) of record. In such case, need not to
473 // record the subsequent VAR_ADDED type variables again.
474 //
475 if ((Offset & 0xFFFF0000UL) != 0) {
476 StopRecord = TRUE;
477 }
478
479 if (!StopRecord) {
480 IndexTable->Index[IndexTable->Length++] = (UINT16) Offset;
481 }
482 LastVariable = Variable;
483 }
484
485 if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
486 return EFI_SUCCESS;
487 }
488 }
489
490 Variable = GetNextVariablePtr (Variable);
491 }
492 //
493 // If gone through the VariableStore, that means we never find in Firmware any more.
494 //
495 if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME) {
496 IndexTable->GoneThrough = 1;
497 }
498
499 PtrTrack->CurrPtr = NULL;
500
501 return EFI_NOT_FOUND;
502 }
503
504 /**
505 This service retrieves a variable's value using its name and GUID.
506
507 Read the specified variable from the UEFI variable store. If the Data
508 buffer is too small to hold the contents of the variable, the error
509 EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer
510 size to obtain the data.
511
512 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
513 @param VariableName A pointer to a null-terminated string that is the variable's name.
514 @param VariableGuid A pointer to an EFI_GUID that is the variable's GUID. The combination of
515 VariableGuid and VariableName must be unique.
516 @param Attributes If non-NULL, on return, points to the variable's attributes.
517 @param DataSize On entry, points to the size in bytes of the Data buffer.
518 On return, points to the size of the data returned in Data.
519 @param Data Points to the buffer which will hold the returned variable value.
520
521 @retval EFI_SUCCESS The variable was read successfully.
522 @retval EFI_NOT_FOUND The variable could not be found.
523 @retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the resulting data.
524 DataSize is updated with the size required for
525 the specified variable.
526 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.
527 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
528
529 **/
530 EFI_STATUS
531 EFIAPI
532 PeiGetVariable (
533 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
534 IN CONST CHAR16 *VariableName,
535 IN CONST EFI_GUID *VariableGuid,
536 OUT UINT32 *Attributes,
537 IN OUT UINTN *DataSize,
538 OUT VOID *Data
539 )
540 {
541 VARIABLE_POINTER_TRACK Variable;
542 UINTN VarDataSize;
543 EFI_STATUS Status;
544 CONST EFI_PEI_SERVICES **PeiServices;
545
546 PeiServices = GetPeiServicesTablePointer ();
547 if (VariableName == NULL || VariableGuid == NULL || DataSize == NULL) {
548 return EFI_INVALID_PARAMETER;
549 }
550 //
551 // Find existing variable
552 //
553 Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
554 if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
555 return Status;
556 }
557 //
558 // Get data size
559 //
560 VarDataSize = DataSizeOfVariable (Variable.CurrPtr);
561 if (*DataSize >= VarDataSize) {
562 if (Data == NULL) {
563 return EFI_INVALID_PARAMETER;
564 }
565
566 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
567
568 if (Attributes != NULL) {
569 *Attributes = Variable.CurrPtr->Attributes;
570 }
571
572 *DataSize = VarDataSize;
573 return EFI_SUCCESS;
574 } else {
575 *DataSize = VarDataSize;
576 return EFI_BUFFER_TOO_SMALL;
577 }
578 }
579
580 /**
581 Return the next variable name and GUID.
582
583 This function is called multiple times to retrieve the VariableName
584 and VariableGuid of all variables currently available in the system.
585 On each call, the previous results are passed into the interface,
586 and, on return, the interface returns the data for the next
587 interface. When the entire variable list has been returned,
588 EFI_NOT_FOUND is returned.
589
590 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
591
592 @param VariableNameSize On entry, points to the size of the buffer pointed to by VariableName.
593 @param VariableName On entry, a pointer to a null-terminated string that is the variable's name.
594 On return, points to the next variable's null-terminated name string.
595 @param VariableGuid On entry, a pointer to an EFI_GUID that is the variable's GUID.
596 On return, a pointer to the next variable's GUID.
597
598 @retval EFI_SUCCESS The variable was read successfully.
599 @retval EFI_NOT_FOUND The variable could not be found.
600 @retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the resulting
601 data. VariableNameSize is updated with the size
602 required for the specified variable.
603 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or
604 VariableNameSize is NULL.
605 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
606
607 **/
608 EFI_STATUS
609 EFIAPI
610 PeiGetNextVariableName (
611 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
612 IN OUT UINTN *VariableNameSize,
613 IN OUT CHAR16 *VariableName,
614 IN OUT EFI_GUID *VariableGuid
615 )
616 {
617 VARIABLE_POINTER_TRACK Variable;
618 UINTN VarNameSize;
619 EFI_STATUS Status;
620 CONST EFI_PEI_SERVICES **PeiServices;
621
622 PeiServices = GetPeiServicesTablePointer ();
623 if (VariableName == NULL || VariableGuid == NULL || VariableNameSize == NULL) {
624 return EFI_INVALID_PARAMETER;
625 }
626
627 Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
628 if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
629 return Status;
630 }
631
632 if (VariableName[0] != 0) {
633 //
634 // If variable name is not NULL, get next variable
635 //
636 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
637 }
638
639 while (!(Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL)) {
640 if (IsValidVariableHeader (Variable.CurrPtr)) {
641 if (Variable.CurrPtr->State == VAR_ADDED) {
642 ASSERT (NameSizeOfVariable (Variable.CurrPtr) != 0);
643
644 VarNameSize = (UINTN) NameSizeOfVariable (Variable.CurrPtr);
645 if (VarNameSize <= *VariableNameSize) {
646 CopyMem (VariableName, GetVariableNamePtr (Variable.CurrPtr), VarNameSize);
647
648 CopyMem (VariableGuid, &Variable.CurrPtr->VendorGuid, sizeof (EFI_GUID));
649
650 Status = EFI_SUCCESS;
651 } else {
652 Status = EFI_BUFFER_TOO_SMALL;
653 }
654
655 *VariableNameSize = VarNameSize;
656 return Status;
657 //
658 // Variable is found
659 //
660 } else {
661 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
662 }
663 } else {
664 break;
665 }
666 }
667
668 return EFI_NOT_FOUND;
669 }
EFI Development Kit II mirror for PVE