MdeModulePkg/Variable: Add RT GetVariable() cache support
REF:https://bugzilla.tianocore.org/show_bug.cgi?id=2220 This change reduces SMIs for GetVariable () by maintaining a UEFI variable cache in Runtime DXE in addition to the pre- existing cache in SMRAM. When the Runtime Service GetVariable() is invoked, a Runtime DXE cache is used instead of triggering an SMI to VariableSmm. This can improve overall system performance by servicing variable read requests without rendezvousing all cores into SMM. The runtime cache can be disabled with by setting the FeaturePCD gEfiMdeModulePkgTokenSpaceGuid.PcdEnableVariableRuntimeCache to FALSE. If the PCD is set to FALSE, the runtime cache will not be used and an SMI will be triggered for Runtime Service GetVariable () and GetNextVariableName () invocations. The following are important points regarding the behavior of the variable drivers when the variable runtime cache is enabled. 1. All of the non-volatile storage contents are loaded into the cache upon driver load. This one time load operation from storage is preferred as opposed to building the cache on demand. An on- demand cache would require a fallback SMI to load data into the cache as variables are requested. 2. SetVariable () requests will continue to always trigger an SMI. This occurs regardless of whether the variable is volatile or non-volatile. 3. Both volatile and non-volatile variables are cached in a runtime buffer. As is the case in the current EDK II variable driver, they continue to be cached in separate buffers. 4. The cache in Runtime DXE and SMM are intended to be exact copies of one another. All SMM variable accesses only return data from the SMM cache. The runtime caches are only updated after the variable I/O operation is successful in SMM. The runtime caches are only updated from SMM. 5. Synchronization mechanisms are in place to ensure the runtime cache content integrity with the SMM cache. These may result in updates to runtime cache that are the same in content but different in offset and size from updates to the SMM cache. When using SMM variables with runtime cache enabled, two caches will now be present. 1. "Runtime Cache" - Maintained in VariableSmmRuntimeDxe. Used to service Runtime Services GetVariable () and GetNextVariableName () callers. 2. "SMM Cache" - Maintained in VariableSmm to service SMM GetVariable () and GetNextVariableName () callers. a. This cache is retained so SMM modules do not operate on data outside SMRAM. Because a race condition can occur if an SMI occurs during the execution of runtime code reading from the runtime cache, a runtime cache read lock is introduced that explicitly moves pending updates from SMM to the runtime cache if an SMM update occurs while the runtime cache is locked. Note that it is not expected a Runtime services call will interrupt SMM processing since all CPU cores rendezvous in SMM. It is possible to view UEFI variable read and write statistics by setting the gEfiMdeModulePkgTokenSpaceGuid.PcdVariableCollectStatistics FeaturePcd to TRUE and using the VariableInfo UEFI application in MdeModulePkg to dump variable statistics to the console. By doing so, a user can view the number of GetVariable () hits from the Runtime DXE variable driver (Runtime Cache hits) and the SMM variable driver (SMM Cache hits). SMM Cache hits for GetVariable () will occur when SMM modules invoke GetVariable (). Cc: Dandan Bi <dandan.bi@intel.com> Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org> Cc: Eric Dong <eric.dong@intel.com> Cc: Laszlo Ersek <lersek@redhat.com> Cc: Liming Gao <liming.gao@intel.com> Cc: Michael D Kinney <michael.d.kinney@intel.com> Cc: Ray Ni <ray.ni@intel.com> Cc: Jian J Wang <jian.j.wang@intel.com> Cc: Hao A Wu <hao.a.wu@intel.com> Cc: Jiewen Yao <jiewen.yao@intel.com> Signed-off-by: Michael Kubacki <michael.a.kubacki@intel.com> Reviewed-by: Jian J Wang <jian.j.wang@intel.com>
This commit is contained in:
@@ -13,7 +13,7 @@
|
||||
|
||||
InitCommunicateBuffer() is really function to check the variable data size.
|
||||
|
||||
Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>
|
||||
Copyright (c) 2010 - 2019, Intel Corporation. All rights reserved.<BR>
|
||||
SPDX-License-Identifier: BSD-2-Clause-Patent
|
||||
|
||||
**/
|
||||
@@ -39,6 +39,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
|
||||
#include <Guid/SmmVariableCommon.h>
|
||||
|
||||
#include "PrivilegePolymorphic.h"
|
||||
#include "VariableParsing.h"
|
||||
|
||||
EFI_HANDLE mHandle = NULL;
|
||||
EFI_SMM_VARIABLE_PROTOCOL *mSmmVariable = NULL;
|
||||
@@ -46,8 +47,19 @@ EFI_EVENT mVirtualAddressChangeEvent = NULL;
|
||||
EFI_SMM_COMMUNICATION_PROTOCOL *mSmmCommunication = NULL;
|
||||
UINT8 *mVariableBuffer = NULL;
|
||||
UINT8 *mVariableBufferPhysical = NULL;
|
||||
VARIABLE_INFO_ENTRY *mVariableInfo = NULL;
|
||||
VARIABLE_STORE_HEADER *mVariableRuntimeHobCacheBuffer = NULL;
|
||||
VARIABLE_STORE_HEADER *mVariableRuntimeNvCacheBuffer = NULL;
|
||||
VARIABLE_STORE_HEADER *mVariableRuntimeVolatileCacheBuffer = NULL;
|
||||
UINTN mVariableBufferSize;
|
||||
UINTN mVariableRuntimeHobCacheBufferSize;
|
||||
UINTN mVariableRuntimeNvCacheBufferSize;
|
||||
UINTN mVariableRuntimeVolatileCacheBufferSize;
|
||||
UINTN mVariableBufferPayloadSize;
|
||||
BOOLEAN mVariableRuntimeCachePendingUpdate;
|
||||
BOOLEAN mVariableRuntimeCacheReadLock;
|
||||
BOOLEAN mVariableAuthFormat;
|
||||
BOOLEAN mHobFlushComplete;
|
||||
EFI_LOCK mVariableServicesLock;
|
||||
EDKII_VARIABLE_LOCK_PROTOCOL mVariableLock;
|
||||
EDKII_VAR_CHECK_PROTOCOL mVarCheck;
|
||||
@@ -107,6 +119,72 @@ ReleaseLockOnlyAtBootTime (
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Return TRUE if ExitBootServices () has been called.
|
||||
|
||||
@retval TRUE If ExitBootServices () has been called. FALSE if ExitBootServices () has not been called.
|
||||
**/
|
||||
BOOLEAN
|
||||
AtRuntime (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
return EfiAtRuntime ();
|
||||
}
|
||||
|
||||
/**
|
||||
Initialize the variable cache buffer as an empty variable store.
|
||||
|
||||
@param[out] VariableCacheBuffer A pointer to pointer of a cache variable store.
|
||||
@param[in,out] TotalVariableCacheSize On input, the minimum size needed for the UEFI variable store cache
|
||||
buffer that is allocated. On output, the actual size of the buffer allocated.
|
||||
If TotalVariableCacheSize is zero, a buffer will not be allocated and the
|
||||
function will return with EFI_SUCCESS.
|
||||
|
||||
@retval EFI_SUCCESS The variable cache was allocated and initialized successfully.
|
||||
@retval EFI_INVALID_PARAMETER A given pointer is NULL or an invalid variable store size was specified.
|
||||
@retval EFI_OUT_OF_RESOURCES Insufficient resources are available to allocate the variable store cache buffer.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
InitVariableCache (
|
||||
OUT VARIABLE_STORE_HEADER **VariableCacheBuffer,
|
||||
IN OUT UINTN *TotalVariableCacheSize
|
||||
)
|
||||
{
|
||||
VARIABLE_STORE_HEADER *VariableCacheStorePtr;
|
||||
|
||||
if (TotalVariableCacheSize == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
if (*TotalVariableCacheSize == 0) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
if (VariableCacheBuffer == NULL || *TotalVariableCacheSize < sizeof (VARIABLE_STORE_HEADER)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
*TotalVariableCacheSize = ALIGN_VALUE (*TotalVariableCacheSize, sizeof (UINT32));
|
||||
|
||||
//
|
||||
// Allocate NV Storage Cache and initialize it to all 1's (like an erased FV)
|
||||
//
|
||||
*VariableCacheBuffer = (VARIABLE_STORE_HEADER *) AllocateRuntimePages (
|
||||
EFI_SIZE_TO_PAGES (*TotalVariableCacheSize)
|
||||
);
|
||||
if (*VariableCacheBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
VariableCacheStorePtr = *VariableCacheBuffer;
|
||||
SetMem32 ((VOID *) VariableCacheStorePtr, *TotalVariableCacheSize, (UINT32) 0xFFFFFFFF);
|
||||
|
||||
ZeroMem ((VOID *) VariableCacheStorePtr, sizeof (VARIABLE_STORE_HEADER));
|
||||
VariableCacheStorePtr->Size = (UINT32) *TotalVariableCacheSize;
|
||||
VariableCacheStorePtr->Format = VARIABLE_STORE_FORMATTED;
|
||||
VariableCacheStorePtr->State = VARIABLE_STORE_HEALTHY;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
/**
|
||||
Initialize the communicate buffer using DataSize and Function.
|
||||
|
||||
@@ -425,7 +503,56 @@ Done:
|
||||
}
|
||||
|
||||
/**
|
||||
This code finds variable in storage blocks (Volatile or Non-Volatile).
|
||||
Signals SMM to synchronize any pending variable updates with the runtime cache(s).
|
||||
|
||||
**/
|
||||
VOID
|
||||
SyncRuntimeCache (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
//
|
||||
// Init the communicate buffer. The buffer data size is:
|
||||
// SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE.
|
||||
//
|
||||
InitCommunicateBuffer (NULL, 0, SMM_VARIABLE_FUNCTION_SYNC_RUNTIME_CACHE);
|
||||
|
||||
//
|
||||
// Send data to SMM.
|
||||
//
|
||||
SendCommunicateBuffer (0);
|
||||
}
|
||||
|
||||
/**
|
||||
Check whether a SMI must be triggered to retrieve pending cache updates.
|
||||
|
||||
If the variable HOB was finished being flushed since the last check for a runtime cache update, this function
|
||||
will prevent the HOB cache from being used for future runtime cache hits.
|
||||
|
||||
**/
|
||||
VOID
|
||||
CheckForRuntimeCacheSync (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mVariableRuntimeCachePendingUpdate) {
|
||||
SyncRuntimeCache ();
|
||||
}
|
||||
ASSERT (!mVariableRuntimeCachePendingUpdate);
|
||||
|
||||
//
|
||||
// The HOB variable data may have finished being flushed in the runtime cache sync update
|
||||
//
|
||||
if (mHobFlushComplete && mVariableRuntimeHobCacheBuffer != NULL) {
|
||||
if (!EfiAtRuntime ()) {
|
||||
FreePages (mVariableRuntimeHobCacheBuffer, EFI_SIZE_TO_PAGES (mVariableRuntimeHobCacheBufferSize));
|
||||
}
|
||||
mVariableRuntimeHobCacheBuffer = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Finds the given variable in a runtime cache variable store.
|
||||
|
||||
Caution: This function may receive untrusted input.
|
||||
The data size is external input, so this function will validate it carefully to avoid buffer overflow.
|
||||
@@ -437,20 +564,131 @@ Done:
|
||||
data, this value contains the required size.
|
||||
@param[out] Data Data pointer.
|
||||
|
||||
@retval EFI_SUCCESS Found the specified variable.
|
||||
@retval EFI_INVALID_PARAMETER Invalid parameter.
|
||||
@retval EFI_SUCCESS Find the specified variable.
|
||||
@retval EFI_NOT_FOUND Not found.
|
||||
@retval EFI_BUFFER_TO_SMALL DataSize is too small for the result.
|
||||
@retval EFI_NOT_FOUND The specified variable could not be found.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
RuntimeServiceGetVariable (
|
||||
FindVariableInRuntimeCache (
|
||||
IN CHAR16 *VariableName,
|
||||
IN EFI_GUID *VendorGuid,
|
||||
OUT UINT32 *Attributes OPTIONAL,
|
||||
IN OUT UINTN *DataSize,
|
||||
OUT VOID *Data
|
||||
OUT VOID *Data OPTIONAL
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINTN TempDataSize;
|
||||
VARIABLE_POINTER_TRACK RtPtrTrack;
|
||||
VARIABLE_STORE_TYPE StoreType;
|
||||
VARIABLE_STORE_HEADER *VariableStoreList[VariableStoreTypeMax];
|
||||
|
||||
Status = EFI_NOT_FOUND;
|
||||
|
||||
if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
// The UEFI specification restricts Runtime Services callers from invoking the same or certain other Runtime Service
|
||||
// functions prior to completion and return from a previous Runtime Service call. These restrictions prevent
|
||||
// a GetVariable () or GetNextVariable () call from being issued until a prior call has returned. The runtime
|
||||
// cache read lock should always be free when entering this function.
|
||||
//
|
||||
ASSERT (!mVariableRuntimeCacheReadLock);
|
||||
|
||||
mVariableRuntimeCacheReadLock = TRUE;
|
||||
CheckForRuntimeCacheSync ();
|
||||
|
||||
if (!mVariableRuntimeCachePendingUpdate) {
|
||||
//
|
||||
// 0: Volatile, 1: HOB, 2: Non-Volatile.
|
||||
// The index and attributes mapping must be kept in this order as FindVariable
|
||||
// makes use of this mapping to implement search algorithm.
|
||||
//
|
||||
VariableStoreList[VariableStoreTypeVolatile] = mVariableRuntimeVolatileCacheBuffer;
|
||||
VariableStoreList[VariableStoreTypeHob] = mVariableRuntimeHobCacheBuffer;
|
||||
VariableStoreList[VariableStoreTypeNv] = mVariableRuntimeNvCacheBuffer;
|
||||
|
||||
for (StoreType = (VARIABLE_STORE_TYPE) 0; StoreType < VariableStoreTypeMax; StoreType++) {
|
||||
if (VariableStoreList[StoreType] == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
RtPtrTrack.StartPtr = GetStartPointer (VariableStoreList[StoreType]);
|
||||
RtPtrTrack.EndPtr = GetEndPointer (VariableStoreList[StoreType]);
|
||||
RtPtrTrack.Volatile = (BOOLEAN) (StoreType == VariableStoreTypeVolatile);
|
||||
|
||||
Status = FindVariableEx (VariableName, VendorGuid, FALSE, &RtPtrTrack, mVariableAuthFormat);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!EFI_ERROR (Status)) {
|
||||
//
|
||||
// Get data size
|
||||
//
|
||||
TempDataSize = DataSizeOfVariable (RtPtrTrack.CurrPtr, mVariableAuthFormat);
|
||||
ASSERT (TempDataSize != 0);
|
||||
|
||||
if (*DataSize >= TempDataSize) {
|
||||
if (Data == NULL) {
|
||||
Status = EFI_INVALID_PARAMETER;
|
||||
goto Done;
|
||||
}
|
||||
|
||||
CopyMem (Data, GetVariableDataPtr (RtPtrTrack.CurrPtr, mVariableAuthFormat), TempDataSize);
|
||||
if (Attributes != NULL) {
|
||||
*Attributes = RtPtrTrack.CurrPtr->Attributes;
|
||||
}
|
||||
|
||||
*DataSize = TempDataSize;
|
||||
|
||||
UpdateVariableInfo (VariableName, VendorGuid, RtPtrTrack.Volatile, TRUE, FALSE, FALSE, TRUE, &mVariableInfo);
|
||||
|
||||
Status = EFI_SUCCESS;
|
||||
goto Done;
|
||||
} else {
|
||||
*DataSize = TempDataSize;
|
||||
Status = EFI_BUFFER_TOO_SMALL;
|
||||
goto Done;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Done:
|
||||
mVariableRuntimeCacheReadLock = FALSE;
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
Finds the given variable in a variable store in SMM.
|
||||
|
||||
Caution: This function may receive untrusted input.
|
||||
The data size is external input, so this function will validate it carefully to avoid buffer overflow.
|
||||
|
||||
@param[in] VariableName Name of Variable to be found.
|
||||
@param[in] VendorGuid Variable vendor GUID.
|
||||
@param[out] Attributes Attribute value of the variable found.
|
||||
@param[in, out] DataSize Size of Data found. If size is less than the
|
||||
data, this value contains the required size.
|
||||
@param[out] Data Data pointer.
|
||||
|
||||
@retval EFI_SUCCESS Found the specified variable.
|
||||
@retval EFI_INVALID_PARAMETER Invalid parameter.
|
||||
@retval EFI_NOT_FOUND The specified variable could not be found.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
FindVariableInSmm (
|
||||
IN CHAR16 *VariableName,
|
||||
IN EFI_GUID *VendorGuid,
|
||||
OUT UINT32 *Attributes OPTIONAL,
|
||||
IN OUT UINTN *DataSize,
|
||||
OUT VOID *Data OPTIONAL
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
@@ -474,8 +712,6 @@ RuntimeServiceGetVariable (
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
AcquireLockOnlyAtBootTime(&mVariableServicesLock);
|
||||
|
||||
//
|
||||
// Init the communicate buffer. The buffer data size is:
|
||||
// SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.
|
||||
@@ -488,7 +724,7 @@ RuntimeServiceGetVariable (
|
||||
}
|
||||
PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + VariableNameSize + TempDataSize;
|
||||
|
||||
Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_GET_VARIABLE);
|
||||
Status = InitCommunicateBuffer ((VOID **) &SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_GET_VARIABLE);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Done;
|
||||
}
|
||||
@@ -534,10 +770,57 @@ RuntimeServiceGetVariable (
|
||||
}
|
||||
|
||||
Done:
|
||||
ReleaseLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
This code finds variable in storage blocks (Volatile or Non-Volatile).
|
||||
|
||||
Caution: This function may receive untrusted input.
|
||||
The data size is external input, so this function will validate it carefully to avoid buffer overflow.
|
||||
|
||||
@param[in] VariableName Name of Variable to be found.
|
||||
@param[in] VendorGuid Variable vendor GUID.
|
||||
@param[out] Attributes Attribute value of the variable found.
|
||||
@param[in, out] DataSize Size of Data found. If size is less than the
|
||||
data, this value contains the required size.
|
||||
@param[out] Data Data pointer.
|
||||
|
||||
@retval EFI_INVALID_PARAMETER Invalid parameter.
|
||||
@retval EFI_SUCCESS Find the specified variable.
|
||||
@retval EFI_NOT_FOUND Not found.
|
||||
@retval EFI_BUFFER_TO_SMALL DataSize is too small for the result.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
RuntimeServiceGetVariable (
|
||||
IN CHAR16 *VariableName,
|
||||
IN EFI_GUID *VendorGuid,
|
||||
OUT UINT32 *Attributes OPTIONAL,
|
||||
IN OUT UINTN *DataSize,
|
||||
OUT VOID *Data
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
if (VariableName[0] == 0) {
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
AcquireLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
if (FeaturePcdGet (PcdEnableVariableRuntimeCache)) {
|
||||
Status = FindVariableInRuntimeCache (VariableName, VendorGuid, Attributes, DataSize, Data);
|
||||
} else {
|
||||
Status = FindVariableInSmm (VariableName, VendorGuid, Attributes, DataSize, Data);
|
||||
}
|
||||
ReleaseLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
This code Finds the Next available variable.
|
||||
@@ -870,6 +1153,17 @@ OnReadyToBoot (
|
||||
//
|
||||
SendCommunicateBuffer (0);
|
||||
|
||||
//
|
||||
// Install the system configuration table for variable info data captured
|
||||
//
|
||||
if (FeaturePcdGet (PcdEnableVariableRuntimeCache) && FeaturePcdGet (PcdVariableCollectStatistics)) {
|
||||
if (mVariableAuthFormat) {
|
||||
gBS->InstallConfigurationTable (&gEfiAuthenticatedVariableGuid, mVariableInfo);
|
||||
} else {
|
||||
gBS->InstallConfigurationTable (&gEfiVariableGuid, mVariableInfo);
|
||||
}
|
||||
}
|
||||
|
||||
gBS->CloseEvent (Event);
|
||||
}
|
||||
|
||||
@@ -893,6 +1187,9 @@ VariableAddressChangeEvent (
|
||||
{
|
||||
EfiConvertPointer (0x0, (VOID **) &mVariableBuffer);
|
||||
EfiConvertPointer (0x0, (VOID **) &mSmmCommunication);
|
||||
EfiConvertPointer (EFI_OPTIONAL_PTR, (VOID **) &mVariableRuntimeHobCacheBuffer);
|
||||
EfiConvertPointer (EFI_OPTIONAL_PTR, (VOID **) &mVariableRuntimeNvCacheBuffer);
|
||||
EfiConvertPointer (EFI_OPTIONAL_PTR, (VOID **) &mVariableRuntimeVolatileCacheBuffer);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -969,6 +1266,159 @@ Done:
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
This code gets information needed from SMM for runtime cache initialization.
|
||||
|
||||
@param[out] TotalHobStorageSize Output pointer for the total HOB storage size in bytes.
|
||||
@param[out] TotalNvStorageSize Output pointer for the total non-volatile storage size in bytes.
|
||||
@param[out] TotalVolatileStorageSize Output pointer for the total volatile storage size in bytes.
|
||||
@param[out] AuthenticatedVariableUsage Output pointer that indicates if authenticated variables are to be used.
|
||||
|
||||
@retval EFI_SUCCESS Retrieved the size successfully.
|
||||
@retval EFI_INVALID_PARAMETER TotalNvStorageSize parameter is NULL.
|
||||
@retval EFI_OUT_OF_RESOURCES The memory resources needed for a CommBuffer are not available.
|
||||
@retval Others Could not retrieve the size successfully.
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
GetRuntimeCacheInfo (
|
||||
OUT UINTN *TotalHobStorageSize,
|
||||
OUT UINTN *TotalNvStorageSize,
|
||||
OUT UINTN *TotalVolatileStorageSize,
|
||||
OUT BOOLEAN *AuthenticatedVariableUsage
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
SMM_VARIABLE_COMMUNICATE_GET_RUNTIME_CACHE_INFO *SmmGetRuntimeCacheInfo;
|
||||
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
|
||||
SMM_VARIABLE_COMMUNICATE_HEADER *SmmVariableFunctionHeader;
|
||||
UINTN CommSize;
|
||||
UINT8 *CommBuffer;
|
||||
|
||||
SmmGetRuntimeCacheInfo = NULL;
|
||||
CommBuffer = mVariableBuffer;
|
||||
|
||||
if (TotalHobStorageSize == NULL || TotalNvStorageSize == NULL || TotalVolatileStorageSize == NULL || AuthenticatedVariableUsage == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (CommBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
AcquireLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
|
||||
CommSize = SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_GET_RUNTIME_CACHE_INFO);
|
||||
ZeroMem (CommBuffer, CommSize);
|
||||
|
||||
SmmCommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *) CommBuffer;
|
||||
CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmVariableProtocolGuid);
|
||||
SmmCommunicateHeader->MessageLength = SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_GET_RUNTIME_CACHE_INFO);
|
||||
|
||||
SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) SmmCommunicateHeader->Data;
|
||||
SmmVariableFunctionHeader->Function = SMM_VARIABLE_FUNCTION_GET_RUNTIME_CACHE_INFO;
|
||||
SmmGetRuntimeCacheInfo = (SMM_VARIABLE_COMMUNICATE_GET_RUNTIME_CACHE_INFO *) SmmVariableFunctionHeader->Data;
|
||||
|
||||
//
|
||||
// Send data to SMM.
|
||||
//
|
||||
Status = mSmmCommunication->Communicate (mSmmCommunication, CommBuffer, &CommSize);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
if (CommSize <= SMM_VARIABLE_COMMUNICATE_HEADER_SIZE) {
|
||||
Status = EFI_BAD_BUFFER_SIZE;
|
||||
goto Done;
|
||||
}
|
||||
|
||||
Status = SmmVariableFunctionHeader->ReturnStatus;
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Done;
|
||||
}
|
||||
|
||||
//
|
||||
// Get data from SMM.
|
||||
//
|
||||
*TotalHobStorageSize = SmmGetRuntimeCacheInfo->TotalHobStorageSize;
|
||||
*TotalNvStorageSize = SmmGetRuntimeCacheInfo->TotalNvStorageSize;
|
||||
*TotalVolatileStorageSize = SmmGetRuntimeCacheInfo->TotalVolatileStorageSize;
|
||||
*AuthenticatedVariableUsage = SmmGetRuntimeCacheInfo->AuthenticatedVariableUsage;
|
||||
|
||||
Done:
|
||||
ReleaseLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
Sends the runtime variable cache context information to SMM.
|
||||
|
||||
@retval EFI_SUCCESS Retrieved the size successfully.
|
||||
@retval EFI_INVALID_PARAMETER TotalNvStorageSize parameter is NULL.
|
||||
@retval EFI_OUT_OF_RESOURCES The memory resources needed for a CommBuffer are not available.
|
||||
@retval Others Could not retrieve the size successfully.;
|
||||
|
||||
**/
|
||||
EFI_STATUS
|
||||
SendRuntimeVariableCacheContextToSmm (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
SMM_VARIABLE_COMMUNICATE_RUNTIME_VARIABLE_CACHE_CONTEXT *SmmRuntimeVarCacheContext;
|
||||
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
|
||||
SMM_VARIABLE_COMMUNICATE_HEADER *SmmVariableFunctionHeader;
|
||||
UINTN CommSize;
|
||||
UINT8 *CommBuffer;
|
||||
|
||||
SmmRuntimeVarCacheContext = NULL;
|
||||
CommBuffer = mVariableBuffer;
|
||||
|
||||
if (CommBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
AcquireLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
|
||||
//
|
||||
// Init the communicate buffer. The buffer data size is:
|
||||
// SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_RUNTIME_VARIABLE_CACHE_CONTEXT);
|
||||
//
|
||||
CommSize = SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_RUNTIME_VARIABLE_CACHE_CONTEXT);
|
||||
ZeroMem (CommBuffer, CommSize);
|
||||
|
||||
SmmCommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *) CommBuffer;
|
||||
CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmVariableProtocolGuid);
|
||||
SmmCommunicateHeader->MessageLength = SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + sizeof (SMM_VARIABLE_COMMUNICATE_RUNTIME_VARIABLE_CACHE_CONTEXT);
|
||||
|
||||
SmmVariableFunctionHeader = (SMM_VARIABLE_COMMUNICATE_HEADER *) SmmCommunicateHeader->Data;
|
||||
SmmVariableFunctionHeader->Function = SMM_VARIABLE_FUNCTION_INIT_RUNTIME_VARIABLE_CACHE_CONTEXT;
|
||||
SmmRuntimeVarCacheContext = (SMM_VARIABLE_COMMUNICATE_RUNTIME_VARIABLE_CACHE_CONTEXT *) SmmVariableFunctionHeader->Data;
|
||||
|
||||
SmmRuntimeVarCacheContext->RuntimeHobCache = mVariableRuntimeHobCacheBuffer;
|
||||
SmmRuntimeVarCacheContext->RuntimeVolatileCache = mVariableRuntimeVolatileCacheBuffer;
|
||||
SmmRuntimeVarCacheContext->RuntimeNvCache = mVariableRuntimeNvCacheBuffer;
|
||||
SmmRuntimeVarCacheContext->PendingUpdate = &mVariableRuntimeCachePendingUpdate;
|
||||
SmmRuntimeVarCacheContext->ReadLock = &mVariableRuntimeCacheReadLock;
|
||||
SmmRuntimeVarCacheContext->HobFlushComplete = &mHobFlushComplete;
|
||||
|
||||
//
|
||||
// Send data to SMM.
|
||||
//
|
||||
Status = mSmmCommunication->Communicate (mSmmCommunication, CommBuffer, &CommSize);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
if (CommSize <= SMM_VARIABLE_COMMUNICATE_HEADER_SIZE) {
|
||||
Status = EFI_BAD_BUFFER_SIZE;
|
||||
goto Done;
|
||||
}
|
||||
|
||||
Status = SmmVariableFunctionHeader->ReturnStatus;
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto Done;
|
||||
}
|
||||
|
||||
Done:
|
||||
ReleaseLockOnlyAtBootTime (&mVariableServicesLock);
|
||||
return Status;
|
||||
}
|
||||
|
||||
/**
|
||||
Initialize variable service and install Variable Architectural protocol.
|
||||
|
||||
@@ -985,7 +1435,7 @@ SmmVariableReady (
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
Status = gBS->LocateProtocol (&gEfiSmmVariableProtocolGuid, NULL, (VOID **)&mSmmVariable);
|
||||
Status = gBS->LocateProtocol (&gEfiSmmVariableProtocolGuid, NULL, (VOID **) &mSmmVariable);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return;
|
||||
}
|
||||
@@ -1007,6 +1457,42 @@ SmmVariableReady (
|
||||
//
|
||||
mVariableBufferPhysical = mVariableBuffer;
|
||||
|
||||
if (FeaturePcdGet (PcdEnableVariableRuntimeCache)) {
|
||||
DEBUG ((DEBUG_INFO, "Variable driver runtime cache is enabled.\n"));
|
||||
//
|
||||
// Allocate runtime variable cache memory buffers.
|
||||
//
|
||||
Status = GetRuntimeCacheInfo (
|
||||
&mVariableRuntimeHobCacheBufferSize,
|
||||
&mVariableRuntimeNvCacheBufferSize,
|
||||
&mVariableRuntimeVolatileCacheBufferSize,
|
||||
&mVariableAuthFormat
|
||||
);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
Status = InitVariableCache (&mVariableRuntimeHobCacheBuffer, &mVariableRuntimeHobCacheBufferSize);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
Status = InitVariableCache (&mVariableRuntimeNvCacheBuffer, &mVariableRuntimeNvCacheBufferSize);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
Status = InitVariableCache (&mVariableRuntimeVolatileCacheBuffer, &mVariableRuntimeVolatileCacheBufferSize);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
Status = SendRuntimeVariableCacheContextToSmm ();
|
||||
if (!EFI_ERROR (Status)) {
|
||||
SyncRuntimeCache ();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (EFI_ERROR (Status)) {
|
||||
mVariableRuntimeHobCacheBuffer = NULL;
|
||||
mVariableRuntimeNvCacheBuffer = NULL;
|
||||
mVariableRuntimeVolatileCacheBuffer = NULL;
|
||||
}
|
||||
}
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
} else {
|
||||
DEBUG ((DEBUG_INFO, "Variable driver runtime cache is disabled.\n"));
|
||||
}
|
||||
|
||||
gRT->GetVariable = RuntimeServiceGetVariable;
|
||||
gRT->GetNextVariableName = RuntimeServiceGetNextVariableName;
|
||||
gRT->SetVariable = RuntimeServiceSetVariable;
|
||||
|
Reference in New Issue
Block a user