]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Variable/Pei/Variable.c
projects / mirror_edk2.git / blob
? search:


f98d2364435c8bb1b0041b3597a14abba45f46c2
[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[0] != 0 && 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 VariableIndexTableUpdate (IndexTable, Variable);
447
448 if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
449 return EFI_SUCCESS;
450 }
451 }
452
453 Variable = GetNextVariablePtr (Variable);
454 }
455 //
456 // If gone through the VariableStore, that means we never find in Firmware any more.
457 //
458 if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME) {
459 IndexTable->GoneThrough = 1;
460 }
461
462 PtrTrack->CurrPtr = NULL;
463
464 return EFI_NOT_FOUND;
465 }
466
467 /**
468 This service retrieves a variable's value using its name and GUID.
469
470 Read the specified variable from the UEFI variable store. If the Data
471 buffer is too small to hold the contents of the variable, the error
472 EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer
473 size to obtain the data.
474
475 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
476 @param VariableName A pointer to a null-terminated string that is the variable's name.
477 @param VariableGuid A pointer to an EFI_GUID that is the variable's GUID. The combination of
478 VariableGuid and VariableName must be unique.
479 @param Attributes If non-NULL, on return, points to the variable's attributes.
480 @param DataSize On entry, points to the size in bytes of the Data buffer.
481 On return, points to the size of the data returned in Data.
482 @param Data Points to the buffer which will hold the returned variable value.
483
484 @retval EFI_SUCCESS The variable was read successfully.
485 @retval EFI_NOT_FOUND The variable could not be found.
486 @retval EFI_BUFFER_TOO_SMALL The DataSize is too small for the resulting data.
487 DataSize is updated with the size required for
488 the specified variable.
489 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.
490 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
491
492 **/
493 EFI_STATUS
494 EFIAPI
495 PeiGetVariable (
496 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
497 IN CONST CHAR16 *VariableName,
498 IN CONST EFI_GUID *VariableGuid,
499 OUT UINT32 *Attributes,
500 IN OUT UINTN *DataSize,
501 OUT VOID *Data
502 )
503 {
504 VARIABLE_POINTER_TRACK Variable;
505 UINTN VarDataSize;
506 EFI_STATUS Status;
507 CONST EFI_PEI_SERVICES **PeiServices;
508
509 PeiServices = GetPeiServicesTablePointer ();
510 if (VariableName == NULL || VariableGuid == NULL || DataSize == NULL) {
511 return EFI_INVALID_PARAMETER;
512 }
513 //
514 // Find existing variable
515 //
516 Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
517 if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
518 return Status;
519 }
520 //
521 // Get data size
522 //
523 VarDataSize = DataSizeOfVariable (Variable.CurrPtr);
524 if (*DataSize >= VarDataSize) {
525 if (Data == NULL) {
526 return EFI_INVALID_PARAMETER;
527 }
528
529 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
530
531 if (Attributes != NULL) {
532 *Attributes = Variable.CurrPtr->Attributes;
533 }
534
535 *DataSize = VarDataSize;
536 return EFI_SUCCESS;
537 } else {
538 *DataSize = VarDataSize;
539 return EFI_BUFFER_TOO_SMALL;
540 }
541 }
542
543 /**
544 Return the next variable name and GUID.
545
546 This function is called multiple times to retrieve the VariableName
547 and VariableGuid of all variables currently available in the system.
548 On each call, the previous results are passed into the interface,
549 and, on return, the interface returns the data for the next
550 interface. When the entire variable list has been returned,
551 EFI_NOT_FOUND is returned.
552
553 @param This A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
554
555 @param VariableNameSize On entry, points to the size of the buffer pointed to by VariableName.
556 @param VariableName On entry, a pointer to a null-terminated string that is the variable's name.
557 On return, points to the next variable's null-terminated name string.
558 @param VariableGuid On entry, a pointer to an UEFI _GUID that is the variable's GUID.
559 On return, a pointer to the next variable's GUID.
560
561 @retval EFI_SUCCESS The variable was read successfully.
562 @retval EFI_NOT_FOUND The variable could not be found.
563 @retval EFI_BUFFER_TOO_SMALL The VariableNameSize is too small for the resulting
564 data. VariableNameSize is updated with the size
565 required for the specified variable.
566 @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or
567 VariableNameSize is NULL.
568 @retval EFI_DEVICE_ERROR The variable could not be retrieved because of a device error.
569
570 **/
571 EFI_STATUS
572 EFIAPI
573 PeiGetNextVariableName (
574 IN CONST EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
575 IN OUT UINTN *VariableNameSize,
576 IN OUT CHAR16 *VariableName,
577 IN OUT EFI_GUID *VariableGuid
578 )
579 {
580 VARIABLE_POINTER_TRACK Variable;
581 UINTN VarNameSize;
582 EFI_STATUS Status;
583 CONST EFI_PEI_SERVICES **PeiServices;
584
585 PeiServices = GetPeiServicesTablePointer ();
586 if (VariableName == NULL || VariableGuid == NULL || VariableNameSize == NULL) {
587 return EFI_INVALID_PARAMETER;
588 }
589
590 Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
591 if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
592 return Status;
593 }
594
595 if (VariableName[0] != 0) {
596 //
597 // If variable name is not NULL, get next variable
598 //
599 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
600 }
601
602 while (!(Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL)) {
603 if (IsValidVariableHeader (Variable.CurrPtr)) {
604 if (Variable.CurrPtr->State == VAR_ADDED) {
605 ASSERT (NameSizeOfVariable (Variable.CurrPtr) != 0);
606
607 VarNameSize = (UINTN) NameSizeOfVariable (Variable.CurrPtr);
608 if (VarNameSize <= *VariableNameSize) {
609 CopyMem (VariableName, GetVariableNamePtr (Variable.CurrPtr), VarNameSize);
610
611 CopyMem (VariableGuid, &Variable.CurrPtr->VendorGuid, sizeof (EFI_GUID));
612
613 Status = EFI_SUCCESS;
614 } else {
615 Status = EFI_BUFFER_TOO_SMALL;
616 }
617
618 *VariableNameSize = VarNameSize;
619 return Status;
620 //
621 // Variable is found
622 //
623 } else {
624 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
625 }
626 } else {
627 break;
628 }
629 }
630
631 return EFI_NOT_FOUND;
632 }
EFI Development Kit II mirror for PVE