MdeModulePkg/Universal/Variable/Pei/Variable.c

   1 /** @file
   2
   3   Implement ReadOnly Variable Services required by PEIM and install
   4   PEI ReadOnly Varaiable2 PPI. These services operates the non volatile storage space.
   5
   6 Copyright (c) 2006 - 2008 Intel Corporation. <BR>
   7 All rights reserved. This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14 Module Name:
  15
  16 **/
  17
  18
  19 #include "Variable.h"
  20
  21 //
  22 // Module globals
  23 //
  24 EFI_PEI_READ_ONLY_VARIABLE2_PPI mVariablePpi = {
  25   PeiGetVariable,
  26   PeiGetNextVariableName
  27 };
  28
  29 EFI_PEI_PPI_DESCRIPTOR     mPpiListVariable = {
  30   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  31   &gEfiPeiReadOnlyVariable2PpiGuid,
  32   &mVariablePpi
  33 };
  34
  35 EFI_GUID mEfiVariableIndexTableGuid = EFI_VARIABLE_INDEX_TABLE_GUID;
  36
  37
  38 /**
  39   Provide the functionality of the variable services.
  40
  41   @param  FileHandle   Handle of the file being invoked.
  42                        Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile().
  43   @param  PeiServices  General purpose services available to every PEIM.
  44
  45   @retval EFI_SUCCESS  If the interface could be successfully installed
  46   @retval Others       Returned from PeiServicesInstallPpi()
  47
  48 **/
  49 EFI_STATUS
  50 EFIAPI
  51 PeimInitializeVariableServices (
  52   IN       EFI_PEI_FILE_HANDLE       FileHandle,
  53   IN CONST EFI_PEI_SERVICES          **PeiServices
  54   )
  55 {
  56   EFI_BOOT_MODE BootMode;
  57   EFI_STATUS    Status;
  58
  59   //
  60   // Check if this is recovery boot path. If no, publish the variable access capability
  61   // to other modules. If yes, the content of variable area is not reliable. Therefore,
  62   // in this case we should not provide variable service to other pei modules.
  63   //
  64   Status = (*PeiServices)->GetBootMode (PeiServices, &BootMode);
  65   ASSERT_EFI_ERROR (Status);
  66
  67   if (BootMode == BOOT_IN_RECOVERY_MODE) {
  68     return EFI_UNSUPPORTED;
  69   }
  70
  71   return PeiServicesInstallPpi (&mPpiListVariable);
  72
  73 }
  74
  75 /**
  76
  77   Gets the pointer to the first variable header in given variable store area.
  78
  79   @param VarStoreHeader  Pointer to the Variable Store Header.
  80
  81   @return Pointer to the first variable header
  82
  83 **/
  84 VARIABLE_HEADER *
  85 GetStartPointer (
  86   IN VARIABLE_STORE_HEADER       *VarStoreHeader
  87   )
  88 {
  89   //
  90   // The end of variable store
  91   //
  92   return (VARIABLE_HEADER *) HEADER_ALIGN (VarStoreHeader + 1);
  93 }
  94
  95
  96 /**
  97   This code gets the pointer to the last variable memory pointer byte.
  98
  99   @param  VarStoreHeader  Pointer to the Variable Store Header.
 100
 101   @return VARIABLE_HEADER* pointer to last unavailable Variable Header.
 102
 103 **/
 104 VARIABLE_HEADER *
 105 GetEndPointer (
 106   IN VARIABLE_STORE_HEADER       *VarStoreHeader
 107   )
 108 {
 109   //
 110   // The end of variable store
 111   //
 112   return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);
 113 }
 114
 115
 116 /**
 117   This code checks if variable header is valid or not.
 118
 119   @param  Variable  Pointer to the Variable Header.
 120
 121   @retval TRUE      Variable header is valid.
 122   @retval FALSE     Variable header is not valid.
 123
 124 **/
 125 BOOLEAN
 126 IsValidVariableHeader (
 127   IN  VARIABLE_HEADER   *Variable
 128   )
 129 {
 130   if (Variable == NULL || Variable->StartId != VARIABLE_DATA ) {
 131     return FALSE;
 132   }
 133
 134   return TRUE;
 135 }
 136
 137
 138 /**
 139   This code gets the size of name of variable.
 140
 141   @param  Variable  Pointer to the Variable Header.
 142
 143   @return Size of variable in bytes in type UINTN.
 144
 145 **/
 146 UINTN
 147 NameSizeOfVariable (
 148   IN  VARIABLE_HEADER   *Variable
 149   )
 150 {
 151   if (Variable->State    == (UINT8) (-1) ||
 152       Variable->DataSize == (UINT32) (-1) ||
 153       Variable->NameSize == (UINT32) (-1) ||
 154       Variable->Attributes == (UINT32) (-1)) {
 155     return 0;
 156   }
 157   return (UINTN) Variable->NameSize;
 158 }
 159
 160
 161 /**
 162   This code gets the size of data of variable.
 163
 164   @param  Variable  Pointer to the Variable Header.
 165
 166   @return Size of variable in bytes in type UINTN.
 167
 168 **/
 169 UINTN
 170 DataSizeOfVariable (
 171   IN  VARIABLE_HEADER   *Variable
 172   )
 173 {
 174   if (Variable->State    == (UINT8)  (-1) ||
 175       Variable->DataSize == (UINT32) (-1) ||
 176       Variable->NameSize == (UINT32) (-1) ||
 177       Variable->Attributes == (UINT32) (-1)) {
 178     return 0;
 179   }
 180   return (UINTN) Variable->DataSize;
 181 }
 182
 183 /**
 184   This code gets the pointer to the variable name.
 185
 186   @param   Variable  Pointer to the Variable Header.
 187
 188   @return  A CHAR16* pointer to Variable Name.
 189
 190 **/
 191 CHAR16 *
 192 GetVariableNamePtr (
 193   IN  VARIABLE_HEADER   *Variable
 194   )
 195 {
 196
 197   return (CHAR16 *) (Variable + 1);
 198 }
 199
 200
 201 /**
 202   This code gets the pointer to the variable data.
 203
 204   @param   Variable  Pointer to the Variable Header.
 205
 206   @return  A UINT8* pointer to Variable Data.
 207
 208 **/
 209 UINT8 *
 210 GetVariableDataPtr (
 211   IN  VARIABLE_HEADER   *Variable
 212   )
 213 {
 214   UINTN Value;
 215
 216   //
 217   // Be careful about pad size for alignment
 218   //
 219   Value =  (UINTN) GetVariableNamePtr (Variable);
 220   Value += NameSizeOfVariable (Variable);
 221   Value += GET_PAD_SIZE (NameSizeOfVariable (Variable));
 222
 223   return (UINT8 *) Value;
 224 }
 225
 226
 227 /**
 228   This code gets the pointer to the next variable header.
 229
 230   @param  Variable  Pointer to the Variable Header.
 231
 232   @return  A VARIABLE_HEADER* pointer to next variable header.
 233
 234 **/
 235 VARIABLE_HEADER *
 236 GetNextVariablePtr (
 237   IN  VARIABLE_HEADER   *Variable
 238   )
 239 {
 240   UINTN Value;
 241
 242   if (!IsValidVariableHeader (Variable)) {
 243     return NULL;
 244   }
 245
 246   Value =  (UINTN) GetVariableDataPtr (Variable);
 247   Value += DataSizeOfVariable (Variable);
 248   Value += GET_PAD_SIZE (DataSizeOfVariable (Variable));
 249
 250   //
 251   // Be careful about pad size for alignment
 252   //
 253   return (VARIABLE_HEADER *) HEADER_ALIGN (Value);
 254 }
 255
 256 /**
 257   This code gets the pointer to the variable name.
 258
 259   @param  VarStoreHeader  Pointer to the Variable Store Header.
 260
 261   @retval  EfiRaw      Variable store is raw
 262   @retval  EfiValid    Variable store is valid
 263   @retval  EfiInvalid  Variable store is invalid
 264
 265 **/
 266 VARIABLE_STORE_STATUS
 267 GetVariableStoreStatus (
 268   IN VARIABLE_STORE_HEADER *VarStoreHeader
 269   )
 270 {
 271
 272   if (CompareGuid (&VarStoreHeader->Signature, &gEfiVariableGuid) &&
 273       VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
 274       VarStoreHeader->State == VARIABLE_STORE_HEALTHY
 275       ) {
 276
 277     return EfiValid;
 278   }
 279
 280   if (((UINT32 *)(&VarStoreHeader->Signature))[0] == 0xffffffff &&
 281       ((UINT32 *)(&VarStoreHeader->Signature))[1] == 0xffffffff &&
 282       ((UINT32 *)(&VarStoreHeader->Signature))[2] == 0xffffffff &&
 283       ((UINT32 *)(&VarStoreHeader->Signature))[3] == 0xffffffff &&
 284       VarStoreHeader->Size == 0xffffffff &&
 285       VarStoreHeader->Format == 0xff &&
 286       VarStoreHeader->State == 0xff
 287       ) {
 288
 289     return EfiRaw;
 290   } else {
 291     return EfiInvalid;
 292   }
 293 }
 294
 295
 296 /**
 297   This function compares a variable with variable entries in database.
 298
 299   @param  Variable      Pointer to the variable in our database
 300   @param  VariableName  Name of the variable to compare to 'Variable'
 301   @param  VendorGuid    GUID of the variable to compare to 'Variable'
 302   @param  PtrTrack      Variable Track Pointer structure that contains Variable Information.
 303
 304   @retval EFI_SUCCESS    Found match variable
 305   @retval EFI_NOT_FOUND  Variable not found
 306
 307 **/
 308 EFI_STATUS
 309 CompareWithValidVariable (
 310   IN  VARIABLE_HEADER               *Variable,
 311   IN  CONST CHAR16                  *VariableName,
 312   IN  CONST EFI_GUID                *VendorGuid,
 313   OUT VARIABLE_POINTER_TRACK        *PtrTrack
 314   )
 315 {
 316   VOID  *Point;
 317
 318   if (VariableName[0] == 0) {
 319     PtrTrack->CurrPtr = Variable;
 320     return EFI_SUCCESS;
 321   } else {
 322     //
 323     // Don't use CompareGuid function here for performance reasons.
 324     // Instead we compare the GUID a UINT32 at a time and branch
 325     // on the first failed comparison.
 326     //
 327     if ((((INT32 *) VendorGuid)[0] == ((INT32 *) &Variable->VendorGuid)[0]) &&
 328         (((INT32 *) VendorGuid)[1] == ((INT32 *) &Variable->VendorGuid)[1]) &&
 329         (((INT32 *) VendorGuid)[2] == ((INT32 *) &Variable->VendorGuid)[2]) &&
 330         (((INT32 *) VendorGuid)[3] == ((INT32 *) &Variable->VendorGuid)[3])
 331         ) {
 332       ASSERT (NameSizeOfVariable (Variable) != 0);
 333       Point = (VOID *) GetVariableNamePtr (Variable);
 334       if (CompareMem (VariableName, Point, NameSizeOfVariable (Variable)) == 0) {
 335         PtrTrack->CurrPtr = Variable;
 336         return EFI_SUCCESS;
 337       }
 338     }
 339   }
 340
 341   return EFI_NOT_FOUND;
 342 }
 343
 344
 345 /**
 346   This code finds variable in storage blocks (Non-Volatile).
 347
 348   @param  PeiServices   General purpose services available to every PEIM.
 349   @param  VariableName  Name of the variable to be found
 350   @param  VendorGuid    Vendor GUID to be found.
 351   @param  PtrTrack      Variable Track Pointer structure that contains Variable Information.
 352
 353   @retval  EFI_SUCCESS            Variable found successfully
 354   @retval  EFI_NOT_FOUND          Variable not found
 355   @retval  EFI_INVALID_PARAMETER  Invalid variable name
 356
 357 **/
 358 EFI_STATUS
 359 FindVariable (
 360   IN CONST EFI_PEI_SERVICES   **PeiServices,
 361   IN CONST  CHAR16            *VariableName,
 362   IN CONST  EFI_GUID          *VendorGuid,
 363   OUT VARIABLE_POINTER_TRACK  *PtrTrack
 364   )
 365 {
 366   EFI_HOB_GUID_TYPE       *GuidHob;
 367   VARIABLE_STORE_HEADER   *VariableStoreHeader;
 368   VARIABLE_HEADER         *Variable;
 369   VARIABLE_HEADER         *MaxIndex;
 370   VARIABLE_INDEX_TABLE    *IndexTable;
 371   UINT32                  Count;
 372   UINT8                   *VariableBase;
 373
 374   if (VariableName[0] != 0 && VendorGuid == NULL) {
 375     return EFI_INVALID_PARAMETER;
 376   }
 377   //
 378   // No Variable Address equals zero, so 0 as initial value is safe.
 379   //
 380   MaxIndex = 0;
 381
 382   GuidHob = GetFirstGuidHob (&mEfiVariableIndexTableGuid);
 383   if (GuidHob == NULL) {
 384     IndexTable = BuildGuidHob (&mEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));
 385     IndexTable->Length      = 0;
 386     IndexTable->StartPtr    = NULL;
 387     IndexTable->EndPtr      = NULL;
 388     IndexTable->GoneThrough = 0;
 389   } else {
 390     IndexTable = GET_GUID_HOB_DATA (GuidHob);
 391     for (Count = 0; Count < IndexTable->Length; Count++) {
 392       MaxIndex = GetVariableByIndex (IndexTable, Count);
 393
 394       if (CompareWithValidVariable (MaxIndex, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
 395         PtrTrack->StartPtr  = IndexTable->StartPtr;
 396         PtrTrack->EndPtr    = IndexTable->EndPtr;
 397
 398         return EFI_SUCCESS;
 399       }
 400     }
 401
 402     if (IndexTable->GoneThrough != 0) {
 403       return EFI_NOT_FOUND;
 404     }
 405   }
 406   //
 407   // If not found in HOB, then let's start from the MaxIndex we've found.
 408   //
 409   if (MaxIndex != NULL) {
 410     Variable = GetNextVariablePtr (MaxIndex);
 411   } else {
 412     if ((IndexTable->StartPtr != NULL) || (IndexTable->EndPtr != NULL)) {
 413       Variable = IndexTable->StartPtr;
 414     } else {
 415       VariableBase = (UINT8 *) (UINTN) PcdGet32 (PcdFlashNvStorageVariableBase);
 416       VariableStoreHeader = (VARIABLE_STORE_HEADER *) (VariableBase + \
 417                             ((EFI_FIRMWARE_VOLUME_HEADER *) (VariableBase)) -> HeaderLength);
 418
 419       if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {
 420         return EFI_UNSUPPORTED;
 421       }
 422
 423       if (~VariableStoreHeader->Size == 0) {
 424         return EFI_NOT_FOUND;
 425       }
 426       //
 427       // Find the variable by walk through non-volatile variable store
 428       //
 429       IndexTable->StartPtr  = GetStartPointer (VariableStoreHeader);
 430       IndexTable->EndPtr    = GetEndPointer (VariableStoreHeader);
 431
 432       //
 433       // Start Pointers for the variable.
 434       // Actual Data Pointer where data can be written.
 435       //
 436       Variable = IndexTable->StartPtr;
 437     }
 438   }
 439   //
 440   // Find the variable by walk through non-volatile variable store
 441   //
 442   PtrTrack->StartPtr  = IndexTable->StartPtr;
 443   PtrTrack->EndPtr    = IndexTable->EndPtr;
 444
 445   while (IsValidVariableHeader (Variable) && (Variable <= IndexTable->EndPtr)) {
 446     if (Variable->State == VAR_ADDED) {
 447       //
 448       // Record Variable in VariableIndex HOB
 449       //
 450       VariableIndexTableUpdate (IndexTable, Variable);
 451
 452       if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
 453         return EFI_SUCCESS;
 454       }
 455     }
 456
 457     Variable = GetNextVariablePtr (Variable);
 458   }
 459   //
 460   // If gone through the VariableStore, that means we never find in Firmware any more.
 461   //
 462   if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME) {
 463     IndexTable->GoneThrough = 1;
 464   }
 465
 466   PtrTrack->CurrPtr = NULL;
 467
 468   return EFI_NOT_FOUND;
 469 }
 470
 471 /**
 472   This service retrieves a variable's value using its name and GUID.
 473
 474   Read the specified variable from the UEFI variable store. If the Data
 475   buffer is too small to hold the contents of the variable, the error
 476   EFI_BUFFER_TOO_SMALL is returned and DataSize is set to the required buffer
 477   size to obtain the data.
 478
 479   @param  This                  A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
 480   @param  VariableName          A pointer to a null-terminated string that is the variable's name.
 481   @param  VariableGuid          A pointer to an EFI_GUID that is the variable's GUID. The combination of
 482                                 VariableGuid and VariableName must be unique.
 483   @param  Attributes            If non-NULL, on return, points to the variable's attributes.
 484   @param  DataSize              On entry, points to the size in bytes of the Data buffer.
 485                                 On return, points to the size of the data returned in Data.
 486   @param  Data                  Points to the buffer which will hold the returned variable value.
 487
 488   @retval EFI_SUCCESS           The variable was read successfully.
 489   @retval EFI_NOT_FOUND         The variable could not be found.
 490   @retval EFI_BUFFER_TOO_SMALL  The DataSize is too small for the resulting data.
 491                                 DataSize is updated with the size required for
 492                                 the specified variable.
 493   @retval EFI_INVALID_PARAMETER VariableName, VariableGuid, DataSize or Data is NULL.
 494   @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.
 495
 496 **/
 497 EFI_STATUS
 498 EFIAPI
 499 PeiGetVariable (
 500   IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
 501   IN CONST  CHAR16                          *VariableName,
 502   IN CONST  EFI_GUID                        *VariableGuid,
 503   OUT       UINT32                          *Attributes,
 504   IN OUT    UINTN                           *DataSize,
 505   OUT       VOID                            *Data
 506   )
 507 {
 508   VARIABLE_POINTER_TRACK  Variable;
 509   UINTN                   VarDataSize;
 510   EFI_STATUS              Status;
 511   CONST EFI_PEI_SERVICES  **PeiServices;
 512
 513   PeiServices = GetPeiServicesTablePointer ();
 514   if (VariableName == NULL || VariableGuid == NULL || DataSize == NULL) {
 515     return EFI_INVALID_PARAMETER;
 516   }
 517   //
 518   // Find existing variable
 519   //
 520   Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
 521   if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
 522     return Status;
 523   }
 524   //
 525   // Get data size
 526   //
 527   VarDataSize = DataSizeOfVariable (Variable.CurrPtr);
 528   if (*DataSize >= VarDataSize) {
 529     if (Data == NULL) {
 530       return EFI_INVALID_PARAMETER;
 531     }
 532
 533     CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
 534
 535     if (Attributes != NULL) {
 536       *Attributes = Variable.CurrPtr->Attributes;
 537     }
 538
 539     *DataSize = VarDataSize;
 540     return EFI_SUCCESS;
 541   } else {
 542     *DataSize = VarDataSize;
 543     return EFI_BUFFER_TOO_SMALL;
 544   }
 545 }
 546
 547 /**
 548   Return the next variable name and GUID.
 549
 550   This function is called multiple times to retrieve the VariableName
 551   and VariableGuid of all variables currently available in the system.
 552   On each call, the previous results are passed into the interface,
 553   and, on return, the interface returns the data for the next
 554   interface. When the entire variable list has been returned,
 555   EFI_NOT_FOUND is returned.
 556
 557   @param  This              A pointer to this instance of the EFI_PEI_READ_ONLY_VARIABLE2_PPI.
 558
 559   @param  VariableNameSize  On entry, points to the size of the buffer pointed to by VariableName.
 560   @param  VariableName      On entry, a pointer to a null-terminated string that is the variable's name.
 561                             On return, points to the next variable's null-terminated name string.
 562   @param  VariableGuid      On entry, a pointer to an UEFI _GUID that is the variable's GUID.
 563                             On return, a pointer to the next variable's GUID.
 564
 565   @retval EFI_SUCCESS           The variable was read successfully.
 566   @retval EFI_NOT_FOUND         The variable could not be found.
 567   @retval EFI_BUFFER_TOO_SMALL  The VariableNameSize is too small for the resulting
 568                                 data. VariableNameSize is updated with the size
 569                                 required for the specified variable.
 570   @retval EFI_INVALID_PARAMETER VariableName, VariableGuid or
 571                                 VariableNameSize is NULL.
 572   @retval EFI_DEVICE_ERROR      The variable could not be retrieved because of a device error.
 573
 574 **/
 575 EFI_STATUS
 576 EFIAPI
 577 PeiGetNextVariableName (
 578   IN CONST  EFI_PEI_READ_ONLY_VARIABLE2_PPI *This,
 579   IN OUT UINTN                              *VariableNameSize,
 580   IN OUT CHAR16                             *VariableName,
 581   IN OUT EFI_GUID                           *VariableGuid
 582   )
 583 {
 584   VARIABLE_POINTER_TRACK  Variable;
 585   UINTN                   VarNameSize;
 586   EFI_STATUS              Status;
 587   CONST EFI_PEI_SERVICES  **PeiServices;
 588
 589   PeiServices = GetPeiServicesTablePointer ();
 590   if (VariableName == NULL || VariableGuid == NULL || VariableNameSize == NULL) {
 591     return EFI_INVALID_PARAMETER;
 592   }
 593
 594   Status = FindVariable (PeiServices, VariableName, VariableGuid, &Variable);
 595   if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
 596     return Status;
 597   }
 598
 599   if (VariableName[0] != 0) {
 600     //
 601     // If variable name is not NULL, get next variable
 602     //
 603     Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
 604   }
 605
 606   while (!(Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL)) {
 607     if (IsValidVariableHeader (Variable.CurrPtr)) {
 608       if (Variable.CurrPtr->State == VAR_ADDED) {
 609         ASSERT (NameSizeOfVariable (Variable.CurrPtr) != 0);
 610
 611         VarNameSize = (UINTN) NameSizeOfVariable (Variable.CurrPtr);
 612         if (VarNameSize <= *VariableNameSize) {
 613           CopyMem (VariableName, GetVariableNamePtr (Variable.CurrPtr), VarNameSize);
 614
 615           CopyMem (VariableGuid, &Variable.CurrPtr->VendorGuid, sizeof (EFI_GUID));
 616
 617           Status = EFI_SUCCESS;
 618         } else {
 619           Status = EFI_BUFFER_TOO_SMALL;
 620         }
 621
 622         *VariableNameSize = VarNameSize;
 623         return Status;
 624         //
 625         // Variable is found
 626         //
 627       } else {
 628         Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
 629       }
 630     } else {
 631       break;
 632     }
 633   }
 634
 635   return EFI_NOT_FOUND;
 636 }