Virtualization
/
edk2
mirror of https://gitlab.com/qemu-project/edk2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add in EmuVariableRuntimeDxe 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3123 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
qwang12 2007-07-06 10:39:15 +00:00
parent 46913d4de4
commit f80315c3c9
8 changed files with 1773 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

849
MdeModulePkg/Universal/EmuVariableRuntimeDxe/EmuVariable.c Normal file
View File

@ -0,0 +1,849 @@
/*++
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:
EmuVariable.c
Abstract:
Revision History
--*/
#include "Variable.h"
//
// Don't use module globals after the SetVirtualAddress map is signaled
//
ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
//
// This is a temperary function which will be removed
// when EfiAcquireLock in UefiLib can handle the
// the call in UEFI Runtimer driver in RT phase.
//
STATIC
VOID
AcquireLockOnlyAtBootTime (
IN EFI_LOCK *Lock
)
{
if (!EfiAtRuntime ()) {
EfiAcquireLock (Lock);
}
}
//
// This is a temperary function which will be removed
// when EfiAcquireLock in UefiLib can handle the
// the call in UEFI Runtimer driver in RT phase.
//
STATIC
VOID
ReleaseLockOnlyAtBootTime (
IN EFI_LOCK *Lock
)
{
if (!EfiAtRuntime ()) {
EfiReleaseLock (Lock);
}
}
STATIC
UINT8 *
EFIAPI
GetVariableDataPtr (
IN VARIABLE_HEADER *Variable
)
/*++
Routine Description:
This code gets the pointer to the variable data.
Arguments:
Variable Pointer to the Variable Header.
Returns:
UINT8* Pointer to Variable Data
--*/
{
if (Variable->StartId != VARIABLE_DATA) {
return NULL;
}
//
// Be careful about pad size for alignment
//
return (UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (Variable) + Variable->NameSize + GET_PAD_SIZE (Variable->NameSize));
}
STATIC
VARIABLE_HEADER *
EFIAPI
GetNextVariablePtr (
IN VARIABLE_HEADER *Variable
)
/*++
Routine Description:
This code gets the pointer to the next variable header.
Arguments:
Variable Pointer to the Variable Header.
Returns:
VARIABLE_HEADER* Pointer to next variable header.
--*/
{
VARIABLE_HEADER *VarHeader;
if (Variable->StartId != VARIABLE_DATA) {
return NULL;
}
//
// Be careful about pad size for alignment
//
VarHeader = (VARIABLE_HEADER *) (GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
if (VarHeader->StartId != VARIABLE_DATA ||
(sizeof (VARIABLE_HEADER) + VarHeader->DataSize + VarHeader->NameSize) > MAX_VARIABLE_SIZE
) {
return NULL;
}
return VarHeader;
}
STATIC
VARIABLE_HEADER *
EFIAPI
GetEndPointer (
IN VARIABLE_STORE_HEADER *VolHeader
)
/*++
Routine Description:
This code gets the pointer to the last variable memory pointer byte
Arguments:
Variable Pointer to the Variable Header.
Returns:
VARIABLE_HEADER* Pointer to last unavailable Variable Header
--*/
{
//
// The end of variable store
//
return (VARIABLE_HEADER *) ((UINTN) VolHeader + VolHeader->Size);
}
STATIC
EFI_STATUS
EFIAPI
FindVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack,
IN VARIABLE_GLOBAL *Global
)
/*++
Routine Description:
This code finds variable in storage blocks (Volatile or Non-Volatile)
Arguments:
VariableName Name of the variable to be found
VendorGuid Vendor GUID to be found.
PtrTrack Variable Track Pointer structure that contains
Variable Information.
Contains the pointer of Variable header.
Global VARIABLE_GLOBAL pointer
Returns:
EFI STATUS
--*/
{
VARIABLE_HEADER *Variable[2];
VARIABLE_STORE_HEADER *VariableStoreHeader[2];
UINTN Index;
//
// We aquire the lock at the entry of FindVariable as GetVariable, GetNextVariableName
// 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);
//
// 0: Non-Volatile, 1: Volatile
//
VariableStoreHeader[0] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);
VariableStoreHeader[1] = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
//
// Start Pointers for the variable.
// Actual Data Pointer where data can be written.
//
Variable[0] = (VARIABLE_HEADER *) (VariableStoreHeader[0] + 1);
Variable[1] = (VARIABLE_HEADER *) (VariableStoreHeader[1] + 1);
if (VariableName[0] != 0 && VendorGuid == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Find the variable by walk through non-volatile and volatile variable store
//
for (Index = 0; Index < 2; Index++) {
PtrTrack->StartPtr = (VARIABLE_HEADER *) (VariableStoreHeader[Index] + 1);
PtrTrack->EndPtr = GetEndPointer (VariableStoreHeader[Index]);
while ((Variable[Index] != NULL) && (Variable[Index] <= GetEndPointer (VariableStoreHeader[Index]))) {
if (Variable[Index]->StartId == VARIABLE_DATA && Variable[Index]->State == VAR_ADDED) {
if (!(EfiAtRuntime () && !(Variable[Index]->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {
if (VariableName[0] == 0) {
PtrTrack->CurrPtr = Variable[Index];
PtrTrack->Volatile = (BOOLEAN) Index;
return EFI_SUCCESS;
} else {
if (CompareGuid (VendorGuid, &Variable[Index]->VendorGuid)) {
if (!CompareMem (VariableName, GET_VARIABLE_NAME_PTR (Variable[Index]), Variable[Index]->NameSize)) {
PtrTrack->CurrPtr = Variable[Index];
PtrTrack->Volatile = (BOOLEAN) Index;
return EFI_SUCCESS;
}
}
}
}
}
Variable[Index] = GetNextVariablePtr (Variable[Index]);
}
}
PtrTrack->CurrPtr = NULL;
return EFI_NOT_FOUND;
}
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:
This code finds variable in storage blocks (Volatile or Non-Volatile)
Arguments:
VariableName Name of Variable to be found
VendorGuid Variable vendor GUID
Attributes OPTIONAL Attribute value of the variable found
DataSize Size of Data found. If size is less than the
data, this value contains the required size.
Data Data pointer
Global Pointer to VARIABLE_GLOBAL structure
Instance Instance of the Firmware Volume.
Returns:
EFI STATUS
--*/
{
VARIABLE_POINTER_TRACK Variable;
UINTN VarDataSize;
EFI_STATUS Status;
if (VariableName == NULL || VendorGuid == NULL || DataSize == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Find existing variable
//
Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
goto Done;
}
//
// Get data size
//
VarDataSize = Variable.CurrPtr->DataSize;
if (*DataSize >= VarDataSize) {
if (Data == NULL) {
Status = EFI_INVALID_PARAMETER;
goto Done;
}
CopyMem (Data, GetVariableDataPtr (Variable.CurrPtr), VarDataSize);
if (Attributes != NULL) {
*Attributes = Variable.CurrPtr->Attributes;
}
*DataSize = VarDataSize;
Status = EFI_SUCCESS;
goto Done;
} else {
*DataSize = VarDataSize;
Status = EFI_BUFFER_TOO_SMALL;
goto Done;
}
Done:
ReleaseLockOnlyAtBootTime (&Global->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:
This code Finds the Next available variable
Arguments:
VariableNameSize Size of the variable
VariableName Pointer to variable name
VendorGuid Variable Vendor Guid
Global VARIABLE_GLOBAL structure pointer.
Instance FV instance
Returns:
EFI STATUS
--*/
{
VARIABLE_POINTER_TRACK Variable;
UINTN VarNameSize;
EFI_STATUS Status;
if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {
goto Done;
}
while (TRUE) {
if (VariableName[0] != 0) {
//
// If variable name is not NULL, get next variable
//
Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
}
//
// If both volatile and non-volatile variable store are parsed,
// return not found
//
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));
} else {
Status = EFI_NOT_FOUND;
goto Done;
}
Variable.CurrPtr = Variable.StartPtr;
if (Variable.CurrPtr->StartId != VARIABLE_DATA) {
continue;
}
}
//
// Variable is found
//
if (Variable.CurrPtr->StartId == VARIABLE_DATA && Variable.CurrPtr->State == VAR_ADDED) {
if (!(EfiAtRuntime () && !(Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS))) {
VarNameSize = Variable.CurrPtr->NameSize;
if (VarNameSize <= *VariableNameSize) {
CopyMem (
VariableName,
GET_VARIABLE_NAME_PTR (Variable.CurrPtr),
VarNameSize
);
CopyMem (
VendorGuid,
&Variable.CurrPtr->VendorGuid,
sizeof (EFI_GUID)
);
Status = EFI_SUCCESS;
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*VariableNameSize = VarNameSize;
goto Done;
}
}
}
Done:
ReleaseLockOnlyAtBootTime (&Global->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:
This code sets variable in storage blocks (Volatile or Non-Volatile)
Arguments:
VariableName Name of Variable to be found
VendorGuid Variable vendor GUID
Attributes Attribute value of the variable found
DataSize Size of Data found. If size is less than the
data, this value contains the required size.
Data Data pointer
Global Pointer to VARIABLE_GLOBAL structure
VolatileOffset The offset of last volatile variable
NonVolatileOffset The offset of last non-volatile variable
Instance Instance of the Firmware Volume.
Returns:
EFI STATUS
--*/
{
VARIABLE_POINTER_TRACK Variable;
EFI_STATUS Status;
VARIABLE_HEADER *NextVariable;
UINTN VarNameSize;
UINTN VarNameOffset;
UINTN VarDataOffset;
UINTN VarSize;
if (VariableName == NULL || VariableName[0] == 0 || VendorGuid == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = FindVariable (VariableName, VendorGuid, &Variable, Global);
if (Status == EFI_INVALID_PARAMETER) {
goto Done;
} else if (!EFI_ERROR (Status) && Variable.Volatile && EfiAtRuntime()) {
//
// If EfiAtRuntime and the variable is Volatile and Runtime Access,
// the volatile is ReadOnly, and SetVariable should be aborted and
// return EFI_WRITE_PROTECTED.
//
Status = EFI_WRITE_PROTECTED;
goto Done;
} else if (sizeof (VARIABLE_HEADER) + (StrSize (VariableName) + DataSize) > MAX_VARIABLE_SIZE) {
//
// The size of the VariableName, including the Unicode Null in bytes plus
// the DataSize is limited to maximum size of MAX_VARIABLE_SIZE (1024) bytes.
//
Status = EFI_INVALID_PARAMETER;
goto Done;
} else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS
) {
//
// Make sure if runtime bit is set, boot service bit is set also
//
Status = EFI_INVALID_PARAMETER;
goto Done;
} else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
//
// Runtime but Attribute is not Runtime
//
Status = EFI_INVALID_PARAMETER;
goto Done;
} else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_NON_VOLATILE)) {
//
// Cannot set volatile variable in Runtime
//
Status = EFI_INVALID_PARAMETER;
goto Done;
} else if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {
//
// Setting a data variable with no access, or zero DataSize attributes
// specified causes it to be deleted.
//
if (!EFI_ERROR (Status)) {
Variable.CurrPtr->State &= VAR_DELETED;
Status = EFI_SUCCESS;
goto Done;
}
Status = EFI_NOT_FOUND;
goto Done;
} else {
if (!EFI_ERROR (Status)) {
//
// If the variable is marked valid and the same data has been passed in
// then return to the caller immediately.
//
if (Variable.CurrPtr->DataSize == DataSize &&
!CompareMem (Data, GetVariableDataPtr (Variable.CurrPtr), DataSize)
) {
Status = EFI_SUCCESS;
goto Done;
} else if (Variable.CurrPtr->State == VAR_ADDED) {
//
// Mark the old variable as in delete transition
//
Variable.CurrPtr->State &= VAR_IN_DELETED_TRANSITION;
}
}
//
// Create a new variable and copy the data.
//
VarNameOffset = sizeof (VARIABLE_HEADER);
VarNameSize = StrSize (VariableName);
VarDataOffset = VarNameOffset + VarNameSize + GET_PAD_SIZE (VarNameSize);
VarSize = VarDataOffset + DataSize + GET_PAD_SIZE (DataSize);
if (Attributes & EFI_VARIABLE_NON_VOLATILE) {
if ((UINT32) (VarSize +*NonVolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->NonVolatileVariableBase)))->Size
) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
NextVariable = (VARIABLE_HEADER *) (UINT8 *) (*NonVolatileOffset + (UINTN) Global->NonVolatileVariableBase);
*NonVolatileOffset = *NonVolatileOffset + VarSize;
} else {
if (EfiAtRuntime ()) {
Status = EFI_INVALID_PARAMETER;
goto Done;
}
if ((UINT32) (VarSize +*VolatileOffset) >
((VARIABLE_STORE_HEADER *) ((UINTN) (Global->VolatileVariableBase)))->Size
) {
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
NextVariable = (VARIABLE_HEADER *) (UINT8 *) (*VolatileOffset + (UINTN) Global->VolatileVariableBase);
*VolatileOffset = *VolatileOffset + VarSize;
}
NextVariable->StartId = VARIABLE_DATA;
NextVariable->Attributes = Attributes;
NextVariable->State = VAR_ADDED;
NextVariable->Reserved = 0;
//
// There will be pad bytes after Data, the NextVariable->NameSize and
// NextVariable->NameSize should not include pad size so that variable
// service can get actual size in GetVariable
//
NextVariable->NameSize = (UINT32)VarNameSize;
NextVariable->DataSize = (UINT32)DataSize;
CopyMem (&NextVariable->VendorGuid, VendorGuid, sizeof (EFI_GUID));
CopyMem (
(UINT8 *) ((UINTN) NextVariable + VarNameOffset),
VariableName,
VarNameSize
);
CopyMem (
(UINT8 *) ((UINTN) NextVariable + VarDataOffset),
Data,
DataSize
);
//
// Mark the old variable as deleted
//
if (!EFI_ERROR (Status)) {
Variable.CurrPtr->State &= VAR_DELETED;
}
}
Status = EFI_SUCCESS;
Done:
ReleaseLockOnlyAtBootTime (&Global->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:
This code returns information about the EFI variables.
Arguments:
Attributes Attributes bitmask to specify the type of variables
on which to return information.
MaximumVariableStorageSize Pointer to the maximum size of the storage space available
for the EFI variables associated with the attributes specified.
RemainingVariableStorageSize Pointer to the remaining size of the storage space available
for the EFI variables associated with the attributes specified.
MaximumVariableSize Pointer to the maximum size of the individual EFI variables
associated with the attributes specified.
Global Pointer to VARIABLE_GLOBAL structure.
Instance Instance of the Firmware Volume.
Returns:
EFI STATUS
EFI_INVALID_PARAMETER - An invalid combination of attribute bits was supplied.
EFI_SUCCESS - Query successfully.
EFI_UNSUPPORTED - The attribute is not supported on this platform.
--*/
{
VARIABLE_HEADER *Variable;
VARIABLE_HEADER *NextVariable;
UINT64 VariableSize;
VARIABLE_STORE_HEADER *VariableStoreHeader;
if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL) {
return EFI_INVALID_PARAMETER;
}
if((Attributes & (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)) == 0) {
//
// Make sure the Attributes combination is supported by the platform.
//
return EFI_UNSUPPORTED;
} else if ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == EFI_VARIABLE_RUNTIME_ACCESS) {
//
// Make sure if runtime bit is set, boot service bit is set also.
//
return EFI_INVALID_PARAMETER;
} else if (EfiAtRuntime () && !(Attributes & EFI_VARIABLE_RUNTIME_ACCESS)) {
//
// Make sure RT Attribute is set if we are in Runtime phase.
//
return EFI_INVALID_PARAMETER;
} else if (EfiAtRuntime () && Attributes && !(Attributes & EFI_VARIABLE_NON_VOLATILE)) {
//
// Cannot Query volatile variable in Runtime
//
return EFI_INVALID_PARAMETER;
}
AcquireLockOnlyAtBootTime(&Global->VariableServicesLock);
if((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
//
// Query is Volatile related.
//
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->VolatileVariableBase);
} else {
//
// Query is Non-Volatile related.
//
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) Global->NonVolatileVariableBase);
}
//
// Now let's fill *MaximumVariableStorageSize *RemainingVariableStorageSize
// with the storage size (excluding the storage header size)
//
*MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
*RemainingVariableStorageSize = VariableStoreHeader->Size - sizeof (VARIABLE_STORE_HEADER);
//
// Let *MaximumVariableSize be MAX_VARIABLE_SIZE
//
*MaximumVariableSize = MAX_VARIABLE_SIZE;
//
// Point to the starting address of the variables.
//
Variable = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
//
// Now walk through the related variable store.
//
while (Variable < GetEndPointer (VariableStoreHeader)) {
if (Variable->StartId != VARIABLE_DATA) {
break;
}
NextVariable = (VARIABLE_HEADER *) (GetVariableDataPtr (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
VariableSize = (UINT64) (UINTN) NextVariable - (UINT64) (UINTN) Variable;
if (Variable->State == VAR_ADDED) {
*RemainingVariableStorageSize -= VariableSize;
}
//
// Go to the next one.
//
Variable = NextVariable;
}
ReleaseLockOnlyAtBootTime (&Global->VariableServicesLock);
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
InitializeVariableStore (
OUT EFI_PHYSICAL_ADDRESS *VariableBase,
OUT UINTN *LastVariableOffset
)
/*++
Routine Description:
This function initializes variable store
Arguments:
Returns:
--*/
{
VARIABLE_STORE_HEADER *VariableStore;
//
// Allocate memory for volatile variable store
//
VariableStore = (VARIABLE_STORE_HEADER *) AllocateRuntimePool (
VARIABLE_STORE_SIZE
);
if (NULL == VariableStore) {
return EFI_OUT_OF_RESOURCES;
}
SetMem (VariableStore, VARIABLE_STORE_SIZE, 0xff);
//
// Variable Specific Data
//
*VariableBase = (EFI_PHYSICAL_ADDRESS) (UINTN) VariableStore;
*LastVariableOffset = sizeof (VARIABLE_STORE_HEADER);
VariableStore->Signature = VARIABLE_STORE_SIGNATURE;
VariableStore->Size = VARIABLE_STORE_SIZE;
VariableStore->Format = VARIABLE_STORE_FORMATTED;
VariableStore->State = VARIABLE_STORE_HEALTHY;
VariableStore->Reserved = 0;
VariableStore->Reserved1 = 0;
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
VariableCommonInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
This function does common initialization for variable services
Arguments:
Returns:
--*/
{
EFI_STATUS Status;
//
// Allocate memory for mVariableModuleGlobal
//
mVariableModuleGlobal = (ESAL_VARIABLE_GLOBAL *) AllocateRuntimePool (
sizeof (ESAL_VARIABLE_GLOBAL)
);
if (NULL == mVariableModuleGlobal) {
return EFI_OUT_OF_RESOURCES;
}
EfiInitializeLock(&mVariableModuleGlobal->VariableGlobal[Physical].VariableServicesLock, TPL_NOTIFY);
//
// Intialize volatile variable store
//
Status = InitializeVariableStore (
&mVariableModuleGlobal->VariableGlobal[Physical].VolatileVariableBase,
&mVariableModuleGlobal->VolatileLastVariableOffset
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Intialize non volatile variable store
//
Status = InitializeVariableStore (
&mVariableModuleGlobal->VariableGlobal[Physical].NonVolatileVariableBase,
&mVariableModuleGlobal->NonVolatileLastVariableOffset
);
return Status;
}

106
MdeModulePkg/Universal/EmuVariableRuntimeDxe/EmuVariable.infa Normal file
View File

@ -0,0 +1,106 @@
#/** @file
# Emulation Variable for EFI_RUNTIME_SERVICES.
#
# This module provides three EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName
# 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.
#
#
#**/
################################################################################
#
# Defines Section - statements that will be processed to create a Makefile.
#
################################################################################
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = EmuVariable
FILE_GUID = CBD2E4D5-7068-4FF5-B866-9822B4AD8D61
MODULE_TYPE = DXE_RUNTIME_DRIVER
VERSION_STRING = 1.0
EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x00020000
ENTRY_POINT = VariableServiceInitialize
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64 EBC
#
################################################################################
#
# Sources Section - list of files that are required for the build to succeed.
#
################################################################################
[Sources.common]
InitVariable.c
EmuVariable.c
Variable.h
################################################################################
#
# Package Dependency Section - list of Package files that are required for
# this module.
#
################################################################################
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
################################################################################
#
# Library Class Section - list of Library Classes that are required for
# this module.
#
################################################################################
[LibraryClasses]
BaseLib
UefiLib
UefiBootServicesTableLib
UefiDriverEntryPoint
UefiRuntimeLib
DebugLib
MemoryAllocationLib
BaseMemoryLib
################################################################################
#
# Protocol C Name Section - list of Protocol and Protocol Notify C Names
# that this module uses or produces.
#
################################################################################
[Protocols.IA32]
gEfiVariableArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED
gEfiVariableWriteArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED
[Protocols.X64]
gEfiVariableArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED
gEfiVariableWriteArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED
################################################################################
#
# Dependency Expression Section - list of Dependency expressions that are required for
# this module.
#
################################################################################
[Depex]
TRUE

75
MdeModulePkg/Universal/EmuVariableRuntimeDxe/EmuVariable.msa Normal file
View File

@ -0,0 +1,75 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<MsaHeader>
<ModuleName>EmuVariable</ModuleName>
<ModuleType>DXE_RUNTIME_DRIVER</ModuleType>
<GuidValue>CBD2E4D5-7068-4FF5-B866-9822B4AD8D61</GuidValue>
<Version>1.0</Version>
<Abstract>Emulation Variable for EFI_RUNTIME_SERVICES.</Abstract>
<Description>This module provides three EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName</Description>
<Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>
<License>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.</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IA32 X64 EBC</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>EmuVariable</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseMemoryLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiRuntimeLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverEntryPoint</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiBootServicesTableLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>Variable.h</Filename>
<Filename>EmuVariable.c</Filename>
<Filename>EmuVariable.dxs</Filename>
<Filename>InitVariable.c</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
</PackageDependencies>
<Protocols>
<Protocol Usage="ALWAYS_PRODUCED" SupArchList="IA32 X64">
<ProtocolCName>gEfiVariableWriteArchProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_PRODUCED" SupArchList="IA32 X64">
<ProtocolCName>gEfiVariableArchProtocolGuid</ProtocolCName>
</Protocol>
</Protocols>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
<Extern>
<ModuleEntryPoint>VariableServiceInitialize</ModuleEntryPoint>
</Extern>
</Externs>
</ModuleSurfaceArea>

102
MdeModulePkg/Universal/EmuVariableRuntimeDxe/EmuVariableIpf.inf Normal file
View File

@ -0,0 +1,102 @@
#/** @file
# Emulation Variable for EFI_RUNTIME_SERVICES.
#
# This module provides three EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName
# 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.
#
#
#**/
################################################################################
#
# Defines Section - statements that will be processed to create a Makefile.
#
################################################################################
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = EmuVariableIpf
FILE_GUID = A46320E8-0514-489a-BC4E-481624D9CE33
MODULE_TYPE = DXE_SAL_DRIVER
VERSION_STRING = 1.0
EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x00020000
ENTRY_POINT = VariableServiceInitialize
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IPF
#
################################################################################
#
# Sources Section - list of files that are required for the build to succeed.
#
################################################################################
[Sources.common]
Ipf/InitVariable.c
EmuVariable.c
Variable.h
################################################################################
#
# Package Dependency Section - list of Package files that are required for
# this module.
#
################################################################################
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
################################################################################
#
# Library Class Section - list of Library Classes that are required for
# this module.
#
################################################################################
[LibraryClasses]
ExtendedSalLib
BaseLib
UefiLib
UefiBootServicesTableLib
UefiDriverEntryPoint
UefiRuntimeLib
DebugLib
MemoryAllocationLib
BaseMemoryLib
################################################################################
#
# Protocol C Name Section - list of Protocol and Protocol Notify C Names
# that this module uses or produces.
#
################################################################################
[Protocols]
gEfiExtendedSalVariableServicesProtocolGuid # PROTOCOL ALWAYS_CONSUMED
################################################################################
#
# Dependency Expression Section - list of Dependency expressions that are required for
# this module.
#
################################################################################
[Depex]
TRUE

75
MdeModulePkg/Universal/EmuVariableRuntimeDxe/EmuVariableIpf.msa Normal file
View File

@ -0,0 +1,75 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<MsaHeader>
<ModuleName>EmuVariableIpf</ModuleName>
<ModuleType>DXE_SAL_DRIVER</ModuleType>
<GuidValue>A46320E8-0514-489a-BC4E-481624D9CE33</GuidValue>
<Version>1.0</Version>
<Abstract>Emulation Variable for EFI_RUNTIME_SERVICES.</Abstract>
<Description>This module provides three EFI_RUNTIME_SERVICES: SetVariable, GetVariable, GetNextVariableName</Description>
<Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>
<License>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.</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IPF</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>EmuVariableIpf</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseMemoryLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiRuntimeLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverEntryPoint</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiBootServicesTableLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>ExtendedSalLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>Variable.h</Filename>
<Filename>EmuVariable.c</Filename>
<Filename>EmuVariable.dxs</Filename>
<Filename>Ipf/InitVariable.c</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
</PackageDependencies>
<Protocols>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiExtendedSalVariableServicesProtocolGuid</ProtocolCName>
</Protocol>
</Protocols>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
<Extern>
<ModuleEntryPoint>VariableServiceInitialize</ModuleEntryPoint>
</Extern>
</Externs>
</ModuleSurfaceArea>

214
MdeModulePkg/Universal/EmuVariableRuntimeDxe/InitVariable.c Normal file
View File

@ -0,0 +1,214 @@
/*++
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"
//
// 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);
return EFI_SUCCESS;
}

181
MdeModulePkg/Universal/EmuVariableRuntimeDxe/Ipf/InitVariable.c Normal file
View File

@ -0,0 +1,181 @@
/*++
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:
IpfVariable.c
Abstract:
Revision History
--*/
#include "Variable.h"
#include <IndustryStandard/Sal.h>
//
// Don't use module globals after the SetVirtualAddress map is signaled
//
STATIC
SAL_RETURN_REGS
EsalVariableCommonEntry (
IN UINT64 FunctionId,
IN UINT64 Arg2,
IN UINT64 Arg3,
IN UINT64 Arg4,
IN UINT64 Arg5,
IN UINT64 Arg6,
IN UINT64 Arg7,
IN UINT64 Arg8,
IN SAL_EXTENDED_SAL_PROC ExtendedSalProc,
IN BOOLEAN VirtualMode,
IN ESAL_VARIABLE_GLOBAL *Global
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
SAL_RETURN_REGS ReturnVal;
switch (FunctionId) {
case EsalGetVariable:
ReturnVal.Status = GetVariable (
(CHAR16 *) Arg2,
(EFI_GUID *) Arg3,
(UINT32 *) Arg4,
(UINTN *) Arg5,
(VOID *) Arg6,
&Global->VariableGlobal[VirtualMode],
Global->FvbInstance
);
return ReturnVal;
case EsalGetNextVariableName:
ReturnVal.Status = GetNextVariableName (
(UINTN *) Arg2,
(CHAR16 *) Arg3,
(EFI_GUID *) Arg4,
&Global->VariableGlobal[VirtualMode],
Global->FvbInstance
);
return ReturnVal;
case EsalSetVariable:
ReturnVal.Status = SetVariable (
(CHAR16 *) Arg2,
(EFI_GUID *) Arg3,
(UINT32) Arg4,
(UINTN) Arg5,
(VOID *) Arg6,
&Global->VariableGlobal[VirtualMode],
(UINTN *) &Global->VolatileLastVariableOffset,
(UINTN *) &Global->NonVolatileLastVariableOffset,
Global->FvbInstance
);
return ReturnVal;
case EsalQueryVariableInfo:
ReturnVal.Status = QueryVariableInfo (
(UINT32) Arg2,
(UINT64 *) Arg3,
(UINT64 *) Arg4,
(UINT64 *) Arg5,
&Global->VariableGlobal[VirtualMode],
Global->FvbInstance
);
return ReturnVal;
default:
ReturnVal.Status = EFI_SAL_INVALID_ARGUMENT;
return ReturnVal;
}
}
VOID
VariableClassAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
CopyMem (
&mVariableModuleGlobal->VariableGlobal[Virtual],
&mVariableModuleGlobal->VariableGlobal[Physical],
sizeof (VARIABLE_GLOBAL)
);
EfiConvertPointer (
0x0,
(VOID **) &mVariableModuleGlobal->VariableGlobal[Virtual].NonVolatileVariableBase
);
EfiConvertPointer (
0x0,
(VOID **) &mVariableModuleGlobal->VariableGlobal[Virtual].VolatileVariableBase
);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
}
EFI_STATUS
VariableServiceInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
EFI_STATUS Status;
Status = VariableCommonInitialize (ImageHandle, SystemTable);
ASSERT_EFI_ERROR (Status);
//
// Register All the Functions with Extended Sal.
//
RegisterEsalClass (
&gEfiExtendedSalVariableServicesProtocolGuid,
mVariableModuleGlobal,
EsalVariableCommonEntry,
EsalGetVariable,
EsalVariableCommonEntry,
EsalGetNextVariableName,
EsalVariableCommonEntry,
EsalSetVariable,
EsalVariableCommonEntry,
EsalQueryVariableInfo,
NULL
);
return EFI_SUCCESS;
}

171
MdeModulePkg/Universal/EmuVariableRuntimeDxe/Variable.h Normal file
View File

@ -0,0 +1,171 @@
/*++
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:
Variable.h
Abstract:
--*/
#ifndef _VARIABLE_H
#define _VARIABLE_H
//
// Statements that include other header files
//
//
// The package level header files this module uses
//
#include <PiDxe.h>
//
// The protocols, PPI and GUID defintions for this module
//
#include <Protocol/VariableWrite.h>
#include <Protocol/Variable.h>
//
// The Library classes this module consumes
//
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiRuntimeLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/BaseLib.h>
//
// BugBug: We need relcate the head file.
//
#include <Common/Variable.h>
#define VARIABLE_STORE_SIZE (64 * 1024)
#define SCRATCH_SIZE (4 * 1024)
//
// Define GET_PAD_SIZE to optimize compiler
//
#if ((ALIGNMENT == 0) || (ALIGNMENT == 1))
#define GET_PAD_SIZE(a) (0)
#else
#define GET_PAD_SIZE(a) (((~a) + 1) & (ALIGNMENT - 1))
#endif
#define GET_VARIABLE_NAME_PTR(a) (CHAR16 *) ((UINTN) (a) + sizeof (VARIABLE_HEADER))
typedef enum {
Physical,
Virtual
} VARIABLE_POINTER_TYPE;
typedef struct {
VARIABLE_HEADER *CurrPtr;
VARIABLE_HEADER *EndPtr;
VARIABLE_HEADER *StartPtr;
BOOLEAN Volatile;
} VARIABLE_POINTER_TRACK;
typedef struct {
EFI_PHYSICAL_ADDRESS VolatileVariableBase;
EFI_PHYSICAL_ADDRESS NonVolatileVariableBase;
EFI_LOCK VariableServicesLock;
} VARIABLE_GLOBAL;
typedef struct {
VARIABLE_GLOBAL VariableGlobal[2];
UINTN VolatileLastVariableOffset;
UINTN NonVolatileLastVariableOffset;
UINT32 FvbInstance;
} ESAL_VARIABLE_GLOBAL;
extern ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
//
// Functions
//
EFI_STATUS
EFIAPI
VariableCommonInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
;
EFI_STATUS
EFIAPI
VariableServiceInitialize (
IN EFI_HANDLE ImageHandle,
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
)
;
#endif