]> 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
Coding style checked
[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 - 2008 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 if (VarStoreHeader->Signature == VARIABLE_STORE_SIGNATURE &&
272 VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
273 VarStoreHeader->State == VARIABLE_STORE_HEALTHY
274 ) {
275
276 return EfiValid;
277 }
278
279 if (VarStoreHeader->Signature == 0xffffffff &&
280 VarStoreHeader->Size == 0xffffffff &&
281 VarStoreHeader->Format == 0xff &&
282 VarStoreHeader->State == 0xff
283 ) {
284
285 return EfiRaw;
286 } else {
287 return EfiInvalid;
288 }
289 }
290
291
292 /**
293 This function compares a variable with variable entries in database.
294
295 @param Variable Pointer to the variable in our database
296 @param VariableName Name of the variable to compare to 'Variable'
297 @param VendorGuid GUID of the variable to compare to 'Variable'
298 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
299
300 @retval EFI_SUCCESS Found match variable
301 @retval EFI_NOT_FOUND Variable not found
302
303 **/
304 EFI_STATUS
305 CompareWithValidVariable (
306 IN VARIABLE_HEADER *Variable,
307 IN CONST CHAR16 *VariableName,
308 IN CONST EFI_GUID *VendorGuid,
309 OUT VARIABLE_POINTER_TRACK *PtrTrack
310 )
311 {
312 VOID *Point;
313
314 if (VariableName[0] == 0) {
315 PtrTrack->CurrPtr = Variable;
316 return EFI_SUCCESS;
317 } else {
318 //
319 // Don't use CompareGuid function here for performance reasons.
320 // Instead we compare the GUID a UINT32 at a time and branch
321 // on the first failed comparison.
322 //
323 if ((((INT32 *) VendorGuid)[0] == ((INT32 *) &Variable->VendorGuid)[0]) &&
324 (((INT32 *) VendorGuid)[1] == ((INT32 *) &Variable->VendorGuid)[1]) &&
325 (((INT32 *) VendorGuid)[2] == ((INT32 *) &Variable->VendorGuid)[2]) &&
326 (((INT32 *) VendorGuid)[3] == ((INT32 *) &Variable->VendorGuid)[3])
327 ) {
328 ASSERT (NameSizeOfVariable (Variable) != 0);
329 Point = (VOID *) GetVariableNamePtr (Variable);
330 if (CompareMem (VariableName, Point, NameSizeOfVariable (Variable)) == 0) {
331 PtrTrack->CurrPtr = Variable;
332 return EFI_SUCCESS;
333 }
334 }
335 }
336
337 return EFI_NOT_FOUND;
338 }
339
340
341 /**
342 This code finds variable in storage blocks (Non-Volatile).
343
344 @param PeiServices General purpose services available to every PEIM.
345 @param VariableName Name of the variable to be found
346 @param VendorGuid Vendor GUID to be found.
347 @param PtrTrack Variable Track Pointer structure that contains Variable Information.
348
349 @retval EFI_SUCCESS Variable found successfully
350 @retval EFI_NOT_FOUND Variable not found
351 @retval EFI_INVALID_PARAMETER Invalid variable name
352
353 **/
354 EFI_STATUS
355 FindVariable (
356 IN CONST EFI_PEI_SERVICES **PeiServices,
357 IN CONST CHAR16 *VariableName,
358 IN CONST EFI_GUID *VendorGuid,
359 OUT VARIABLE_POINTER_TRACK *PtrTrack
360 )
361 {
362 EFI_HOB_GUID_TYPE *GuidHob;
363 VARIABLE_STORE_HEADER *VariableStoreHeader;
364 VARIABLE_HEADER *Variable;
365 VARIABLE_HEADER *MaxIndex;
366 VARIABLE_INDEX_TABLE *IndexTable;
367 UINT32 Count;
368 UINT8 *VariableBase;
369
370 if (VariableName != NULL && VendorGuid == NULL) {
371 return EFI_INVALID_PARAMETER;
372 }
373 //
374 // No Variable Address equals zero, so 0 as initial value is safe.
375 //
376 MaxIndex = 0;
377
378 GuidHob = GetFirstGuidHob (&mEfiVariableIndexTableGuid);
379 if (GuidHob == NULL) {
380 IndexTable = BuildGuidHob (&mEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));
381 IndexTable->Length = 0;
382 IndexTable->StartPtr = NULL;
383 IndexTable->EndPtr = NULL;
384 IndexTable->GoneThrough = 0;
385 } else {
386 IndexTable = GET_GUID_HOB_DATA (GuidHob);
387 for (Count = 0; Count < IndexTable->Length; Count++) {
388 MaxIndex = GetVariableByIndex (IndexTable, Count);
389
390 if (CompareWithValidVariable (MaxIndex, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
391 PtrTrack->StartPtr = IndexTable->StartPtr;
392 PtrTrack->EndPtr = IndexTable->EndPtr;
393
394 return EFI_SUCCESS;
395 }
396 }
397
398 if (IndexTable->GoneThrough != 0) {
399 return EFI_NOT_FOUND;
400 }
401 }
402 //
403 // If not found in HOB, then let's start from the MaxIndex we've found.
404 //
405 if (MaxIndex != NULL) {
406 Variable = GetNextVariablePtr (MaxIndex);
407 } else {
408 if ((IndexTable->StartPtr != NULL) || (IndexTable->EndPtr != NULL)) {
409 Variable = IndexTable->StartPtr;
410 } else {
411 VariableBase = (UINT8 *) (UINTN) PcdGet32 (PcdFlashNvStorageVariableBase);
412 VariableStoreHeader = (VARIABLE_STORE_HEADER *) (VariableBase + \
413 ((EFI_FIRMWARE_VOLUME_HEADER *) (VariableBase)) -> HeaderLength);
414
415 if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {
416 return EFI_UNSUPPORTED;
417 }
418
419 if (~VariableStoreHeader->Size == 0) {
420 return EFI_NOT_FOUND;
421 }
422 //
423 // Find the variable by walk through non-volatile variable store
424 //
425 IndexTable->StartPtr = GetStartPointer (VariableStoreHeader);
426 IndexTable->EndPtr = GetEndPointer (VariableStoreHeader);
427
428 //
429 // Start Pointers for the variable.
430 // Actual Data Pointer where data can be written.
431 //
432 Variable = IndexTable->StartPtr;
433 }
434 }
435 //
436 // Find the variable by walk through non-volatile variable store
437 //
438 PtrTrack->StartPtr = IndexTable->StartPtr;
439 PtrTrack->EndPtr = IndexTable->EndPtr;
440
441 while (IsValidVariableHeader (Variable) && (Variable <= IndexTable->EndPtr)) {
442 if (Variable->State == VAR_ADDED) {
443 //
444 // Record Variable in VariableIndex HOB
445 //
446 if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME) {
447 VariableIndexTableUpdate (IndexTable, Variable);
448 }
449
450 if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
451 return EFI_SUCCESS;
452 }
453 }
454
455 Variable = GetNextVariablePtr (Variable);
456 }
457 //
458 // If gone through the VariableStore, that means we never find in Firmware any more.
459 //
460 if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME) {
461 IndexTable->GoneThrough = 1;
462 }
463
464 PtrTrack->CurrPtr = NULL;
465
466 return EFI_NOT_FOUND;
467 }
468
469 /**
470 This service retrieves a variable's value using its name and GUID.
471
472 Read the specified variable from the UEFI variable store. If the Data
473 buffer is too small to hold the contents of the variable, the error
474 EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer
475 size to obtain the data.
476
477 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
478 @param VariableName A pointer to a null-terminated string that is the variable's name.
479 @param VariableGuid A pointer to an EFI_GUID that is the variable's GUID. The combination of
480 VariableGuid and VariableName must be unique.
481 @param Attributes If non-NULL, on return, points to the variable's attributes.
482 @param DataSize On entry, points to the size in bytes of the Data buffer.
483 On return, points to the size of the data returned in Data.
484 @param Data Points to the buffer which will hold the returned variable value.
485
486 @retval EFI_SUCCESS The variable was read successfully.
487 @retval EFI_NOT_FOUND The variable could not be found.
488 @retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the resulting data.
489 DataSize is updated with the size required for
490 the specified variable.
491 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.
492 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
493
494 **/
495 EFI_STATUS
496 EFIAPI
497 PeiGetVariable (
498 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
499 IN CONST CHAR16 *VariableName,
500 IN CONST EFI_GUID *VariableGuid,
501 OUT UINT32 *Attributes,
502 IN OUT UINTN *DataSize,
503 OUT VOID *Data
504 )
505 {
506 VARIABLE_POINTER_TRACK Variable;
507 UINTN VarDataSize;
508 EFI_STATUS Status;
509 CONST EFI_PEI_SERVICES **PeiServices;
510
511 PeiServices = GetPeiServicesTablePointer ();
512 if (VariableName == NULL || VariableGuid == NULL || DataSize == NULL) {
513 return EFI_INVALID_PARAMETER;
514 }
515 //
516 // Find existing variable
517 //
518 Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
519 if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
520 return Status;
521 }
522 //
523 // Get data size
524 //
525 VarDataSize = DataSizeOfVariable (Variable.CurrPtr);
526 if (*DataSize >= VarDataSize) {
527 if (Data == NULL) {
528 return EFI_INVALID_PARAMETER;
529 }
530
531 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
532
533 if (Attributes != NULL) {
534 *Attributes = Variable.CurrPtr->Attributes;
535 }
536
537 *DataSize = VarDataSize;
538 return EFI_SUCCESS;
539 } else {
540 *DataSize = VarDataSize;
541 return EFI_BUFFER_TOO_SMALL;
542 }
543 }
544
545 /**
546 Return the next variable name and GUID.
547
548 This function is called multiple times to retrieve the VariableName
549 and VariableGuid of all variables currently available in the system.
550 On each call, the previous results are passed into the interface,
551 and, on return, the interface returns the data for the next
552 interface. When the entire variable list has been returned,
553 EFI_NOT_FOUND is returned.
554
555 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
556
557 @param VariableNameSize On entry, points to the size of the buffer pointed to by VariableName.
558 @param VariableName On entry, a pointer to a null-terminated string that is the variable's name.
559 On return, points to the next variable's null-terminated name string.
560 @param VariableGuid On entry, a pointer to an UEFI _GUID that is the variable's GUID.
561 On return, a pointer to the next variable's GUID.
562
563 @retval EFI_SUCCESS The variable was read successfully.
564 @retval EFI_NOT_FOUND The variable could not be found.
565 @retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the resulting
566 data. VariableNameSize is updated with the size
567 required for the specified variable.
568 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or
569 VariableNameSize is NULL.
570 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
571
572 **/
573 EFI_STATUS
574 EFIAPI
575 PeiGetNextVariableName (
576 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
577 IN OUT UINTN *VariableNameSize,
578 IN OUT CHAR16 *VariableName,
579 IN OUT EFI_GUID *VariableGuid
580 )
581 {
582 VARIABLE_POINTER_TRACK Variable;
583 UINTN VarNameSize;
584 EFI_STATUS Status;
585 CONST EFI_PEI_SERVICES **PeiServices;
586
587 PeiServices = GetPeiServicesTablePointer ();
588 if (VariableName == NULL || VariableGuid == NULL || VariableNameSize == NULL) {
589 return EFI_INVALID_PARAMETER;
590 }
591
592 Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
593 if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
594 return Status;
595 }
596
597 if (VariableName[0] != 0) {
598 //
599 // If variable name is not NULL, get next variable
600 //
601 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
602 }
603
604 while (!(Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL)) {
605 if (IsValidVariableHeader (Variable.CurrPtr)) {
606 if (Variable.CurrPtr->State == VAR_ADDED) {
607 ASSERT (NameSizeOfVariable (Variable.CurrPtr) != 0);
608
609 VarNameSize = (UINTN) NameSizeOfVariable (Variable.CurrPtr);
610 if (VarNameSize <= *VariableNameSize) {
611 CopyMem (VariableName, GetVariableNamePtr (Variable.CurrPtr), VarNameSize);
612
613 CopyMem (VariableGuid, &Variable.CurrPtr->VendorGuid, sizeof (EFI_GUID));
614
615 Status = EFI_SUCCESS;
616 } else {
617 Status = EFI_BUFFER_TOO_SMALL;
618 }
619
620 *VariableNameSize = VarNameSize;
621 return Status;
622 //
623 // Variable is found
624 //
625 } else {
626 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
627 }
628 } else {
629 break;
630 }
631 }
632
633 return EFI_NOT_FOUND;
634 }
EFI Development Kit II mirror for PVE