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] [Guids]
gEfiSystemNvDataFvGuid # ALWAYS_CONSUMED gEfiSystemNvDataFvGuid # ALWAYS_CONSUMED
gEfiFlashMapHobGuid
[Protocols] [Protocols]
gEfiFirmwareVolumeBlockProtocolGuid # PROTOCOL ALWAYS_CONSUMED 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;
}

402
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 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
All rights reserved. This program and the accompanying materials WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
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:
Variable.c
Abstract:
Revision History
--*/
#include "Variable.h" #include "Variable.h"
#include <Guid/FlashMapHob.h>
#include <Guid/VariableInfo.h>
#include <Guid/GlobalVariable.h>
VARIABLE_MODULE_GLOBAL mRuntimeData;
VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal = &mRuntimeData;
// EFI_EVENT mVirtualAddressChangeEvent = NULL;
// Don't use module globals after the SetVirtualAddress map is signaled EFI_HANDLE mHandle = NULL;
//
ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
// //
@ -68,6 +56,26 @@ ReleaseLockOnlyAtBootTime (
GLOBAL_REMOVE_IF_UNREFERENCED VARIABLE_INFO_ENTRY *gVariableInfo = NULL; 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 VOID
UpdateVariableInfo ( UpdateVariableInfo (
IN CHAR16 *VariableName, IN CHAR16 *VariableName,
@ -89,7 +97,13 @@ UpdateVariableInfo (
} }
if (gVariableInfo == NULL) { 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)); gVariableInfo = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
ASSERT (gVariableInfo != NULL);
CopyGuid (&gVariableInfo->VendorGuid, VendorGuid); CopyGuid (&gVariableInfo->VendorGuid, VendorGuid);
gVariableInfo->Name = AllocatePool (StrLen (VariableName)); gVariableInfo->Name = AllocatePool (StrLen (VariableName));
StrCpy (gVariableInfo->Name, VariableName); StrCpy (gVariableInfo->Name, VariableName);
@ -120,7 +134,12 @@ UpdateVariableInfo (
} }
if (Entry->Next == NULL) { 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)); Entry->Next = AllocateZeroPool (sizeof (VARIABLE_INFO_ENTRY));
ASSERT (Entry->Next != NULL);
CopyGuid (&Entry->Next->VendorGuid, VendorGuid); CopyGuid (&Entry->Next->VendorGuid, VendorGuid);
Entry->Next->Name = AllocatePool (StrLen (VariableName)); Entry->Next->Name = AllocatePool (StrLen (VariableName));
@ -134,9 +153,7 @@ UpdateVariableInfo (
STATIC
BOOLEAN BOOLEAN
EFIAPI
IsValidVariableHeader ( IsValidVariableHeader (
IN VARIABLE_HEADER *Variable IN VARIABLE_HEADER *Variable
) )
@ -165,9 +182,8 @@ Returns:
return TRUE; return TRUE;
} }
STATIC
EFI_STATUS EFI_STATUS
EFIAPI
UpdateVariableStore ( UpdateVariableStore (
IN VARIABLE_GLOBAL *Global, IN VARIABLE_GLOBAL *Global,
IN BOOLEAN Volatile, IN BOOLEAN Volatile,
@ -231,7 +247,7 @@ Returns:
// written // written
// //
if (SetByIndex) { if (SetByIndex) {
DataPtr += Global->NonVolatileVariableBase; DataPtr += mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase;
} }
if ((DataPtr + DataSize) >= ((EFI_PHYSICAL_ADDRESS) (UINTN) ((UINT8 *) FwVolHeader + FwVolHeader->FvLength))) { 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 // Data Pointer should point to the actual Address where data is to be
// written // written
// //
VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase); VolatileBase = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
if (SetByIndex) { if (SetByIndex) {
DataPtr += Global->VolatileVariableBase; DataPtr += mVariableModuleGlobal->VariableGlobal.VolatileVariableBase;
} }
if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) { if ((DataPtr + DataSize) >= ((UINTN) ((UINT8 *) VolatileBase + VolatileBase->Size))) {
@ -314,9 +330,8 @@ Returns:
return EFI_SUCCESS; return EFI_SUCCESS;
} }
STATIC
VARIABLE_STORE_STATUS VARIABLE_STORE_STATUS
EFIAPI
GetVariableStoreStatus ( GetVariableStoreStatus (
IN VARIABLE_STORE_HEADER *VarStoreHeader IN VARIABLE_STORE_HEADER *VarStoreHeader
) )
@ -356,9 +371,8 @@ Returns:
} }
} }
STATIC
UINT8 * UINT8 *
EFIAPI
GetVariableDataPtr ( GetVariableDataPtr (
IN VARIABLE_HEADER *Variable IN VARIABLE_HEADER *Variable
) )
@ -384,7 +398,7 @@ Returns:
return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize)); return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
} }
STATIC
VARIABLE_HEADER * VARIABLE_HEADER *
GetNextVariablePtr ( GetNextVariablePtr (
IN VARIABLE_HEADER *Variable IN VARIABLE_HEADER *Variable
@ -414,9 +428,8 @@ Returns:
return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize)); return (VARIABLE_HEADER *) ((UINTN) GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
} }
STATIC
VARIABLE_HEADER * VARIABLE_HEADER *
EFIAPI
GetEndPointer ( GetEndPointer (
IN VARIABLE_STORE_HEADER *VarStoreHeader IN VARIABLE_STORE_HEADER *VarStoreHeader
) )
@ -442,9 +455,8 @@ Returns:
return (VARIABLE_HEADER *) ((UINTN) VarStoreHeader + VarStoreHeader->Size); return (VARIABLE_HEADER *) ((UINTN) VarStoreHeader + VarStoreHeader->Size);
} }
STATIC
EFI_STATUS EFI_STATUS
EFIAPI
Reclaim ( Reclaim (
IN EFI_PHYSICAL_ADDRESS VariableBase, IN EFI_PHYSICAL_ADDRESS VariableBase,
OUT UINTN *LastVariableOffset, OUT UINTN *LastVariableOffset,
@ -559,13 +571,6 @@ Returns:
return Status; 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. // 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 VOID
UpdateVariableCache ( UpdateVariableCache (
IN CHAR16 *VariableName, IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid, IN EFI_GUID *VendorGuid,
OUT UINT32 Attributes, IN UINT32 Attributes,
IN OUT UINTN DataSize, IN UINTN DataSize,
OUT VOID *Data IN VOID *Data
) )
{ {
VARIABLE_CACHE_ENTRY *Entry; 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 EFI_STATUS
FindVariableInCache ( FindVariableInCache (
IN CHAR16 *VariableName, IN CHAR16 *VariableName,
@ -644,11 +674,14 @@ FindVariableInCache (
if (CompareGuid (VendorGuid, Entry->Guid)) { if (CompareGuid (VendorGuid, Entry->Guid)) {
if (StrCmp (VariableName, Entry->Name) == 0) { if (StrCmp (VariableName, Entry->Name) == 0) {
if (Entry->DataSize == 0) { if (Entry->DataSize == 0) {
// Variable was deleted so return not found
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} else if (Entry->DataSize != *DataSize) { } else if (Entry->DataSize != *DataSize) {
// If the buffer is too small return correct size
*DataSize = Entry->DataSize; *DataSize = Entry->DataSize;
return EFI_BUFFER_TOO_SMALL; return EFI_BUFFER_TOO_SMALL;
} else { } else {
// Return the data
CopyMem (Data, Entry->Data, Entry->DataSize); CopyMem (Data, Entry->Data, Entry->DataSize);
if (Attributes != NULL) { if (Attributes != NULL) {
*Attributes = Entry->Attributes; *Attributes = Entry->Attributes;
@ -700,13 +733,13 @@ Returns:
// SetVariable all call FindVariable at entry point. Please move "Aquire Lock" to // SetVariable all call FindVariable at entry point. Please move "Aquire Lock" to
// the correct places if this assumption does not hold TRUE anymore. // the correct places if this assumption does not hold TRUE anymore.
// //
AcquireLockOnlyAtBootTime(&Global->VariableServicesLock); AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
// //
// 0: Volatile, 1: Non-Volatile // 0: Volatile, 1: Non-Volatile
// //
VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase); VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase); VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
// //
// Start Pointers for the variable. // 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: 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; VARIABLE_POINTER_TRACK Variable;
UINTN VarDataSize; UINTN VarDataSize;
EFI_STATUS Status;
if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) { if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
@ -808,7 +840,7 @@ Returns:
return Status; return Status;
} }
Status = FindVariable (VariableName, VendorGuid, &Variable, Global); Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) { if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
goto Done; goto Done;
} }
@ -841,19 +873,12 @@ Returns:
} }
Done: Done:
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock); ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return Status; 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: Routine Description:
@ -873,6 +898,13 @@ Returns:
EFI STATUS EFI STATUS
--*/ --*/
EFI_STATUS
EFIAPI
RuntimeServiceGetNextVariableName (
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
)
{ {
VARIABLE_POINTER_TRACK Variable; VARIABLE_POINTER_TRACK Variable;
UINTN VarNameSize; UINTN VarNameSize;
@ -882,8 +914,7 @@ Returns:
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
Status = FindVariable (VariableName, VendorGuid, &Variable, Global); Status = FindVariable (VariableName, VendorGuid, &Variable, &mVariableModuleGlobal->VariableGlobal);
if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) { if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
goto Done; goto Done;
} }
@ -903,8 +934,8 @@ Returns:
if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) { if (Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL) {
Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1)); Variable.Volatile = (BOOLEAN) (Variable.Volatile ^ ((BOOLEAN) 0x1));
if (Variable.Volatile) { if (Variable.Volatile) {
Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (Global->VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER))); Variable.StartPtr = (VARIABLE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase + sizeof (VARIABLE_STORE_HEADER)));
Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase)); Variable.EndPtr = (VARIABLE_HEADER *) GetEndPointer ((VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase));
} else { } else {
Status = EFI_NOT_FOUND; Status = EFI_NOT_FOUND;
goto Done; goto Done;
@ -946,23 +977,11 @@ Returns:
} }
Done: Done:
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock); ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return Status; 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: Routine Description:
@ -992,6 +1011,15 @@ Returns:
EFI_WRITE_PROTECTED - Variable is read-only 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; VARIABLE_POINTER_TRACK Variable;
EFI_STATUS Status; EFI_STATUS Status;
@ -1002,8 +1030,14 @@ Returns:
UINTN VarSize; UINTN VarSize;
UINT8 State; UINT8 State;
BOOLEAN Reclaimed; BOOLEAN Reclaimed;
UINTN *VolatileOffset;
UINTN *NonVolatileOffset;
UINT32 Instance;
Reclaimed = FALSE; Reclaimed = FALSE;
VolatileOffset = &mVariableModuleGlobal->VolatileLastVariableOffset;
NonVolatileOffset = &mVariableModuleGlobal->NonVolatileLastVariableOffset;
Instance = mVariableModuleGlobal->FvbInstance;
// //
// Check input parameters // Check input parameters
@ -1041,7 +1075,7 @@ Returns:
// Check whether the input variable is already existed // 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) { if (Status == EFI_SUCCESS && Variable.CurrPtr != NULL) {
// //
@ -1075,7 +1109,7 @@ Returns:
State &= VAR_DELETED; State &= VAR_DELETED;
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
Variable.Volatile, Variable.Volatile,
FALSE, FALSE,
Instance, Instance,
@ -1108,7 +1142,7 @@ Returns:
State &= VAR_IN_DELETED_TRANSITION; State &= VAR_IN_DELETED_TRANSITION;
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
Variable.Volatile, Variable.Volatile,
FALSE, FALSE,
Instance, Instance,
@ -1157,7 +1191,7 @@ Returns:
// Tricky part: Use scratch data area at the end of volatile variable store // Tricky part: Use scratch data area at the end of volatile variable store
// as a temporary storage. // 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); SetMem (NextVariable, SCRATCH_SIZE, 0xff);
@ -1201,7 +1235,7 @@ Returns:
Variable.Volatile = FALSE; Variable.Volatile = FALSE;
if ((UINT32) (VarSize +*NonVolatileOffset) > if ((UINT32) (VarSize +*NonVolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
) { ) {
if (EfiAtRuntime ()) { if (EfiAtRuntime ()) {
Status = EFI_OUT_OF_RESOURCES; Status = EFI_OUT_OF_RESOURCES;
@ -1210,7 +1244,7 @@ Returns:
// //
// Perform garbage collection & reclaim operation // Perform garbage collection & reclaim operation
// //
Status = Reclaim (Global->NonVolatileVariableBase, NonVolatileOffset, FALSE); Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, NonVolatileOffset, FALSE);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
goto Done; goto Done;
} }
@ -1218,7 +1252,7 @@ Returns:
// If still no enough space, return out of resources // If still no enough space, return out of resources
// //
if ((UINT32) (VarSize +*NonVolatileOffset) > if ((UINT32) (VarSize +*NonVolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size
) { ) {
Status = EFI_OUT_OF_RESOURCES; Status = EFI_OUT_OF_RESOURCES;
goto Done; goto Done;
@ -1236,7 +1270,7 @@ Returns:
// Step 1: // Step 1:
// //
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
FALSE, FALSE,
TRUE, TRUE,
Instance, Instance,
@ -1252,7 +1286,7 @@ Returns:
// Step 2: // Step 2:
// //
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
FALSE, FALSE,
TRUE, TRUE,
Instance, Instance,
@ -1269,7 +1303,7 @@ Returns:
// //
NextVariable->State = VAR_ADDED; NextVariable->State = VAR_ADDED;
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
FALSE, FALSE,
TRUE, TRUE,
Instance, Instance,
@ -1291,11 +1325,11 @@ Returns:
Variable.Volatile = TRUE; Variable.Volatile = TRUE;
if ((UINT32) (VarSize +*VolatileOffset) > if ((UINT32) (VarSize +*VolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size) { ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size) {
// //
// Perform garbage collection & reclaim operation // Perform garbage collection & reclaim operation
// //
Status = Reclaim (Global->VolatileVariableBase, VolatileOffset, TRUE); Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, VolatileOffset, TRUE);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
goto Done; goto Done;
} }
@ -1303,7 +1337,7 @@ Returns:
// If still no enough space, return out of resources // If still no enough space, return out of resources
// //
if ((UINT32) (VarSize +*VolatileOffset) > if ((UINT32) (VarSize +*VolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size ((VARIABLE_STORE_HEADER *) ((UINTN) (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase)))->Size
) { ) {
Status = EFI_OUT_OF_RESOURCES; Status = EFI_OUT_OF_RESOURCES;
goto Done; goto Done;
@ -1314,7 +1348,7 @@ Returns:
NextVariable->State = VAR_ADDED; NextVariable->State = VAR_ADDED;
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
TRUE, TRUE,
TRUE, TRUE,
Instance, Instance,
@ -1337,7 +1371,7 @@ Returns:
State &= VAR_DELETED; State &= VAR_DELETED;
Status = UpdateVariableStore ( Status = UpdateVariableStore (
Global, &mVariableModuleGlobal->VariableGlobal,
Variable.Volatile, Variable.Volatile,
FALSE, FALSE,
Instance, Instance,
@ -1358,20 +1392,11 @@ Returns:
UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data); UpdateVariableCache (VariableName, VendorGuid, Attributes, DataSize, Data);
Done: Done:
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock); ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return Status; 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: Routine Description:
@ -1399,6 +1424,14 @@ Returns:
EFI_UNSUPPORTED - The attribute is not supported on this platform. 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 *Variable;
VARIABLE_HEADER *NextVariable; VARIABLE_HEADER *NextVariable;
@ -1426,18 +1459,18 @@ Returns:
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
AcquireLockOnlyAtBootTime(&Global->VariableServicesLock); AcquireLockOnlyAtBootTime(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) { if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
// //
// Query is Volatile related. // Query is Volatile related.
// //
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase); VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
} else { } else {
// //
// Query is Non-Volatile related. // 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); *MaximumVariableSize = *RemainingVariableStorageSize - sizeof (VARIABLE_HEADER);
} }
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock); ReleaseLockOnlyAtBootTime (&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
EFIAPI
VariableCommonInitialize ( VariableCommonInitialize (
IN EFI_HANDLE ImageHandle, IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable IN EFI_SYSTEM_TABLE *SystemTable
@ -1541,18 +1573,15 @@ Returns:
EFI_PHYSICAL_ADDRESS FvVolHdr; EFI_PHYSICAL_ADDRESS FvVolHdr;
UINT64 TempVariableStoreHeader; UINT64 TempVariableStoreHeader;
EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor; EFI_GCD_MEMORY_SPACE_DESCRIPTOR GcdDescriptor;
EFI_FLASH_SUBAREA_ENTRY VariableStoreEntry;
UINT64 BaseAddress; UINT64 BaseAddress;
UINT64 Length; UINT64 Length;
UINTN Index; UINTN Index;
UINT8 Data; 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 // Allocate memory for volatile variable store
@ -1568,7 +1597,7 @@ Returns:
// //
// Variable Specific Data // 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); mVariableModuleGlobal->VolatileLastVariableOffset = sizeof (VARIABLE_STORE_HEADER);
VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE; VolatileVariableStore->Signature = VARIABLE_STORE_SIGNATURE;
@ -1583,15 +1612,15 @@ Returns:
// //
TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase); TempVariableStoreHeader = (UINT64) PcdGet32 (PcdFlashNvStorageVariableBase);
VariableStoreEntry.Base = TempVariableStoreHeader + \ VariableStoreBase = TempVariableStoreHeader + \
(((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength); (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
VariableStoreEntry.Length = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \ VariableStoreLength = (UINT64) PcdGet32 (PcdFlashNvStorageVariableSize) - \
(((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength); (((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (TempVariableStoreHeader)) -> HeaderLength);
// //
// Mark the variable storage region of the FLASH as RUNTIME // Mark the variable storage region of the FLASH as RUNTIME
// //
BaseAddress = VariableStoreEntry.Base & (~EFI_PAGE_MASK); BaseAddress = VariableStoreBase & (~EFI_PAGE_MASK);
Length = VariableStoreEntry.Length + (VariableStoreEntry.Base - BaseAddress); Length = VariableStoreLength + (VariableStoreBase - BaseAddress);
Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK); Length = (Length + EFI_PAGE_SIZE - 1) & (~EFI_PAGE_MASK);
Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor); Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &GcdDescriptor);
@ -1614,7 +1643,7 @@ Returns:
// //
// Get address of non volatile variable store base // Get address of non volatile variable store base
// //
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase = VariableStoreEntry.Base; mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase = VariableStoreBase;
// //
// Check Integrity // Check Integrity
@ -1623,7 +1652,7 @@ Returns:
// Find the Correct Instance of the FV Block Service. // Find the Correct Instance of the FV Block Service.
// //
Instance = 0; Instance = 0;
CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase); CurrPtr = (CHAR8 *) ((UINTN) mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) { while (EfiFvbGetPhysicalAddress (Instance, &FvVolHdr) == EFI_SUCCESS) {
FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr); FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);
if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) { if (CurrPtr >= (CHAR8 *) FwVolHeader && CurrPtr < (((CHAR8 *) FwVolHeader) + FwVolHeader->FvLength)) {
@ -1638,13 +1667,13 @@ Returns:
if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) { if (GetVariableStoreStatus (VariableStoreHeader) == EfiValid) {
if (~VariableStoreHeader->Size == 0) { if (~VariableStoreHeader->Size == 0) {
Status = UpdateVariableStore ( Status = UpdateVariableStore (
&mVariableModuleGlobal->VariableGlobal[Physical], &mVariableModuleGlobal->VariableGlobal,
FALSE, FALSE,
FALSE, FALSE,
mVariableModuleGlobal->FvbInstance, mVariableModuleGlobal->FvbInstance,
(UINTN) &VariableStoreHeader->Size, (UINTN) &VariableStoreHeader->Size,
sizeof (UINT32), sizeof (UINT32),
(UINT8 *) &VariableStoreEntry.Length (UINT8 *) &VariableStoreLength
); );
// //
// As Variables are stored in NV storage, which are slow devices,such as flash. // 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. // We can assume all Read/Write is OK if we can set Variable store size successfully.
// If write fail, we will assert here // If write fail, we will assert here
// //
ASSERT(VariableStoreHeader->Size == VariableStoreEntry.Length); ASSERT(VariableStoreHeader->Size == VariableStoreLength);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
return 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 // 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) { if ((((VARIABLE_STORE_HEADER *)((UINTN) CurrPtr))->Size - mVariableModuleGlobal->NonVolatileLastVariableOffset) < VARIABLE_RECLAIM_THRESHOLD) {
Status = Reclaim ( Status = Reclaim (
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase, mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
&mVariableModuleGlobal->NonVolatileLastVariableOffset, &mVariableModuleGlobal->NonVolatileLastVariableOffset,
FALSE FALSE
); );
@ -1695,13 +1724,13 @@ Returns:
// Check if the free area is really free. // Check if the free area is really free.
// //
for (Index = mVariableModuleGlobal->NonVolatileLastVariableOffset; Index < VariableStoreHeader->Size; Index++) { 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) { if (Data != 0xff) {
// //
// There must be something wrong in variable store, do reclaim operation. // There must be something wrong in variable store, do reclaim operation.
// //
Status = Reclaim ( Status = Reclaim (
mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase, mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
&mVariableModuleGlobal->NonVolatileLastVariableOffset, &mVariableModuleGlobal->NonVolatileLastVariableOffset,
FALSE FALSE
); );
@ -1717,3 +1746,78 @@ Returns:
return Status; 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/BaseLib.h>
#include <Library/MemoryAllocationLib.h> #include <Library/MemoryAllocationLib.h>
#include <Library/HobLib.h> #include <Library/HobLib.h>
#include <Guid/FlashMapHob.h> #include <Guid/VariableInfo.h>
#include <Guid/GlobalVariable.h>
#include <VariableFormat.h> #include <VariableFormat.h>
#define VARIABLE_RECLAIM_THRESHOLD (1024) #define VARIABLE_RECLAIM_THRESHOLD (1024)
#define VARIABLE_STORE_SIZE (64 * 1024) #define VARIABLE_STORE_SIZE (64 * 1024)
@ -56,10 +59,6 @@ Abstract:
#define GET_VARIABLE_NAME_PTR(a) (CHAR16 *) ((UINTN) (a) + sizeof (VARIABLE_HEADER)) #define GET_VARIABLE_NAME_PTR(a) (CHAR16 *) ((UINTN) (a) + sizeof (VARIABLE_HEADER))
typedef enum {
Physical,
Virtual
} VARIABLE_POINTER_TYPE;
typedef struct { typedef struct {
VARIABLE_HEADER *CurrPtr; VARIABLE_HEADER *CurrPtr;
@ -75,23 +74,24 @@ typedef struct {
} VARIABLE_GLOBAL; } VARIABLE_GLOBAL;
typedef struct { typedef struct {
VARIABLE_GLOBAL VariableGlobal[2]; VARIABLE_GLOBAL VariableGlobal;
UINTN VolatileLastVariableOffset; UINTN VolatileLastVariableOffset;
UINTN NonVolatileLastVariableOffset; UINTN NonVolatileLastVariableOffset;
UINT32 FvbInstance; 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 // Functions
// //
EFI_STATUS
EFIAPI
VariableCommonInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
@ -100,65 +100,6 @@ VariableServiceInitialize (
IN EFI_SYSTEM_TABLE *SystemTable 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 EFI_STATUS
FtwVariableSpace ( FtwVariableSpace (

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

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

1
Nt32Pkg/PlatformBdsDxe/PlatformBdsDxe.inf
View File

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

1
Nt32Pkg/WinNtFlashMapPei/WinNtFlashMapPei.inf
View File

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