MdeModulePkg/Library/VarCheckLib/VarCheckLib.c

   1 /** @file
   2   Implementation functions and structures for var check services.
   3
   4 Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
   5 SPDX-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
  18 BOOLEAN mVarCheckLibEndOfDxe    = FALSE;
  19
  20 #define VAR_CHECK_TABLE_SIZE    0x8
  21
  22 UINTN                                   mVarCheckLibEndOfDxeCallbackCount = 0;
  23 UINTN                                   mVarCheckLibEndOfDxeCallbackMaxCount = 0;
  24 VAR_CHECK_END_OF_DXE_CALLBACK           *mVarCheckLibEndOfDxeCallback = NULL;
  25
  26 UINTN                                   mVarCheckLibAddressPointerCount = 0;
  27 UINTN                                   mVarCheckLibAddressPointerMaxCount = 0;
  28 VOID                                    ***mVarCheckLibAddressPointer = NULL;
  29
  30 UINTN                                   mNumberOfVarCheckHandler = 0;
  31 UINTN                                   mMaxNumberOfVarCheckHandler = 0;
  32 VAR_CHECK_SET_VARIABLE_CHECK_HANDLER    *mVarCheckHandlerTable = NULL;
  33
  34 typedef struct {
  35   EFI_GUID                      Guid;
  36   VAR_CHECK_VARIABLE_PROPERTY   VariableProperty;
  37   //CHAR16                        *Name;
  38 } VAR_CHECK_VARIABLE_ENTRY;
  39
  40 UINTN                                   mNumberOfVarCheckVariable = 0;
  41 UINTN                                   mMaxNumberOfVarCheckVariable = 0;
  42 VARIABLE_ENTRY_PROPERTY                 **mVarCheckVariableTable = NULL;
  43
  44 //
  45 // Handle variables with wildcard name specially.
  46 //
  47 VARIABLE_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 **/
 106 BOOLEAN
 107 EFIAPI
 108 VarCheckInternalIsHexaDecimalDigitCharacter (
 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 **/
 125 VAR_CHECK_VARIABLE_PROPERTY *
 126 VariablePropertyGetWithWildcardName (
 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 **/
 167 VAR_CHECK_VARIABLE_PROPERTY *
 168 VariablePropertyGetFunction (
 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 **/
 201 EFI_STATUS
 202 VarCheckAddTableEntry (
 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 **/
 260 EFI_STATUS
 261 EFIAPI
 262 VarCheckLibRegisterEndOfDxeCallback (
 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 **/
 300 VOID ***
 301 EFIAPI
 302 VarCheckLibInitializeAtEndOfDxe (
 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 **/
 392 EFI_STATUS
 393 EFIAPI
 394 VarCheckLibRegisterAddressPointer (
 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 **/
 434 EFI_STATUS
 435 EFIAPI
 436 VarCheckLibRegisterSetVariableCheckHandler (
 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 **/
 477 EFI_STATUS
 478 EFIAPI
 479 VarCheckLibVariablePropertySet (
 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 **/
 551 EFI_STATUS
 552 EFIAPI
 553 VarCheckLibVariablePropertyGet (
 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 **/
 600 EFI_STATUS
 601 EFIAPI
 602 VarCheckLibSetVariableCheck (
 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 (EFI_ERROR (Status)) {
 659       DEBUG ((EFI_D_INFO, "Variable Check handler fail %r - %g:%s\n", Status, VendorGuid, VariableName));
 660       return Status;
 661     }
 662   }
 663   return EFI_SUCCESS;
 664 }