Fix an K9 issue in variable driver.
[mirror_edk2.git] / MdeModulePkg / Universal / Variable / RuntimeDxe / Variable.c
CommitLineData
052ad7e1 1/** @file\r
504214c4 2\r
8a2d4996 3 The common variable operation routines shared by DXE_RINTIME variable \r
4 module and DXE_SMM variable module.\r
052ad7e1 5 \r
e5eed7d3
HT
6Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
7This program and the accompanying materials \r
504214c4
LG
8are licensed and made available under the terms and conditions of the BSD License \r
9which accompanies this distribution. The full text of the license may be found at \r
10http://opensource.org/licenses/bsd-license.php \r
11\r
12THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
13WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
8d3a5c82 14\r
052ad7e1 15**/\r
8d3a5c82 16\r
8d3a5c82 17#include "Variable.h"\r
33a5a666 18\r
7800593d 19VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal;\r
8d3a5c82 20\r
7c80e839 21///\r
8a2d4996 22/// Define a memory cache that improves the search performance for a variable.\r
7c80e839 23///\r
8a2d4996 24VARIABLE_STORE_HEADER *mNvVariableCache = NULL;\r
aa79b0b3 25\r
8a2d4996 26///\r
27/// The memory entry used for variable statistics data.\r
28///\r
29VARIABLE_INFO_ENTRY *gVariableInfo = NULL;\r
8d3a5c82 30\r
33a5a666 31\r
052ad7e1
A
32/**\r
33 Routine used to track statistical information about variable usage. \r
34 The data is stored in the EFI system table so it can be accessed later.\r
35 VariableInfo.efi can dump out the table. Only Boot Services variable \r
36 accesses are tracked by this code. The PcdVariableCollectStatistics\r
37 build flag controls if this feature is enabled. \r
38\r
39 A read that hits in the cache will have Read and Cache true for \r
40 the transaction. Data is allocated by this routine, but never\r
41 freed.\r
42\r
8a2d4996 43 @param[in] VariableName Name of the Variable to track.\r
44 @param[in] VendorGuid Guid of the Variable to track.\r
45 @param[in] Volatile TRUE if volatile FALSE if non-volatile.\r
46 @param[in] Read TRUE if GetVariable() was called.\r
47 @param[in] Write TRUE if SetVariable() was called.\r
48 @param[in] Delete TRUE if deleted via SetVariable().\r
052ad7e1
A
49 @param[in] Cache TRUE for a cache hit.\r
50\r
51**/\r
33a5a666
A
52VOID\r
53UpdateVariableInfo (\r
54 IN CHAR16 *VariableName,\r
55 IN EFI_GUID *VendorGuid,\r
56 IN BOOLEAN Volatile,\r
57 IN BOOLEAN Read,\r
58 IN BOOLEAN Write,\r
59 IN BOOLEAN Delete,\r
60 IN BOOLEAN Cache\r
61 )\r
62{\r
63 VARIABLE_INFO_ENTRY *Entry;\r
64\r
65 if (FeaturePcdGet (PcdVariableCollectStatistics)) {\r
66\r
8a2d4996 67 if (AtRuntime ()) {\r
68 // Don't collect statistics at runtime.\r
33a5a666
A
69 return;\r
70 }\r
71\r
72 if (gVariableInfo == NULL) {\r
052ad7e1 73 //\r
8a2d4996 74 // On the first call allocate a entry and place a pointer to it in\r
75 // the EFI System Table.\r
052ad7e1 76 //\r
33a5a666 77 gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));\r
052ad7e1
A
78 ASSERT (gVariableInfo != NULL);\r
79\r
33a5a666 80 CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);\r
bcd7070d 81 gVariableInfo->Name = AllocatePool (StrSize (VariableName));\r
e6c4ef13 82 ASSERT (gVariableInfo->Name != NULL);\r
33a5a666
A
83 StrCpy (gVariableInfo->Name, VariableName);\r
84 gVariableInfo->Volatile = Volatile;\r
33a5a666
A
85 }\r
86\r
87 \r
88 for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) {\r
89 if (CompareGuid (VendorGuid, &Entry->VendorGuid)) {\r
90 if (StrCmp (VariableName, Entry->Name) == 0) {\r
91 if (Read) {\r
92 Entry->ReadCount++;\r
93 }\r
94 if (Write) {\r
95 Entry->WriteCount++;\r
96 }\r
97 if (Delete) {\r
98 Entry->DeleteCount++;\r
99 }\r
100 if (Cache) {\r
101 Entry->CacheCount++;\r
102 }\r
103\r
104 return;\r
105 }\r
106 }\r
107\r
108 if (Entry->Next == NULL) {\r
052ad7e1
A
109 //\r
110 // If the entry is not in the table add it.\r
8a2d4996 111 // Next iteration of the loop will fill in the data.\r
052ad7e1 112 //\r
33a5a666 113 Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));\r
052ad7e1 114 ASSERT (Entry->Next != NULL);\r
33a5a666
A
115\r
116 CopyGuid (&Entry->Next->VendorGuid, VendorGuid);\r
bcd7070d 117 Entry->Next->Name = AllocatePool (StrSize (VariableName));\r
e6c4ef13 118 ASSERT (Entry->Next->Name != NULL);\r
33a5a666
A
119 StrCpy (Entry->Next->Name, VariableName);\r
120 Entry->Next->Volatile = Volatile;\r
121 }\r
122\r
123 }\r
124 }\r
125}\r
126\r
127\r
7c80e839 128/**\r
8d3a5c82 129\r
130 This code checks if variable header is valid or not.\r
131\r
7c80e839 132 @param Variable Pointer to the Variable Header.\r
8d3a5c82 133\r
7c80e839 134 @retval TRUE Variable header is valid.\r
135 @retval FALSE Variable header is not valid.\r
8d3a5c82 136\r
7c80e839 137**/\r
138BOOLEAN\r
139IsValidVariableHeader (\r
140 IN VARIABLE_HEADER *Variable\r
141 )\r
8d3a5c82 142{\r
fdb7765f 143 if (Variable == NULL || Variable->StartId != VARIABLE_DATA) {\r
8d3a5c82 144 return FALSE;\r
145 }\r
146\r
147 return TRUE;\r
148}\r
149\r
052ad7e1 150\r
7c80e839 151/**\r
152\r
153 This function writes data to the FWH at the correct LBA even if the LBAs\r
154 are fragmented.\r
155\r
8a2d4996 156 @param Global Pointer to VARAIBLE_GLOBAL structure.\r
157 @param Volatile Point out the Variable is Volatile or Non-Volatile.\r
158 @param SetByIndex TRUE if target pointer is given as index.\r
159 FALSE if target pointer is absolute.\r
160 @param Fvb Pointer to the writable FVB protocol.\r
7c80e839 161 @param DataPtrIndex Pointer to the Data from the end of VARIABLE_STORE_HEADER\r
8a2d4996 162 structure.\r
163 @param DataSize Size of data to be written.\r
164 @param Buffer Pointer to the buffer from which data is written.\r
7c80e839 165\r
8a2d4996 166 @retval EFI_INVALID_PARAMETER Parameters not valid.\r
167 @retval EFI_SUCCESS Variable store successfully updated.\r
7c80e839 168\r
169**/\r
8d3a5c82 170EFI_STATUS\r
8d3a5c82 171UpdateVariableStore (\r
8a9e0b72 172 IN VARIABLE_GLOBAL *Global,\r
173 IN BOOLEAN Volatile,\r
174 IN BOOLEAN SetByIndex,\r
175 IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb,\r
176 IN UINTN DataPtrIndex,\r
177 IN UINT32 DataSize,\r
178 IN UINT8 *Buffer\r
8d3a5c82 179 )\r
8d3a5c82 180{\r
181 EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;\r
182 UINTN BlockIndex2;\r
183 UINTN LinearOffset;\r
184 UINTN CurrWriteSize;\r
185 UINTN CurrWritePtr;\r
186 UINT8 *CurrBuffer;\r
187 EFI_LBA LbaNumber;\r
188 UINTN Size;\r
189 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
190 VARIABLE_STORE_HEADER *VolatileBase;\r
191 EFI_PHYSICAL_ADDRESS FvVolHdr;\r
192 EFI_PHYSICAL_ADDRESS DataPtr;\r
193 EFI_STATUS Status;\r
194\r
195 FwVolHeader = NULL;\r
196 DataPtr = DataPtrIndex;\r
197\r
198 //\r
8a2d4996 199 // Check if the Data is Volatile.\r
8d3a5c82 200 //\r
201 if (!Volatile) {\r
b59ad751 202 ASSERT (Fvb != NULL);\r
8a9e0b72 203 Status = Fvb->GetPhysicalAddress(Fvb, &FvVolHdr);\r
204 ASSERT_EFI_ERROR (Status);\r
205\r
8d3a5c82 206 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);\r
207 //\r
208 // Data Pointer should point to the actual Address where data is to be\r
8a2d4996 209 // written.\r
8d3a5c82 210 //\r
211 if (SetByIndex) {\r
052ad7e1 212 DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;\r
8d3a5c82 213 }\r
214\r
215 if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {\r
216 return EFI_INVALID_PARAMETER;\r
217 }\r
218 } else {\r
219 //\r
220 // Data Pointer should point to the actual Address where data is to be\r
8a2d4996 221 // written.\r
8d3a5c82 222 //\r
052ad7e1 223 VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
8d3a5c82 224 if (SetByIndex) {\r
052ad7e1 225 DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;\r
8d3a5c82 226 }\r
227\r
228 if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {\r
229 return EFI_INVALID_PARAMETER;\r
230 }\r
c6492839 231 \r
232 //\r
233 // If Volatile Variable just do a simple mem copy.\r
234 // \r
235 CopyMem ((UINT8 *)(UINTN)DataPtr, Buffer, DataSize);\r
8d3a5c82 236 return EFI_SUCCESS;\r
237 }\r
c6492839 238 \r
8d3a5c82 239 //\r
8a2d4996 240 // If we are here we are dealing with Non-Volatile Variables.\r
8d3a5c82 241 //\r
242 LinearOffset = (UINTN) FwVolHeader;\r
243 CurrWritePtr = (UINTN) DataPtr;\r
244 CurrWriteSize = DataSize;\r
245 CurrBuffer = Buffer;\r
246 LbaNumber = 0;\r
247\r
248 if (CurrWritePtr < LinearOffset) {\r
249 return EFI_INVALID_PARAMETER;\r
250 }\r
251\r
252 for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {\r
253 for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {\r
254 //\r
255 // Check to see if the Variable Writes are spanning through multiple\r
256 // blocks.\r
257 //\r
258 if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->Length)) {\r
259 if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->Length)) {\r
8a9e0b72 260 Status = Fvb->Write (\r
261 Fvb,\r
8d3a5c82 262 LbaNumber,\r
263 (UINTN) (CurrWritePtr - LinearOffset),\r
264 &CurrWriteSize,\r
265 CurrBuffer\r
266 );\r
8a9e0b72 267 return Status;\r
8d3a5c82 268 } else {\r
269 Size = (UINT32) (LinearOffset + PtrBlockMapEntry->Length - CurrWritePtr);\r
8a9e0b72 270 Status = Fvb->Write (\r
271 Fvb,\r
8d3a5c82 272 LbaNumber,\r
273 (UINTN) (CurrWritePtr - LinearOffset),\r
274 &Size,\r
275 CurrBuffer\r
276 );\r
277 if (EFI_ERROR (Status)) {\r
278 return Status;\r
279 }\r
280\r
281 CurrWritePtr = LinearOffset + PtrBlockMapEntry->Length;\r
282 CurrBuffer = CurrBuffer + Size;\r
283 CurrWriteSize = CurrWriteSize - Size;\r
284 }\r
285 }\r
286\r
287 LinearOffset += PtrBlockMapEntry->Length;\r
288 LbaNumber++;\r
289 }\r
290 }\r
291\r
292 return EFI_SUCCESS;\r
293}\r
294\r
052ad7e1 295\r
7c80e839 296/**\r
8d3a5c82 297\r
298 This code gets the current status of Variable Store.\r
299\r
7c80e839 300 @param VarStoreHeader Pointer to the Variable Store Header.\r
8d3a5c82 301\r
8a2d4996 302 @retval EfiRaw Variable store status is raw.\r
303 @retval EfiValid Variable store status is valid.\r
304 @retval EfiInvalid Variable store status is invalid.\r
8d3a5c82 305\r
7c80e839 306**/\r
307VARIABLE_STORE_STATUS\r
308GetVariableStoreStatus (\r
309 IN VARIABLE_STORE_HEADER *VarStoreHeader\r
310 )\r
8d3a5c82 311{\r
3709c4cd 312 if (CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid) &&\r
8d3a5c82 313 VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&\r
314 VarStoreHeader->State == VARIABLE_STORE_HEALTHY\r
315 ) {\r
316\r
317 return EfiValid;\r
3709c4cd 318 } else if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&\r
319 ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&\r
320 ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&\r
321 ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&\r
322 VarStoreHeader->Size == 0xffffffff &&\r
323 VarStoreHeader->Format == 0xff &&\r
324 VarStoreHeader->State == 0xff\r
8d3a5c82 325 ) {\r
326\r
327 return EfiRaw;\r
328 } else {\r
329 return EfiInvalid;\r
330 }\r
331}\r
332\r
130e2569 333\r
7c80e839 334/**\r
130e2569 335\r
336 This code gets the size of name of variable.\r
337\r
8a2d4996 338 @param Variable Pointer to the Variable Header.\r
130e2569 339\r
8a2d4996 340 @return UINTN Size of variable in bytes.\r
130e2569 341\r
7c80e839 342**/\r
343UINTN\r
344NameSizeOfVariable (\r
345 IN VARIABLE_HEADER *Variable\r
346 )\r
130e2569 347{\r
348 if (Variable->State == (UINT8) (-1) ||\r
7c80e839 349 Variable->DataSize == (UINT32) (-1) ||\r
350 Variable->NameSize == (UINT32) (-1) ||\r
351 Variable->Attributes == (UINT32) (-1)) {\r
130e2569 352 return 0;\r
353 }\r
354 return (UINTN) Variable->NameSize;\r
355}\r
356\r
7c80e839 357/**\r
130e2569 358\r
7c80e839 359 This code gets the size of variable data.\r
130e2569 360\r
8a2d4996 361 @param Variable Pointer to the Variable Header.\r
130e2569 362\r
8a2d4996 363 @return Size of variable in bytes.\r
130e2569 364\r
7c80e839 365**/\r
366UINTN\r
367DataSizeOfVariable (\r
368 IN VARIABLE_HEADER *Variable\r
369 )\r
130e2569 370{\r
7c80e839 371 if (Variable->State == (UINT8) (-1) ||\r
372 Variable->DataSize == (UINT32) (-1) ||\r
373 Variable->NameSize == (UINT32) (-1) ||\r
374 Variable->Attributes == (UINT32) (-1)) {\r
130e2569 375 return 0;\r
376 }\r
377 return (UINTN) Variable->DataSize;\r
378}\r
379\r
7c80e839 380/**\r
130e2569 381\r
382 This code gets the pointer to the variable name.\r
383\r
8a2d4996 384 @param Variable Pointer to the Variable Header.\r
130e2569 385\r
8a2d4996 386 @return Pointer to Variable Name which is Unicode encoding.\r
130e2569 387\r
7c80e839 388**/\r
389CHAR16 *\r
390GetVariableNamePtr (\r
391 IN VARIABLE_HEADER *Variable\r
392 )\r
130e2569 393{\r
394\r
395 return (CHAR16 *) (Variable + 1);\r
396}\r
397\r
7c80e839 398/**\r
8d3a5c82 399\r
400 This code gets the pointer to the variable data.\r
401\r
8a2d4996 402 @param Variable Pointer to the Variable Header.\r
8d3a5c82 403\r
8a2d4996 404 @return Pointer to Variable Data.\r
8d3a5c82 405\r
7c80e839 406**/\r
407UINT8 *\r
408GetVariableDataPtr (\r
409 IN VARIABLE_HEADER *Variable\r
410 )\r
8d3a5c82 411{\r
130e2569 412 UINTN Value;\r
413 \r
8d3a5c82 414 //\r
8a2d4996 415 // Be careful about pad size for alignment.\r
8d3a5c82 416 //\r
130e2569 417 Value = (UINTN) GetVariableNamePtr (Variable);\r
418 Value += NameSizeOfVariable (Variable);\r
419 Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));\r
420\r
421 return (UINT8 *) Value;\r
8d3a5c82 422}\r
423\r
052ad7e1 424\r
7c80e839 425/**\r
8d3a5c82 426\r
427 This code gets the pointer to the next variable header.\r
428\r
8a2d4996 429 @param Variable Pointer to the Variable Header.\r
8d3a5c82 430\r
8a2d4996 431 @return Pointer to next variable header.\r
8d3a5c82 432\r
7c80e839 433**/\r
434VARIABLE_HEADER *\r
435GetNextVariablePtr (\r
436 IN VARIABLE_HEADER *Variable\r
437 )\r
8d3a5c82 438{\r
130e2569 439 UINTN Value;\r
440\r
8d3a5c82 441 if (!IsValidVariableHeader (Variable)) {\r
442 return NULL;\r
443 }\r
130e2569 444\r
445 Value = (UINTN) GetVariableDataPtr (Variable);\r
446 Value += DataSizeOfVariable (Variable);\r
447 Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));\r
448\r
8d3a5c82 449 //\r
8a2d4996 450 // Be careful about pad size for alignment.\r
8d3a5c82 451 //\r
130e2569 452 return (VARIABLE_HEADER *) HEADER_ALIGN (Value);\r
8d3a5c82 453}\r
454\r
7c80e839 455/**\r
9cad030b 456\r
7c80e839 457 Gets the pointer to the first variable header in given variable store area.\r
9cad030b 458\r
7c80e839 459 @param VarStoreHeader Pointer to the Variable Store Header.\r
9cad030b 460\r
8a2d4996 461 @return Pointer to the first variable header.\r
9cad030b 462\r
7c80e839 463**/\r
464VARIABLE_HEADER *\r
465GetStartPointer (\r
466 IN VARIABLE_STORE_HEADER *VarStoreHeader\r
467 )\r
9cad030b 468{\r
469 //\r
8a2d4996 470 // The end of variable store.\r
9cad030b 471 //\r
472 return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);\r
473}\r
052ad7e1 474\r
7c80e839 475/**\r
8d3a5c82 476\r
7c80e839 477 Gets the pointer to the end of the variable storage area.\r
8d3a5c82 478\r
7c80e839 479 This function gets pointer to the end of the variable storage\r
480 area, according to the input variable store header.\r
8d3a5c82 481\r
8a2d4996 482 @param VarStoreHeader Pointer to the Variable Store Header.\r
8d3a5c82 483\r
8a2d4996 484 @return Pointer to the end of the variable storage area. \r
8d3a5c82 485\r
7c80e839 486**/\r
487VARIABLE_HEADER *\r
488GetEndPointer (\r
489 IN VARIABLE_STORE_HEADER *VarStoreHeader\r
490 )\r
8d3a5c82 491{\r
492 //\r
493 // The end of variable store\r
494 //\r
9cad030b 495 return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);\r
8d3a5c82 496}\r
497\r
052ad7e1 498\r
7c80e839 499/**\r
500\r
501 Variable store garbage collection and reclaim operation.\r
502\r
8a2d4996 503 @param VariableBase Base address of variable store.\r
504 @param LastVariableOffset Offset of last variable.\r
505 @param IsVolatile The variable store is volatile or not;\r
506 if it is non-volatile, need FTW.\r
507 @param UpdatingVariable Pointer to updating variable.\r
7c80e839 508\r
509 @return EFI_OUT_OF_RESOURCES\r
510 @return EFI_SUCCESS\r
511 @return Others\r
512\r
513**/\r
8d3a5c82 514EFI_STATUS\r
8d3a5c82 515Reclaim (\r
516 IN EFI_PHYSICAL_ADDRESS VariableBase,\r
517 OUT UINTN *LastVariableOffset,\r
814bae52 518 IN BOOLEAN IsVolatile,\r
519 IN VARIABLE_HEADER *UpdatingVariable\r
8d3a5c82 520 )\r
8d3a5c82 521{\r
522 VARIABLE_HEADER *Variable;\r
814bae52 523 VARIABLE_HEADER *AddedVariable;\r
8d3a5c82 524 VARIABLE_HEADER *NextVariable;\r
814bae52 525 VARIABLE_HEADER *NextAddedVariable;\r
8d3a5c82 526 VARIABLE_STORE_HEADER *VariableStoreHeader;\r
527 UINT8 *ValidBuffer;\r
814bae52 528 UINTN MaximumBufferSize;\r
8d3a5c82 529 UINTN VariableSize;\r
49e70927 530 UINTN VariableNameSize;\r
531 UINTN UpdatingVariableNameSize;\r
814bae52 532 UINTN NameSize;\r
8d3a5c82 533 UINT8 *CurrPtr;\r
814bae52 534 VOID *Point0;\r
535 VOID *Point1;\r
536 BOOLEAN FoundAdded;\r
8d3a5c82 537 EFI_STATUS Status;\r
49e70927 538 CHAR16 *VariableNamePtr;\r
539 CHAR16 *UpdatingVariableNamePtr;\r
8d3a5c82 540\r
541 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);\r
2fcdca1d 542 //\r
8a2d4996 543 // Recalculate the total size of Common/HwErr type variables in non-volatile area.\r
2fcdca1d 544 //\r
545 if (!IsVolatile) {\r
546 mVariableModuleGlobal->CommonVariableTotalSize = 0;\r
547 mVariableModuleGlobal->HwErrVariableTotalSize = 0;\r
548 }\r
8d3a5c82 549\r
550 //\r
551 // Start Pointers for the variable.\r
552 //\r
814bae52 553 Variable = GetStartPointer (VariableStoreHeader);\r
554 MaximumBufferSize = sizeof (VARIABLE_STORE_HEADER);\r
8d3a5c82 555\r
556 while (IsValidVariableHeader (Variable)) {\r
557 NextVariable = GetNextVariablePtr (Variable);\r
814bae52 558 if (Variable->State == VAR_ADDED || \r
559 Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)\r
560 ) {\r
8d3a5c82 561 VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
814bae52 562 MaximumBufferSize += VariableSize;\r
8d3a5c82 563 }\r
564\r
565 Variable = NextVariable;\r
566 }\r
567\r
814bae52 568 //\r
569 // Reserve the 1 Bytes with Oxff to identify the \r
570 // end of the variable buffer. \r
571 // \r
572 MaximumBufferSize += 1;\r
573 ValidBuffer = AllocatePool (MaximumBufferSize);\r
8d3a5c82 574 if (ValidBuffer == NULL) {\r
575 return EFI_OUT_OF_RESOURCES;\r
576 }\r
577\r
814bae52 578 SetMem (ValidBuffer, MaximumBufferSize, 0xff);\r
8d3a5c82 579\r
580 //\r
8a2d4996 581 // Copy variable store header.\r
8d3a5c82 582 //\r
814bae52 583 CopyMem (ValidBuffer, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));\r
584 CurrPtr = (UINT8 *) GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);\r
8d3a5c82 585\r
814bae52 586 //\r
8a2d4996 587 // Reinstall all ADDED variables as long as they are not identical to Updating Variable.\r
814bae52 588 // \r
589 Variable = GetStartPointer (VariableStoreHeader);\r
8d3a5c82 590 while (IsValidVariableHeader (Variable)) {\r
591 NextVariable = GetNextVariablePtr (Variable);\r
592 if (Variable->State == VAR_ADDED) {\r
5ead4a07 593 if (UpdatingVariable != NULL) {\r
594 if (UpdatingVariable == Variable) {\r
595 Variable = NextVariable;\r
596 continue;\r
597 }\r
49e70927 598\r
599 VariableNameSize = NameSizeOfVariable(Variable);\r
600 UpdatingVariableNameSize = NameSizeOfVariable(UpdatingVariable);\r
601\r
602 VariableNamePtr = GetVariableNamePtr (Variable);\r
603 UpdatingVariableNamePtr = GetVariableNamePtr (UpdatingVariable);\r
5ead4a07 604 if (CompareGuid (&Variable->VendorGuid, &UpdatingVariable->VendorGuid) &&\r
49e70927 605 VariableNameSize == UpdatingVariableNameSize &&\r
606 CompareMem (VariableNamePtr, UpdatingVariableNamePtr, VariableNameSize) == 0 ) {\r
5ead4a07 607 Variable = NextVariable;\r
608 continue;\r
609 }\r
610 }\r
8d3a5c82 611 VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
612 CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
613 CurrPtr += VariableSize;\r
2fcdca1d 614 if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
615 mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
616 } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
617 mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;\r
618 }\r
8d3a5c82 619 }\r
8d3a5c82 620 Variable = NextVariable;\r
621 }\r
5ead4a07 622\r
623 //\r
8a2d4996 624 // Reinstall the variable being updated if it is not NULL.\r
5ead4a07 625 //\r
626 if (UpdatingVariable != NULL) {\r
627 VariableSize = (UINTN)(GetNextVariablePtr (UpdatingVariable)) - (UINTN)UpdatingVariable;\r
628 CopyMem (CurrPtr, (UINT8 *) UpdatingVariable, VariableSize);\r
629 CurrPtr += VariableSize;\r
2fcdca1d 630 if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
631 mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
632 } else if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
633 mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;\r
634 }\r
5ead4a07 635 }\r
636\r
814bae52 637 //\r
8a2d4996 638 // Reinstall all in delete transition variables.\r
814bae52 639 // \r
640 Variable = GetStartPointer (VariableStoreHeader);\r
641 while (IsValidVariableHeader (Variable)) {\r
642 NextVariable = GetNextVariablePtr (Variable);\r
5ead4a07 643 if (Variable != UpdatingVariable && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
814bae52 644\r
645 //\r
646 // Buffer has cached all ADDED variable. \r
647 // Per IN_DELETED variable, we have to guarantee that\r
648 // no ADDED one in previous buffer. \r
649 // \r
650 \r
651 FoundAdded = FALSE;\r
652 AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);\r
653 while (IsValidVariableHeader (AddedVariable)) {\r
654 NextAddedVariable = GetNextVariablePtr (AddedVariable);\r
655 NameSize = NameSizeOfVariable (AddedVariable);\r
656 if (CompareGuid (&AddedVariable->VendorGuid, &Variable->VendorGuid) &&\r
657 NameSize == NameSizeOfVariable (Variable)\r
658 ) {\r
659 Point0 = (VOID *) GetVariableNamePtr (AddedVariable);\r
660 Point1 = (VOID *) GetVariableNamePtr (Variable);\r
5ead4a07 661 if (CompareMem (Point0, Point1, NameSizeOfVariable (AddedVariable)) == 0) {\r
814bae52 662 FoundAdded = TRUE;\r
663 break;\r
664 }\r
665 }\r
666 AddedVariable = NextAddedVariable;\r
667 }\r
668 if (!FoundAdded) {\r
5ead4a07 669 //\r
8a2d4996 670 // Promote VAR_IN_DELETED_TRANSITION to VAR_ADDED.\r
5ead4a07 671 //\r
814bae52 672 VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
673 CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
5ead4a07 674 ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;\r
814bae52 675 CurrPtr += VariableSize;\r
2fcdca1d 676 if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
677 mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;\r
678 } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
679 mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;\r
680 }\r
814bae52 681 }\r
682 }\r
683\r
684 Variable = NextVariable;\r
685 }\r
8d3a5c82 686\r
687 if (IsVolatile) {\r
688 //\r
8a2d4996 689 // If volatile variable store, just copy valid buffer.\r
8d3a5c82 690 //\r
691 SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);\r
814bae52 692 CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, (UINTN) (CurrPtr - (UINT8 *) ValidBuffer));\r
8a2d4996 693 Status = EFI_SUCCESS;\r
8d3a5c82 694 } else {\r
695 //\r
696 // If non-volatile variable store, perform FTW here.\r
697 //\r
698 Status = FtwVariableSpace (\r
699 VariableBase,\r
700 ValidBuffer,\r
814bae52 701 (UINTN) (CurrPtr - (UINT8 *) ValidBuffer)\r
8d3a5c82 702 );\r
8a2d4996 703 CopyMem (mNvVariableCache, (CHAR8 *)(UINTN)VariableBase, VariableStoreHeader->Size);\r
8d3a5c82 704 }\r
814bae52 705 if (!EFI_ERROR (Status)) {\r
706 *LastVariableOffset = (UINTN) (CurrPtr - (UINT8 *) ValidBuffer);\r
707 } else {\r
8d3a5c82 708 *LastVariableOffset = 0;\r
709 }\r
710\r
814bae52 711 FreePool (ValidBuffer);\r
712\r
8d3a5c82 713 return Status;\r
714}\r
715\r
33a5a666 716\r
7c80e839 717/**\r
718 Finds variable in storage blocks of volatile and non-volatile storage areas.\r
719\r
720 This code finds variable in storage blocks of volatile and non-volatile storage areas.\r
721 If VariableName is an empty string, then we just return the first\r
722 qualified variable without comparing VariableName and VendorGuid.\r
723 Otherwise, VariableName and VendorGuid are compared.\r
724\r
8a2d4996 725 @param VariableName Name of the variable to be found.\r
7c80e839 726 @param VendorGuid Vendor GUID to be found.\r
727 @param PtrTrack VARIABLE_POINTER_TRACK structure for output,\r
728 including the range searched and the target position.\r
729 @param Global Pointer to VARIABLE_GLOBAL structure, including\r
730 base of volatile variable storage area, base of\r
731 NV variable storage area, and a lock.\r
732\r
733 @retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while\r
8a2d4996 734 VendorGuid is NULL.\r
735 @retval EFI_SUCCESS Variable successfully found.\r
255a3f33 736 @retval EFI_NOT_FOUND Variable not found\r
33a5a666 737\r
7c80e839 738**/\r
8d3a5c82 739EFI_STATUS\r
8d3a5c82 740FindVariable (\r
741 IN CHAR16 *VariableName,\r
742 IN EFI_GUID *VendorGuid,\r
743 OUT VARIABLE_POINTER_TRACK *PtrTrack,\r
744 IN VARIABLE_GLOBAL *Global\r
745 )\r
8d3a5c82 746{\r
814bae52 747 VARIABLE_HEADER *Variable[2];\r
748 VARIABLE_HEADER *InDeletedVariable;\r
749 VARIABLE_STORE_HEADER *VariableStoreHeader[2];\r
750 UINTN InDeletedStorageIndex;\r
751 UINTN Index;\r
752 VOID *Point;\r
8d3a5c82 753\r
8d3a5c82 754 //\r
8a2d4996 755 // 0: Volatile, 1: Non-Volatile.\r
36873a61 756 // The index and attributes mapping must be kept in this order as RuntimeServiceGetNextVariableName\r
8a2d4996 757 // make use of this mapping to implement search algorithm.\r
8d3a5c82 758 //\r
052ad7e1 759 VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
8a2d4996 760 VariableStoreHeader[1] = mNvVariableCache;\r
8d3a5c82 761\r
762 //\r
763 // Start Pointers for the variable.\r
764 // Actual Data Pointer where data can be written.\r
765 //\r
9cad030b 766 Variable[0] = GetStartPointer (VariableStoreHeader[0]);\r
767 Variable[1] = GetStartPointer (VariableStoreHeader[1]);\r
8d3a5c82 768\r
769 if (VariableName[0] != 0 && VendorGuid == NULL) {\r
770 return EFI_INVALID_PARAMETER;\r
771 }\r
814bae52 772\r
8d3a5c82 773 //\r
8a2d4996 774 // Find the variable by walk through volatile and then non-volatile variable store.\r
8d3a5c82 775 //\r
814bae52 776 InDeletedVariable = NULL;\r
777 InDeletedStorageIndex = 0;\r
8d3a5c82 778 for (Index = 0; Index < 2; Index++) {\r
79749182 779 while ((Variable[Index] < GetEndPointer (VariableStoreHeader[Index])) && IsValidVariableHeader (Variable[Index])) {\r
814bae52 780 if (Variable[Index]->State == VAR_ADDED || \r
781 Variable[Index]->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)\r
782 ) {\r
8a2d4996 783 if (!AtRuntime () || ((Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {\r
8d3a5c82 784 if (VariableName[0] == 0) {\r
814bae52 785 if (Variable[Index]->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
786 InDeletedVariable = Variable[Index];\r
787 InDeletedStorageIndex = Index;\r
788 } else {\r
789 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Index]);\r
790 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);\r
791 PtrTrack->CurrPtr = Variable[Index];\r
792 PtrTrack->Volatile = (BOOLEAN)(Index == 0);\r
793\r
794 return EFI_SUCCESS;\r
795 }\r
8d3a5c82 796 } else {\r
797 if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {\r
130e2569 798 Point = (VOID *) GetVariableNamePtr (Variable[Index]);\r
799\r
800 ASSERT (NameSizeOfVariable (Variable[Index]) != 0);\r
c24b392c 801 if (CompareMem (VariableName, Point, NameSizeOfVariable (Variable[Index])) == 0) {\r
814bae52 802 if (Variable[Index]->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {\r
803 InDeletedVariable = Variable[Index];\r
804 InDeletedStorageIndex = Index;\r
805 } else {\r
806 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[Index]);\r
807 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);\r
808 PtrTrack->CurrPtr = Variable[Index];\r
809 PtrTrack->Volatile = (BOOLEAN)(Index == 0);\r
810\r
811 return EFI_SUCCESS;\r
812 }\r
8d3a5c82 813 }\r
814 }\r
815 }\r
816 }\r
817 }\r
818\r
819 Variable[Index] = GetNextVariablePtr (Variable[Index]);\r
820 }\r
814bae52 821 if (InDeletedVariable != NULL) {\r
822 PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader[InDeletedStorageIndex]);\r
823 PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[InDeletedStorageIndex]);\r
824 PtrTrack->CurrPtr = InDeletedVariable;\r
825 PtrTrack->Volatile = (BOOLEAN)(InDeletedStorageIndex == 0);\r
826 return EFI_SUCCESS;\r
827 }\r
8d3a5c82 828 }\r
8d3a5c82 829 PtrTrack->CurrPtr = NULL;\r
830 return EFI_NOT_FOUND;\r
831}\r
832\r
7c80e839 833/**\r
72399dae 834 Get index from supported language codes according to language string.\r
835\r
836 This code is used to get corresponding index in supported language codes. It can handle\r
0254efc0 837 RFC4646 and ISO639 language tags.\r
72399dae 838 In ISO639 language tags, take 3-characters as a delimitation to find matched string and calculate the index.\r
0254efc0 839 In RFC4646 language tags, take semicolon as a delimitation to find matched string and calculate the index.\r
72399dae 840\r
841 For example:\r
842 SupportedLang = "engfraengfra"\r
843 Lang = "eng"\r
844 Iso639Language = TRUE\r
845 The return value is "0".\r
846 Another example:\r
847 SupportedLang = "en;fr;en-US;fr-FR"\r
848 Lang = "fr-FR"\r
849 Iso639Language = FALSE\r
850 The return value is "3".\r
851\r
852 @param SupportedLang Platform supported language codes.\r
853 @param Lang Configured language.\r
0254efc0 854 @param Iso639Language A bool value to signify if the handler is operated on ISO639 or RFC4646.\r
72399dae 855\r
8a2d4996 856 @retval The index of language in the language codes.\r
8d3a5c82 857\r
7c80e839 858**/\r
72399dae 859UINTN\r
72399dae 860GetIndexFromSupportedLangCodes(\r
861 IN CHAR8 *SupportedLang,\r
862 IN CHAR8 *Lang,\r
863 IN BOOLEAN Iso639Language\r
864 ) \r
8d3a5c82 865{\r
72399dae 866 UINTN Index;\r
255a3f33
RN
867 UINTN CompareLength;\r
868 UINTN LanguageLength;\r
72399dae 869\r
72399dae 870 if (Iso639Language) {\r
255a3f33 871 CompareLength = ISO_639_2_ENTRY_SIZE;\r
72399dae 872 for (Index = 0; Index < AsciiStrLen (SupportedLang); Index += CompareLength) {\r
873 if (AsciiStrnCmp (Lang, SupportedLang + Index, CompareLength) == 0) {\r
874 //\r
875 // Successfully find the index of Lang string in SupportedLang string.\r
876 //\r
877 Index = Index / CompareLength;\r
878 return Index;\r
879 }\r
880 }\r
881 ASSERT (FALSE);\r
882 return 0;\r
883 } else {\r
884 //\r
0254efc0 885 // Compare RFC4646 language code\r
72399dae 886 //\r
255a3f33
RN
887 Index = 0;\r
888 for (LanguageLength = 0; Lang[LanguageLength] != '\0'; LanguageLength++);\r
889\r
890 for (Index = 0; *SupportedLang != '\0'; Index++, SupportedLang += CompareLength) {\r
72399dae 891 //\r
255a3f33 892 // Skip ';' characters in SupportedLang\r
72399dae 893 //\r
255a3f33
RN
894 for (; *SupportedLang != '\0' && *SupportedLang == ';'; SupportedLang++);\r
895 //\r
896 // Determine the length of the next language code in SupportedLang\r
897 //\r
898 for (CompareLength = 0; SupportedLang[CompareLength] != '\0' && SupportedLang[CompareLength] != ';'; CompareLength++);\r
899 \r
900 if ((CompareLength == LanguageLength) && \r
901 (AsciiStrnCmp (Lang, SupportedLang, CompareLength) == 0)) {\r
72399dae 902 //\r
903 // Successfully find the index of Lang string in SupportedLang string.\r
904 //\r
905 return Index;\r
906 }\r
72399dae 907 }\r
908 ASSERT (FALSE);\r
909 return 0;\r
8d3a5c82 910 }\r
72399dae 911}\r
33a5a666 912\r
72399dae 913/**\r
914 Get language string from supported language codes according to index.\r
915\r
8a2d4996 916 This code is used to get corresponding language strings in supported language codes. It can handle\r
0254efc0 917 RFC4646 and ISO639 language tags.\r
72399dae 918 In ISO639 language tags, take 3-characters as a delimitation. Find language string according to the index.\r
0254efc0 919 In RFC4646 language tags, take semicolon as a delimitation. Find language string according to the index.\r
72399dae 920\r
921 For example:\r
922 SupportedLang = "engfraengfra"\r
923 Index = "1"\r
924 Iso639Language = TRUE\r
925 The return value is "fra".\r
926 Another example:\r
927 SupportedLang = "en;fr;en-US;fr-FR"\r
928 Index = "1"\r
929 Iso639Language = FALSE\r
930 The return value is "fr".\r
931\r
932 @param SupportedLang Platform supported language codes.\r
8a2d4996 933 @param Index The index in supported language codes.\r
0254efc0 934 @param Iso639Language A bool value to signify if the handler is operated on ISO639 or RFC4646.\r
72399dae 935\r
8a2d4996 936 @retval The language string in the language codes.\r
8d3a5c82 937\r
72399dae 938**/\r
939CHAR8 *\r
72399dae 940GetLangFromSupportedLangCodes (\r
941 IN CHAR8 *SupportedLang,\r
942 IN UINTN Index,\r
943 IN BOOLEAN Iso639Language\r
944)\r
945{\r
946 UINTN SubIndex;\r
255a3f33 947 UINTN CompareLength;\r
72399dae 948 CHAR8 *Supported;\r
8d3a5c82 949\r
72399dae 950 SubIndex = 0;\r
951 Supported = SupportedLang;\r
952 if (Iso639Language) {\r
953 //\r
8a2d4996 954 // According to the index of Lang string in SupportedLang string to get the language.\r
955 // This code will be invoked in RUNTIME, therefore there is not a memory allocate/free operation.\r
72399dae 956 // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.\r
957 //\r
255a3f33
RN
958 CompareLength = ISO_639_2_ENTRY_SIZE;\r
959 mVariableModuleGlobal->Lang[CompareLength] = '\0';\r
72399dae 960 return CopyMem (mVariableModuleGlobal->Lang, SupportedLang + Index * CompareLength, CompareLength);\r
8a2d4996 961 \r
8d3a5c82 962 } else {\r
72399dae 963 while (TRUE) {\r
964 //\r
8a2d4996 965 // Take semicolon as delimitation, sequentially traverse supported language codes.\r
72399dae 966 //\r
967 for (CompareLength = 0; *Supported != ';' && *Supported != '\0'; CompareLength++) {\r
968 Supported++;\r
969 }\r
970 if ((*Supported == '\0') && (SubIndex != Index)) {\r
971 //\r
972 // Have completed the traverse, but not find corrsponding string.\r
973 // This case is not allowed to happen.\r
974 //\r
975 ASSERT(FALSE);\r
976 return NULL;\r
977 }\r
978 if (SubIndex == Index) {\r
979 //\r
8a2d4996 980 // According to the index of Lang string in SupportedLang string to get the language.\r
72399dae 981 // As this code will be invoked in RUNTIME, therefore there is not memory allocate/free operation.\r
982 // In driver entry, it pre-allocates a runtime attribute memory to accommodate this string.\r
983 //\r
255a3f33 984 mVariableModuleGlobal->PlatformLang[CompareLength] = '\0';\r
72399dae 985 return CopyMem (mVariableModuleGlobal->PlatformLang, Supported - CompareLength, CompareLength);\r
986 }\r
987 SubIndex++;\r
8a2d4996 988\r
5c033766
RN
989 //\r
990 // Skip ';' characters in Supported\r
991 //\r
992 for (; *Supported != '\0' && *Supported == ';'; Supported++);\r
72399dae 993 }\r
8d3a5c82 994 }\r
8d3a5c82 995}\r
996\r
255a3f33
RN
997/**\r
998 Returns a pointer to an allocated buffer that contains the best matching language \r
999 from a set of supported languages. \r
1000 \r
1001 This function supports both ISO 639-2 and RFC 4646 language codes, but language \r
1002 code types may not be mixed in a single call to this function. This function\r
1003 supports a variable argument list that allows the caller to pass in a prioritized\r
1004 list of language codes to test against all the language codes in SupportedLanguages.\r
1005\r
1006 If SupportedLanguages is NULL, then ASSERT().\r
1007\r
1008 @param[in] SupportedLanguages A pointer to a Null-terminated ASCII string that\r
1009 contains a set of language codes in the format \r
1010 specified by Iso639Language.\r
1011 @param[in] Iso639Language If TRUE, then all language codes are assumed to be\r
1012 in ISO 639-2 format. If FALSE, then all language\r
1013 codes are assumed to be in RFC 4646 language format\r
1014 @param[in] ... A variable argument list that contains pointers to \r
1015 Null-terminated ASCII strings that contain one or more\r
1016 language codes in the format specified by Iso639Language.\r
1017 The first language code from each of these language\r
1018 code lists is used to determine if it is an exact or\r
1019 close match to any of the language codes in \r
1020 SupportedLanguages. Close matches only apply to RFC 4646\r
1021 language codes, and the matching algorithm from RFC 4647\r
1022 is used to determine if a close match is present. If \r
1023 an exact or close match is found, then the matching\r
1024 language code from SupportedLanguages is returned. If\r
1025 no matches are found, then the next variable argument\r
1026 parameter is evaluated. The variable argument list \r
1027 is terminated by a NULL.\r
1028\r
1029 @retval NULL The best matching language could not be found in SupportedLanguages.\r
1030 @retval NULL There are not enough resources available to return the best matching \r
1031 language.\r
1032 @retval Other A pointer to a Null-terminated ASCII string that is the best matching \r
1033 language in SupportedLanguages.\r
1034\r
1035**/\r
1036CHAR8 *\r
e1adae60 1037EFIAPI\r
255a3f33
RN
1038VariableGetBestLanguage (\r
1039 IN CONST CHAR8 *SupportedLanguages, \r
1040 IN BOOLEAN Iso639Language,\r
1041 ...\r
1042 )\r
1043{\r
1044 VA_LIST Args;\r
1045 CHAR8 *Language;\r
1046 UINTN CompareLength;\r
1047 UINTN LanguageLength;\r
1048 CONST CHAR8 *Supported;\r
1049 CHAR8 *Buffer;\r
1050\r
1051 ASSERT (SupportedLanguages != NULL);\r
1052\r
1053 VA_START (Args, Iso639Language);\r
1054 while ((Language = VA_ARG (Args, CHAR8 *)) != NULL) {\r
1055 //\r
1056 // Default to ISO 639-2 mode\r
1057 //\r
1058 CompareLength = 3;\r
1059 LanguageLength = MIN (3, AsciiStrLen (Language));\r
1060\r
1061 //\r
1062 // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language\r
1063 //\r
1064 if (!Iso639Language) {\r
1065 for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++);\r
1066 }\r
1067\r
1068 //\r
1069 // Trim back the length of Language used until it is empty\r
1070 //\r
1071 while (LanguageLength > 0) {\r
1072 //\r
1073 // Loop through all language codes in SupportedLanguages\r
1074 //\r
1075 for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {\r
1076 //\r
1077 // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages\r
1078 //\r
1079 if (!Iso639Language) {\r
1080 //\r
1081 // Skip ';' characters in Supported\r
1082 //\r
1083 for (; *Supported != '\0' && *Supported == ';'; Supported++);\r
1084 //\r
1085 // Determine the length of the next language code in Supported\r
1086 //\r
1087 for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++);\r
1088 //\r
1089 // If Language is longer than the Supported, then skip to the next language\r
1090 //\r
1091 if (LanguageLength > CompareLength) {\r
1092 continue;\r
1093 }\r
1094 }\r
1095 //\r
1096 // See if the first LanguageLength characters in Supported match Language\r
1097 //\r
1098 if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {\r
1099 VA_END (Args);\r
1100\r
1101 Buffer = Iso639Language ? mVariableModuleGlobal->Lang : mVariableModuleGlobal->PlatformLang;\r
1102 Buffer[CompareLength] = '\0';\r
1103 return CopyMem (Buffer, Supported, CompareLength);\r
1104 }\r
1105 }\r
1106\r
1107 if (Iso639Language) {\r
1108 //\r
1109 // If ISO 639 mode, then each language can only be tested once\r
1110 //\r
1111 LanguageLength = 0;\r
1112 } else {\r
1113 //\r
1114 // If RFC 4646 mode, then trim Language from the right to the next '-' character \r
1115 //\r
1116 for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--);\r
1117 }\r
1118 }\r
1119 }\r
1120 VA_END (Args);\r
1121\r
1122 //\r
1123 // No matches were found \r
1124 //\r
1125 return NULL;\r
1126}\r
1127\r
72399dae 1128/**\r
1129 Hook the operations in PlatformLangCodes, LangCodes, PlatformLang and Lang.\r
052ad7e1 1130\r
72399dae 1131 When setting Lang/LangCodes, simultaneously update PlatformLang/PlatformLangCodes.\r
052ad7e1 1132\r
72399dae 1133 According to UEFI spec, PlatformLangCodes/LangCodes are only set once in firmware initialization,\r
1134 and are read-only. Therefore, in variable driver, only store the original value for other use.\r
8d3a5c82 1135\r
8a2d4996 1136 @param[in] VariableName Name of variable.\r
8d3a5c82 1137\r
8a2d4996 1138 @param[in] Data Variable data.\r
8d3a5c82 1139\r
8a2d4996 1140 @param[in] DataSize Size of data. 0 means delete.\r
72399dae 1141\r
7c80e839 1142**/\r
255a3f33 1143VOID\r
72399dae 1144AutoUpdateLangVariable(\r
1145 IN CHAR16 *VariableName,\r
1146 IN VOID *Data,\r
1147 IN UINTN DataSize\r
052ad7e1 1148 )\r
8d3a5c82 1149{\r
255a3f33
RN
1150 EFI_STATUS Status;\r
1151 CHAR8 *BestPlatformLang;\r
1152 CHAR8 *BestLang;\r
1153 UINTN Index;\r
1154 UINT32 Attributes;\r
72399dae 1155 VARIABLE_POINTER_TRACK Variable;\r
255a3f33 1156 BOOLEAN SetLanguageCodes;\r
8d3a5c82 1157\r
72399dae 1158 //\r
255a3f33 1159 // Don't do updates for delete operation\r
72399dae 1160 //\r
255a3f33
RN
1161 if (DataSize == 0) {\r
1162 return;\r
1163 }\r
1164\r
1165 SetLanguageCodes = FALSE;\r
8d3a5c82 1166\r
72399dae 1167 if (StrCmp (VariableName, L"PlatformLangCodes") == 0) {\r
255a3f33
RN
1168 //\r
1169 // PlatformLangCodes is a volatile variable, so it can not be updated at runtime.\r
1170 //\r
8a2d4996 1171 if (AtRuntime ()) {\r
255a3f33
RN
1172 return;\r
1173 }\r
1174\r
1175 SetLanguageCodes = TRUE;\r
1176\r
72399dae 1177 //\r
1178 // According to UEFI spec, PlatformLangCodes is only set once in firmware initialization, and is read-only\r
1179 // Therefore, in variable driver, only store the original value for other use.\r
1180 //\r
255a3f33
RN
1181 if (mVariableModuleGlobal->PlatformLangCodes != NULL) {\r
1182 FreePool (mVariableModuleGlobal->PlatformLangCodes);\r
1183 }\r
1184 mVariableModuleGlobal->PlatformLangCodes = AllocateRuntimeCopyPool (DataSize, Data);\r
1185 ASSERT (mVariableModuleGlobal->PlatformLangCodes != NULL);\r
1186\r
72399dae 1187 //\r
255a3f33
RN
1188 // PlatformLang holds a single language from PlatformLangCodes, \r
1189 // so the size of PlatformLangCodes is enough for the PlatformLang.\r
72399dae 1190 //\r
255a3f33
RN
1191 if (mVariableModuleGlobal->PlatformLang != NULL) {\r
1192 FreePool (mVariableModuleGlobal->PlatformLang);\r
1193 }\r
1194 mVariableModuleGlobal->PlatformLang = AllocateRuntimePool (DataSize);\r
1195 ASSERT (mVariableModuleGlobal->PlatformLang != NULL);\r
fdb7765f 1196\r
255a3f33 1197 } else if (StrCmp (VariableName, L"LangCodes") == 0) {\r
72399dae 1198 //\r
255a3f33 1199 // LangCodes is a volatile variable, so it can not be updated at runtime.\r
72399dae 1200 //\r
8a2d4996 1201 if (AtRuntime ()) {\r
255a3f33
RN
1202 return;\r
1203 }\r
1204\r
1205 SetLanguageCodes = TRUE;\r
8d3a5c82 1206\r
8d3a5c82 1207 //\r
255a3f33
RN
1208 // According to UEFI spec, LangCodes is only set once in firmware initialization, and is read-only\r
1209 // Therefore, in variable driver, only store the original value for other use.\r
8d3a5c82 1210 //\r
255a3f33
RN
1211 if (mVariableModuleGlobal->LangCodes != NULL) {\r
1212 FreePool (mVariableModuleGlobal->LangCodes);\r
1213 }\r
1214 mVariableModuleGlobal->LangCodes = AllocateRuntimeCopyPool (DataSize, Data);\r
1215 ASSERT (mVariableModuleGlobal->LangCodes != NULL);\r
1216 }\r
8d3a5c82 1217\r
255a3f33
RN
1218 if (SetLanguageCodes \r
1219 && (mVariableModuleGlobal->PlatformLangCodes != NULL)\r
1220 && (mVariableModuleGlobal->LangCodes != NULL)) {\r
8d3a5c82 1221 //\r
255a3f33
RN
1222 // Update Lang if PlatformLang is already set\r
1223 // Update PlatformLang if Lang is already set\r
8d3a5c82 1224 //\r
255a3f33
RN
1225 Status = FindVariable (L"PlatformLang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *) mVariableModuleGlobal);\r
1226 if (!EFI_ERROR (Status)) {\r
1227 //\r
1228 // Update Lang\r
1229 //\r
1230 VariableName = L"PlatformLang";\r
1231 Data = GetVariableDataPtr (Variable.CurrPtr);\r
1232 DataSize = Variable.CurrPtr->DataSize;\r
1233 } else {\r
1234 Status = FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *) mVariableModuleGlobal);\r
1235 if (!EFI_ERROR (Status)) {\r
1236 //\r
1237 // Update PlatformLang\r
1238 //\r
1239 VariableName = L"Lang";\r
1240 Data = GetVariableDataPtr (Variable.CurrPtr);\r
1241 DataSize = Variable.CurrPtr->DataSize;\r
1242 } else {\r
1243 //\r
1244 // Neither PlatformLang nor Lang is set, directly return\r
1245 //\r
1246 return;\r
1247 }\r
1248 }\r
1249 }\r
1250 \r
1251 //\r
1252 // According to UEFI spec, "Lang" and "PlatformLang" is NV|BS|RT attributions.\r
1253 //\r
1254 Attributes = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;\r
8d3a5c82 1255\r
255a3f33 1256 if (StrCmp (VariableName, L"PlatformLang") == 0) {\r
8d3a5c82 1257 //\r
255a3f33 1258 // Update Lang when PlatformLangCodes/LangCodes were set.\r
8d3a5c82 1259 //\r
255a3f33
RN
1260 if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {\r
1261 //\r
1262 // When setting PlatformLang, firstly get most matched language string from supported language codes.\r
1263 //\r
1264 BestPlatformLang = VariableGetBestLanguage (mVariableModuleGlobal->PlatformLangCodes, FALSE, Data, NULL);\r
1265 if (BestPlatformLang != NULL) {\r
1266 //\r
1267 // Get the corresponding index in language codes.\r
1268 //\r
1269 Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, BestPlatformLang, FALSE);\r
fdb7765f 1270\r
255a3f33
RN
1271 //\r
1272 // Get the corresponding ISO639 language tag according to RFC4646 language tag.\r
1273 //\r
1274 BestLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, Index, TRUE);\r
8d3a5c82 1275\r
255a3f33
RN
1276 //\r
1277 // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.\r
1278 //\r
1279 FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *)mVariableModuleGlobal);\r
8d3a5c82 1280\r
8a2d4996 1281 Status = UpdateVariable (L"Lang", &gEfiGlobalVariableGuid, BestLang,\r
1282 ISO_639_2_ENTRY_SIZE + 1, Attributes, &Variable);\r
8d3a5c82 1283\r
255a3f33 1284 DEBUG ((EFI_D_INFO, "Variable Driver Auto Update PlatformLang, PlatformLang:%a, Lang:%a\n", BestPlatformLang, BestLang));\r
72399dae 1285\r
255a3f33
RN
1286 ASSERT_EFI_ERROR(Status);\r
1287 }\r
1288 }\r
72399dae 1289\r
255a3f33 1290 } else if (StrCmp (VariableName, L"Lang") == 0) {\r
72399dae 1291 //\r
255a3f33 1292 // Update PlatformLang when PlatformLangCodes/LangCodes were set.\r
72399dae 1293 //\r
255a3f33
RN
1294 if ((mVariableModuleGlobal->PlatformLangCodes != NULL) && (mVariableModuleGlobal->LangCodes != NULL)) {\r
1295 //\r
1296 // When setting Lang, firstly get most matched language string from supported language codes.\r
1297 //\r
1298 BestLang = VariableGetBestLanguage (mVariableModuleGlobal->LangCodes, TRUE, Data, NULL);\r
1299 if (BestLang != NULL) {\r
1300 //\r
1301 // Get the corresponding index in language codes.\r
1302 //\r
1303 Index = GetIndexFromSupportedLangCodes (mVariableModuleGlobal->LangCodes, BestLang, TRUE);\r
72399dae 1304\r
255a3f33
RN
1305 //\r
1306 // Get the corresponding RFC4646 language tag according to ISO639 language tag.\r
1307 //\r
1308 BestPlatformLang = GetLangFromSupportedLangCodes (mVariableModuleGlobal->PlatformLangCodes, Index, FALSE);\r
1309\r
1310 //\r
1311 // Successfully convert Lang to PlatformLang, and set the BestPlatformLang value into PlatformLang variable simultaneously.\r
1312 //\r
1313 FindVariable (L"PlatformLang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *)mVariableModuleGlobal);\r
72399dae 1314\r
255a3f33
RN
1315 Status = UpdateVariable (L"PlatformLang", &gEfiGlobalVariableGuid, BestPlatformLang, \r
1316 AsciiStrSize (BestPlatformLang), Attributes, &Variable);\r
72399dae 1317\r
255a3f33
RN
1318 DEBUG ((EFI_D_INFO, "Variable Driver Auto Update Lang, Lang:%a, PlatformLang:%a\n", BestLang, BestPlatformLang));\r
1319 ASSERT_EFI_ERROR (Status);\r
1320 }\r
1321 }\r
72399dae 1322 }\r
8d3a5c82 1323}\r
1324\r
7c80e839 1325/**\r
72399dae 1326 Update the variable region with Variable information. These are the same \r
1327 arguments as the EFI Variable services.\r
052ad7e1 1328\r
8a2d4996 1329 @param[in] VariableName Name of variable.\r
1330 @param[in] VendorGuid Guid of variable.\r
1331 @param[in] Data Variable data.\r
1332 @param[in] DataSize Size of data. 0 means delete.\r
1333 @param[in] Attributes Attribues of the variable.\r
1334 @param[in] CacheVariable The variable information which is used to keep track of variable usage.\r
1335 \r
72399dae 1336 @retval EFI_SUCCESS The update operation is success.\r
72399dae 1337 @retval EFI_OUT_OF_RESOURCES Variable region is full, can not write other data into this region.\r
8d3a5c82 1338\r
7c80e839 1339**/\r
052ad7e1 1340EFI_STATUS\r
72399dae 1341UpdateVariable (\r
8a2d4996 1342 IN CHAR16 *VariableName,\r
1343 IN EFI_GUID *VendorGuid,\r
1344 IN VOID *Data,\r
1345 IN UINTN DataSize,\r
1346 IN UINT32 Attributes OPTIONAL,\r
1347 IN VARIABLE_POINTER_TRACK *CacheVariable\r
052ad7e1 1348 )\r
8d3a5c82 1349{\r
8a9e0b72 1350 EFI_STATUS Status;\r
1351 VARIABLE_HEADER *NextVariable;\r
72399dae 1352 UINTN ScratchSize;\r
1353 UINTN NonVolatileVarableStoreSize;\r
8a9e0b72 1354 UINTN VarNameOffset;\r
1355 UINTN VarDataOffset;\r
72399dae 1356 UINTN VarNameSize;\r
8a9e0b72 1357 UINTN VarSize;\r
72399dae 1358 BOOLEAN Volatile;\r
1359 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
8a9e0b72 1360 UINT8 State;\r
1361 BOOLEAN Reclaimed;\r
8a2d4996 1362 VARIABLE_POINTER_TRACK *Variable;\r
1363 VARIABLE_POINTER_TRACK NvVariable;\r
1364 VARIABLE_STORE_HEADER *VariableStoreHeader;\r
1365 UINTN CacheOffset;\r
fdb7765f 1366\r
5456306f 1367 if ((mVariableModuleGlobal->FvbInstance == NULL) && ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0)) {\r
1368 //\r
1369 // The FVB protocol is not ready. Trying to update NV variable prior to the installation\r
1370 // of EFI_VARIABLE_WRITE_ARCH_PROTOCOL.\r
1371 //\r
1372 return EFI_NOT_AVAILABLE_YET; \r
1373 }\r
1374\r
1375 if ((CacheVariable->CurrPtr == NULL) || CacheVariable->Volatile) {\r
8a2d4996 1376 Variable = CacheVariable;\r
1377 } else {\r
8a2d4996 1378 //\r
5456306f 1379 // Update/Delete existing NV variable.\r
8a2d4996 1380 // CacheVariable points to the variable in the memory copy of Flash area\r
1381 // Now let Variable points to the same variable in Flash area.\r
1382 //\r
1383 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);\r
1384 Variable = &NvVariable; \r
1385 Variable->StartPtr = GetStartPointer (VariableStoreHeader);\r
1386 Variable->EndPtr = GetEndPointer (VariableStoreHeader);\r
5456306f 1387 Variable->CurrPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));\r
1388 Variable->Volatile = FALSE;\r
1389 } \r
1390\r
1391 Fvb = mVariableModuleGlobal->FvbInstance;\r
1392 Reclaimed = FALSE;\r
fdb7765f 1393\r
72399dae 1394 if (Variable->CurrPtr != NULL) {\r
8d3a5c82 1395 //\r
8a2d4996 1396 // Update/Delete existing variable.\r
8d3a5c82 1397 //\r
8a2d4996 1398 if (AtRuntime ()) { \r
c6492839 1399 //\r
8a2d4996 1400 // If AtRuntime and the variable is Volatile and Runtime Access, \r
c6492839 1401 // the volatile is ReadOnly, and SetVariable should be aborted and \r
1402 // return EFI_WRITE_PROTECTED.\r
1403 //\r
72399dae 1404 if (Variable->Volatile) {\r
c6492839 1405 Status = EFI_WRITE_PROTECTED;\r
1406 goto Done;\r
1407 }\r
1408 //\r
8a2d4996 1409 // Only variable that have NV attributes can be updated/deleted in Runtime.\r
c6492839 1410 //\r
72399dae 1411 if ((Variable->CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {\r
c6492839 1412 Status = EFI_INVALID_PARAMETER;\r
1413 goto Done; \r
1414 }\r
1415 }\r
8a2d4996 1416\r
8d3a5c82 1417 //\r
c6492839 1418 // Setting a data variable with no access, or zero DataSize attributes\r
8a2d4996 1419 // causes it to be deleted.\r
8d3a5c82 1420 //\r
c6492839 1421 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) { \r
72399dae 1422 State = Variable->CurrPtr->State;\r
c6492839 1423 State &= VAR_DELETED;\r
1424\r
1425 Status = UpdateVariableStore (\r
052ad7e1 1426 &mVariableModuleGlobal->VariableGlobal,\r
72399dae 1427 Variable->Volatile,\r
c6492839 1428 FALSE,\r
8a9e0b72 1429 Fvb,\r
72399dae 1430 (UINTN) &Variable->CurrPtr->State,\r
c6492839 1431 sizeof (UINT8),\r
1432 &State\r
1433 ); \r
33a5a666 1434 if (!EFI_ERROR (Status)) {\r
8a2d4996 1435 UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, FALSE, TRUE, FALSE);\r
1436 if (!Variable->Volatile) {\r
1437 CacheVariable->CurrPtr->State = State;\r
1438 }\r
33a5a666 1439 }\r
c6492839 1440 goto Done; \r
1441 }\r
8d3a5c82 1442 //\r
8a2d4996 1443 // If the variable is marked valid, and the same data has been passed in,\r
c6492839 1444 // then return to the caller immediately.\r
8d3a5c82 1445 //\r
72399dae 1446 if (DataSizeOfVariable (Variable->CurrPtr) == DataSize &&\r
1447 (CompareMem (Data, GetVariableDataPtr (Variable->CurrPtr), DataSize) == 0)) {\r
33a5a666 1448 \r
8a2d4996 1449 UpdateVariableInfo (VariableName, VendorGuid, Variable->Volatile, FALSE, TRUE, FALSE, FALSE);\r
c6492839 1450 Status = EFI_SUCCESS;\r
1451 goto Done;\r
72399dae 1452 } else if ((Variable->CurrPtr->State == VAR_ADDED) ||\r
1453 (Variable->CurrPtr->State == (VAR_ADDED & VAR_IN_DELETED_TRANSITION))) {\r
814bae52 1454\r
c6492839 1455 //\r
8a2d4996 1456 // Mark the old variable as in delete transition.\r
c6492839 1457 //\r
72399dae 1458 State = Variable->CurrPtr->State;\r
c6492839 1459 State &= VAR_IN_DELETED_TRANSITION;\r
1460\r
1461 Status = UpdateVariableStore (\r
052ad7e1 1462 &mVariableModuleGlobal->VariableGlobal,\r
72399dae 1463 Variable->Volatile,\r
c6492839 1464 FALSE,\r
8a9e0b72 1465 Fvb,\r
72399dae 1466 (UINTN) &Variable->CurrPtr->State,\r
c6492839 1467 sizeof (UINT8),\r
1468 &State\r
1469 ); \r
1470 if (EFI_ERROR (Status)) {\r
1471 goto Done; \r
33a5a666 1472 } \r
8a2d4996 1473 if (!Variable->Volatile) {\r
1474 CacheVariable->CurrPtr->State = State;\r
1475 }\r
c6492839 1476 } \r
72399dae 1477 } else {\r
8d3a5c82 1478 //\r
8a2d4996 1479 // Not found existing variable. Create a new variable.\r
c6492839 1480 // \r
1481 \r
8d3a5c82 1482 //\r
c6492839 1483 // Make sure we are trying to create a new variable.\r
8a2d4996 1484 // Setting a data variable with zero DataSize or no access attributes means to delete it. \r
8d3a5c82 1485 //\r
c6492839 1486 if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {\r
1487 Status = EFI_NOT_FOUND;\r
1488 goto Done;\r
1489 }\r
1490 \r
8d3a5c82 1491 //\r
8a2d4996 1492 // Only variable have NV|RT attribute can be created in Runtime.\r
c6492839 1493 //\r
8a2d4996 1494 if (AtRuntime () &&\r
45f6c85b 1495 (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0))) {\r
c6492839 1496 Status = EFI_INVALID_PARAMETER;\r
1497 goto Done;\r
1498 } \r
c6492839 1499 }\r
1500\r
1501 //\r
1502 // Function part - create a new variable and copy the data.\r
1503 // Both update a variable and create a variable will come here.\r
8a2d4996 1504\r
c6492839 1505 //\r
1506 // Tricky part: Use scratch data area at the end of volatile variable store\r
1507 // as a temporary storage.\r
1508 //\r
052ad7e1 1509 NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));\r
188e4e84 1510 ScratchSize = MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize));\r
c6492839 1511\r
2fcdca1d 1512 SetMem (NextVariable, ScratchSize, 0xff);\r
c6492839 1513\r
1514 NextVariable->StartId = VARIABLE_DATA;\r
1515 NextVariable->Attributes = Attributes;\r
1516 //\r
1517 // NextVariable->State = VAR_ADDED;\r
1518 //\r
8a2d4996 1519 NextVariable->Reserved = 0;\r
1520 VarNameOffset = sizeof (VARIABLE_HEADER);\r
1521 VarNameSize = StrSize (VariableName);\r
c6492839 1522 CopyMem (\r
1523 (UINT8 *) ((UINTN) NextVariable + VarNameOffset),\r
1524 VariableName,\r
1525 VarNameSize\r
1526 );\r
1527 VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);\r
1528 CopyMem (\r
1529 (UINT8 *) ((UINTN) NextVariable + VarDataOffset),\r
1530 Data,\r
1531 DataSize\r
1532 );\r
1533 CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));\r
1534 //\r
1535 // There will be pad bytes after Data, the NextVariable->NameSize and\r
1536 // NextVariable->DataSize should not include pad size so that variable\r
8a2d4996 1537 // service can get actual size in GetVariable.\r
c6492839 1538 //\r
1539 NextVariable->NameSize = (UINT32)VarNameSize;\r
1540 NextVariable->DataSize = (UINT32)DataSize;\r
1541\r
1542 //\r
1543 // The actual size of the variable that stores in storage should\r
1544 // include pad size.\r
1545 //\r
1546 VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);\r
45f6c85b 1547 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
8d3a5c82 1548 //\r
8a2d4996 1549 // Create a nonvolatile variable.\r
8d3a5c82 1550 //\r
fd51bf70 1551 Volatile = FALSE;\r
2fcdca1d 1552 NonVolatileVarableStoreSize = ((VARIABLE_STORE_HEADER *)(UINTN)(mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase))->Size;\r
1553 if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) \r
188e4e84 1554 && ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))\r
2fcdca1d 1555 || (((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0) \r
188e4e84 1556 && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > NonVolatileVarableStoreSize - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize)))) {\r
8a2d4996 1557 if (AtRuntime ()) {\r
c6492839 1558 Status = EFI_OUT_OF_RESOURCES;\r
1559 goto Done;\r
1560 }\r
1561 //\r
8a2d4996 1562 // Perform garbage collection & reclaim operation.\r
c6492839 1563 //\r
72399dae 1564 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, \r
1565 &mVariableModuleGlobal->NonVolatileLastVariableOffset, FALSE, Variable->CurrPtr);\r
8d3a5c82 1566 if (EFI_ERROR (Status)) {\r
1567 goto Done;\r
1568 }\r
8d3a5c82 1569 //\r
8a2d4996 1570 // If still no enough space, return out of resources.\r
8d3a5c82 1571 //\r
2fcdca1d 1572 if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) \r
188e4e84 1573 && ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32 (PcdHwErrStorageSize)))\r
2fcdca1d 1574 || (((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0) \r
188e4e84 1575 && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) > NonVolatileVarableStoreSize - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize)))) {\r
c6492839 1576 Status = EFI_OUT_OF_RESOURCES;\r
8d3a5c82 1577 goto Done;\r
8d3a5c82 1578 }\r
c6492839 1579 Reclaimed = TRUE;\r
8d3a5c82 1580 }\r
1581 //\r
8a2d4996 1582 // Four steps\r
c6492839 1583 // 1. Write variable header\r
130e2569 1584 // 2. Set variable state to header valid \r
1585 // 3. Write variable data\r
1586 // 4. Set variable state to valid\r
8d3a5c82 1587 //\r
8d3a5c82 1588 //\r
c6492839 1589 // Step 1:\r
8d3a5c82 1590 //\r
8a2d4996 1591 CacheOffset = mVariableModuleGlobal->NonVolatileLastVariableOffset;\r
c6492839 1592 Status = UpdateVariableStore (\r
052ad7e1 1593 &mVariableModuleGlobal->VariableGlobal,\r
c6492839 1594 FALSE,\r
1595 TRUE,\r
8a9e0b72 1596 Fvb,\r
72399dae 1597 mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
c6492839 1598 sizeof (VARIABLE_HEADER),\r
1599 (UINT8 *) NextVariable\r
1600 );\r
1601\r
1602 if (EFI_ERROR (Status)) {\r
1603 goto Done;\r
1604 }\r
130e2569 1605\r
8d3a5c82 1606 //\r
c6492839 1607 // Step 2:\r
8d3a5c82 1608 //\r
130e2569 1609 NextVariable->State = VAR_HEADER_VALID_ONLY;\r
1610 Status = UpdateVariableStore (\r
1611 &mVariableModuleGlobal->VariableGlobal,\r
1612 FALSE,\r
1613 TRUE,\r
8a9e0b72 1614 Fvb,\r
8a2d4996 1615 mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),\r
1616 sizeof (UINT8),\r
1617 &NextVariable->State\r
130e2569 1618 );\r
1619\r
1620 if (EFI_ERROR (Status)) {\r
1621 goto Done;\r
1622 }\r
1623 //\r
1624 // Step 3:\r
1625 //\r
c6492839 1626 Status = UpdateVariableStore (\r
052ad7e1 1627 &mVariableModuleGlobal->VariableGlobal,\r
c6492839 1628 FALSE,\r
1629 TRUE,\r
8a9e0b72 1630 Fvb,\r
72399dae 1631 mVariableModuleGlobal->NonVolatileLastVariableOffset + sizeof (VARIABLE_HEADER),\r
c6492839 1632 (UINT32) VarSize - sizeof (VARIABLE_HEADER),\r
1633 (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)\r
1634 );\r
1635\r
1636 if (EFI_ERROR (Status)) {\r
1637 goto Done;\r
1638 }\r
8d3a5c82 1639 //\r
130e2569 1640 // Step 4:\r
8d3a5c82 1641 //\r
c6492839 1642 NextVariable->State = VAR_ADDED;\r
1643 Status = UpdateVariableStore (\r
052ad7e1 1644 &mVariableModuleGlobal->VariableGlobal,\r
c6492839 1645 FALSE,\r
1646 TRUE,\r
8a9e0b72 1647 Fvb,\r
8a2d4996 1648 mVariableModuleGlobal->NonVolatileLastVariableOffset + OFFSET_OF (VARIABLE_HEADER, State),\r
1649 sizeof (UINT8),\r
1650 &NextVariable->State\r
c6492839 1651 );\r
1652\r
1653 if (EFI_ERROR (Status)) {\r
1654 goto Done;\r
1655 }\r
8d3a5c82 1656\r
72399dae 1657 mVariableModuleGlobal->NonVolatileLastVariableOffset += HEADER_ALIGN (VarSize);\r
8d3a5c82 1658\r
2fcdca1d 1659 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {\r
1660 mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VarSize);\r
1661 } else {\r
1662 mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VarSize);\r
1663 }\r
8a2d4996 1664 //\r
1665 // update the memory copy of Flash region.\r
1666 //\r
1667 CopyMem ((UINT8 *)mNvVariableCache + CacheOffset, (UINT8 *)NextVariable, VarSize);\r
c6492839 1668 } else {\r
1669 //\r
8a2d4996 1670 // Create a volatile variable.\r
c6492839 1671 // \r
fd51bf70 1672 Volatile = TRUE;\r
c6492839 1673\r
72399dae 1674 if ((UINT32) (VarSize + mVariableModuleGlobal->VolatileLastVariableOffset) >\r
052ad7e1 1675 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {\r
8d3a5c82 1676 //\r
8a2d4996 1677 // Perform garbage collection & reclaim operation.\r
8d3a5c82 1678 //\r
72399dae 1679 Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, \r
1680 &mVariableModuleGlobal->VolatileLastVariableOffset, TRUE, Variable->CurrPtr);\r
8d3a5c82 1681 if (EFI_ERROR (Status)) {\r
1682 goto Done;\r
1683 }\r
1684 //\r
8a2d4996 1685 // If still no enough space, return out of resources.\r
8d3a5c82 1686 //\r
72399dae 1687 if ((UINT32) (VarSize + mVariableModuleGlobal->VolatileLastVariableOffset) >\r
052ad7e1 1688 ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size\r
8d3a5c82 1689 ) {\r
c6492839 1690 Status = EFI_OUT_OF_RESOURCES;\r
8d3a5c82 1691 goto Done;\r
1692 }\r
c6492839 1693 Reclaimed = TRUE;\r
8d3a5c82 1694 }\r
8d3a5c82 1695\r
c6492839 1696 NextVariable->State = VAR_ADDED;\r
1697 Status = UpdateVariableStore (\r
052ad7e1 1698 &mVariableModuleGlobal->VariableGlobal,\r
c6492839 1699 TRUE,\r
1700 TRUE,\r
8a9e0b72 1701 Fvb,\r
72399dae 1702 mVariableModuleGlobal->VolatileLastVariableOffset,\r
c6492839 1703 (UINT32) VarSize,\r
1704 (UINT8 *) NextVariable\r
1705 );\r
1706\r
1707 if (EFI_ERROR (Status)) {\r
1708 goto Done;\r
8d3a5c82 1709 }\r
c6492839 1710\r
72399dae 1711 mVariableModuleGlobal->VolatileLastVariableOffset += HEADER_ALIGN (VarSize);\r
c6492839 1712 }\r
72399dae 1713\r
c6492839 1714 //\r
8a2d4996 1715 // Mark the old variable as deleted.\r
c6492839 1716 //\r
72399dae 1717 if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != NULL) {\r
1718 State = Variable->CurrPtr->State;\r
c6492839 1719 State &= VAR_DELETED;\r
1720\r
1721 Status = UpdateVariableStore (\r
72399dae 1722 &mVariableModuleGlobal->VariableGlobal,\r
1723 Variable->Volatile,\r
1724 FALSE,\r
1725 Fvb,\r
1726 (UINTN) &Variable->CurrPtr->State,\r
1727 sizeof (UINT8),\r
1728 &State\r
1729 );\r
8a2d4996 1730 if (!EFI_ERROR (Status) && !Variable->Volatile) { \r
1731 CacheVariable->CurrPtr->State = State;\r
1732 }\r
72399dae 1733 }\r
1734\r
1735 if (!EFI_ERROR (Status)) {\r
1736 UpdateVariableInfo (VariableName, VendorGuid, Volatile, FALSE, TRUE, FALSE, FALSE);\r
72399dae 1737 }\r
1738\r
1739Done:\r
1740 return Status;\r
1741}\r
1742\r
1743/**\r
1744\r
1745 This code finds variable in storage blocks (Volatile or Non-Volatile).\r
1746\r
1747 @param VariableName Name of Variable to be found.\r
1748 @param VendorGuid Variable vendor GUID.\r
1749 @param Attributes Attribute value of the variable found.\r
1750 @param DataSize Size of Data found. If size is less than the\r
1751 data, this value contains the required size.\r
1752 @param Data Data pointer.\r
1753 \r
8a2d4996 1754 @return EFI_INVALID_PARAMETER Invalid parameter.\r
1755 @return EFI_SUCCESS Find the specified variable.\r
1756 @return EFI_NOT_FOUND Not found.\r
1757 @return EFI_BUFFER_TO_SMALL DataSize is too small for the result.\r
72399dae 1758\r
1759**/\r
1760EFI_STATUS\r
1761EFIAPI\r
8a2d4996 1762VariableServiceGetVariable (\r
72399dae 1763 IN CHAR16 *VariableName,\r
1764 IN EFI_GUID *VendorGuid,\r
1765 OUT UINT32 *Attributes OPTIONAL,\r
1766 IN OUT UINTN *DataSize,\r
1767 OUT VOID *Data\r
1768 )\r
1769{\r
1770 EFI_STATUS Status;\r
1771 VARIABLE_POINTER_TRACK Variable;\r
1772 UINTN VarDataSize;\r
1773\r
1774 if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {\r
1775 return EFI_INVALID_PARAMETER;\r
1776 }\r
1777\r
1778 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
72399dae 1779 \r
1780 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);\r
1781 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
1782 goto Done;\r
1783 }\r
1784\r
1785 //\r
1786 // Get data size\r
1787 //\r
1788 VarDataSize = DataSizeOfVariable (Variable.CurrPtr);\r
1789 ASSERT (VarDataSize != 0);\r
1790\r
1791 if (*DataSize >= VarDataSize) {\r
1792 if (Data == NULL) {\r
1793 Status = EFI_INVALID_PARAMETER;\r
1794 goto Done;\r
33a5a666 1795 }\r
72399dae 1796\r
1797 CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);\r
1798 if (Attributes != NULL) {\r
1799 *Attributes = Variable.CurrPtr->Attributes;\r
1800 }\r
1801\r
1802 *DataSize = VarDataSize;\r
1803 UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE);\r
72399dae 1804 \r
1805 Status = EFI_SUCCESS;\r
1806 goto Done;\r
1807 } else {\r
1808 *DataSize = VarDataSize;\r
1809 Status = EFI_BUFFER_TOO_SMALL;\r
1810 goto Done;\r
8d3a5c82 1811 }\r
1812\r
72399dae 1813Done:\r
1814 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
1815 return Status;\r
1816}\r
1817\r
1818\r
1819\r
1820/**\r
1821\r
1822 This code Finds the Next available variable.\r
1823\r
8a2d4996 1824 @param VariableNameSize Size of the variable name.\r
1825 @param VariableName Pointer to variable name.\r
1826 @param VendorGuid Variable Vendor Guid.\r
72399dae 1827\r
8a2d4996 1828 @return EFI_INVALID_PARAMETER Invalid parameter.\r
1829 @return EFI_SUCCESS Find the specified variable.\r
1830 @return EFI_NOT_FOUND Not found.\r
1831 @return EFI_BUFFER_TO_SMALL DataSize is too small for the result.\r
72399dae 1832\r
1833**/\r
1834EFI_STATUS\r
1835EFIAPI\r
8a2d4996 1836VariableServiceGetNextVariableName (\r
72399dae 1837 IN OUT UINTN *VariableNameSize,\r
1838 IN OUT CHAR16 *VariableName,\r
1839 IN OUT EFI_GUID *VendorGuid\r
1840 )\r
1841{\r
1842 VARIABLE_POINTER_TRACK Variable;\r
1843 UINTN VarNameSize;\r
1844 EFI_STATUS Status;\r
1845\r
1846 if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {\r
1847 return EFI_INVALID_PARAMETER;\r
1848 }\r
1849\r
1850 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
1851\r
1852 Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);\r
1853 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
1854 goto Done;\r
1855 }\r
1856\r
1857 if (VariableName[0] != 0) {\r
1858 //\r
8a2d4996 1859 // If variable name is not NULL, get next variable.\r
72399dae 1860 //\r
1861 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
1862 }\r
1863\r
1864 while (TRUE) {\r
1865 //\r
1866 // If both volatile and non-volatile variable store are parsed,\r
8a2d4996 1867 // return not found.\r
72399dae 1868 //\r
1869 if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {\r
1870 Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));\r
1871 if (!Variable.Volatile) {\r
1872 Variable.StartPtr = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);\r
1873 Variable.EndPtr = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase));\r
1874 } else {\r
1875 Status = EFI_NOT_FOUND;\r
1876 goto Done;\r
1877 }\r
1878\r
1879 Variable.CurrPtr = Variable.StartPtr;\r
1880 if (!IsValidVariableHeader (Variable.CurrPtr)) {\r
1881 continue;\r
1882 }\r
1883 }\r
1884 //\r
1885 // Variable is found\r
1886 //\r
1887 if (IsValidVariableHeader (Variable.CurrPtr) && Variable.CurrPtr->State == VAR_ADDED) {\r
8a2d4996 1888 if ((AtRuntime () && ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) == 0) {\r
72399dae 1889 VarNameSize = NameSizeOfVariable (Variable.CurrPtr);\r
1890 ASSERT (VarNameSize != 0);\r
1891\r
1892 if (VarNameSize <= *VariableNameSize) {\r
1893 CopyMem (\r
1894 VariableName,\r
1895 GetVariableNamePtr (Variable.CurrPtr),\r
1896 VarNameSize\r
1897 );\r
1898 CopyMem (\r
1899 VendorGuid,\r
1900 &Variable.CurrPtr->VendorGuid,\r
1901 sizeof (EFI_GUID)\r
1902 );\r
1903 Status = EFI_SUCCESS;\r
1904 } else {\r
1905 Status = EFI_BUFFER_TOO_SMALL;\r
1906 }\r
1907\r
1908 *VariableNameSize = VarNameSize;\r
1909 goto Done;\r
1910 }\r
1911 }\r
1912\r
1913 Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
1914 }\r
33a5a666 1915\r
8d3a5c82 1916Done:\r
72399dae 1917 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
1918 return Status;\r
1919}\r
1920\r
1921/**\r
1922\r
1923 This code sets variable in storage blocks (Volatile or Non-Volatile).\r
1924\r
8a2d4996 1925 @param VariableName Name of Variable to be found.\r
1926 @param VendorGuid Variable vendor GUID.\r
72399dae 1927 @param Attributes Attribute value of the variable found\r
1928 @param DataSize Size of Data found. If size is less than the\r
1929 data, this value contains the required size.\r
8a2d4996 1930 @param Data Data pointer.\r
72399dae 1931\r
8a2d4996 1932 @return EFI_INVALID_PARAMETER Invalid parameter.\r
1933 @return EFI_SUCCESS Set successfully.\r
1934 @return EFI_OUT_OF_RESOURCES Resource not enough to set variable.\r
1935 @return EFI_NOT_FOUND Not found.\r
1936 @return EFI_WRITE_PROTECTED Variable is read-only.\r
72399dae 1937\r
1938**/\r
1939EFI_STATUS\r
1940EFIAPI\r
8a2d4996 1941VariableServiceSetVariable (\r
72399dae 1942 IN CHAR16 *VariableName,\r
1943 IN EFI_GUID *VendorGuid,\r
1944 IN UINT32 Attributes,\r
1945 IN UINTN DataSize,\r
1946 IN VOID *Data\r
1947 )\r
1948{\r
1949 VARIABLE_POINTER_TRACK Variable;\r
1950 EFI_STATUS Status;\r
1951 VARIABLE_HEADER *NextVariable;\r
1952 EFI_PHYSICAL_ADDRESS Point;\r
1953\r
1954 //\r
8a2d4996 1955 // Check input parameters.\r
72399dae 1956 //\r
1957 if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {\r
1958 return EFI_INVALID_PARAMETER;\r
8a2d4996 1959 } \r
48a0e6bf 1960\r
1961 if (DataSize != 0 && Data == NULL) {\r
1962 return EFI_INVALID_PARAMETER;\r
1963 }\r
1964\r
8e38f18e 1965 //\r
1966 // Not support authenticated variable write yet.\r
1967 //\r
1968 if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
1969 return EFI_INVALID_PARAMETER;\r
1970 }\r
1971\r
72399dae 1972 //\r
8a2d4996 1973 // Make sure if runtime bit is set, boot service bit is set also.\r
72399dae 1974 //\r
1975 if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {\r
1976 return EFI_INVALID_PARAMETER;\r
1977 }\r
1978\r
1979 //\r
1980 // The size of the VariableName, including the Unicode Null in bytes plus\r
188e4e84 1981 // the DataSize is limited to maximum size of PcdGet32 (PcdMaxHardwareErrorVariableSize)\r
1982 // bytes for HwErrRec, and PcdGet32 (PcdMaxVariableSize) bytes for the others.\r
72399dae 1983 //\r
1984 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
188e4e84 1985 if ((DataSize > PcdGet32 (PcdMaxHardwareErrorVariableSize)) ||\r
1986 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > PcdGet32 (PcdMaxHardwareErrorVariableSize))) {\r
72399dae 1987 return EFI_INVALID_PARAMETER;\r
1988 }\r
1989 //\r
8a2d4996 1990 // According to UEFI spec, HARDWARE_ERROR_RECORD variable name convention should be L"HwErrRecXXXX".\r
72399dae 1991 //\r
1992 if (StrnCmp(VariableName, L"HwErrRec", StrLen(L"HwErrRec")) != 0) {\r
1993 return EFI_INVALID_PARAMETER;\r
1994 }\r
1995 } else {\r
1996 //\r
1997 // The size of the VariableName, including the Unicode Null in bytes plus\r
188e4e84 1998 // the DataSize is limited to maximum size of PcdGet32 (PcdMaxVariableSize) bytes.\r
72399dae 1999 //\r
188e4e84 2000 if ((DataSize > PcdGet32 (PcdMaxVariableSize)) ||\r
2001 (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > PcdGet32 (PcdMaxVariableSize))) {\r
72399dae 2002 return EFI_INVALID_PARAMETER;\r
2003 } \r
2004 } \r
2005\r
2006 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
2007\r
2008 //\r
8a2d4996 2009 // Consider reentrant in MCA/INIT/NMI. It needs be reupdated.\r
72399dae 2010 //\r
2011 if (1 < InterlockedIncrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState)) {\r
8a2d4996 2012 Point = mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;\r
72399dae 2013 //\r
8a2d4996 2014 // Parse non-volatile variable data and get last variable offset.\r
72399dae 2015 //\r
2016 NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point);\r
2017 while ((NextVariable < GetEndPointer ((VARIABLE_STORE_HEADER *) (UINTN) Point)) \r
2018 && IsValidVariableHeader (NextVariable)) {\r
2019 NextVariable = GetNextVariablePtr (NextVariable);\r
2020 }\r
2021 mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) Point;\r
2022 }\r
2023\r
2024 //\r
8a2d4996 2025 // Check whether the input variable is already existed.\r
72399dae 2026 //\r
2027 FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);\r
2028\r
2029 //\r
8a2d4996 2030 // Hook the operation of setting PlatformLangCodes/PlatformLang and LangCodes/Lang.\r
72399dae 2031 //\r
2032 AutoUpdateLangVariable (VariableName, Data, DataSize);\r
2033\r
2034 Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, &Variable);\r
2035\r
fdb7765f 2036 InterlockedDecrement (&mVariableModuleGlobal->VariableGlobal.ReentrantState);\r
052ad7e1 2037 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
fdb7765f 2038\r
8d3a5c82 2039 return Status;\r
2040}\r
2041\r
7c80e839 2042/**\r
8d3a5c82 2043\r
2044 This code returns information about the EFI variables.\r
2045\r
7c80e839 2046 @param Attributes Attributes bitmask to specify the type of variables\r
2047 on which to return information.\r
2048 @param MaximumVariableStorageSize Pointer to the maximum size of the storage space available\r
2049 for the EFI variables associated with the attributes specified.\r
2050 @param RemainingVariableStorageSize Pointer to the remaining size of the storage space available\r
2051 for EFI variables associated with the attributes specified.\r
2052 @param MaximumVariableSize Pointer to the maximum size of an individual EFI variables\r
2053 associated with the attributes specified.\r
8d3a5c82 2054\r
7c80e839 2055 @return EFI_INVALID_PARAMETER An invalid combination of attribute bits was supplied.\r
2056 @return EFI_SUCCESS Query successfully.\r
2057 @return EFI_UNSUPPORTED The attribute is not supported on this platform.\r
8d3a5c82 2058\r
7c80e839 2059**/\r
052ad7e1
A
2060EFI_STATUS\r
2061EFIAPI\r
8a2d4996 2062VariableServiceQueryVariableInfo (\r
052ad7e1
A
2063 IN UINT32 Attributes,\r
2064 OUT UINT64 *MaximumVariableStorageSize,\r
2065 OUT UINT64 *RemainingVariableStorageSize,\r
2066 OUT UINT64 *MaximumVariableSize\r
2067 )\r
8d3a5c82 2068{\r
2069 VARIABLE_HEADER *Variable;\r
2070 VARIABLE_HEADER *NextVariable;\r
2071 UINT64 VariableSize;\r
2072 VARIABLE_STORE_HEADER *VariableStoreHeader;\r
2fcdca1d 2073 UINT64 CommonVariableTotalSize;\r
2074 UINT64 HwErrVariableTotalSize;\r
2075\r
2076 CommonVariableTotalSize = 0;\r
2077 HwErrVariableTotalSize = 0;\r
8d3a5c82 2078\r
c6492839 2079 if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {\r
8d3a5c82 2080 return EFI_INVALID_PARAMETER;\r
2081 }\r
2fcdca1d 2082\r
c6492839 2083 if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == 0) {\r
8d3a5c82 2084 //\r
2085 // Make sure the Attributes combination is supported by the platform.\r
2086 //\r
c6492839 2087 return EFI_UNSUPPORTED; \r
8d3a5c82 2088 } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {\r
2089 //\r
2090 // Make sure if runtime bit is set, boot service bit is set also.\r
2091 //\r
2092 return EFI_INVALID_PARAMETER;\r
8a2d4996 2093 } else if (AtRuntime () && ((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) {\r
8d3a5c82 2094 //\r
2095 // Make sure RT Attribute is set if we are in Runtime phase.\r
2096 //\r
2097 return EFI_INVALID_PARAMETER;\r
2fcdca1d 2098 } else if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
2099 //\r
2100 // Make sure Hw Attribute is set with NV.\r
2101 //\r
2102 return EFI_INVALID_PARAMETER;\r
8e38f18e 2103 } else if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
2104 //\r
2105 // Not support authentiated variable write yet.\r
2106 //\r
2107 return EFI_UNSUPPORTED;\r
8d3a5c82 2108 }\r
2109\r
052ad7e1 2110 AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
8d3a5c82 2111\r
2112 if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {\r
2113 //\r
2114 // Query is Volatile related.\r
2115 //\r
052ad7e1 2116 VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);\r
8d3a5c82 2117 } else {\r
2118 //\r
2119 // Query is Non-Volatile related.\r
2120 //\r
8a2d4996 2121 VariableStoreHeader = mNvVariableCache;\r
8d3a5c82 2122 }\r
2123\r
2124 //\r
2125 // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize\r
2126 // with the storage size (excluding the storage header size).\r
2127 //\r
2128 *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);\r
c6492839 2129\r
2130 //\r
2131 // Harware error record variable needs larger size.\r
2132 //\r
2fcdca1d 2133 if ((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
188e4e84 2134 *MaximumVariableStorageSize = PcdGet32 (PcdHwErrStorageSize);\r
2135 *MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER);\r
2fcdca1d 2136 } else {\r
2137 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
188e4e84 2138 ASSERT (PcdGet32 (PcdHwErrStorageSize) < VariableStoreHeader->Size);\r
2139 *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize);\r
2fcdca1d 2140 }\r
2141\r
2142 //\r
188e4e84 2143 // Let *MaximumVariableSize be PcdGet32 (PcdMaxVariableSize) with the exception of the variable header size.\r
2fcdca1d 2144 //\r
188e4e84 2145 *MaximumVariableSize = PcdGet32 (PcdMaxVariableSize) - sizeof (VARIABLE_HEADER);\r
c6492839 2146 }\r
8d3a5c82 2147\r
2148 //\r
2149 // Point to the starting address of the variables.\r
2150 //\r
9cad030b 2151 Variable = GetStartPointer (VariableStoreHeader);\r
8d3a5c82 2152\r
2153 //\r
2154 // Now walk through the related variable store.\r
2155 //\r
6f90dfbc 2156 while ((Variable < GetEndPointer (VariableStoreHeader)) && IsValidVariableHeader (Variable)) {\r
8d3a5c82 2157 NextVariable = GetNextVariablePtr (Variable);\r
2158 VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;\r
2159\r
8a2d4996 2160 if (AtRuntime ()) {\r
8d3a5c82 2161 //\r
8a2d4996 2162 // We don't take the state of the variables in mind\r
8d3a5c82 2163 // when calculating RemainingVariableStorageSize,\r
2164 // since the space occupied by variables not marked with\r
2165 // VAR_ADDED is not allowed to be reclaimed in Runtime.\r
2166 //\r
2fcdca1d 2167 if ((NextVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
2168 HwErrVariableTotalSize += VariableSize;\r
2169 } else {\r
2170 CommonVariableTotalSize += VariableSize;\r
2171 }\r
8d3a5c82 2172 } else {\r
2173 //\r
8a2d4996 2174 // Only care about Variables with State VAR_ADDED, because\r
8d3a5c82 2175 // the space not marked as VAR_ADDED is reclaimable now.\r
2176 //\r
2177 if (Variable->State == VAR_ADDED) {\r
2fcdca1d 2178 if ((NextVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) {\r
2179 HwErrVariableTotalSize += VariableSize;\r
2180 } else {\r
2181 CommonVariableTotalSize += VariableSize;\r
2182 }\r
8d3a5c82 2183 }\r
2184 }\r
2185\r
2186 //\r
8a2d4996 2187 // Go to the next one.\r
8d3a5c82 2188 //\r
2189 Variable = NextVariable;\r
2190 }\r
2191\r
2fcdca1d 2192 if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD){\r
2193 *RemainingVariableStorageSize = *MaximumVariableStorageSize - HwErrVariableTotalSize;\r
2194 }else {\r
2195 *RemainingVariableStorageSize = *MaximumVariableStorageSize - CommonVariableTotalSize;\r
2196 }\r
2197\r
c6492839 2198 if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {\r
2199 *MaximumVariableSize = 0;\r
2200 } else if ((*RemainingVariableStorageSize - sizeof (VARIABLE_HEADER)) < *MaximumVariableSize) {\r
2201 *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);\r
2202 }\r
2203\r
052ad7e1 2204 ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);\r
8d3a5c82 2205 return EFI_SUCCESS;\r
2206}\r
2207\r
7c80e839 2208\r
2209/**\r
8a2d4996 2210 This function reclaims variable storage if free size is below the threshold.\r
2211 \r
7c80e839 2212**/\r
7800593d 2213VOID\r
7800593d 2214ReclaimForOS(\r
8a2d4996 2215 VOID\r
7800593d
LG
2216 )\r
2217{\r
9948c0b0 2218 EFI_STATUS Status;\r
2fcdca1d 2219 UINTN CommonVariableSpace;\r
2220 UINTN RemainingCommonVariableSpace;\r
2221 UINTN RemainingHwErrVariableSpace;\r
7800593d 2222\r
7800593d
LG
2223 Status = EFI_SUCCESS; \r
2224\r
2fcdca1d 2225 CommonVariableSpace = ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size - sizeof (VARIABLE_STORE_HEADER) - PcdGet32(PcdHwErrStorageSize); //Allowable max size of common variable storage space\r
2226\r
2227 RemainingCommonVariableSpace = CommonVariableSpace - mVariableModuleGlobal->CommonVariableTotalSize;\r
2228\r
2229 RemainingHwErrVariableSpace = PcdGet32 (PcdHwErrStorageSize) - mVariableModuleGlobal->HwErrVariableTotalSize;\r
7800593d 2230 //\r
9948c0b0 2231 // Check if the free area is blow a threshold.\r
7800593d 2232 //\r
2fcdca1d 2233 if ((RemainingCommonVariableSpace < PcdGet32 (PcdMaxVariableSize))\r
9948c0b0 2234 || ((PcdGet32 (PcdHwErrStorageSize) != 0) && \r
2235 (RemainingHwErrVariableSpace < PcdGet32 (PcdMaxHardwareErrorVariableSize)))){\r
7800593d 2236 Status = Reclaim (\r
2fcdca1d 2237 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
2238 &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
2239 FALSE,\r
2240 NULL\r
2241 );\r
7800593d
LG
2242 ASSERT_EFI_ERROR (Status);\r
2243 }\r
2244}\r
2245\r
8a2d4996 2246\r
7c80e839 2247/**\r
8a2d4996 2248 Initializes variable write service after FVB was ready.\r
7c80e839 2249\r
8a2d4996 2250 @retval EFI_SUCCESS Function successfully executed.\r
2251 @retval Others Fail to initialize the variable service.\r
2252\r
2253**/\r
2254EFI_STATUS\r
2255VariableWriteServiceInitialize (\r
2256 VOID\r
2257 )\r
2258{\r
2259 EFI_STATUS Status;\r
2260 VARIABLE_STORE_HEADER *VariableStoreHeader;\r
2261 UINTN Index;\r
2262 UINT8 Data;\r
8a2d4996 2263 EFI_PHYSICAL_ADDRESS VariableStoreBase;\r
2264 UINT64 VariableStoreLength;\r
2265\r
2266 VariableStoreBase = mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;\r
2267 VariableStoreHeader = (VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase;\r
2268 VariableStoreLength = VariableStoreHeader->Size;\r
2269 \r
2270 //\r
2271 // Check if the free area is really free.\r
2272 //\r
2273 for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreLength; Index++) {\r
2274 Data = ((UINT8 *) mNvVariableCache)[Index];\r
2275 if (Data != 0xff) {\r
2276 //\r
2277 // There must be something wrong in variable store, do reclaim operation.\r
2278 //\r
2279 Status = Reclaim (\r
2280 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
2281 &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
2282 FALSE,\r
2283 NULL\r
2284 );\r
2285 if (EFI_ERROR (Status)) {\r
2286 return Status;\r
2287 }\r
2288 break;\r
2289 }\r
2290 }\r
2291\r
8a2d4996 2292 return EFI_SUCCESS;\r
2293}\r
2294\r
2295\r
2296/**\r
2297 Initializes variable store area for non-volatile and volatile variable.\r
7c80e839 2298\r
2299 @retval EFI_SUCCESS Function successfully executed.\r
2300 @retval EFI_OUT_OF_RESOURCES Fail to allocate enough memory resource.\r
2301\r
2302**/\r
8d3a5c82 2303EFI_STATUS\r
8d3a5c82 2304VariableCommonInitialize (\r
8a2d4996 2305 VOID\r
8d3a5c82 2306 )\r
8d3a5c82 2307{\r
2308 EFI_STATUS Status;\r
8d3a5c82 2309 VARIABLE_STORE_HEADER *VolatileVariableStore;\r
2310 VARIABLE_STORE_HEADER *VariableStoreHeader;\r
2311 VARIABLE_HEADER *NextVariable;\r
8a9e0b72 2312 EFI_PHYSICAL_ADDRESS TempVariableStoreHeader;\r
8a9e0b72 2313 EFI_PHYSICAL_ADDRESS VariableStoreBase;\r
052ad7e1 2314 UINT64 VariableStoreLength;\r
2fcdca1d 2315 UINTN ScratchSize;\r
aa75dfec 2316 UINTN VariableSize;\r
8d3a5c82 2317\r
7800593d
LG
2318 //\r
2319 // Allocate runtime memory for variable driver global structure.\r
2320 //\r
72399dae 2321 mVariableModuleGlobal = AllocateRuntimeZeroPool (sizeof (VARIABLE_MODULE_GLOBAL));\r
7800593d
LG
2322 if (mVariableModuleGlobal == NULL) {\r
2323 return EFI_OUT_OF_RESOURCES;\r
2324 }\r
8d3a5c82 2325\r
8a2d4996 2326 InitializeLock (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);\r
8d3a5c82 2327\r
48cd992a 2328 //\r
2329 // Note that in EdkII variable driver implementation, Hardware Error Record type variable\r
2330 // is stored with common variable in the same NV region. So the platform integrator should\r
2331 // ensure that the value of PcdHwErrStorageSize is less than or equal to the value of \r
2332 // PcdFlashNvStorageVariableSize.\r
2333 //\r
188e4e84 2334 ASSERT (PcdGet32 (PcdHwErrStorageSize) <= PcdGet32 (PcdFlashNvStorageVariableSize));\r
48cd992a 2335\r
8d3a5c82 2336 //\r
2fcdca1d 2337 // Allocate memory for volatile variable store, note that there is a scratch space to store scratch data.\r
8d3a5c82 2338 //\r
188e4e84 2339 ScratchSize = MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize));\r
2340 VolatileVariableStore = AllocateRuntimePool (PcdGet32 (PcdVariableStoreSize) + ScratchSize);\r
8d3a5c82 2341 if (VolatileVariableStore == NULL) {\r
2342 FreePool (mVariableModuleGlobal);\r
2343 return EFI_OUT_OF_RESOURCES;\r
2344 }\r
2345\r
188e4e84 2346 SetMem (VolatileVariableStore, PcdGet32 (PcdVariableStoreSize) + ScratchSize, 0xff);\r
8d3a5c82 2347\r
2348 //\r
8a2d4996 2349 // Initialize Variable Specific Data.\r
8d3a5c82 2350 //\r
052ad7e1 2351 mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;\r
9cad030b 2352 mVariableModuleGlobal->VolatileLastVariableOffset = (UINTN) GetStartPointer (VolatileVariableStore) - (UINTN) VolatileVariableStore;\r
8a2d4996 2353 mVariableModuleGlobal->FvbInstance = NULL;\r
8d3a5c82 2354\r
3709c4cd 2355 CopyGuid (&VolatileVariableStore->Signature, &gEfiVariableGuid);\r
8a2d4996 2356 VolatileVariableStore->Size = PcdGet32 (PcdVariableStoreSize);\r
2357 VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;\r
2358 VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;\r
2359 VolatileVariableStore->Reserved = 0;\r
2360 VolatileVariableStore->Reserved1 = 0;\r
8d3a5c82 2361\r
2362 //\r
8a2d4996 2363 // Get non-volatile varaible store.\r
8d3a5c82 2364 //\r
2365\r
92a4f6f3 2366 TempVariableStoreHeader = (EFI_PHYSICAL_ADDRESS) PcdGet64 (PcdFlashNvStorageVariableBase64);\r
2367 if (TempVariableStoreHeader == 0) {\r
2368 TempVariableStoreHeader = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageVariableBase);\r
2369 }\r
8a2d4996 2370 VariableStoreBase = TempVariableStoreHeader + \\r
2371 (((EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(TempVariableStoreHeader)) -> HeaderLength);\r
2372 VariableStoreLength = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \\r
8a9e0b72 2373 (((EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(TempVariableStoreHeader)) -> HeaderLength);\r
8d3a5c82 2374\r
8a2d4996 2375 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;\r
2376 VariableStoreHeader = (VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase;\r
2377 if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {\r
2378 Status = EFI_VOLUME_CORRUPTED;\r
2379 DEBUG((EFI_D_INFO, "Variable Store header is corrupted\n"));\r
7800593d 2380 goto Done;\r
8a2d4996 2381 } \r
2382 ASSERT(VariableStoreHeader->Size == VariableStoreLength);\r
2383 \r
8d3a5c82 2384 //\r
8a2d4996 2385 // Parse non-volatile variable data and get last variable offset.\r
8d3a5c82 2386 //\r
8a2d4996 2387 NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase);\r
2388 while (IsValidVariableHeader (NextVariable)) {\r
2389 VariableSize = NextVariable->NameSize + NextVariable->DataSize + sizeof (VARIABLE_HEADER);\r
2390 if ((NextVariable->Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {\r
2391 mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VariableSize);\r
2392 } else {\r
2393 mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VariableSize);\r
8d3a5c82 2394 }\r
2395\r
8a2d4996 2396 NextVariable = GetNextVariablePtr (NextVariable);\r
2397 }\r
7800593d 2398\r
8a2d4996 2399 mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) VariableStoreBase;\r
2400 \r
2401 //\r
2402 // Allocate runtime memory used for a memory copy of the FLASH region.\r
2403 // Keep the memory and the FLASH in sync as updates occur\r
2404 //\r
2405 mNvVariableCache = AllocateRuntimeZeroPool ((UINTN)VariableStoreLength);\r
2406 if (mNvVariableCache == NULL) {\r
2407 Status = EFI_OUT_OF_RESOURCES;\r
2408 goto Done;\r
8d3a5c82 2409 }\r
8a2d4996 2410 CopyMem (mNvVariableCache, (CHAR8 *)(UINTN)VariableStoreBase, (UINTN)VariableStoreLength);\r
2411 Status = EFI_SUCCESS;\r
8d3a5c82 2412\r
7800593d 2413Done:\r
8d3a5c82 2414 if (EFI_ERROR (Status)) {\r
2415 FreePool (mVariableModuleGlobal);\r
2416 FreePool (VolatileVariableStore);\r
2417 }\r
2418\r
2419 return Status;\r
2420}\r
052ad7e1 2421\r
052ad7e1 2422\r
aa75dfec 2423/**\r
8a2d4996 2424 Get the proper fvb handle and/or fvb protocol by the given Flash address.\r
aa75dfec 2425\r
8a2d4996 2426 @param[in] Address The Flash address.\r
2427 @param[out] FvbHandle In output, if it is not NULL, it points to the proper FVB handle.\r
2428 @param[out] FvbProtocol In output, if it is not NULL, it points to the proper FVB protocol.\r
aa75dfec 2429\r
aa75dfec 2430**/\r
8a2d4996 2431EFI_STATUS\r
2432GetFvbInfoByAddress (\r
2433 IN EFI_PHYSICAL_ADDRESS Address,\r
2434 OUT EFI_HANDLE *FvbHandle OPTIONAL,\r
2435 OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvbProtocol OPTIONAL\r
8a9e0b72 2436 )\r
2437{\r
8a2d4996 2438 EFI_STATUS Status;\r
2439 EFI_HANDLE *HandleBuffer;\r
2440 UINTN HandleCount;\r
2441 UINTN Index;\r
2442 EFI_PHYSICAL_ADDRESS FvbBaseAddress;\r
2443 EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb;\r
2444 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
2445 EFI_FVB_ATTRIBUTES_2 Attributes;\r
2446 \r
8a9e0b72 2447 //\r
8a2d4996 2448 // Get all FVB handles.\r
8a9e0b72 2449 //\r
8a2d4996 2450 Status = GetFvbCountAndBuffer (&HandleCount, &HandleBuffer);\r
8a9e0b72 2451 if (EFI_ERROR (Status)) {\r
8a2d4996 2452 return EFI_NOT_FOUND;\r
8a9e0b72 2453 }\r
8a2d4996 2454\r
8a9e0b72 2455 //\r
8a2d4996 2456 // Get the FVB to access variable store.\r
8a9e0b72 2457 //\r
8a2d4996 2458 Fvb = NULL;\r
f0480ecf 2459 for (Index = 0; Index < HandleCount; Index += 1, Status = EFI_NOT_FOUND, Fvb = NULL) {\r
8a2d4996 2460 Status = GetFvbByHandle (HandleBuffer[Index], &Fvb);\r
8a9e0b72 2461 if (EFI_ERROR (Status)) {\r
2462 Status = EFI_NOT_FOUND;\r
2463 break;\r
2464 }\r
2465\r
2466 //\r
2467 // Ensure this FVB protocol supported Write operation.\r
2468 //\r
2469 Status = Fvb->GetAttributes (Fvb, &Attributes);\r
2470 if (EFI_ERROR (Status) || ((Attributes & EFI_FVB2_WRITE_STATUS) == 0)) {\r
2471 continue; \r
2472 }\r
8a2d4996 2473 \r
8a9e0b72 2474 //\r
8a2d4996 2475 // Compare the address and select the right one.\r
8a9e0b72 2476 //\r
2477 Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);\r
2478 if (EFI_ERROR (Status)) {\r
2479 continue;\r
2480 }\r
2481\r
2482 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);\r
8a2d4996 2483 if ((Address >= FvbBaseAddress) && (Address < (FvbBaseAddress + FwVolHeader->FvLength))) {\r
2484 if (FvbHandle != NULL) {\r
2485 *FvbHandle = HandleBuffer[Index];\r
2486 }\r
2487 if (FvbProtocol != NULL) {\r
2488 *FvbProtocol = Fvb;\r
2489 }\r
2490 Status = EFI_SUCCESS;\r
8a9e0b72 2491 break;\r
2492 }\r
2493 }\r
8a9e0b72 2494 FreePool (HandleBuffer);\r
533020ef 2495\r
8a2d4996 2496 if (Fvb == NULL) {\r
2497 Status = EFI_NOT_FOUND;\r
8a9e0b72 2498 }\r
052ad7e1 2499 \r
8a2d4996 2500 return Status; \r
052ad7e1
A
2501}\r
2502\r