VirtualBox

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

Last change on this file since 109193 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 20.2 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 {
146 return &mVarCheckVariableWithWildcardName[Index].VariableProperty;
147 }
148 }
149
150 if (StrCmp (mVarCheckVariableWithWildcardName[Index].Name, VariableName) == 0) {
151 return &mVarCheckVariableWithWildcardName[Index].VariableProperty;
152 }
153 }
154 }
155
156 return NULL;
157}
158
159/**
160 Variable property get function.
161
162 @param[in] Name Pointer to the variable name.
163 @param[in] Guid Pointer to the vendor GUID.
164 @param[in] WildcardMatch Try wildcard match or not.
165
166 @return Pointer to the property of variable specified by the Name and Guid.
167
168**/
169VAR_CHECK_VARIABLE_PROPERTY *
170VariablePropertyGetFunction (
171 IN CHAR16 *Name,
172 IN EFI_GUID *Guid,
173 IN BOOLEAN WildcardMatch
174 )
175{
176 UINTN Index;
177 VAR_CHECK_VARIABLE_ENTRY *Entry;
178 CHAR16 *VariableName;
179
180 for (Index = 0; Index < mNumberOfVarCheckVariable; Index++) {
181 Entry = (VAR_CHECK_VARIABLE_ENTRY *)mVarCheckVariableTable[Index];
182 VariableName = (CHAR16 *)((UINTN)Entry + sizeof (*Entry));
183 if (CompareGuid (&Entry->Guid, Guid) && (StrCmp (VariableName, Name) == 0)) {
184 return &Entry->VariableProperty;
185 }
186 }
187
188 return VariablePropertyGetWithWildcardName (Name, Guid, WildcardMatch);
189}
190
191/**
192 Var check add table entry.
193
194 @param[in, out] Table Pointer to table buffer.
195 @param[in, out] MaxNumber Pointer to maximum number of entry in the table.
196 @param[in, out] CurrentNumber Pointer to current number of entry in the table.
197 @param[in] Entry Entry will be added to the table.
198
199 @retval EFI_SUCCESS Reallocate memory successfully.
200 @retval EFI_OUT_OF_RESOURCES No enough memory to allocate.
201
202**/
203EFI_STATUS
204VarCheckAddTableEntry (
205 IN OUT UINTN **Table,
206 IN OUT UINTN *MaxNumber,
207 IN OUT UINTN *CurrentNumber,
208 IN UINTN Entry
209 )
210{
211 UINTN *TempTable;
212
213 //
214 // Check whether the table is enough to store new entry.
215 //
216 if (*CurrentNumber == *MaxNumber) {
217 //
218 // Reallocate memory for the table.
219 //
220 TempTable = ReallocateRuntimePool (
221 *MaxNumber * sizeof (UINTN),
222 (*MaxNumber + VAR_CHECK_TABLE_SIZE) * sizeof (UINTN),
223 *Table
224 );
225
226 //
227 // No enough resource to allocate.
228 //
229 if (TempTable == NULL) {
230 return EFI_OUT_OF_RESOURCES;
231 }
232
233 *Table = TempTable;
234 //
235 // Increase max number.
236 //
237 *MaxNumber += VAR_CHECK_TABLE_SIZE;
238 }
239
240 //
241 // Add entry to the table.
242 //
243 (*Table)[*CurrentNumber] = Entry;
244 (*CurrentNumber)++;
245
246 return EFI_SUCCESS;
247}
248
249/**
250 Register END_OF_DXE callback.
251 The callback will be invoked by VarCheckLibInitializeAtEndOfDxe().
252
253 @param[in] Callback END_OF_DXE callback.
254
255 @retval EFI_SUCCESS The callback was registered successfully.
256 @retval EFI_INVALID_PARAMETER Callback is NULL.
257 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
258 already been signaled.
259 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the callback register request.
260
261**/
262EFI_STATUS
263EFIAPI
264VarCheckLibRegisterEndOfDxeCallback (
265 IN VAR_CHECK_END_OF_DXE_CALLBACK Callback
266 )
267{
268 EFI_STATUS Status;
269
270 if (Callback == NULL) {
271 return EFI_INVALID_PARAMETER;
272 }
273
274 if (mVarCheckLibEndOfDxe) {
275 return EFI_ACCESS_DENIED;
276 }
277
278 Status = VarCheckAddTableEntry (
279 (UINTN **)&mVarCheckLibEndOfDxeCallback,
280 &mVarCheckLibEndOfDxeCallbackMaxCount,
281 &mVarCheckLibEndOfDxeCallbackCount,
282 (UINTN)Callback
283 );
284
285 DEBUG ((DEBUG_INFO, "VarCheckLibRegisterEndOfDxeCallback - 0x%x %r\n", Callback, Status));
286
287 return Status;
288}
289
290/**
291 Var check initialize at END_OF_DXE.
292
293 This function needs to be called at END_OF_DXE.
294 Address pointers may be returned,
295 and caller needs to ConvertPointer() for the pointers.
296
297 @param[in, out] AddressPointerCount Output pointer to address pointer count.
298
299 @return Address pointer buffer, NULL if input AddressPointerCount is NULL.
300
301**/
302VOID ***
303EFIAPI
304VarCheckLibInitializeAtEndOfDxe (
305 IN OUT UINTN *AddressPointerCount OPTIONAL
306 )
307{
308 VOID *TempTable;
309 UINTN TotalCount;
310 UINTN Index;
311
312 for (Index = 0; Index < mVarCheckLibEndOfDxeCallbackCount; Index++) {
313 //
314 // Invoke the callback registered by VarCheckLibRegisterEndOfDxeCallback().
315 //
316 mVarCheckLibEndOfDxeCallback[Index]();
317 }
318
319 if (mVarCheckLibEndOfDxeCallback != NULL) {
320 //
321 // Free the callback buffer.
322 //
323 mVarCheckLibEndOfDxeCallbackCount = 0;
324 mVarCheckLibEndOfDxeCallbackMaxCount = 0;
325 FreePool ((VOID *)mVarCheckLibEndOfDxeCallback);
326 mVarCheckLibEndOfDxeCallback = NULL;
327 }
328
329 mVarCheckLibEndOfDxe = TRUE;
330
331 if (AddressPointerCount == NULL) {
332 if (mVarCheckLibAddressPointer != NULL) {
333 //
334 // Free the address pointer buffer.
335 //
336 mVarCheckLibAddressPointerCount = 0;
337 mVarCheckLibAddressPointerMaxCount = 0;
338 FreePool ((VOID *)mVarCheckLibAddressPointer);
339 mVarCheckLibAddressPointer = NULL;
340 }
341
342 return NULL;
343 }
344
345 //
346 // Get the total count needed.
347 // Also cover VarCheckHandler and the entries, and VarCheckVariable and the entries.
348 //
349 TotalCount = mVarCheckLibAddressPointerCount + (mNumberOfVarCheckHandler + 1) + (mNumberOfVarCheckVariable + 1);
350 TempTable = ReallocateRuntimePool (
351 mVarCheckLibAddressPointerMaxCount * sizeof (VOID **),
352 TotalCount * sizeof (VOID **),
353 (VOID *)mVarCheckLibAddressPointer
354 );
355
356 if (TempTable != NULL) {
357 mVarCheckLibAddressPointer = (VOID ***)TempTable;
358
359 //
360 // Cover VarCheckHandler and the entries.
361 //
362 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **)&mVarCheckHandlerTable;
363 for (Index = 0; Index < mNumberOfVarCheckHandler; Index++) {
364 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **)&mVarCheckHandlerTable[Index];
365 }
366
367 //
368 // Cover VarCheckVariable and the entries.
369 //
370 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **)&mVarCheckVariableTable;
371 for (Index = 0; Index < mNumberOfVarCheckVariable; Index++) {
372 mVarCheckLibAddressPointer[mVarCheckLibAddressPointerCount++] = (VOID **)&mVarCheckVariableTable[Index];
373 }
374
375 ASSERT (mVarCheckLibAddressPointerCount == TotalCount);
376 mVarCheckLibAddressPointerMaxCount = mVarCheckLibAddressPointerCount;
377 }
378
379 *AddressPointerCount = mVarCheckLibAddressPointerCount;
380 return mVarCheckLibAddressPointer;
381}
382
383/**
384 Register address pointer.
385 The AddressPointer may be returned by VarCheckLibInitializeAtEndOfDxe().
386
387 @param[in] AddressPointer Address pointer.
388
389 @retval EFI_SUCCESS The address pointer was registered successfully.
390 @retval EFI_INVALID_PARAMETER AddressPointer is NULL.
391 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
392 already been signaled.
393 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the address pointer register request.
394
395**/
396EFI_STATUS
397EFIAPI
398VarCheckLibRegisterAddressPointer (
399 IN VOID **AddressPointer
400 )
401{
402 EFI_STATUS Status;
403
404 if (AddressPointer == NULL) {
405 return EFI_INVALID_PARAMETER;
406 }
407
408 if (mVarCheckLibEndOfDxe) {
409 return EFI_ACCESS_DENIED;
410 }
411
412 Status = VarCheckAddTableEntry (
413 (UINTN **)&mVarCheckLibAddressPointer,
414 &mVarCheckLibAddressPointerMaxCount,
415 &mVarCheckLibAddressPointerCount,
416 (UINTN)AddressPointer
417 );
418
419 DEBUG ((DEBUG_INFO, "VarCheckLibRegisterAddressPointer - 0x%x %r\n", AddressPointer, Status));
420
421 return Status;
422}
423
424/**
425 Register SetVariable check handler.
426
427 @param[in] Handler Pointer to check handler.
428
429 @retval EFI_SUCCESS The SetVariable check handler was registered successfully.
430 @retval EFI_INVALID_PARAMETER Handler is NULL.
431 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
432 already been signaled.
433 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the SetVariable check handler register request.
434 @retval EFI_UNSUPPORTED This interface is not implemented.
435 For example, it is unsupported in VarCheck protocol if both VarCheck and SmmVarCheck protocols are present.
436
437**/
438EFI_STATUS
439EFIAPI
440VarCheckLibRegisterSetVariableCheckHandler (
441 IN VAR_CHECK_SET_VARIABLE_CHECK_HANDLER Handler
442 )
443{
444 EFI_STATUS Status;
445
446 if (Handler == NULL) {
447 return EFI_INVALID_PARAMETER;
448 }
449
450 if (mVarCheckLibEndOfDxe) {
451 return EFI_ACCESS_DENIED;
452 }
453
454 Status = VarCheckAddTableEntry (
455 (UINTN **)&mVarCheckHandlerTable,
456 &mMaxNumberOfVarCheckHandler,
457 &mNumberOfVarCheckHandler,
458 (UINTN)Handler
459 );
460
461 DEBUG ((DEBUG_INFO, "VarCheckLibRegisterSetVariableCheckHandler - 0x%x %r\n", Handler, Status));
462
463 return Status;
464}
465
466/**
467 Variable property set.
468
469 @param[in] Name Pointer to the variable name.
470 @param[in] Guid Pointer to the vendor GUID.
471 @param[in] VariableProperty Pointer to the input variable property.
472
473 @retval EFI_SUCCESS The property of variable specified by the Name and Guid was set successfully.
474 @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string,
475 or the fields of VariableProperty are not valid.
476 @retval EFI_ACCESS_DENIED EFI_END_OF_DXE_EVENT_GROUP_GUID or EFI_EVENT_GROUP_READY_TO_BOOT has
477 already been signaled.
478 @retval EFI_OUT_OF_RESOURCES There is not enough resource for the variable property set request.
479
480**/
481EFI_STATUS
482EFIAPI
483VarCheckLibVariablePropertySet (
484 IN CHAR16 *Name,
485 IN EFI_GUID *Guid,
486 IN VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
487 )
488{
489 EFI_STATUS Status;
490 VAR_CHECK_VARIABLE_ENTRY *Entry;
491 CHAR16 *VariableName;
492 VAR_CHECK_VARIABLE_PROPERTY *Property;
493
494 if ((Name == NULL) || (Name[0] == 0) || (Guid == NULL)) {
495 return EFI_INVALID_PARAMETER;
496 }
497
498 if (VariableProperty == NULL) {
499 return EFI_INVALID_PARAMETER;
500 }
501
502 if (VariableProperty->Revision != VAR_CHECK_VARIABLE_PROPERTY_REVISION) {
503 return EFI_INVALID_PARAMETER;
504 }
505
506 if (mVarCheckLibEndOfDxe) {
507 return EFI_ACCESS_DENIED;
508 }
509
510 Status = EFI_SUCCESS;
511
512 //
513 // Get the pointer of property data for set.
514 //
515 Property = VariablePropertyGetFunction (Name, Guid, FALSE);
516 if (Property != NULL) {
517 CopyMem (Property, VariableProperty, sizeof (*VariableProperty));
518 } else {
519 Entry = AllocateRuntimeZeroPool (sizeof (*Entry) + StrSize (Name));
520 if (Entry == NULL) {
521 return EFI_OUT_OF_RESOURCES;
522 }
523
524 VariableName = (CHAR16 *)((UINTN)Entry + sizeof (*Entry));
525 StrCpyS (VariableName, StrSize (Name)/sizeof (CHAR16), Name);
526 CopyGuid (&Entry->Guid, Guid);
527 CopyMem (&Entry->VariableProperty, VariableProperty, sizeof (*VariableProperty));
528
529 Status = VarCheckAddTableEntry (
530 (UINTN **)&mVarCheckVariableTable,
531 &mMaxNumberOfVarCheckVariable,
532 &mNumberOfVarCheckVariable,
533 (UINTN)Entry
534 );
535
536 if (EFI_ERROR (Status)) {
537 FreePool (Entry);
538 }
539 }
540
541 return Status;
542}
543
544/**
545 Variable property get.
546
547 @param[in] Name Pointer to the variable name.
548 @param[in] Guid Pointer to the vendor GUID.
549 @param[out] VariableProperty Pointer to the output variable property.
550
551 @retval EFI_SUCCESS The property of variable specified by the Name and Guid was got successfully.
552 @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or Name is an empty string.
553 @retval EFI_NOT_FOUND The property of variable specified by the Name and Guid was not found.
554
555**/
556EFI_STATUS
557EFIAPI
558VarCheckLibVariablePropertyGet (
559 IN CHAR16 *Name,
560 IN EFI_GUID *Guid,
561 OUT VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
562 )
563{
564 VAR_CHECK_VARIABLE_PROPERTY *Property;
565
566 if ((Name == NULL) || (Name[0] == 0) || (Guid == NULL)) {
567 return EFI_INVALID_PARAMETER;
568 }
569
570 if (VariableProperty == NULL) {
571 return EFI_INVALID_PARAMETER;
572 }
573
574 Property = VariablePropertyGetFunction (Name, Guid, TRUE);
575 //
576 // Also check the property revision before using the property data.
577 // There is no property set to this variable(wildcard name)
578 // if the revision is not VAR_CHECK_VARIABLE_PROPERTY_REVISION.
579 //
580 if ((Property != NULL) && (Property->Revision == VAR_CHECK_VARIABLE_PROPERTY_REVISION)) {
581 CopyMem (VariableProperty, Property, sizeof (*VariableProperty));
582 return EFI_SUCCESS;
583 }
584
585 return EFI_NOT_FOUND;
586}
587
588/**
589 SetVariable check.
590
591 @param[in] VariableName Name of Variable to set.
592 @param[in] VendorGuid Variable vendor GUID.
593 @param[in] Attributes Attribute value of the variable.
594 @param[in] DataSize Size of Data to set.
595 @param[in] Data Data pointer.
596 @param[in] RequestSource Request source.
597
598 @retval EFI_SUCCESS The SetVariable check result was success.
599 @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, GUID,
600 DataSize and Data value was supplied.
601 @retval EFI_WRITE_PROTECTED The variable in question is read-only.
602 @retval Others The other return status from check handler.
603
604**/
605EFI_STATUS
606EFIAPI
607VarCheckLibSetVariableCheck (
608 IN CHAR16 *VariableName,
609 IN EFI_GUID *VendorGuid,
610 IN UINT32 Attributes,
611 IN UINTN DataSize,
612 IN VOID *Data,
613 IN VAR_CHECK_REQUEST_SOURCE RequestSource
614 )
615{
616 EFI_STATUS Status;
617 UINTN Index;
618 VAR_CHECK_VARIABLE_PROPERTY *Property;
619
620 if (!mVarCheckLibEndOfDxe) {
621 //
622 // Only do check after End Of Dxe.
623 //
624 return EFI_SUCCESS;
625 }
626
627 Property = VariablePropertyGetFunction (VariableName, VendorGuid, TRUE);
628 //
629 // Also check the property revision before using the property data.
630 // There is no property set to this variable(wildcard name)
631 // if the revision is not VAR_CHECK_VARIABLE_PROPERTY_REVISION.
632 //
633 if ((Property != NULL) && (Property->Revision == VAR_CHECK_VARIABLE_PROPERTY_REVISION)) {
634 if ((RequestSource != VarCheckFromTrusted) && ((Property->Property & VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY) != 0)) {
635 DEBUG ((DEBUG_INFO, "Variable Check ReadOnly variable fail %r - %g:%s\n", EFI_WRITE_PROTECTED, VendorGuid, VariableName));
636 return EFI_WRITE_PROTECTED;
637 }
638
639 if (!((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0))) {
640 //
641 // Not to delete variable.
642 //
643 if ((Property->Attributes != 0) && ((Attributes & (~EFI_VARIABLE_APPEND_WRITE)) != Property->Attributes)) {
644 DEBUG ((DEBUG_INFO, "Variable Check Attributes(0x%08x to 0x%08x) fail %r - %g:%s\n", Property->Attributes, Attributes, EFI_INVALID_PARAMETER, VendorGuid, VariableName));
645 return EFI_INVALID_PARAMETER;
646 }
647
648 if (DataSize != 0) {
649 if ((DataSize < Property->MinSize) || (DataSize > Property->MaxSize)) {
650 DEBUG ((DEBUG_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));
651 return EFI_INVALID_PARAMETER;
652 }
653 }
654 }
655 }
656
657 for (Index = 0; Index < mNumberOfVarCheckHandler; Index++) {
658 Status = mVarCheckHandlerTable[Index](
659 VariableName,
660 VendorGuid,
661 Attributes,
662 DataSize,
663 Data
664 );
665 if ((Status == EFI_WRITE_PROTECTED) && (RequestSource == VarCheckFromTrusted)) {
666 //
667 // If RequestSource is trusted, then allow variable to be set even if it
668 // is write protected.
669 //
670 continue;
671 }
672
673 if (EFI_ERROR (Status)) {
674 DEBUG ((DEBUG_INFO, "Variable Check handler fail %r - %g:%s\n", Status, VendorGuid, VariableName));
675 return Status;
676 }
677 }
678
679 return EFI_SUCCESS;
680}
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