tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update comments in Variable driver and removed references to FLASH Map Hob in INF files 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4019 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
AJFISH 2007-10-05 14:40:23 +00:00
parent d4ef798f71
commit 052ad7e191
7 changed files with 267 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteDxe/FtwLite.inf
View File

@ -67,7 +67,6 @@
[Guids]
gEfiSystemNvDataFvGuid # ALWAYS_CONSUMED
gEfiFlashMapHobGuid
[Protocols]
gEfiFirmwareVolumeBlockProtocolGuid # PROTOCOL ALWAYS_CONSUMED

229
MdeModulePkg/Universal/Variable/RuntimeDxe/InitVariable.c
View File

@ -1,229 +0,0 @@
/*++
Copyright (c) 2006 - 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
InitVariable.c
Abstract:
Revision History
--*/
#include "Variable.h"
//
// Event for Virtual Address Change Callback
//
STATIC EFI_EVENT mVirtualAddressChangeEvent = NULL;
//
// Don't use module globals after the SetVirtualAddress map is signaled
//
extern ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
EFI_STATUS
EFIAPI
RuntimeServiceGetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
return GetVariable (
VariableName,
VendorGuid,
Attributes OPTIONAL,
DataSize,
Data,
&mVariableModuleGlobal->VariableGlobal[Physical],
mVariableModuleGlobal->FvbInstance
);
}
EFI_STATUS
EFIAPI
RuntimeServiceGetNextVariableName (
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
return GetNextVariableName (
VariableNameSize,
VariableName,
VendorGuid,
&mVariableModuleGlobal->VariableGlobal[Physical],
mVariableModuleGlobal->FvbInstance
);
}
EFI_STATUS
EFIAPI
RuntimeServiceSetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
return SetVariable (
VariableName,
VendorGuid,
Attributes,
DataSize,
Data,
&mVariableModuleGlobal->VariableGlobal[Physical],
&mVariableModuleGlobal->VolatileLastVariableOffset,
&mVariableModuleGlobal->NonVolatileLastVariableOffset,
mVariableModuleGlobal->FvbInstance
);
}
EFI_STATUS
EFIAPI
RuntimeServiceQueryVariableInfo (
IN UINT32 Attributes,
OUT UINT64 *MaximumVariableStorageSize,
OUT UINT64 *RemainingVariableStorageSize,
OUT UINT64 *MaximumVariableSize
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
return QueryVariableInfo (
Attributes,
MaximumVariableStorageSize,
RemainingVariableStorageSize,
MaximumVariableSize,
&mVariableModuleGlobal->VariableGlobal[Physical],
mVariableModuleGlobal->FvbInstance
);
}
VOID
EFIAPI
VariableClassAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
EfiConvertPointer (
0x0,
(VOID **) &mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase
);
EfiConvertPointer (
0x0,
(VOID **) &mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase
);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
}
EFI_STATUS
EFIAPI
VariableServiceInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
EFI_HANDLE NewHandle;
EFI_STATUS Status;
Status = VariableCommonInitialize (ImageHandle, SystemTable);
ASSERT_EFI_ERROR (Status);
SystemTable->RuntimeServices->GetVariable = RuntimeServiceGetVariable;
SystemTable->RuntimeServices->GetNextVariableName = RuntimeServiceGetNextVariableName;
SystemTable->RuntimeServices->SetVariable = RuntimeServiceSetVariable;
SystemTable->RuntimeServices->QueryVariableInfo = RuntimeServiceQueryVariableInfo;
//
// Now install the Variable Runtime Architectural Protocol on a new handle
//
NewHandle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&NewHandle,
&gEfiVariableArchProtocolGuid,
NULL,
&gEfiVariableWriteArchProtocolGuid,
NULL,
NULL
);
ASSERT_EFI_ERROR (Status);
Status = gBS->CreateEvent (
EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
TPL_NOTIFY,
VariableClassAddressChangeEvent,
NULL,
&mVirtualAddressChangeEvent
);
ASSERT_EFI_ERROR (Status);
return EFI_SUCCESS;
}

400
MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
View File

