VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/VarCheckLib/VarCheckLib.c@ 99396

Last change on this file since 99396 was 89983, checked in by vboxsync, 4 years ago

Devices/EFI: Merge edk-stable202105 and openssl 1.1.1j and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 20.4 KB
Line 
1/** @file
2 Implementation functions and structures for var check services.
3
4Copyright (c) 2015 - 2021, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include <Library/VarCheckLib.h>
10#include <Library/BaseLib.h>
11#include <Library/BaseMemoryLib.h>
12#include <Library/DebugLib.h>
13#include <Library/MemoryAllocationLib.h>
14
15#include <Guid/GlobalVariable.h>
16#include <Guid/HardwareErrorVariable.h>
17
18BOOLEAN mVarCheckLibEndOfDxe = FALSE;
19
20#define VAR_CHECK_TABLE_SIZE 0x8
21
22UINTN mVarCheckLibEndOfDxeCallbackCount = 0;
23UINTN mVarCheckLibEndOfDxeCallbackMaxCount = 0;
24VAR_CHECK_END_OF_DXE_CALLBACK *mVarCheckLibEndOfDxeCallback = NULL;
25
26UINTN mVarCheckLibAddressPointerCount = 0;
27UINTN mVarCheckLibAddressPointerMaxCount = 0;
28VOID ***mVarCheckLibAddressPointer = NULL;
29
30UINTN mNumberOfVarCheckHandler = 0;
31UINTN mMaxNumberOfVarCheckHandler = 0;
32VAR_CHECK_SET_VARIABLE_CHECK_HANDLER *mVarCheckHandlerTable = NULL;
33
34typedef struct {
35 EFI_GUID Guid;
36 VAR_CHECK_VARIABLE_PROPERTY VariableProperty;
37 //CHAR16 *Name;
38} VAR_CHECK_VARIABLE_ENTRY;
39
40UINTN mNumberOfVarCheckVariable = 0;
41UINTN mMaxNumberOfVarCheckVariable = 0;
42VARIABLE_ENTRY_PROPERTY **mVarCheckVariableTable = NULL;
43
44//
45// Handle variables with wildcard name specially.
46//
47VARIABLE_ENTRY_PROPERTY mVarCheckVariableWithWildcardName[] = {
48 {
49 &gEfiGlobalVariableGuid,
50 L"Boot####",
51 {
52 0
53 },
54 },
55 {
56 &gEfiGlobalVariableGuid,
57 L"Driver####",
58 {
59 0
60 },
61 },
62 {
63 &gEfiGlobalVariableGuid,
64 L"SysPrep####",
65 {
66 0
67 },
68 },
69 {
70 &gEfiGlobalVariableGuid,
71 L"Key####",
72 {
73 0
74 },
75 },
76 {
77 &gEfiGlobalVariableGuid,
78 L"PlatformRecovery####",
79 {
80 0
81 },
82 },
83 {
84 &gEfiHardwareErrorVariableGuid,
85 L"HwErrRec####",
86 {
87 0
88 },
89 },
90};
91
92/**
93 Check if a Unicode character is an upper case hexadecimal character.
94
95 This function checks if a Unicode character is an upper case
96 hexadecimal character. The valid upper case hexadecimal character is
97 L'0' to L'9', or L'A' to L'F'.
98
99
100 @param[in] Char The character to check against.
101
102 @retval TRUE If the Char is an upper case hexadecmial character.
103 @retval FALSE If the Char is not an upper case hexadecmial character.
104
105**/
106BOOLEAN
107EFIAPI
108VarCheckInternalIsHexaDecimalDigitCharacter (
109 IN CHAR16 Char
110 )
111{
112 return (BOOLEAN) ((Char >= L'0' && Char <= L'9') || (Char >= L'A' && Char <= L'F'));
113}
114
115/**
116 Variable property get with wildcard name.
117
118 @param[in] VariableName Pointer to variable name.
119 @param[in] VendorGuid Pointer to variable vendor GUID.
120 @param[in] WildcardMatch Try wildcard match or not.
121
122 @return Pointer to variable property.
123
124**/
125VAR_CHECK_VARIABLE_PROPERTY *
126VariablePropertyGetWithWildcardName (
127 IN CHAR16 *VariableName,
128 IN EFI_GUID *VendorGuid,
129 IN BOOLEAN WildcardMatch
130 )
131{
132 UINTN Index;
133 UINTN NameLength;
134
135 NameLength = StrLen (VariableName) - 4;
136 for (Index = 0; Index < sizeof (mVarCheckVariableWithWildcardName)/sizeof (mVarCheckVariableWithWildcardName[0]); Index++) {
137 if (CompareGuid (mVarCheckVariableWithWildcardName[Index].Guid, VendorGuid)){
138 if (WildcardMatch) {
139 if ((StrLen (VariableName) == StrLen (mVarCheckVariableWithWildcardName[Index].Name)) &&
140 (StrnCmp (VariableName, mVarCheckVariableWithWildcardName[Index].Name, NameLength) == 0) &&
141 VarCheckInternalIsHexaDecimalDigitCharacter (VariableName[NameLength]) &&
142 VarCheckInternalIsHexaDecimalDigitCharacter (VariableName[NameLength + 1]) &&
143 VarCheckInternalIsHexaDecimalDigitCharacter (VariableName[NameLength + 2]) &&
144 VarCheckInternalIsHexaDecimalDigitCharacter (VariableName[NameLength + 3])) {
145 return &mVarCheckVariableWithWildcardName[Index].VariableProperty;
146 }
147 }
148 if (StrCmp (mVarCheckVariableWithWildcardName[Index].Name, VariableName) == 0) {
149 return &mVarCheckVariableWithWildcardName[Index].VariableProperty;
150 }
151 }
152 }
153
154 return NULL;
155}
156
157/**
158 Variable property get function.
159
160 @param[in] Name Pointer to the variable name.
161 @param[in] Guid Pointer to the vendor GUID.
162 @param[in] WildcardMatch Try wildcard match or not.
163
164 @return Pointer to the property of variable specified by the Name and Guid.
165
166**/
167VAR_CHECK_VARIABLE_PROPERTY *
168VariablePropertyGetFunction (
169 IN CHAR16 *Name,
170 IN EFI_GUID *Guid,
171 IN BOOLEAN WildcardMatch
172 )
173{
174 UINTN Index;
175 VAR_CHECK_VARIABLE_ENTRY *Entry;
176 CHAR16 *VariableName;
177
178 for (Index = 0; Index < mNumberOfVarCheckVariable; Index++) {
179 Entry = (VAR_CHECK_VARIABLE_ENTRY *) mVarCheckVariableTable[Index];
180 VariableName = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));
181 if (CompareGuid (&Entry->Guid, Guid) && (StrCmp (VariableName, Name) == 0)) {
182 return &Entry->VariableProperty;
183 }
184 }
185
186 return VariablePropertyGetWithWildcardName (Name, Guid, WildcardMatch);
187}
188
189/**
190 Var check add table entry.
191
192 @param[in, out] Table Pointer to table buffer.
193 @param[in, out] MaxNumber Pointer to maximum number of entry in the table.
194 @param[in, out] CurrentNumber Pointer to current number of entry in the table.
195 @param[in] Entry Entry will be added to the table.
196
197 @retval EFI_SUCCESS Reallocate memory successfully.
198 @retval EFI_OUT_OF_RESOURCES No enough memory to allocate.
199
200**/
201EFI_STATUS
202VarCheckAddTableEntry (
203 IN OUT UINTN **Table,
204 IN OUT UINTN *MaxNumber,
205 IN OUT UINTN *CurrentNumber,
206 IN UINTN Entry
207 )
208{
209 UINTN *TempTable;
210
211 //
212 // Check whether the table is enough to store new entry.
213 //
214 if (*CurrentNumber == *MaxNumber) {
215 //
216 // Reallocate memory for the table.
217 //
218 TempTable = ReallocateRuntimePool (
219 *MaxNumber * sizeof (UINTN),
220 (*MaxNumber + VAR_CHECK_TABLE_SIZE) * sizeof (UINTN),
221 *Table
222 );
223
224 //
225 // No enough resource to allocate.
226 //
227 if (TempTable == NULL) {
228 return EFI_OUT_OF_RESOURCES;
229 }
230
231 *Table = TempTable;
232 //
233 // Increase max number.
234 //
235 *MaxNumber += VAR_CHECK_TABLE_SIZE;
236 }
237
238 //
239 // Add entry to the table.
240 //
241 (*Table)[*CurrentNumber] = Entry;
242 (*CurrentNumber)++;
243
244 return EFI_SUCCESS;
245}
246
247/**
248 Register END_OF_DXE callback.
249 The callback will be invoked by VarCheckLibInitializeAtEndOfDxe().
250
251 @param[in] Callback END_OF_DXE callback.
252
253 @retval EFI_SUCCESS The callback was registered successfully.
254 @retval EFI_INVALID_PARAMETER Callback is NULL.
255 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
256 already been signaled.
257 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the callback register request.
258
259**/
260EFI_STATUS
261EFIAPI
262VarCheckLibRegisterEndOfDxeCallback (
263 IN VAR_CHECK_END_OF_DXE_CALLBACK Callback
264 )
265{
266 EFI_STATUS Status;
267
268 if (Callback == NULL) {
269 return EFI_INVALID_PARAMETER;
270 }
271
272 if (mVarCheckLibEndOfDxe) {
273 return EFI_ACCESS_DENIED;
274 }
275
276 Status = VarCheckAddTableEntry (
277 (UINTN **) &mVarCheckLibEndOfDxeCallback,
278 &mVarCheckLibEndOfDxeCallbackMaxCount,
279 &mVarCheckLibEndOfDxeCallbackCount,
280 (UINTN) Callback
281 );
282
283 DEBUG ((EFI_D_INFO, "VarCheckLibRegisterEndOfDxeCallback - 0x%x %r\n", Callback, Status));
284
285 return Status;
286}
287
288/**
289 Var check initialize at END_OF_DXE.
290
291 This function needs to be called at END_OF_DXE.
292 Address pointers may be returned,
293 and caller needs to ConvertPointer() for the pointers.
294
295 @param[in, out] AddressPointerCount Output pointer to address pointer count.
296
297 @return Address pointer buffer, NULL if input AddressPointerCount is NULL.
298
299**/
300VOID ***
301EFIAPI
302VarCheckLibInitializeAtEndOfDxe (
303 IN OUT UINTN *AddressPointerCount OPTIONAL
304 )
305{
306 VOID *TempTable;
307 UINTN TotalCount;
308 UINTN Index;
309
310 for (Index = 0; Index < mVarCheckLibEndOfDxeCallbackCount; Index++) {
311 //
312 // Invoke the callback registered by VarCheckLibRegisterEndOfDxeCallback().
313 //
314 mVarCheckLibEndOfDxeCallback[Index] ();
315 }
316 if (mVarCheckLibEndOfDxeCallback != NULL) {
317 //
318 // Free the callback buffer.
319 //
320 mVarCheckLibEndOfDxeCallbackCount = 0;
321 mVarCheckLibEndOfDxeCallbackMaxCount = 0;
322 FreePool ((VOID *) mVarCheckLibEndOfDxeCallback);
323 mVarCheckLibEndOfDxeCallback = NULL;
324 }
325
326 mVarCheckLibEndOfDxe = TRUE;
327
328 if (AddressPointerCount == NULL) {
329 if (mVarCheckLibAddressPointer != NULL) {
330 //
331 // Free the address pointer buffer.
332 //
333 mVarCheckLibAddressPointerCount = 0;
334 mVarCheckLibAddressPointerMaxCount = 0;
335 FreePool ((VOID *) mVarCheckLibAddressPointer);
336 mVarCheckLibAddressPointer = NULL;
337 }
338 return NULL;
339 }
340
341 //
342 // Get the total count needed.
343 // Also cover VarCheckHandler and the entries, and VarCheckVariable and the entries.
344 //
345 TotalCount = mVarCheckLibAddressPointerCount + (mNumberOfVarCheckHandler + 1) + (mNumberOfVarCheckVariable + 1);
346 TempTable = ReallocateRuntimePool (
347 mVarCheckLibAddressPointerMaxCount * sizeof (VOID **),
348 TotalCount * sizeof (VOID **),
349 (VOID *) mVarCheckLibAddressPointer
350 );
351
352 if (TempTable != NULL) {
353 mVarCheckLibAddressPointer = (VOID ***) TempTable;
354
355 //
356 // Cover VarCheckHandler and the entries.
357 //
358 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **) &mVarCheckHandlerTable;
359 for (Index = 0; Index < mNumberOfVarCheckHandler; Index++) {
360 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **) &mVarCheckHandlerTable[Index];
361 }
362
363 //
364 // Cover VarCheckVariable and the entries.
365 //
366 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **) &mVarCheckVariableTable;
367 for (Index = 0; Index < mNumberOfVarCheckVariable; Index++) {
368 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **) &mVarCheckVariableTable[Index];
369 }
370
371 ASSERT (mVarCheckLibAddressPointerCount == TotalCount);
372 mVarCheckLibAddressPointerMaxCount = mVarCheckLibAddressPointerCount;
373 }
374
375 *AddressPointerCount = mVarCheckLibAddressPointerCount;
376 return mVarCheckLibAddressPointer;
377}
378
379/**
380 Register address pointer.
381 The AddressPointer may be returned by VarCheckLibInitializeAtEndOfDxe().
382
383 @param[in] AddressPointer Address pointer.
384
385 @retval EFI_SUCCESS The address pointer was registered successfully.
386 @retval EFI_INVALID_PARAMETER AddressPointer is NULL.
387 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
388 already been signaled.
389 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the address pointer register request.
390
391**/
392EFI_STATUS
393EFIAPI
394VarCheckLibRegisterAddressPointer (
395 IN VOID **AddressPointer
396 )
397{
398 EFI_STATUS Status;
399
400 if (AddressPointer == NULL) {
401 return EFI_INVALID_PARAMETER;
402 }
403
404 if (mVarCheckLibEndOfDxe) {
405 return EFI_ACCESS_DENIED;
406 }
407
408 Status = VarCheckAddTableEntry(
409 (UINTN **) &mVarCheckLibAddressPointer,
410 &mVarCheckLibAddressPointerMaxCount,
411 &mVarCheckLibAddressPointerCount,
412 (UINTN) AddressPointer
413 );
414
415 DEBUG ((EFI_D_INFO, "VarCheckLibRegisterAddressPointer - 0x%x %r\n", AddressPointer, Status));
416
417 return Status;
418}
419
420/**
421 Register SetVariable check handler.
422
423 @param[in] Handler Pointer to check handler.
424
425 @retval EFI_SUCCESS The SetVariable check handler was registered successfully.
426 @retval EFI_INVALID_PARAMETER Handler is NULL.
427 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
428 already been signaled.
429 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the SetVariable check handler register request.
430 @retval EFI_UNSUPPORTED This interface is not implemented.
431 For example, it is unsupported in VarCheck protocol if both VarCheck and SmmVarCheck protocols are present.
432
433**/
434EFI_STATUS
435EFIAPI
436VarCheckLibRegisterSetVariableCheckHandler (
437 IN VAR_CHECK_SET_VARIABLE_CHECK_HANDLER Handler
438 )
439{
440 EFI_STATUS Status;
441
442 if (Handler == NULL) {
443 return EFI_INVALID_PARAMETER;
444 }
445
446 if (mVarCheckLibEndOfDxe) {
447 return EFI_ACCESS_DENIED;
448 }
449
450 Status = VarCheckAddTableEntry(
451 (UINTN **) &mVarCheckHandlerTable,
452 &mMaxNumberOfVarCheckHandler,
453 &mNumberOfVarCheckHandler,
454 (UINTN) Handler
455 );
456
457 DEBUG ((EFI_D_INFO, "VarCheckLibRegisterSetVariableCheckHandler - 0x%x %r\n", Handler, Status));
458
459 return Status;
460}
461
462/**
463 Variable property set.
464
465 @param[in] Name Pointer to the variable name.
466 @param[in] Guid Pointer to the vendor GUID.
467 @param[in] VariableProperty Pointer to the input variable property.
468
469 @retval EFI_SUCCESS The property of variable specified by the Name and Guid was set successfully.
470 @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string,
471 or the fields of VariableProperty are not valid.
472 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
473 already been signaled.
474 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the variable property set request.
475
476**/
477EFI_STATUS
478EFIAPI
479VarCheckLibVariablePropertySet (
480 IN CHAR16 *Name,
481 IN EFI_GUID *Guid,
482 IN VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
483 )
484{
485 EFI_STATUS Status;
486 VAR_CHECK_VARIABLE_ENTRY *Entry;
487 CHAR16 *VariableName;
488 VAR_CHECK_VARIABLE_PROPERTY *Property;
489
490 if (Name == NULL || Name[0] == 0 || Guid == NULL) {
491 return EFI_INVALID_PARAMETER;
492 }
493
494 if (VariableProperty == NULL) {
495 return EFI_INVALID_PARAMETER;
496 }
497
498 if (VariableProperty->Revision != VAR_CHECK_VARIABLE_PROPERTY_REVISION) {
499 return EFI_INVALID_PARAMETER;
500 }
501
502 if (mVarCheckLibEndOfDxe) {
503 return EFI_ACCESS_DENIED;
504 }
505
506 Status = EFI_SUCCESS;
507
508 //
509 // Get the pointer of property data for set.
510 //
511 Property = VariablePropertyGetFunction (Name, Guid, FALSE);
512 if (Property != NULL) {
513 CopyMem (Property, VariableProperty, sizeof (*VariableProperty));
514 } else {
515 Entry = AllocateRuntimeZeroPool (sizeof (*Entry) + StrSize (Name));
516 if (Entry == NULL) {
517 return EFI_OUT_OF_RESOURCES;
518 }
519 VariableName = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));
520 StrCpyS (VariableName, StrSize (Name)/sizeof (CHAR16), Name);
521 CopyGuid (&Entry->Guid, Guid);
522 CopyMem (&Entry->VariableProperty, VariableProperty, sizeof (*VariableProperty));
523
524 Status = VarCheckAddTableEntry(
525 (UINTN **) &mVarCheckVariableTable,
526 &mMaxNumberOfVarCheckVariable,
527 &mNumberOfVarCheckVariable,
528 (UINTN) Entry
529 );
530
531 if (EFI_ERROR (Status)) {
532 FreePool (Entry);
533 }
534 }
535
536 return Status;
537}
538
539/**
540 Variable property get.
541
542 @param[in] Name Pointer to the variable name.
543 @param[in] Guid Pointer to the vendor GUID.
544 @param[out] VariableProperty Pointer to the output variable property.
545
546 @retval EFI_SUCCESS The property of variable specified by the Name and Guid was got successfully.
547 @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string.
548 @retval EFI_NOT_FOUND The property of variable specified by the Name and Guid was not found.
549
550**/
551EFI_STATUS
552EFIAPI
553VarCheckLibVariablePropertyGet (
554 IN CHAR16 *Name,
555 IN EFI_GUID *Guid,
556 OUT VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
557 )
558{
559 VAR_CHECK_VARIABLE_PROPERTY *Property;
560
561 if (Name == NULL || Name[0] == 0 || Guid == NULL) {
562 return EFI_INVALID_PARAMETER;
563 }
564
565 if (VariableProperty == NULL) {
566 return EFI_INVALID_PARAMETER;
567 }
568
569 Property = VariablePropertyGetFunction (Name, Guid, TRUE);
570 //
571 // Also check the property revision before using the property data.
572 // There is no property set to this variable(wildcard name)
573 // if the revision is not VAR_CHECK_VARIABLE_PROPERTY_REVISION.
574 //
575 if ((Property != NULL) && (Property->Revision == VAR_CHECK_VARIABLE_PROPERTY_REVISION)) {
576 CopyMem (VariableProperty, Property, sizeof (*VariableProperty));
577 return EFI_SUCCESS;
578 }
579
580 return EFI_NOT_FOUND;
581}
582
583/**
584 SetVariable check.
585
586 @param[in] VariableName Name of Variable to set.
587 @param[in] VendorGuid Variable vendor GUID.
588 @param[in] Attributes Attribute value of the variable.
589 @param[in] DataSize Size of Data to set.
590 @param[in] Data Data pointer.
591 @param[in] RequestSource Request source.
592
593 @retval EFI_SUCCESS The SetVariable check result was success.
594 @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, GUID,
595 DataSize and Data value was supplied.
596 @retval EFI_WRITE_PROTECTED The variable in question is read-only.
597 @retval Others The other return status from check handler.
598
599**/
600EFI_STATUS
601EFIAPI
602VarCheckLibSetVariableCheck (
603 IN CHAR16 *VariableName,
604 IN EFI_GUID *VendorGuid,
605 IN UINT32 Attributes,
606 IN UINTN DataSize,
607 IN VOID *Data,
608 IN VAR_CHECK_REQUEST_SOURCE RequestSource
609 )
610{
611 EFI_STATUS Status;
612 UINTN Index;
613 VAR_CHECK_VARIABLE_PROPERTY *Property;
614
615 if (!mVarCheckLibEndOfDxe) {
616 //
617 // Only do check after End Of Dxe.
618 //
619 return EFI_SUCCESS;
620 }
621
622 Property = VariablePropertyGetFunction (VariableName, VendorGuid, TRUE);
623 //
624 // Also check the property revision before using the property data.
625 // There is no property set to this variable(wildcard name)
626 // if the revision is not VAR_CHECK_VARIABLE_PROPERTY_REVISION.
627 //
628 if ((Property != NULL) && (Property->Revision == VAR_CHECK_VARIABLE_PROPERTY_REVISION)) {
629 if ((RequestSource != VarCheckFromTrusted) && ((Property->Property & VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY) != 0)) {
630 DEBUG ((EFI_D_INFO, "Variable Check ReadOnly variable fail %r - %g:%s\n", EFI_WRITE_PROTECTED, VendorGuid, VariableName));
631 return EFI_WRITE_PROTECTED;
632 }
633 if (!((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0))) {
634 //
635 // Not to delete variable.
636 //
637 if ((Property->Attributes != 0) && ((Attributes & (~EFI_VARIABLE_APPEND_WRITE)) != Property->Attributes)) {
638 DEBUG ((EFI_D_INFO, "Variable Check Attributes(0x%08x to 0x%08x) fail %r - %g:%s\n", Property->Attributes, Attributes, EFI_INVALID_PARAMETER, VendorGuid, VariableName));
639 return EFI_INVALID_PARAMETER;
640 }
641 if (DataSize != 0) {
642 if ((DataSize < Property->MinSize) || (DataSize > Property->MaxSize)) {
643 DEBUG ((EFI_D_INFO, "Variable Check DataSize fail(0x%x not in 0x%x - 0x%x) %r - %g:%s\n", DataSize, Property->MinSize, Property->MaxSize, EFI_INVALID_PARAMETER, VendorGuid, VariableName));
644 return EFI_INVALID_PARAMETER;
645 }
646 }
647 }
648 }
649
650 for (Index = 0; Index < mNumberOfVarCheckHandler; Index++) {
651 Status = mVarCheckHandlerTable[Index] (
652 VariableName,
653 VendorGuid,
654 Attributes,
655 DataSize,
656 Data
657 );
658 if (Status == EFI_WRITE_PROTECTED && RequestSource == VarCheckFromTrusted) {
659 //
660 // If RequestSource is trusted, then allow variable to be set even if it
661 // is write protected.
662 //
663 continue;
664 }
665 if (EFI_ERROR (Status)) {
666 DEBUG ((EFI_D_INFO, "Variable Check handler fail %r - %g:%s\n", Status, VendorGuid, VariableName));
667 return Status;
668 }
669 }
670 return EFI_SUCCESS;
671}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette