X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;ds=sidebyside;f=MdeModulePkg%2FUniversal%2FVariable%2FEmuRuntimeDxe%2FEmuVariable.c;h=f17dab03b02130b2a35c2eb11c18c9012403511c;hb=e4ddc008868b38f0a7945f5e0a3c026fa02a72e0;hp=158e396963dd837ae393fbd6f60225b38ee656e8;hpb=504214c4870e9183418014634268ce630eb5332a;p=mirror_edk2.git diff --git a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c index 158e396963..f17dab03b0 100644 --- a/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c +++ b/MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariable.c @@ -16,17 +16,25 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. #include "Variable.h" -// -// Don't use module globals after the SetVirtualAddress map is signaled -// +/// +/// Don't use module globals after the SetVirtualAddress map is signaled +/// ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal; -// -// This is a temperary function which will be removed -// when EfiAcquireLock in UefiLib can handle the -// the call in UEFI Runtimer driver in RT phase. -// -STATIC +VARIABLE_INFO_ENTRY *gVariableInfo = NULL; + +/** + Acquires lock only at boot time. Simply returns at runtime. + + This is a temperary function which will be removed when + EfiAcquireLock() in UefiLib can handle the call in UEFI + Runtimer driver in RT phase. + It calls EfiAcquireLock() at boot time, and simply returns + at runtime + + @param Lock A pointer to the lock to acquire + +**/ VOID AcquireLockOnlyAtBootTime ( IN EFI_LOCK *Lock @@ -37,12 +45,18 @@ AcquireLockOnlyAtBootTime ( } } -// -// This is a temperary function which will be removed -// when EfiAcquireLock in UefiLib can handle the -// the call in UEFI Runtimer driver in RT phase. -// -STATIC +/** + Releases lock only at boot time. Simply returns at runtime. + + This is a temperary function which will be removed when + EfiReleaseLock() in UefiLib can handle the call in UEFI + Runtimer driver in RT phase. + It calls EfiReleaseLock() at boot time, and simply returns + at runtime + + @param Lock A pointer to the lock to release + +**/ VOID ReleaseLockOnlyAtBootTime ( IN EFI_LOCK *Lock @@ -53,26 +67,21 @@ ReleaseLockOnlyAtBootTime ( } } -STATIC -UINT8 * -GetVariableDataPtr ( - IN VARIABLE_HEADER *Variable - ) -/*++ - -Routine Description: - - This code gets the pointer to the variable data. +/** + Gets pointer to the variable data. -Arguments: + This function gets the pointer to the variable data according + to the input pointer to the variable header. - Variable Pointer to the Variable Header. + @param Variable Pointer to the variable header. -Returns: + @return Pointer to variable data - UINT8* Pointer to Variable Data - ---*/ +**/ +UINT8 * +GetVariableDataPtr ( + IN VARIABLE_HEADER *Variable + ) { if (Variable->StartId != VARIABLE_DATA) { return NULL; @@ -83,26 +92,21 @@ Returns: return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize)); } -STATIC -VARIABLE_HEADER * -GetNextVariablePtr ( - IN VARIABLE_HEADER *Variable - ) -/*++ - -Routine Description: - - This code gets the pointer to the next variable header. - -Arguments: +/** + Gets pointer to header of the next variable. - Variable Pointer to the Variable Header. + This function gets the pointer to the next variable header according + to the input point to the variable header. -Returns: + @param Variable Pointer to header of the next variable - VARIABLE_HEADER* Pointer to next variable header. + @return Pointer to next variable header. ---*/ +**/ +VARIABLE_HEADER * +GetNextVariablePtr ( + IN VARIABLE_HEADER *Variable + ) { VARIABLE_HEADER *VarHeader; @@ -115,7 +119,7 @@ Returns: VarHeader = (VARIABLE_HEADER *) (GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize)); if (VarHeader->StartId != VARIABLE_DATA || - (sizeof (VARIABLE_HEADER) + VarHeader->DataSize + VarHeader->NameSize) > MAX_VARIABLE_SIZE + (sizeof (VARIABLE_HEADER) + VarHeader->DataSize + VarHeader->NameSize) > FixedPcdGet32(PcdMaxVariableSize) ) { return NULL; } @@ -123,26 +127,21 @@ Returns: return VarHeader; } -STATIC -VARIABLE_HEADER * -GetEndPointer ( - IN VARIABLE_STORE_HEADER *VolHeader - ) -/*++ +/** + Gets pointer to the end of the variable storage area. -Routine Description: + This function gets pointer to the end of the variable storage + area, according to the input variable store header. - This code gets the pointer to the last variable memory pointer byte + @param VolHeader Pointer to the variale store header -Arguments: + @return Pointer to the end of the variable storage area. - Variable Pointer to the Variable Header. - -Returns: - - VARIABLE_HEADER* Pointer to last unavailable Variable Header - ---*/ +**/ +VARIABLE_HEADER * +GetEndPointer ( + IN VARIABLE_STORE_HEADER *VolHeader + ) { // // The end of variable store @@ -150,34 +149,132 @@ Returns: return (VARIABLE_HEADER *) ((UINTN) VolHeader + VolHeader->Size); } -STATIC -EFI_STATUS -FindVariable ( +/** + Routine used to track statistical information about variable usage. + The data is stored in the EFI system table so it can be accessed later. + VariableInfo.efi can dump out the table. Only Boot Services variable + accesses are tracked by this code. The PcdVariableCollectStatistics + build flag controls if this feature is enabled. + + A read that hits in the cache will have Read and Cache true for + the transaction. Data is allocated by this routine, but never + freed. + + @param[in] VariableName Name of the Variable to track + @param[in] VendorGuid Guid of the Variable to track + @param[in] Volatile TRUE if volatile FALSE if non-volatile + @param[in] Read TRUE if GetVariable() was called + @param[in] Write TRUE if SetVariable() was called + @param[in] Delete TRUE if deleted via SetVariable() + @param[in] Cache TRUE for a cache hit. + +**/ +VOID +UpdateVariableInfo ( IN CHAR16 *VariableName, IN EFI_GUID *VendorGuid, - OUT VARIABLE_POINTER_TRACK *PtrTrack, - IN VARIABLE_GLOBAL *Global + IN BOOLEAN Volatile, + IN BOOLEAN Read, + IN BOOLEAN Write, + IN BOOLEAN Delete, + IN BOOLEAN Cache ) -/*++ +{ + VARIABLE_INFO_ENTRY *Entry; + + if (FeaturePcdGet (PcdVariableCollectStatistics)) { + + if (EfiAtRuntime ()) { + // Don't collect statistics at runtime + return; + } + + if (gVariableInfo == NULL) { + // + // on the first call allocate a entry and place a pointer to it in + // the EFI System Table + // + gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY)); + ASSERT (gVariableInfo != NULL); + + CopyGuid (&gVariableInfo->VendorGuid, VendorGuid); + gVariableInfo->Name = AllocatePool (StrLen (VariableName)); + ASSERT (gVariableInfo->Name != NULL); + StrCpy (gVariableInfo->Name, VariableName); + gVariableInfo->Volatile = Volatile; + + gBS->InstallConfigurationTable (&gEfiVariableGuid, gVariableInfo); + } + + + for (Entry = gVariableInfo; Entry != NULL; Entry = Entry->Next) { + if (CompareGuid (VendorGuid, &Entry->VendorGuid)) { + if (StrCmp (VariableName, Entry->Name) == 0) { + if (Read) { + Entry->ReadCount++; + } + if (Write) { + Entry->WriteCount++; + } + if (Delete) { + Entry->DeleteCount++; + } + if (Cache) { + Entry->CacheCount++; + } -Routine Description: + return; + } + } + + if (Entry->Next == NULL) { + // + // If the entry is not in the table add it. + // Next iteration of the loop will fill in the data + // + Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY)); + ASSERT (Entry->Next != NULL); + + CopyGuid (&Entry->Next->VendorGuid, VendorGuid); + Entry->Next->Name = AllocatePool (StrLen (VariableName)); + ASSERT (Entry->Next->Name != NULL); + StrCpy (Entry->Next->Name, VariableName); + Entry->Next->Volatile = Volatile; + } - This code finds variable in storage blocks (Volatile or Non-Volatile) + } + } +} -Arguments: +/** + Finds variable in storage blocks of volatile and non-volatile storage areas. - VariableName Name of the variable to be found - VendorGuid Vendor GUID to be found. - PtrTrack Variable Track Pointer structure that contains - Variable Information. - Contains the pointer of Variable header. - Global VARIABLE_GLOBAL pointer + This code finds variable in storage blocks of volatile and non-volatile storage areas. + If VariableName is an empty string, then we just return the first + qualified variable without comparing VariableName and VendorGuid. + Otherwise, VariableName and VendorGuid are compared. -Returns: + @param VariableName Name of the variable to be found. + @param VendorGuid Vendor GUID to be found. + @param PtrTrack VARIABLE_POINTER_TRACK structure for output, + including the range searched and the target position. + @param Global Pointer to VARIABLE_GLOBAL structure, including + base of volatile variable storage area, base of + NV variable storage area, and a lock. - EFI STATUS + @retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while + VendorGuid is NULL. + @retval EFI_SUCCESS Variable successfully found. + @retval EFI_NOT_FOUND Variable not found. ---*/ +**/ +EFI_STATUS +FindVariable ( + IN CHAR16 *VariableName, + IN EFI_GUID *VendorGuid, + OUT VARIABLE_POINTER_TRACK *PtrTrack, + IN VARIABLE_GLOBAL *Global + ) { VARIABLE_HEADER *Variable[2]; VARIABLE_STORE_HEADER *VariableStoreHeader[2]; @@ -215,14 +312,14 @@ Returns: while ((Variable[Index] != NULL) && (Variable[Index] <= GetEndPointer (VariableStoreHeader[Index]))) { if (Variable[Index]->StartId == VARIABLE_DATA && Variable[Index]->State == VAR_ADDED) { - if (!(EfiAtRuntime () && !(Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) { + if (!(EfiAtRuntime () && ((Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0))) { if (VariableName[0] == 0) { PtrTrack->CurrPtr = Variable[Index]; PtrTrack->Volatile = (BOOLEAN) Index; return EFI_SUCCESS; } else { if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) { - if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize)) { + if (CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize) == 0) { PtrTrack->CurrPtr = Variable[Index]; PtrTrack->Volatile = (BOOLEAN) Index; return EFI_SUCCESS; @@ -239,6 +336,28 @@ Returns: return EFI_NOT_FOUND; } +/** + This code finds variable in storage blocks (Volatile or Non-Volatile). + + @param VariableName A Null-terminated Unicode string that is the name of + the vendor's variable. + @param VendorGuid A unique identifier for the vendor. + @param Attributes If not NULL, a pointer to the memory location to return the + attributes bitmask for the variable. + @param DataSize Size of Data found. If size is less than the + data, this value contains the required size. + @param Data On input, the size in bytes of the return Data buffer. + On output, the size of data returned in Data. + @param Global Pointer to VARIABLE_GLOBAL structure + @param Instance Instance of the Firmware Volume. + + @retval EFI_SUCCESS The function completed successfully. + @retval EFI_NOT_FOUND The variable was not found. + @retval EFI_BUFFER_TOO_SMALL DataSize is too small for the result. DataSize has + been updated with the size needed to complete the request. + @retval EFI_INVALID_PARAMETER VariableName or VendorGuid or DataSize is NULL. + +**/ EFI_STATUS EFIAPI GetVariable ( @@ -250,32 +369,6 @@ GetVariable ( IN VARIABLE_GLOBAL * Global, IN UINT32 Instance ) -/*++ - -Routine Description: - - This code finds variable in storage blocks (Volatile or Non-Volatile) - -Arguments: - - VariableName Name of Variable to be found - VendorGuid Variable vendor GUID - Attributes OPTIONAL Attribute value of the variable found - DataSize Size of Data found. If size is less than the - data, this value contains the required size. - Data Data pointer - Global Pointer to VARIABLE_GLOBAL structure - Instance Instance of the Firmware Volume. - -Returns: - - EFI_INVALID_PARAMETER - Invalid parameter - EFI_SUCCESS - Find the specified variable - EFI_NOT_FOUND - Not found - EFI_BUFFER_TO_SMALL - DataSize is too small for the result - - ---*/ { VARIABLE_POINTER_TRACK Variable; UINTN VarDataSize; @@ -308,6 +401,7 @@ Returns: } *DataSize = VarDataSize; + UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, TRUE, FALSE, FALSE, FALSE); Status = EFI_SUCCESS; goto Done; } else { @@ -321,6 +415,25 @@ Done: return Status; } +/** + + This code Finds the Next available variable. + + @param VariableNameSize Size of the variable. + @param VariableName On input, supplies the last VariableName that was returned by GetNextVariableName(). + On output, returns the Null-terminated Unicode string of the current variable. + @param VendorGuid On input, supplies the last VendorGuid that was returned by GetNextVariableName(). + On output, returns the VendorGuid of the current variable. + @param Global Pointer to VARIABLE_GLOBAL structure. + @param Instance Instance of the Firmware Volume. + + @retval EFI_SUCCESS The function completed successfully. + @retval EFI_NOT_FOUND The next variable was not found. + @retval EFI_BUFFER_TOO_SMALL VariableNameSize is too small for the result. + VariableNameSize has been updated with the size needed to complete the request. + @retval EFI_INVALID_PARAMETER VariableNameSize or VariableName or VendorGuid is NULL. + +**/ EFI_STATUS EFIAPI GetNextVariableName ( @@ -330,25 +443,6 @@ GetNextVariableName ( IN VARIABLE_GLOBAL *Global, IN UINT32 Instance ) -/*++ - -Routine Description: - - This code Finds the Next available variable - -Arguments: - - VariableNameSize Size of the variable - VariableName Pointer to variable name - VendorGuid Variable Vendor Guid - Global VARIABLE_GLOBAL structure pointer. - Instance FV instance - -Returns: - - EFI STATUS - ---*/ { VARIABLE_POINTER_TRACK Variable; UINTN VarNameSize; @@ -394,7 +488,7 @@ Returns: // Variable is found // if (Variable.CurrPtr->StartId == VARIABLE_DATA && Variable.CurrPtr->State == VAR_ADDED) { - if (!(EfiAtRuntime () && !(Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) { + if (!(EfiAtRuntime () && ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0))) { VarNameSize = Variable.CurrPtr->NameSize; if (VarNameSize <= *VariableNameSize) { CopyMem ( @@ -424,6 +518,36 @@ Done: } +/** + + This code sets variable in storage blocks (Volatile or Non-Volatile). + + @param VariableName A Null-terminated Unicode string that is the name of the vendor's + variable. Each VariableName is unique for each + VendorGuid. VariableName must contain 1 or more + Unicode characters. If VariableName is an empty Unicode + string, then EFI_INVALID_PARAMETER is returned. + @param VendorGuid A unique identifier for the vendor + @param Attributes Attributes bitmask to set for the variable + @param DataSize The size in bytes of the Data buffer. A size of zero causes the + variable to be deleted. + @param Data The contents for the variable + @param Global Pointer to VARIABLE_GLOBAL structure + @param VolatileOffset The offset of last volatile variable + @param NonVolatileOffset The offset of last non-volatile variable + @param Instance Instance of the Firmware Volume. + + @retval EFI_SUCCESS The firmware has successfully stored the variable and its data as + defined by the Attributes. + @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits was supplied, or the + DataSize exceeds the maximum allowed, or VariableName is an empty + Unicode string, or VendorGuid is NULL. + @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data. + @retval EFI_DEVICE_ERROR The variable could not be saved due to a hardware failure. + @retval EFI_WRITE_PROTECTED The variable in question is read-only or cannot be deleted. + @retval EFI_NOT_FOUND The variable trying to be updated or deleted was not found. + +**/ EFI_STATUS EFIAPI SetVariable ( @@ -437,35 +561,6 @@ SetVariable ( IN UINTN *NonVolatileOffset, IN UINT32 Instance ) -/*++ - -Routine Description: - - This code sets variable in storage blocks (Volatile or Non-Volatile) - -Arguments: - - VariableName Name of Variable to be found - VendorGuid Variable vendor GUID - Attributes Attribute value of the variable found - DataSize Size of Data found. If size is less than the - data, this value contains the required size. - Data Data pointer - Global Pointer to VARIABLE_GLOBAL structure - VolatileOffset The offset of last volatile variable - NonVolatileOffset The offset of last non-volatile variable - Instance Instance of the Firmware Volume. - -Returns: - - EFI_INVALID_PARAMETER - Invalid parameter - EFI_SUCCESS - Set successfully - EFI_OUT_OF_RESOURCES - Resource not enough to set variable - EFI_NOT_FOUND - Not found - EFI_DEVICE_ERROR - Variable can not be saved due to hardware failure - EFI_WRITE_PROTECTED - Variable is read-only - ---*/ { VARIABLE_POINTER_TRACK Variable; EFI_STATUS Status; @@ -489,21 +584,21 @@ Returns: } // // The size of the VariableName, including the Unicode Null in bytes plus - // the DataSize is limited to maximum size of MAX_HARDWARE_ERROR_VARIABLE_SIZE (32K) - // bytes for HwErrRec, and MAX_VARIABLE_SIZE (1024) bytes for the others. + // the DataSize is limited to maximum size of FixedPcdGet32(PcdMaxHardwareErrorVariableSize) + // bytes for HwErrRec, and FixedPcdGet32(PcdMaxVariableSize) bytes for the others. // if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) { - if ((DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE) || - (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_HARDWARE_ERROR_VARIABLE_SIZE)) { + if ((DataSize > FixedPcdGet32(PcdMaxHardwareErrorVariableSize)) || + (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > FixedPcdGet32(PcdMaxHardwareErrorVariableSize))) { return EFI_INVALID_PARAMETER; } } else { // // The size of the VariableName, including the Unicode Null in bytes plus - // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes. + // the DataSize is limited to maximum size of FixedPcdGet32(PcdMaxVariableSize) bytes. // - if ((DataSize > MAX_VARIABLE_SIZE) || - (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_VARIABLE_SIZE)) { + if ((DataSize > FixedPcdGet32(PcdMaxVariableSize)) || + (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > FixedPcdGet32(PcdMaxVariableSize))) { return EFI_INVALID_PARAMETER; } } @@ -531,7 +626,7 @@ Returns: // // Only variable have NV attribute can be updated/deleted in Runtime // - if (!(Variable.CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE)) { + if ((Variable.CurrPtr->Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) { Status = EFI_INVALID_PARAMETER; goto Done; } @@ -543,6 +638,7 @@ Returns: // if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) { Variable.CurrPtr->State &= VAR_DELETED; + UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, FALSE, FALSE, TRUE, FALSE); Status = EFI_SUCCESS; goto Done; } @@ -552,7 +648,7 @@ Returns: // then return to the caller immediately. // if (Variable.CurrPtr->DataSize == DataSize && - !CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize) + CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize) == 0 ) { Status = EFI_SUCCESS; goto Done; @@ -581,7 +677,7 @@ Returns: // Only variable have NV|RT attribute can be created in Runtime // if (EfiAtRuntime () && - (!(Attributes & EFI_VARIABLE_RUNTIME_ACCESS) || !(Attributes & EFI_VARIABLE_NON_VOLATILE))) { + (((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0) || ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0))) { Status = EFI_INVALID_PARAMETER; goto Done; } @@ -603,7 +699,7 @@ Returns: VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize); VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize); - if (Attributes & EFI_VARIABLE_NON_VOLATILE) { + if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) { if ((UINT32) (VarSize +*NonVolatileOffset) > ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size ) { @@ -657,12 +753,36 @@ Returns: Variable.CurrPtr->State &= VAR_DELETED; } + UpdateVariableInfo (VariableName, VendorGuid, Variable.Volatile, FALSE, TRUE, FALSE, FALSE); + Status = EFI_SUCCESS; Done: ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock); return Status; } +/** + + This code returns information about the EFI variables. + + @param Attributes Attributes bitmask to specify the type of variables + on which to return information. + @param MaximumVariableStorageSize On output the maximum size of the storage space available for + the EFI variables associated with the attributes specified. + @param RemainingVariableStorageSize Returns the remaining size of the storage space available for EFI + variables associated with the attributes specified. + @param MaximumVariableSize Returns the maximum size of an individual EFI variable + associated with the attributes specified. + @param Global Pointer to VARIABLE_GLOBAL structure. + @param Instance Instance of the Firmware Volume. + + @retval EFI_SUCCESS Valid answer returned. + @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits was supplied + @retval EFI_UNSUPPORTED The attribute is not supported on this platform, and the + MaximumVariableStorageSize, RemainingVariableStorageSize, + MaximumVariableSize are undefined. + +**/ EFI_STATUS EFIAPI QueryVariableInfo ( @@ -673,33 +793,6 @@ QueryVariableInfo ( IN VARIABLE_GLOBAL *Global, IN UINT32 Instance ) -/*++ - -Routine Description: - - This code returns information about the EFI variables. - -Arguments: - - Attributes Attributes bitmask to specify the type of variables - on which to return information. - MaximumVariableStorageSize Pointer to the maximum size of the storage space available - for the EFI variables associated with the attributes specified. - RemainingVariableStorageSize Pointer to the remaining size of the storage space available - for EFI variables associated with the attributes specified. - MaximumVariableSize Pointer to the maximum size of an individual EFI variables - associated with the attributes specified. - Global Pointer to VARIABLE_GLOBAL structure. - Instance Instance of the Firmware Volume. - -Returns: - - EFI STATUS - EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied. - EFI_SUCCESS - Query successfully. - EFI_UNSUPPORTED - The attribute is not supported on this platform. - ---*/ { VARIABLE_HEADER *Variable; VARIABLE_HEADER *NextVariable; @@ -720,7 +813,7 @@ Returns: // Make sure if runtime bit is set, boot service bit is set also. // return EFI_INVALID_PARAMETER; - } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) { + } else if (EfiAtRuntime () && ((Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) { // // Make sure RT Attribute is set if we are in Runtime phase. // @@ -749,15 +842,15 @@ Returns: *RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER); // - // Let *MaximumVariableSize be MAX_VARIABLE_SIZE with the exception of the variable header size. + // Let *MaximumVariableSize be FixedPcdGet32(PcdMaxVariableSize) with the exception of the variable header size. // - *MaximumVariableSize = MAX_VARIABLE_SIZE - sizeof (VARIABLE_HEADER); + *MaximumVariableSize = FixedPcdGet32(PcdMaxVariableSize) - sizeof (VARIABLE_HEADER); // // Harware error record variable needs larger size. // if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD) { - *MaximumVariableSize = MAX_HARDWARE_ERROR_VARIABLE_SIZE - sizeof (VARIABLE_HEADER); + *MaximumVariableSize = FixedPcdGet32(PcdMaxHardwareErrorVariableSize) - sizeof (VARIABLE_HEADER); } // @@ -796,22 +889,20 @@ Returns: return EFI_SUCCESS; } -STATIC +/** + Initializes variable store area. + + This function allocates memory space for variable store area and initializes its attributes. + + @param VariableBase Base of the variable store area created + @param LastVariableOffset Size of VARIABLE_STORE_HEADER + +**/ EFI_STATUS InitializeVariableStore ( OUT EFI_PHYSICAL_ADDRESS *VariableBase, OUT UINTN *LastVariableOffset ) -/*++ - -Routine Description: - This function initializes variable store - -Arguments: - -Returns: - ---*/ { VARIABLE_STORE_HEADER *VariableStore; @@ -819,13 +910,13 @@ Returns: // Allocate memory for volatile variable store // VariableStore = (VARIABLE_STORE_HEADER *) AllocateRuntimePool ( - VARIABLE_STORE_SIZE + FixedPcdGet32(PcdVariableStoreSize) ); if (NULL == VariableStore) { return EFI_OUT_OF_RESOURCES; } - SetMem (VariableStore, VARIABLE_STORE_SIZE, 0xff); + SetMem (VariableStore, FixedPcdGet32(PcdVariableStoreSize), 0xff); // // Variable Specific Data @@ -833,8 +924,8 @@ Returns: *VariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStore; *LastVariableOffset = sizeof (VARIABLE_STORE_HEADER); - VariableStore->Signature = VARIABLE_STORE_SIGNATURE; - VariableStore->Size = VARIABLE_STORE_SIZE; + CopyGuid (&VariableStore->Signature, &gEfiVariableGuid); + VariableStore->Size = FixedPcdGet32(PcdVariableStoreSize); VariableStore->Format = VARIABLE_STORE_FORMATTED; VariableStore->State = VARIABLE_STORE_HEALTHY; VariableStore->Reserved = 0; @@ -843,22 +934,25 @@ Returns: return EFI_SUCCESS; } +/** + Initializes variable store area for non-volatile and volatile variable. + + This function allocates and initializes memory space for global context of ESAL + variable service and variable store area for non-volatile and volatile variable. + + @param ImageHandle The Image handle of this driver. + @param SystemTable The pointer of EFI_SYSTEM_TABLE. + + @retval EFI_SUCCESS Function successfully executed. + @retval EFI_OUT_OF_RESOURCES Fail to allocate enough memory resource. + +**/ EFI_STATUS EFIAPI VariableCommonInitialize ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) -/*++ - -Routine Description: - This function does common initialization for variable services - -Arguments: - -Returns: - ---*/ { EFI_STATUS Status;