@ -1,37 +1,25 @@
/*++
/** @file
EFI Runtime Variable services.
Copyright (c) 2006 - 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
Copyright (c) 2006 - 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Variable.c
Abstract:
Revision History
--*/
**/
#include "Variable.h"
#include <Guid/FlashMapHob.h>
#include <Guid/VariableInfo.h>
#include <Guid/GlobalVariable.h>
//
// Don't use module globals after the SetVirtualAddress map is signaled
//
ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
VARIABLE_MODULE_GLOBAL mRuntimeData;
VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal = &mRuntimeData;
EFI_EVENT mVirtualAddressChangeEvent = NULL;
EFI_HANDLE mHandle = NULL;
//
@ -68,6 +56,26 @@ ReleaseLockOnlyAtBootTime (
GLOBAL_REMOVE_IF_UNREFERENCED VARIABLE_INFO_ENTRY *gVariableInfo = NULL;
/**
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,
@ -89,7 +97,13 @@ UpdateVariableInfo (
}
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));
StrCpy (gVariableInfo->Name, VariableName);
@ -120,7 +134,12 @@ UpdateVariableInfo (
}
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));
@ -134,9 +153,7 @@ UpdateVariableInfo (
STATIC
BOOLEAN
EFIAPI
IsValidVariableHeader (
IN VARIABLE_HEADER *Variable
)
@ -165,9 +182,8 @@ Returns:
return TRUE;
}
STATIC
EFI_STATUS
EFIAPI
UpdateVariableStore (
IN VARIABLE_GLOBAL *Global,
IN BOOLEAN Volatile,
@ -231,7 +247,7 @@ Returns:
// written
//
if (SetByIndex) {
DataPtr += Global->NonVolatileVariableBase;
DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;
}
if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) {
@ -242,9 +258,9 @@ Returns:
// Data Pointer should point to the actual Address where data is to be
// written
//
VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
if (SetByIndex) {
DataPtr += Global->VolatileVariableBase;
DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;
}
if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {
@ -314,9 +330,8 @@ Returns:
return EFI_SUCCESS;
}
STATIC
VARIABLE_STORE_STATUS
EFIAPI
GetVariableStoreStatus (
IN VARIABLE_STORE_HEADER *VarStoreHeader
)
@ -356,9 +371,8 @@ Returns:
}
}
STATIC
UINT8 *
EFIAPI
GetVariableDataPtr (
IN VARIABLE_HEADER *Variable
)
@ -384,7 +398,7 @@ Returns:
return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
}
STATIC
VARIABLE_HEADER *
GetNextVariablePtr (
IN VARIABLE_HEADER *Variable
@ -414,9 +428,8 @@ Returns:
return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
}
STATIC
VARIABLE_HEADER *
EFIAPI
GetEndPointer (
IN VARIABLE_STORE_HEADER *VarStoreHeader
)
@ -442,9 +455,8 @@ Returns:
return (VARIABLE_HEADER *) ((UINTN) VarStoreHeader + VarStoreHeader->Size);
}
STATIC
EFI_STATUS
EFIAPI
Reclaim (
IN EFI_PHYSICAL_ADDRESS VariableBase,
OUT UINTN *LastVariableOffset,
@ -559,13 +571,6 @@ Returns:
return Status;
}
typedef struct {
EFI_GUID *Guid;
CHAR16 *Name;
UINT32 Attributes;
UINTN DataSize;
VOID *Data;
} VARIABLE_CACHE_ENTRY;
//
// The current Hii implementation accesses this variable a larg # of times on every boot.
@ -583,13 +588,25 @@ VARIABLE_CACHE_ENTRY mVariableCache[] = {
}
};
/**
Update the Cache with Variable information. These are the same
arguments as the EFI Variable services.
@param[in] VariableName Name of variable
@param[in] VendorGuid Guid of variable
@param[in] Attribute Attribue of the variable
@param[in] DataSize Size of data. 0 means delete
@param[in] Data Variable data
**/
VOID
UpdateVariableCache (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT UINT32 Attributes,
IN OUT UINTN DataSize,
OUT VOID *Data
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data
)
{
VARIABLE_CACHE_ENTRY *Entry;
@ -623,6 +640,19 @@ UpdateVariableCache (
}
/**
Search the cache to see if the variable is in the cache.
@param[in] VariableName Name of variable
@param[in] VendorGuid Guid of variable
@param[in] Attribute Attribue returned
@param[in] DataSize Size of data returned
@param[in] Data Variable data returned
@retval EFI_SUCCESS VariableGuid & VariableName data was returned.
@retval other Not found.
**/
EFI_STATUS
FindVariableInCache (
IN CHAR16 *VariableName,
@ -644,11 +674,14 @@ FindVariableInCache (
if (CompareGuid (VendorGuid, Entry->Guid)) {
if (StrCmp (VariableName, Entry->Name) == 0) {
if (Entry->DataSize == 0) {
// Variable was deleted so return not found
return EFI_NOT_FOUND;
} else if (Entry->DataSize != *DataSize) {
// If the buffer is too small return correct size
*DataSize = Entry->DataSize;
return EFI_BUFFER_TOO_SMALL;
} else {
// Return the data
CopyMem (Data, Entry->Data, Entry->DataSize);
if (Attributes != NULL) {
*Attributes = Entry->Attributes;
@ -700,13 +733,13 @@ Returns:
// SetVariable all call FindVariable at entry point. Please move "Aquire Lock" to
// the correct places if this assumption does not hold TRUE anymore.
//
AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);
AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
//
// 0: Volatile, 1: Non-Volatile
//
VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);
VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
//
// Start Pointers for the variable.
@ -752,17 +785,7 @@ Returns:
}
EFI_STATUS
EFIAPI
GetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data,
IN VARIABLE_GLOBAL *Global,
IN UINT32 Instance
)
/*++
Routine Description:
@ -789,10 +812,19 @@ Returns:
--*/
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;
VARIABLE_POINTER_TRACK Variable;
UINTN VarDataSize;
EFI_STATUS Status;
if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
return EFI_INVALID_PARAMETER;
@ -808,7 +840,7 @@ Returns:
return Status;
}
Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
goto Done;
}
@ -841,19 +873,12 @@ Returns:
}
Done:
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return Status;
}
EFI_STATUS
EFIAPI
GetNextVariableName (
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid,
IN VARIABLE_GLOBAL *Global,
IN UINT32 Instance
)
/*++
Routine Description:
@ -873,6 +898,13 @@ Returns:
EFI STATUS
--*/
EFI_STATUS
EFIAPI
RuntimeServiceGetNextVariableName (
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
)
{
VARIABLE_POINTER_TRACK Variable;
UINTN VarNameSize;
@ -882,8 +914,7 @@ Returns:
return EFI_INVALID_PARAMETER;
}
Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
goto Done;
}
@ -903,8 +934,8 @@ Returns:
if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));
if (Variable.Volatile) {
Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (Global->VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));
Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase));
Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));
Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
} else {
Status = EFI_NOT_FOUND;
goto Done;
@ -946,23 +977,11 @@ Returns:
}
Done:
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return Status;
}
EFI_STATUS
EFIAPI
SetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data,
IN VARIABLE_GLOBAL *Global,
IN UINTN *VolatileOffset,
IN UINTN *NonVolatileOffset,
IN UINT32 Instance
)
/*++
Routine Description:
@ -992,6 +1011,15 @@ Returns:
EFI_WRITE_PROTECTED - Variable is read-only
--*/
EFI_STATUS
EFIAPI
RuntimeServiceSetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data
)
{
VARIABLE_POINTER_TRACK Variable;
EFI_STATUS Status;
@ -1002,8 +1030,14 @@ Returns:
UINTN VarSize;
UINT8 State;
BOOLEAN Reclaimed;
UINTN *VolatileOffset;
UINTN *NonVolatileOffset;
UINT32 Instance;
Reclaimed = FALSE;
Reclaimed = FALSE;
VolatileOffset = &mVariableModuleGlobal->VolatileLastVariableOffset;
NonVolatileOffset = &mVariableModuleGlobal->NonVolatileLastVariableOffset;
Instance = mVariableModuleGlobal->FvbInstance;
//
// Check input parameters
@ -1041,7 +1075,7 @@ Returns:
// Check whether the input variable is already existed
//
Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
if (Status == EFI_SUCCESS && Variable.CurrPtr != NULL) {
//
@ -1075,7 +1109,7 @@ Returns:
State &= VAR_DELETED;
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
Variable.Volatile,
FALSE,
Instance,
@ -1108,7 +1142,7 @@ Returns:
State &= VAR_IN_DELETED_TRANSITION;
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
Variable.Volatile,
FALSE,
Instance,
@ -1157,7 +1191,7 @@ Returns:
// Tricky part: Use scratch data area at the end of volatile variable store
// as a temporary storage.
//
NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase));
NextVariable = GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
SetMem (NextVariable, SCRATCH_SIZE, 0xff);
@ -1201,7 +1235,7 @@ Returns:
Variable.Volatile = FALSE;
if ((UINT32) (VarSize +*NonVolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size
((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
) {
if (EfiAtRuntime ()) {
Status = EFI_OUT_OF_RESOURCES;
@ -1210,7 +1244,7 @@ Returns:
//
// Perform garbage collection & reclaim operation
//
Status = Reclaim (Global->NonVolatileVariableBase, NonVolatileOffset, FALSE);
Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, NonVolatileOffset, FALSE);
if (EFI_ERROR (Status)) {
goto Done;
}
@ -1218,7 +1252,7 @@ Returns:
// If still no enough space, return out of resources
//
if ((UINT32) (VarSize +*NonVolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size
((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
@ -1236,7 +1270,7 @@ Returns:
// Step 1:
//
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
FALSE,
TRUE,
Instance,
@ -1252,7 +1286,7 @@ Returns:
// Step 2:
//
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
FALSE,
TRUE,
Instance,
@ -1269,7 +1303,7 @@ Returns:
//
NextVariable->State = VAR_ADDED;
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
FALSE,
TRUE,
Instance,
@ -1291,11 +1325,11 @@ Returns:
Variable.Volatile = TRUE;
if ((UINT32) (VarSize +*VolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size) {
((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {
//
// Perform garbage collection & reclaim operation
//
Status = Reclaim (Global->VolatileVariableBase, VolatileOffset, TRUE);
Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, VolatileOffset, TRUE);
if (EFI_ERROR (Status)) {
goto Done;
}
@ -1303,7 +1337,7 @@ Returns:
// If still no enough space, return out of resources
//
if ((UINT32) (VarSize +*VolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size
((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size
) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
@ -1314,7 +1348,7 @@ Returns:
NextVariable->State = VAR_ADDED;
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
TRUE,
TRUE,
Instance,
@ -1337,7 +1371,7 @@ Returns:
State &= VAR_DELETED;
Status = UpdateVariableStore (
Global,
&mVariableModuleGlobal->VariableGlobal,
Variable.Volatile,
FALSE,
Instance,
@ -1358,20 +1392,11 @@ Returns:
UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
Done:
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return Status;
}
EFI_STATUS
EFIAPI
QueryVariableInfo (
IN UINT32 Attributes,
OUT UINT64 *MaximumVariableStorageSize,
OUT UINT64 *RemainingVariableStorageSize,
OUT UINT64 *MaximumVariableSize,
IN VARIABLE_GLOBAL *Global,
IN UINT32 Instance
)
/*++
Routine Description:
@ -1399,6 +1424,14 @@ Returns:
EFI_UNSUPPORTED - The attribute is not supported on this platform.
--*/
EFI_STATUS
EFIAPI
RuntimeServiceQueryVariableInfo (
IN UINT32 Attributes,
OUT UINT64 *MaximumVariableStorageSize,
OUT UINT64 *RemainingVariableStorageSize,
OUT UINT64 *MaximumVariableSize
)
{
VARIABLE_HEADER *Variable;
VARIABLE_HEADER *NextVariable;
@ -1426,18 +1459,18 @@ Returns:
return EFI_INVALID_PARAMETER;
}
AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);
AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
//
// Query is Volatile related.
//
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
} else {
//
// Query is Non-Volatile related.
//
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
}
//
@ -1501,12 +1534,11 @@ Returns:
*MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);
}
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
VariableCommonInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
@ -1541,18 +1573,15 @@ Returns:
EFI_PHYSICAL_ADDRESS FvVolHdr;
UINT64 TempVariableStoreHeader;
EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
EFI_FLASH_SUBAREA_ENTRY VariableStoreEntry;
UINT64 BaseAddress;
UINT64 Length;
UINTN Index;
UINT8 Data;
UINT64 VariableStoreBase;
UINT64 VariableStoreLength;
mVariableModuleGlobal = AllocateRuntimePool (sizeof (ESAL_VARIABLE_GLOBAL));
if (mVariableModuleGlobal == NULL) {
return EFI_OUT_OF_RESOURCES;
}
EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal[Physical].VariableServicesLock, TPL_NOTIFY);
EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock, TPL_NOTIFY);
//
// Allocate memory for volatile variable store
@ -1568,7 +1597,7 @@ Returns:
//
// Variable Specific Data
//
mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;
mVariableModuleGlobal->VariableGlobal.VolatileVariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VolatileVariableStore;
mVariableModuleGlobal->VolatileLastVariableOffset = sizeof (VARIABLE_STORE_HEADER);
VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE;
@ -1583,15 +1612,15 @@ Returns:
//
TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase);
VariableStoreEntry.Base = TempVariableStoreHeader + \
VariableStoreBase = TempVariableStoreHeader + \
(((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
VariableStoreEntry.Length = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \
VariableStoreLength = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \
(((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
//
// Mark the variable storage region of the FLASH as RUNTIME
//
BaseAddress = VariableStoreEntry.Base & (~EFI_PAGE_MASK);
Length = VariableStoreEntry.Length + (VariableStoreEntry.Base - BaseAddress);
BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);
Length = VariableStoreLength + (VariableStoreBase - BaseAddress);
Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
@ -1614,7 +1643,7 @@ Returns:
//
// Get address of non volatile variable store base
//
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase = VariableStoreEntry.Base;
mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
//
// Check Integrity
@ -1623,7 +1652,7 @@ Returns:
// Find the Correct Instance of the FV Block Service.
//
Instance = 0;
CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase);
CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) {
FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) {
@ -1638,13 +1667,13 @@ Returns:
if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
if (~VariableStoreHeader->Size == 0) {
Status = UpdateVariableStore (
&mVariableModuleGlobal->VariableGlobal[Physical],
&mVariableModuleGlobal->VariableGlobal,
FALSE,
FALSE,
mVariableModuleGlobal->FvbInstance,
(UINTN) &VariableStoreHeader->Size,
sizeof (UINT32),
(UINT8 *) &VariableStoreEntry.Length
(UINT8 *) &VariableStoreLength
);
//
// As Variables are stored in NV storage, which are slow devices,such as flash.
@ -1654,14 +1683,14 @@ Returns:
// We can assume all Read/Write is OK if we can set Variable store size successfully.
// If write fail, we will assert here
//
ASSERT(VariableStoreHeader->Size == VariableStoreEntry.Length);
ASSERT(VariableStoreHeader->Size == VariableStoreLength);
if (EFI_ERROR (Status)) {
return Status;
}
}
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) CurrPtr);
mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = (EFI_PHYSICAL_ADDRESS) ((UINTN) CurrPtr);
//
// Parse non-volatile variable data and get last variable offset
//
@ -1679,7 +1708,7 @@ Returns:
//
if ((((VARIABLE_STORE_HEADER *)((UINTN) CurrPtr))->Size - mVariableModuleGlobal->NonVolatileLastVariableOffset) < VARIABLE_RECLAIM_THRESHOLD) {
Status = Reclaim (
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase,
mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
&mVariableModuleGlobal->NonVolatileLastVariableOffset,
FALSE
);
@ -1695,13 +1724,13 @@ Returns:
// Check if the free area is really free.
//
for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) {
Data = ((UINT8 *) (UINTN) mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase)[Index];
Data = ((UINT8 *) (UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)[Index];
if (Data != 0xff) {
//
// There must be something wrong in variable store, do reclaim operation.
//
Status = Reclaim (
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase,
mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
&mVariableModuleGlobal->NonVolatileLastVariableOffset,
FALSE
);
@ -1717,3 +1746,78 @@ Returns:
return Status;
}
VOID
EFIAPI
VariableClassAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EfiConvertPointer (
0x0,
(VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase
);
EfiConvertPointer (
0x0,
(VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase
);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
}
/**
Variable Driver main entry point. The Variable driver places the 4 EFI
runtime services in the EFI System Table and installs arch protocols
for variable read and write services being availible.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
EFI_STATUS
EFIAPI
VariableServiceInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
Status = VariableCommonInitialize (ImageHandle, SystemTable);
ASSERT_EFI_ERROR (Status);
SystemTable->RuntimeServices->GetVariable = RuntimeServiceGetVariable;
SystemTable->RuntimeServices->GetNextVariableName = RuntimeServiceGetNextVariableName;
SystemTable->RuntimeServices->SetVariable = RuntimeServiceSetVariable;
SystemTable->RuntimeServices->QueryVariableInfo = RuntimeServiceQueryVariableInfo;
//
// Now install the Variable Runtime Architectural Protocol on a new handle
//
Status = gBS->InstallMultipleProtocolInterfaces (
&mHandle,
&gEfiVariableArchProtocolGuid, NULL,
&gEfiVariableWriteArchProtocolGuid, NULL,
NULL
);
ASSERT_EFI_ERROR (Status);
Status = gBS->CreateEvent (
EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
TPL_NOTIFY,
VariableClassAddressChangeEvent,
NULL,
&mVirtualAddressChangeEvent
);
ASSERT_EFI_ERROR (Status);
return EFI_SUCCESS;
}

87
MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
View File

@ -37,9 +37,12 @@ Abstract:
#include <Library/BaseLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/HobLib.h>
#include <Guid/FlashMapHob.h>
#include <Guid/VariableInfo.h>
#include <Guid/GlobalVariable.h>
#include <VariableFormat.h>
#define VARIABLE_RECLAIM_THRESHOLD (1024)
#define VARIABLE_STORE_SIZE (64 * 1024)
@ -56,10 +59,6 @@ Abstract:
#define GET_VARIABLE_NAME_PTR(a) (CHAR16 *) ((UINTN) (a) + sizeof (VARIABLE_HEADER))
typedef enum {
Physical,
Virtual
} VARIABLE_POINTER_TYPE;
typedef struct {
VARIABLE_HEADER *CurrPtr;
@ -75,23 +74,24 @@ typedef struct {
} VARIABLE_GLOBAL;
typedef struct {
VARIABLE_GLOBAL VariableGlobal[2];
VARIABLE_GLOBAL VariableGlobal;
UINTN VolatileLastVariableOffset;
UINTN NonVolatileLastVariableOffset;
UINT32 FvbInstance;
} ESAL_VARIABLE_GLOBAL;
} VARIABLE_MODULE_GLOBAL;
typedef struct {
EFI_GUID *Guid;
CHAR16 *Name;
UINT32 Attributes;
UINTN DataSize;
VOID *Data;
} VARIABLE_CACHE_ENTRY;
extern ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
//
// Functions
//
EFI_STATUS
EFIAPI
VariableCommonInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
EFI_STATUS
EFIAPI
@ -100,65 +100,6 @@ VariableServiceInitialize (
IN EFI_SYSTEM_TABLE *SystemTable
);
VOID
EFIAPI
VariableClassAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
);
EFI_STATUS
EFIAPI
GetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data,
IN VARIABLE_GLOBAL * Global,
IN UINT32 Instance
);
EFI_STATUS
EFIAPI
GetNextVariableName (
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid,
IN VARIABLE_GLOBAL *Global,
IN UINT32 Instance
);
EFI_STATUS
EFIAPI
SetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data,
IN VARIABLE_GLOBAL *Global,
IN UINTN *VolatileOffset,
IN UINTN *NonVolatileOffset,
IN UINT32 Instance
);
EFI_STATUS
EFIAPI
QueryVariableInfo (
IN UINT32 Attributes,
OUT UINT64 *MaximumVariableStorageSize,
OUT UINT64 *RemainingVariableStorageSize,
OUT UINT64 *MaximumVariableSize,
IN VARIABLE_GLOBAL *Global,
IN UINT32 Instance
);
EFI_STATUS
GetFvbHandleByAddress (
IN EFI_PHYSICAL_ADDRESS VariableStoreBase,
OUT EFI_HANDLE *FvbHandle
);
EFI_STATUS
FtwVariableSpace (

1
MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
View File

@ -34,7 +34,6 @@
#
[Sources.common]
InitVariable.c
reclaim.c
Variable.c
Variable.h

1
Nt32Pkg/PlatformBdsDxe/PlatformBdsDxe.inf
View File

@ -108,7 +108,6 @@
# ProcessorVersion # SOMETIMES_CONSUMED Data Hub
# SystemManufacturer # SOMETIMES_CONSUMED Data Hub
# BiosVendor # SOMETIMES_CONSUMED Data Hub
gEfiFlashMapHobGuid # ALWAYS_CONSUMED Hob: GUID_EXTENSION
gEfiDefaultBmpLogoGuid # SOMETIMES_CONSUMED
gEfiFileInfoGuid # ALWAYS_CONSUMED
gEfiFileSystemVolumeLabelInfoIdGuid # ALWAYS_CONSUMED

1
Nt32Pkg/WinNtFlashMapPei/WinNtFlashMapPei.inf
View File

@ -49,7 +49,6 @@
[Guids]
gEfiFlashMapHobGuid # ALWAYS_CONSUMED Hob: GUID_EXTENSION
gEfiFirmwareFileSystem2Guid # ALWAYS_CONSUMED