+++ /dev/null
-/*++\r
-\r
-Copyright (c) 2006 - 2007, Intel Corporation\r
-All rights reserved. This program and the accompanying materials\r
-are licensed and made available under the terms and conditions of the BSD License\r
-which accompanies this distribution. The full text of the license may be found at\r
-http://opensource.org/licenses/bsd-license.php\r
-\r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-Module Name:\r
-\r
- Variable.c\r
-\r
-Abstract:\r
-\r
-Revision History\r
-\r
---*/\r
-\r
-#include "Variable.h"\r
-#include "reclaim.h"\r
-\r
-//\r
-// Don't use module globals after the SetVirtualAddress map is signaled\r
-//\r
-ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;\r
-\r
-//\r
-// This is a temperary function which will be removed\r
-// when EfiAcquireLock in UefiLib can handle the\r
-// the call in UEFI Runtimer driver in RT phase.\r
-//\r
-STATIC\r
-VOID\r
-AcquireLockOnlyAtBootTime (\r
- IN EFI_LOCK *Lock\r
- )\r
-{\r
- if (!EfiAtRuntime ()) {\r
- EfiAcquireLock (Lock);\r
- }\r
-}\r
-\r
-//\r
-// This is a temperary function which will be removed\r
-// when EfiAcquireLock in UefiLib can handle the\r
-// the call in UEFI Runtimer driver in RT phase.\r
-//\r
-STATIC\r
-VOID\r
-ReleaseLockOnlyAtBootTime (\r
- IN EFI_LOCK *Lock\r
- )\r
-{\r
- if (!EfiAtRuntime ()) {\r
- EfiReleaseLock (Lock);\r
- }\r
-}\r
-\r
-STATIC\r
-BOOLEAN\r
-EFIAPI\r
-IsValidVariableHeader (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code checks if variable header is valid or not.\r
-\r
-Arguments:\r
- Variable Pointer to the Variable Header.\r
-\r
-Returns:\r
- TRUE Variable header is valid.\r
- FALSE Variable header is not valid.\r
-\r
---*/\r
-{\r
- if (Variable == NULL ||\r
- Variable->StartId != VARIABLE_DATA ||\r
- (sizeof (VARIABLE_HEADER) + Variable->NameSize + Variable->DataSize) > MAX_VARIABLE_SIZE\r
- ) {\r
- return FALSE;\r
- }\r
-\r
- return TRUE;\r
-}\r
-\r
-STATIC\r
-EFI_STATUS\r
-EFIAPI\r
-UpdateVariableStore (\r
- IN VARIABLE_GLOBAL *Global,\r
- IN BOOLEAN Volatile,\r
- IN BOOLEAN SetByIndex,\r
- IN UINTN Instance,\r
- IN UINTN DataPtrIndex,\r
- IN UINT32 DataSize,\r
- IN UINT8 *Buffer\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This function writes data to the FWH at the correct LBA even if the LBAs\r
- are fragmented.\r
-\r
-Arguments:\r
-\r
- Global Pointer to VARAIBLE_GLOBAL structure\r
- Volatile If the Variable is Volatile or Non-Volatile\r
- SetByIndex TRUE: Target pointer is given as index\r
- FALSE: Target pointer is absolute\r
- Instance Instance of FV Block services\r
- DataPtrIndex Pointer to the Data from the end of VARIABLE_STORE_HEADER\r
- structure\r
- DataSize Size of data to be written.\r
- Buffer Pointer to the buffer from which data is written\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
-\r
---*/\r
-{\r
- EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;\r
- UINTN BlockIndex2;\r
- UINTN LinearOffset;\r
- UINTN CurrWriteSize;\r
- UINTN CurrWritePtr;\r
- UINT8 *CurrBuffer;\r
- EFI_LBA LbaNumber;\r
- UINTN Size;\r
- EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
- VARIABLE_STORE_HEADER *VolatileBase;\r
- EFI_PHYSICAL_ADDRESS FvVolHdr;\r
- EFI_PHYSICAL_ADDRESS DataPtr;\r
- EFI_STATUS Status;\r
-\r
- FwVolHeader = NULL;\r
- DataPtr = DataPtrIndex;\r
-\r
- //\r
- // Check if the Data is Volatile\r
- //\r
- if (!Volatile) {\r
- EfiFvbGetPhysicalAddress (Instance, &FvVolHdr);\r
- FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);\r
- //\r
- // Data Pointer should point to the actual Address where data is to be\r
- // written\r
- //\r
- if (SetByIndex) {\r
- DataPtr += Global->NonVolatileVariableBase;\r
- }\r
-\r
- if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
- } else {\r
- //\r
- // Data Pointer should point to the actual Address where data is to be\r
- // written\r
- //\r
- VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);\r
- if (SetByIndex) {\r
- DataPtr += Global->VolatileVariableBase;\r
- }\r
-\r
- if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
- }\r
- //\r
- // If Volatile Variable just do a simple mem copy.\r
- //\r
- if (Volatile) {\r
- CopyMem ((UINT8 *) ((UINTN) DataPtr), Buffer, DataSize);\r
- return EFI_SUCCESS;\r
- }\r
- //\r
- // If we are here we are dealing with Non-Volatile Variables\r
- //\r
- LinearOffset = (UINTN) FwVolHeader;\r
- CurrWritePtr = (UINTN) DataPtr;\r
- CurrWriteSize = DataSize;\r
- CurrBuffer = Buffer;\r
- LbaNumber = 0;\r
-\r
- if (CurrWritePtr < LinearOffset) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- for (PtrBlockMapEntry = FwVolHeader->FvBlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {\r
- for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {\r
- //\r
- // Check to see if the Variable Writes are spanning through multiple\r
- // blocks.\r
- //\r
- if ((CurrWritePtr >= LinearOffset) && (CurrWritePtr < LinearOffset + PtrBlockMapEntry->BlockLength)) {\r
- if ((CurrWritePtr + CurrWriteSize) <= (LinearOffset + PtrBlockMapEntry->BlockLength)) {\r
- Status = EfiFvbWriteBlock (\r
- Instance,\r
- LbaNumber,\r
- (UINTN) (CurrWritePtr - LinearOffset),\r
- &CurrWriteSize,\r
- CurrBuffer\r
- );\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
- } else {\r
- Size = (UINT32) (LinearOffset + PtrBlockMapEntry->BlockLength - CurrWritePtr);\r
- Status = EfiFvbWriteBlock (\r
- Instance,\r
- LbaNumber,\r
- (UINTN) (CurrWritePtr - LinearOffset),\r
- &Size,\r
- CurrBuffer\r
- );\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- CurrWritePtr = LinearOffset + PtrBlockMapEntry->BlockLength;\r
- CurrBuffer = CurrBuffer + Size;\r
- CurrWriteSize = CurrWriteSize - Size;\r
- }\r
- }\r
-\r
- LinearOffset += PtrBlockMapEntry->BlockLength;\r
- LbaNumber++;\r
- }\r
- }\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
-STATIC\r
-VARIABLE_STORE_STATUS\r
-EFIAPI\r
-GetVariableStoreStatus (\r
- IN VARIABLE_STORE_HEADER *VarStoreHeader\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code gets the current status of Variable Store.\r
-\r
-Arguments:\r
-\r
- VarStoreHeader Pointer to the Variable Store Header.\r
-\r
-Returns:\r
-\r
- EfiRaw Variable store status is raw\r
- EfiValid Variable store status is valid\r
- EfiInvalid Variable store status is invalid\r
-\r
---*/\r
-{\r
- if (VarStoreHeader->Signature == VARIABLE_STORE_SIGNATURE &&\r
- VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&\r
- VarStoreHeader->State == VARIABLE_STORE_HEALTHY\r
- ) {\r
-\r
- return EfiValid;\r
- } else if (VarStoreHeader->Signature == 0xffffffff &&\r
- VarStoreHeader->Size == 0xffffffff &&\r
- VarStoreHeader->Format == 0xff &&\r
- VarStoreHeader->State == 0xff\r
- ) {\r
-\r
- return EfiRaw;\r
- } else {\r
- return EfiInvalid;\r
- }\r
-}\r
-\r
-STATIC\r
-UINT8 *\r
-EFIAPI\r
-GetVariableDataPtr (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code gets the pointer to the variable data.\r
-\r
-Arguments:\r
-\r
- Variable Pointer to the Variable Header.\r
-\r
-Returns:\r
-\r
- UINT8* Pointer to Variable Data\r
-\r
---*/\r
-{\r
- //\r
- // Be careful about pad size for alignment\r
- //\r
- return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));\r
-}\r
-\r
-STATIC\r
-VARIABLE_HEADER *\r
-EFIAPI\r
-GetNextVariablePtr (\r
- IN VARIABLE_HEADER *Variable\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code gets the pointer to the next variable header.\r
-\r
-Arguments:\r
-\r
- Variable Pointer to the Variable Header.\r
-\r
-Returns:\r
-\r
- VARIABLE_HEADER* Pointer to next variable header.\r
-\r
---*/\r
-{\r
- if (!IsValidVariableHeader (Variable)) {\r
- return NULL;\r
- }\r
- //\r
- // Be careful about pad size for alignment\r
- //\r
- return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));\r
-}\r
-\r
-STATIC\r
-VARIABLE_HEADER *\r
-EFIAPI\r
-GetEndPointer (\r
- IN VARIABLE_STORE_HEADER *VarStoreHeader\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code gets the pointer to the last variable memory pointer byte\r
-\r
-Arguments:\r
-\r
- VarStoreHeader Pointer to the Variable Store Header.\r
-\r
-Returns:\r
-\r
- VARIABLE_HEADER* Pointer to last unavailable Variable Header\r
-\r
---*/\r
-{\r
- //\r
- // The end of variable store\r
- //\r
- return (VARIABLE_HEADER *) ((UINTN) VarStoreHeader + VarStoreHeader->Size);\r
-}\r
-\r
-STATIC\r
-EFI_STATUS\r
-EFIAPI\r
-Reclaim (\r
- IN EFI_PHYSICAL_ADDRESS VariableBase,\r
- OUT UINTN *LastVariableOffset,\r
- IN BOOLEAN IsVolatile\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Variable store garbage collection and reclaim operation\r
-\r
-Arguments:\r
-\r
- VariableBase Base address of variable store\r
- LastVariableOffset Offset of last variable\r
- IsVolatile The variable store is volatile or not,\r
- if it is non-volatile, need FTW\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
-\r
---*/\r
-{\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *NextVariable;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- UINT8 *ValidBuffer;\r
- UINTN ValidBufferSize;\r
- UINTN VariableSize;\r
- UINT8 *CurrPtr;\r
- EFI_STATUS Status;\r
-\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);\r
-\r
- //\r
- // Start Pointers for the variable.\r
- //\r
- Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);\r
-\r
- ValidBufferSize = sizeof (VARIABLE_STORE_HEADER);\r
-\r
- while (IsValidVariableHeader (Variable)) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- if (Variable->State == VAR_ADDED) {\r
- VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
- ValidBufferSize += VariableSize;\r
- }\r
-\r
- Variable = NextVariable;\r
- }\r
-\r
- ValidBuffer = AllocatePool (ValidBufferSize);\r
- if (ValidBuffer == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- SetMem (ValidBuffer, ValidBufferSize, 0xff);\r
-\r
- CurrPtr = ValidBuffer;\r
-\r
- //\r
- // Copy variable store header\r
- //\r
- CopyMem (CurrPtr, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));\r
- CurrPtr += sizeof (VARIABLE_STORE_HEADER);\r
-\r
- //\r
- // Start Pointers for the variable.\r
- //\r
- Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);\r
-\r
- while (IsValidVariableHeader (Variable)) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- if (Variable->State == VAR_ADDED) {\r
- VariableSize = (UINTN) NextVariable - (UINTN) Variable;\r
- CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);\r
- CurrPtr += VariableSize;\r
- }\r
-\r
- Variable = NextVariable;\r
- }\r
-\r
- if (IsVolatile) {\r
- //\r
- // If volatile variable store, just copy valid buffer\r
- //\r
- SetMem ((UINT8 *) (UINTN) VariableBase, VariableStoreHeader->Size, 0xff);\r
- CopyMem ((UINT8 *) (UINTN) VariableBase, ValidBuffer, ValidBufferSize);\r
- *LastVariableOffset = ValidBufferSize;\r
- Status = EFI_SUCCESS;\r
- } else {\r
- //\r
- // If non-volatile variable store, perform FTW here.\r
- //\r
- Status = FtwVariableSpace (\r
- VariableBase,\r
- ValidBuffer,\r
- ValidBufferSize\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- *LastVariableOffset = ValidBufferSize;\r
- }\r
- }\r
-\r
- FreePool (ValidBuffer);\r
-\r
- if (EFI_ERROR (Status)) {\r
- *LastVariableOffset = 0;\r
- }\r
-\r
- return Status;\r
-}\r
-\r
-STATIC\r
-EFI_STATUS\r
-EFIAPI\r
-FindVariable (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- OUT VARIABLE_POINTER_TRACK *PtrTrack,\r
- IN VARIABLE_GLOBAL *Global\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code finds variable in storage blocks (Volatile or Non-Volatile)\r
-\r
-Arguments:\r
-\r
- VariableName Name of the variable to be found\r
- VendorGuid Vendor GUID to be found.\r
- PtrTrack Variable Track Pointer structure that contains\r
- Variable Information.\r
- Contains the pointer of Variable header.\r
- Global VARIABLE_GLOBAL pointer\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
-\r
---*/\r
-{\r
- VARIABLE_HEADER *Variable[2];\r
- VARIABLE_STORE_HEADER *VariableStoreHeader[2];\r
- UINTN Index;\r
-\r
- //\r
- // We aquire the lock at the entry of FindVariable as GetVariable, GetNextVariableName\r
- // SetVariable all call FindVariable at entry point. Please move "Aquire Lock" to\r
- // the correct places if this assumption does not hold TRUE anymore.\r
- //\r
- AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);\r
-\r
- //\r
- // 0: Non-Volatile, 1: Volatile\r
- //\r
- VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);\r
- VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);\r
-\r
- //\r
- // Start Pointers for the variable.\r
- // Actual Data Pointer where data can be written.\r
- //\r
- Variable[0] = (VARIABLE_HEADER *) (VariableStoreHeader[0] + 1);\r
- Variable[1] = (VARIABLE_HEADER *) (VariableStoreHeader[1] + 1);\r
-\r
- if (VariableName[0] != 0 && VendorGuid == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
- //\r
- // Find the variable by walk through non-volatile and volatile variable store\r
- //\r
- for (Index = 0; Index < 2; Index++) {\r
- PtrTrack->StartPtr = (VARIABLE_HEADER *) (VariableStoreHeader[Index] + 1);\r
- PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);\r
-\r
- while (IsValidVariableHeader (Variable[Index]) && (Variable[Index] <= GetEndPointer (VariableStoreHeader[Index]))) {\r
- if (Variable[Index]->State == VAR_ADDED) {\r
- if (!(EfiAtRuntime () && !(Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {\r
- if (VariableName[0] == 0) {\r
- PtrTrack->CurrPtr = Variable[Index];\r
- PtrTrack->Volatile = (BOOLEAN) Index;\r
- return EFI_SUCCESS;\r
- } else {\r
- if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {\r
- if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize)) {\r
- PtrTrack->CurrPtr = Variable[Index];\r
- PtrTrack->Volatile = (BOOLEAN) Index;\r
- return EFI_SUCCESS;\r
- }\r
- }\r
- }\r
- }\r
- }\r
-\r
- Variable[Index] = GetNextVariablePtr (Variable[Index]);\r
- }\r
- //\r
- // While (...)\r
- //\r
- }\r
- //\r
- // for (...)\r
- //\r
- PtrTrack->CurrPtr = NULL;\r
- return EFI_NOT_FOUND;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-GetVariable (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID * VendorGuid,\r
- OUT UINT32 *Attributes OPTIONAL,\r
- IN OUT UINTN *DataSize,\r
- OUT VOID *Data,\r
- IN VARIABLE_GLOBAL * Global,\r
- IN UINT32 Instance\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code finds variable in storage blocks (Volatile or Non-Volatile)\r
-\r
-Arguments:\r
-\r
- VariableName Name of Variable to be found\r
- VendorGuid Variable vendor GUID\r
- Attributes OPTIONAL Attribute value of the variable found\r
- DataSize Size of Data found. If size is less than the\r
- data, this value contains the required size.\r
- Data Data pointer\r
- Global Pointer to VARIABLE_GLOBAL structure\r
- Instance Instance of the Firmware Volume.\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
-\r
---*/\r
-{\r
- VARIABLE_POINTER_TRACK Variable;\r
- UINTN VarDataSize;\r
- EFI_STATUS Status;\r
-\r
- if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
- //\r
- // Find existing variable\r
- //\r
- Status = FindVariable (VariableName, VendorGuid, &Variable, Global);\r
-\r
- if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // Get data size\r
- //\r
- VarDataSize = Variable.CurrPtr->DataSize;\r
- if (*DataSize >= VarDataSize) {\r
- if (Data == NULL) {\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- }\r
-\r
- CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);\r
- if (Attributes != NULL) {\r
- *Attributes = Variable.CurrPtr->Attributes;\r
- }\r
-\r
- *DataSize = VarDataSize;\r
- Status = EFI_SUCCESS;\r
- goto Done;\r
- } else {\r
- *DataSize = VarDataSize;\r
- Status = EFI_BUFFER_TOO_SMALL;\r
- goto Done;\r
- }\r
-\r
-Done:\r
- ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-GetNextVariableName (\r
- IN OUT UINTN *VariableNameSize,\r
- IN OUT CHAR16 *VariableName,\r
- IN OUT EFI_GUID *VendorGuid,\r
- IN VARIABLE_GLOBAL *Global,\r
- IN UINT32 Instance\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code Finds the Next available variable\r
-\r
-Arguments:\r
-\r
- VariableNameSize Size of the variable\r
- VariableName Pointer to variable name\r
- VendorGuid Variable Vendor Guid\r
- Global VARIABLE_GLOBAL structure pointer.\r
- Instance FV instance\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
-\r
---*/\r
-{\r
- VARIABLE_POINTER_TRACK Variable;\r
- UINTN VarNameSize;\r
- EFI_STATUS Status;\r
-\r
- if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- Status = FindVariable (VariableName, VendorGuid, &Variable, Global);\r
-\r
- if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
-\r
- if (VariableName[0] != 0) {\r
- //\r
- // If variable name is not NULL, get next variable\r
- //\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
- }\r
-\r
- while (TRUE) {\r
- //\r
- // If both volatile and non-volatile variable store are parsed,\r
- // return not found\r
- //\r
- if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {\r
- Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));\r
- if (Variable.Volatile) {\r
- Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (Global->VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));\r
- Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase));\r
- } else {\r
- Status = EFI_NOT_FOUND;\r
- goto Done;\r
- }\r
-\r
- Variable.CurrPtr = Variable.StartPtr;\r
- if (!IsValidVariableHeader (Variable.CurrPtr)) {\r
- continue;\r
- }\r
- }\r
- //\r
- // Variable is found\r
- //\r
- if (IsValidVariableHeader (Variable.CurrPtr) && Variable.CurrPtr->State == VAR_ADDED) {\r
- if (!(EfiAtRuntime () && !(Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {\r
- VarNameSize = Variable.CurrPtr->NameSize;\r
- if (VarNameSize <= *VariableNameSize) {\r
- CopyMem (\r
- VariableName,\r
- GET_VARIABLE_NAME_PTR (Variable.CurrPtr),\r
- VarNameSize\r
- );\r
- CopyMem (\r
- VendorGuid,\r
- &Variable.CurrPtr->VendorGuid,\r
- sizeof (EFI_GUID)\r
- );\r
- Status = EFI_SUCCESS;\r
- } else {\r
- Status = EFI_BUFFER_TOO_SMALL;\r
- }\r
-\r
- *VariableNameSize = VarNameSize;\r
- goto Done;\r
- }\r
- }\r
-\r
- Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);\r
- }\r
-\r
-Done:\r
- ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-SetVariable (\r
- IN CHAR16 *VariableName,\r
- IN EFI_GUID *VendorGuid,\r
- IN UINT32 Attributes,\r
- IN UINTN DataSize,\r
- IN VOID *Data,\r
- IN VARIABLE_GLOBAL *Global,\r
- IN UINTN *VolatileOffset,\r
- IN UINTN *NonVolatileOffset,\r
- IN UINT32 Instance\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code sets variable in storage blocks (Volatile or Non-Volatile)\r
-\r
-Arguments:\r
-\r
- VariableName Name of Variable to be found\r
- VendorGuid Variable vendor GUID\r
- Attributes Attribute value of the variable found\r
- DataSize Size of Data found. If size is less than the\r
- data, this value contains the required size.\r
- Data Data pointer\r
- Global Pointer to VARIABLE_GLOBAL structure\r
- VolatileOffset The offset of last volatile variable\r
- NonVolatileOffset The offset of last non-volatile variable\r
- Instance Instance of the Firmware Volume.\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
- EFI_INVALID_PARAMETER - Invalid parameter\r
- EFI_SUCCESS - Set successfully\r
- EFI_OUT_OF_RESOURCES - Resource not enough to set variable\r
- EFI_NOT_FOUND - Not found\r
-\r
---*/\r
-{\r
- VARIABLE_POINTER_TRACK Variable;\r
- EFI_STATUS Status;\r
- VARIABLE_HEADER *NextVariable;\r
- UINTN VarNameSize;\r
- UINTN VarNameOffset;\r
- UINTN VarDataOffset;\r
- UINTN VarSize;\r
- UINT8 State;\r
- BOOLEAN Reclaimed;\r
-\r
- Reclaimed = FALSE;\r
-\r
- if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- Status = FindVariable (VariableName, VendorGuid, &Variable, Global);\r
-\r
- if (Status == EFI_INVALID_PARAMETER) {\r
- goto Done;\r
- } else if (!EFI_ERROR (Status) && Variable.Volatile && EfiAtRuntime()) {\r
- //\r
- // If EfiAtRuntime and the variable is Volatile and Runtime Access,\r
- // the volatile is ReadOnly, and SetVariable should be aborted and\r
- // return EFI_WRITE_PROTECTED.\r
- //\r
- Status = EFI_WRITE_PROTECTED;\r
- goto Done;\r
- } else if (sizeof (VARIABLE_HEADER) + StrSize (VariableName) + DataSize > MAX_VARIABLE_SIZE) {\r
- //\r
- // The size of the VariableName, including the Unicode Null in bytes plus\r
- // the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.\r
- //\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- } else if (Attributes == EFI_VARIABLE_NON_VOLATILE) {\r
- //\r
- // Make sure not only EFI_VARIABLE_NON_VOLATILE is set\r
- //\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) ==\r
- EFI_VARIABLE_RUNTIME_ACCESS) {\r
- //\r
- // Make sure if runtime bit is set, boot service bit is set also\r
- //\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- } else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {\r
- //\r
- // Runtime but Attribute is not Runtime\r
- //\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- } else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_NON_VOLATILE)) {\r
- //\r
- // Cannot set volatile variable in Runtime\r
- //\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- } else if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {\r
- //\r
- // Setting a data variable with no access, or zero DataSize attributes\r
- // specified causes it to be deleted.\r
- //\r
- if (!EFI_ERROR (Status)) {\r
- State = Variable.CurrPtr->State;\r
- State &= VAR_DELETED;\r
-\r
- Status = UpdateVariableStore (\r
- Global,\r
- Variable.Volatile,\r
- FALSE,\r
- Instance,\r
- (UINTN) &Variable.CurrPtr->State,\r
- sizeof (UINT8),\r
- &State\r
- );\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
-\r
- Status = EFI_SUCCESS;\r
- goto Done;\r
- }\r
-\r
- Status = EFI_NOT_FOUND;\r
- goto Done;\r
- } else {\r
- if (!EFI_ERROR (Status)) {\r
- //\r
- // If the variable is marked valid and the same data has been passed in\r
- // then return to the caller immediately.\r
- //\r
- if (Variable.CurrPtr->DataSize == DataSize &&\r
- !CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize)\r
- ) {\r
- Status = EFI_SUCCESS;\r
- goto Done;\r
- } else if (Variable.CurrPtr->State == VAR_ADDED) {\r
- //\r
- // Mark the old variable as in delete transition\r
- //\r
- State = Variable.CurrPtr->State;\r
- State &= VAR_IN_DELETED_TRANSITION;\r
-\r
- Status = UpdateVariableStore (\r
- Global,\r
- Variable.Volatile,\r
- FALSE,\r
- Instance,\r
- (UINTN) &Variable.CurrPtr->State,\r
- sizeof (UINT8),\r
- &State\r
- );\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- }\r
- }\r
- //\r
- // Create a new variable and copy the data.\r
- //\r
- // Tricky part: Use scratch data area at the end of volatile variable store\r
- // as a temporary storage.\r
- //\r
- NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase));\r
-\r
- SetMem (NextVariable, SCRATCH_SIZE, 0xff);\r
-\r
- NextVariable->StartId = VARIABLE_DATA;\r
- NextVariable->Attributes = Attributes;\r
- //\r
- // NextVariable->State = VAR_ADDED;\r
- //\r
- NextVariable->Reserved = 0;\r
- VarNameOffset = sizeof (VARIABLE_HEADER);\r
- VarNameSize = StrSize (VariableName);\r
- CopyMem (\r
- (UINT8 *) ((UINTN) NextVariable + VarNameOffset),\r
- VariableName,\r
- VarNameSize\r
- );\r
- VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);\r
- CopyMem (\r
- (UINT8 *) ((UINTN) NextVariable + VarDataOffset),\r
- Data,\r
- DataSize\r
- );\r
- CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));\r
- //\r
- // There will be pad bytes after Data, the NextVariable->NameSize and\r
- // NextVariable->DataSize should not include pad size so that variable\r
- // service can get actual size in GetVariable\r
- //\r
- NextVariable->NameSize = (UINT32)VarNameSize;\r
- NextVariable->DataSize = (UINT32)DataSize;\r
-\r
- //\r
- // The actual size of the variable that stores in storage should\r
- // include pad size.\r
- //\r
- VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);\r
- if (Attributes & EFI_VARIABLE_NON_VOLATILE) {\r
- if ((UINT32) (VarSize +*NonVolatileOffset) >\r
- ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size\r
- ) {\r
- if (EfiAtRuntime ()) {\r
- Status = EFI_OUT_OF_RESOURCES;\r
- goto Done;\r
- }\r
- //\r
- // Perform garbage collection & reclaim operation\r
- //\r
- Status = Reclaim (Global->NonVolatileVariableBase, NonVolatileOffset, FALSE);\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // If still no enough space, return out of resources\r
- //\r
- if ((UINT32) (VarSize +*NonVolatileOffset) >\r
- ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size\r
- ) {\r
- Status = EFI_OUT_OF_RESOURCES;\r
- goto Done;\r
- }\r
-\r
- Reclaimed = TRUE;\r
- }\r
- //\r
- // Three steps\r
- // 1. Write variable header\r
- // 2. Write variable data\r
- // 3. Set variable state to valid\r
- //\r
- //\r
- // Step 1:\r
- //\r
- Status = UpdateVariableStore (\r
- Global,\r
- FALSE,\r
- TRUE,\r
- Instance,\r
- *NonVolatileOffset,\r
- sizeof (VARIABLE_HEADER),\r
- (UINT8 *) NextVariable\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // Step 2:\r
- //\r
- Status = UpdateVariableStore (\r
- Global,\r
- FALSE,\r
- TRUE,\r
- Instance,\r
- *NonVolatileOffset + sizeof (VARIABLE_HEADER),\r
- (UINT32) VarSize - sizeof (VARIABLE_HEADER),\r
- (UINT8 *) NextVariable + sizeof (VARIABLE_HEADER)\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // Step 3:\r
- //\r
- NextVariable->State = VAR_ADDED;\r
- Status = UpdateVariableStore (\r
- Global,\r
- FALSE,\r
- TRUE,\r
- Instance,\r
- *NonVolatileOffset,\r
- sizeof (VARIABLE_HEADER),\r
- (UINT8 *) NextVariable\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
-\r
- *NonVolatileOffset = *NonVolatileOffset + VarSize;\r
-\r
- } else {\r
- if (EfiAtRuntime ()) {\r
- Status = EFI_INVALID_PARAMETER;\r
- goto Done;\r
- }\r
-\r
- if ((UINT32) (VarSize +*VolatileOffset) >\r
- ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size\r
- ) {\r
- //\r
- // Perform garbage collection & reclaim operation\r
- //\r
- Status = Reclaim (Global->VolatileVariableBase, VolatileOffset, TRUE);\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- //\r
- // If still no enough space, return out of resources\r
- //\r
- if ((UINT32) (VarSize +*VolatileOffset) >\r
- ((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size\r
- ) {\r
- Status = EFI_OUT_OF_RESOURCES;\r
- goto Done;\r
- }\r
-\r
- Reclaimed = TRUE;\r
- }\r
-\r
- NextVariable->State = VAR_ADDED;\r
- Status = UpdateVariableStore (\r
- Global,\r
- TRUE,\r
- TRUE,\r
- Instance,\r
- *VolatileOffset,\r
- (UINT32) VarSize,\r
- (UINT8 *) NextVariable\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
-\r
- *VolatileOffset = *VolatileOffset + VarSize;\r
- }\r
- //\r
- // Mark the old variable as deleted\r
- //\r
- if (!Reclaimed && !EFI_ERROR (Status) && Variable.CurrPtr != NULL) {\r
- State = Variable.CurrPtr->State;\r
- State &= VAR_DELETED;\r
-\r
- Status = UpdateVariableStore (\r
- Global,\r
- Variable.Volatile,\r
- FALSE,\r
- Instance,\r
- (UINTN) &Variable.CurrPtr->State,\r
- sizeof (UINT8),\r
- &State\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
- }\r
- }\r
- }\r
-\r
- Status = EFI_SUCCESS;\r
-Done:\r
- ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);\r
- return Status;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-QueryVariableInfo (\r
- IN UINT32 Attributes,\r
- OUT UINT64 *MaximumVariableStorageSize,\r
- OUT UINT64 *RemainingVariableStorageSize,\r
- OUT UINT64 *MaximumVariableSize,\r
- IN VARIABLE_GLOBAL *Global,\r
- IN UINT32 Instance\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This code returns information about the EFI variables.\r
-\r
-Arguments:\r
-\r
- Attributes Attributes bitmask to specify the type of variables\r
- on which to return information.\r
- MaximumVariableStorageSize Pointer to the maximum size of the storage space available\r
- for the EFI variables associated with the attributes specified.\r
- RemainingVariableStorageSize Pointer to the remaining size of the storage space available\r
- for the EFI variables associated with the attributes specified.\r
- MaximumVariableSize Pointer to the maximum size of the individual EFI variables\r
- associated with the attributes specified.\r
- Global Pointer to VARIABLE_GLOBAL structure.\r
- Instance Instance of the Firmware Volume.\r
-\r
-Returns:\r
-\r
- EFI STATUS\r
- EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.\r
- EFI_SUCCESS - Query successfully.\r
- EFI_UNSUPPORTED - The attribute is not supported on this platform.\r
-\r
---*/\r
-{\r
- VARIABLE_HEADER *Variable;\r
- VARIABLE_HEADER *NextVariable;\r
- UINT64 VariableSize;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
-\r
- if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)) == 0) {\r
- //\r
- // Make sure the Attributes combination is supported by the platform.\r
- //\r
- return EFI_UNSUPPORTED;\r
- } else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {\r
- //\r
- // Make sure if runtime bit is set, boot service bit is set also.\r
- //\r
- return EFI_INVALID_PARAMETER;\r
- } else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {\r
- //\r
- // Make sure RT Attribute is set if we are in Runtime phase.\r
- //\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);\r
-\r
- if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {\r
- //\r
- // Query is Volatile related.\r
- //\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);\r
- } else {\r
- //\r
- // Query is Non-Volatile related.\r
- //\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);\r
- }\r
-\r
- //\r
- // Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize\r
- // with the storage size (excluding the storage header size).\r
- //\r
- *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);\r
- *RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);\r
-\r
- //\r
- // Let *MaximumVariableSize be MAX_VARIABLE_SIZE.\r
- //\r
- *MaximumVariableSize = MAX_VARIABLE_SIZE;\r
-\r
- //\r
- // Point to the starting address of the variables.\r
- //\r
- Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);\r
-\r
- //\r
- // Now walk through the related variable store.\r
- //\r
- while (IsValidVariableHeader (Variable) && (Variable < GetEndPointer (VariableStoreHeader))) {\r
- NextVariable = GetNextVariablePtr (Variable);\r
- VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;\r
-\r
- if (EfiAtRuntime ()) {\r
- //\r
- // we don't take the state of the variables in mind\r
- // when calculating RemainingVariableStorageSize,\r
- // since the space occupied by variables not marked with\r
- // VAR_ADDED is not allowed to be reclaimed in Runtime.\r
- //\r
- *RemainingVariableStorageSize -= VariableSize;\r
- } else {\r
- //\r
- // Only care about Variables with State VAR_ADDED,because\r
- // the space not marked as VAR_ADDED is reclaimable now.\r
- //\r
- if (Variable->State == VAR_ADDED) {\r
- *RemainingVariableStorageSize -= VariableSize;\r
- }\r
- }\r
-\r
- //\r
- // Go to the next one\r
- //\r
- Variable = NextVariable;\r
- }\r
-\r
- ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);\r
- return EFI_SUCCESS;\r
-}\r
-\r
-EFI_STATUS\r
-EFIAPI\r
-VariableCommonInitialize (\r
- IN EFI_HANDLE ImageHandle,\r
- IN EFI_SYSTEM_TABLE *SystemTable\r
- )\r
-/*++\r
-\r
-Routine Description:\r
- This function does common initialization for variable services\r
-\r
-Arguments:\r
-\r
- ImageHandle - The firmware allocated handle for the EFI image.\r
- SystemTable - A pointer to the EFI System Table.\r
-\r
-Returns:\r
-\r
- Status code.\r
-\r
- EFI_NOT_FOUND - Variable store area not found.\r
- EFI_UNSUPPORTED - Currently only one non-volatile variable store is supported.\r
- EFI_SUCCESS - Variable services successfully initialized.\r
-\r
---*/\r
-{\r
- EFI_STATUS Status;\r
- EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;\r
- CHAR8 *CurrPtr;\r
- VARIABLE_STORE_HEADER *VolatileVariableStore;\r
- VARIABLE_STORE_HEADER *VariableStoreHeader;\r
- VARIABLE_HEADER *NextVariable;\r
- UINT32 Instance;\r
- EFI_PHYSICAL_ADDRESS FvVolHdr;\r
-\r
- UINT64 TempVariableStoreHeader;\r
-\r
- EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;\r
- EFI_FLASH_SUBAREA_ENTRY VariableStoreEntry;\r
- UINT64 BaseAddress;\r
- UINT64 Length;\r
- UINTN Index;\r
- UINT8 Data;\r
-\r
- mVariableModuleGlobal = AllocateRuntimePool (sizeof (ESAL_VARIABLE_GLOBAL));\r
- if (mVariableModuleGlobal == NULL) {\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal[Physical].VariableServicesLock, TPL_NOTIFY);\r
-\r
- //\r
- // Allocate memory for volatile variable store\r
- //\r
- VolatileVariableStore = AllocateRuntimePool (VARIABLE_STORE_SIZE + SCRATCH_SIZE);\r
- if (VolatileVariableStore == NULL) {\r
- FreePool (mVariableModuleGlobal);\r
- return EFI_OUT_OF_RESOURCES;\r
- }\r
-\r
- SetMem (VolatileVariableStore, VARIABLE_STORE_SIZE + SCRATCH_SIZE, 0xff);\r
-\r
- //\r
- // Variable Specific Data\r
- //\r
- mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;\r
- mVariableModuleGlobal->VolatileLastVariableOffset = sizeof (VARIABLE_STORE_HEADER);\r
-\r
- VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE;\r
- VolatileVariableStore->Size = VARIABLE_STORE_SIZE;\r
- VolatileVariableStore->Format = VARIABLE_STORE_FORMATTED;\r
- VolatileVariableStore->State = VARIABLE_STORE_HEALTHY;\r
- VolatileVariableStore->Reserved = 0;\r
- VolatileVariableStore->Reserved1 = 0;\r
-\r
- //\r
- // Get non volatile varaible store\r
- //\r
-\r
- TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase);\r
- VariableStoreEntry.Base = TempVariableStoreHeader + \\r
- (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);\r
- VariableStoreEntry.Length = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \\r
- (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);\r
- //\r
- // Mark the variable storage region of the FLASH as RUNTIME\r
- //\r
- BaseAddress = VariableStoreEntry.Base & (~EFI_PAGE_MASK);\r
- Length = VariableStoreEntry.Length + (VariableStoreEntry.Base - BaseAddress);\r
- Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);\r
-\r
- Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);\r
- if (EFI_ERROR (Status)) {\r
- FreePool (mVariableModuleGlobal);\r
- FreePool (VolatileVariableStore);\r
- return EFI_UNSUPPORTED;\r
- }\r
-\r
- Status = gDS->SetMemorySpaceAttributes (\r
- BaseAddress,\r
- Length,\r
- GcdDescriptor.Attributes | EFI_MEMORY_RUNTIME\r
- );\r
- if (EFI_ERROR (Status)) {\r
- FreePool (mVariableModuleGlobal);\r
- FreePool (VolatileVariableStore);\r
- return EFI_UNSUPPORTED;\r
- }\r
- //\r
- // Get address of non volatile variable store base\r
- //\r
- mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase = VariableStoreEntry.Base;\r
-\r
- //\r
- // Check Integrity\r
- //\r
- //\r
- // Find the Correct Instance of the FV Block Service.\r
- //\r
- Instance = 0;\r
- CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase);\r
- while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) {\r
- FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);\r
- if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) {\r
- mVariableModuleGlobal->FvbInstance = Instance;\r
- break;\r
- }\r
-\r
- Instance++;\r
- }\r
-\r
- VariableStoreHeader = (VARIABLE_STORE_HEADER *) CurrPtr;\r
- if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {\r
- if (~VariableStoreHeader->Size == 0) {\r
- Status = UpdateVariableStore (\r
- &mVariableModuleGlobal->VariableGlobal[Physical],\r
- FALSE,\r
- FALSE,\r
- mVariableModuleGlobal->FvbInstance,\r
- (UINTN) &VariableStoreHeader->Size,\r
- sizeof (UINT32),\r
- (UINT8 *) &VariableStoreEntry.Length\r
- );\r
- // \r
- // As Variables are stored in NV storage, which are slow devices,such as flash.\r
- // Variable operation may skip checking variable program result to improve performance,\r
- // We can assume Variable program is OK through some check point.\r
- // Variable Store Size Setting should be the first Variable write operation,\r
- // We can assume all Read/Write is OK if we can set Variable store size successfully.\r
- // If write fail, we will assert here\r
- //\r
- ASSERT(VariableStoreHeader->Size == VariableStoreEntry.Length);\r
-\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
- }\r
-\r
- mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) CurrPtr);\r
- //\r
- // Parse non-volatile variable data and get last variable offset\r
- //\r
- NextVariable = (VARIABLE_HEADER *) (CurrPtr + sizeof (VARIABLE_STORE_HEADER));\r
- Status = EFI_SUCCESS;\r
-\r
- while (IsValidVariableHeader (NextVariable)) {\r
- NextVariable = GetNextVariablePtr (NextVariable);\r
- }\r
-\r
- mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable - (UINTN) CurrPtr;\r
-\r
- //\r
- // Check if the free area is blow a threshold\r
- //\r
- if ((((VARIABLE_STORE_HEADER *)((UINTN) CurrPtr))->Size - mVariableModuleGlobal->NonVolatileLastVariableOffset) < VARIABLE_RECLAIM_THRESHOLD) {\r
- Status = Reclaim (\r
- mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase,\r
- &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
- FALSE\r
- );\r
- }\r
-\r
- if (EFI_ERROR (Status)) {\r
- FreePool (mVariableModuleGlobal);\r
- FreePool (VolatileVariableStore);\r
- return Status;\r
- }\r
-\r
- //\r
- // Check if the free area is really free.\r
- //\r
- for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) {\r
- Data = ((UINT8 *) (UINTN) mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase)[Index];\r
- if (Data != 0xff) {\r
- //\r
- // There must be something wrong in variable store, do reclaim operation.\r
- //\r
- Status = Reclaim (\r
- mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase,\r
- &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
- FALSE\r
- );\r
- break;\r
- }\r
- }\r
- }\r
-\r
- if (EFI_ERROR (Status)) {\r
- FreePool (mVariableModuleGlobal);\r
- FreePool (VolatileVariableStore);\r
- }\r
-\r
- return Status;\r
-}\r