Revision: 16669
http://sourceforge.net/p/edk2/code/16669
Author: lzeng14
Date: 2015-01-27 08:42:47 +0000 (Tue, 27 Jan 2015)
Log Message:
-----------
MdeModulePkg Variable: Implement variable quota management.
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Star Zeng <[email protected]>
Reviewed-by: Jiewen Yao <[email protected]>
Modified Paths:
--------------
trunk/edk2/MdeModulePkg/MdeModulePkg.dec
trunk/edk2/MdeModulePkg/MdeModulePkg.uni
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf
Added Paths:
-----------
trunk/edk2/MdeModulePkg/Include/Guid/VarErrorFlag.h
Added: trunk/edk2/MdeModulePkg/Include/Guid/VarErrorFlag.h
===================================================================
--- trunk/edk2/MdeModulePkg/Include/Guid/VarErrorFlag.h
(rev 0)
+++ trunk/edk2/MdeModulePkg/Include/Guid/VarErrorFlag.h 2015-01-27 08:42:47 UTC
(rev 16669)
@@ -0,0 +1,41 @@
+/** @file
+ Variable error flag definitions.
+
+ Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
+ 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.
+
+**/
+
+#ifndef _VARIABLE_ERROR_FLAG_H_
+#define _VARIABLE_ERROR_FLAG_H_
+
+//
+// Before EndOfDxe, the variable indicates the last boot variable error flag,
+// then it means the last boot variable error flag must be got before EndOfDxe.
+// After EndOfDxe, the variable indicates the current boot variable error flag,
+// then it means the current boot variable error flag must be got after
EndOfDxe.
+//
+// If the variable is not present, it has the same meaning with
VAR_ERROR_FLAG_NO_ERROR.
+//
+#define VAR_ERROR_FLAG_NAME L"VarErrorFlag"
+
+#define VAR_ERROR_FLAG_NO_ERROR 0xFF // 1111-1111
+#define VAR_ERROR_FLAG_SYSTEM_ERROR 0xEF // 1110-1111
+#define VAR_ERROR_FLAG_USER_ERROR 0xFE // 1111-1110
+
+typedef UINT8 VAR_ERROR_FLAG;
+
+#define EDKII_VAR_ERROR_FLAG_GUID { \
+ 0x4b37fe8, 0xf6ae, 0x480b, { 0xbd, 0xd5, 0x37, 0xd9, 0x8c, 0x5e, 0x89, 0xaa
} \
+};
+
+extern EFI_GUID gEdkiiVarErrorFlagGuid;
+
+#endif
+
Modified: trunk/edk2/MdeModulePkg/MdeModulePkg.dec
===================================================================
--- trunk/edk2/MdeModulePkg/MdeModulePkg.dec 2015-01-27 08:42:01 UTC (rev
16668)
+++ trunk/edk2/MdeModulePkg/MdeModulePkg.dec 2015-01-27 08:42:47 UTC (rev
16669)
@@ -279,6 +279,9 @@
## Include/Guid/MemoryProfile.h
gEdkiiMemoryProfileGuid = { 0x821c9a09, 0x541a, 0x40f6, { 0x9f,
0x43, 0xa, 0xd1, 0x93, 0xa1, 0x2c, 0xfe }}
+ ## Include/Protocol/VarErrorFlag.h
+ gEdkiiVarErrorFlagGuid = { 0x4b37fe8, 0xf6ae, 0x480b, { 0xbd,
0xd5, 0x37, 0xd9, 0x8c, 0x5e, 0x89, 0xaa } }
+
[Ppis]
## Include/Ppi/AtaController.h
gPeiAtaControllerPpiGuid = { 0xa45e60d1, 0xc719, 0x44aa, { 0xb0, 0x7a,
0xaa, 0x77, 0x7f, 0x85, 0x90, 0x6d }}
@@ -703,13 +706,38 @@
# @Prompt Maximum HwErr variable size.
gEfiMdeModulePkgTokenSpaceGuid.PcdMaxHardwareErrorVariableSize|0x8000|UINT32|0x30000004
- ## The size of reserved HwErr variable space. Note that this value must be
less than or equal to PcdFlashNvStorageVariableSize.
+ ## The size of reserved HwErr variable space. Note that this value must be
less than (PcdFlashNvStorageVariableSize -
EFI_FIRMWARE_VOLUME_HEADER.HeaderLength - sizeof (VARIABLE_STORE_HEADER)).
# In EdkII implementation, HwErr type variable is stored with common
non-volatile variables in the same NV region.
- # so the platform integrator should ensure this value is less than or equal
to PcdFlashNvStorageVariableSize.
+ # so the platform integrator should ensure this value is less than
(PcdFlashNvStorageVariableSize - EFI_FIRMWARE_VOLUME_HEADER.HeaderLength -
sizeof (VARIABLE_STORE_HEADER)).
# this value is used to guarantee the space of HwErr type variable and not
populated by common variable.
# @Prompt HwErr variable storage size.
gEfiMdeModulePkgTokenSpaceGuid.PcdHwErrStorageSize|0x0000|UINT32|0x30000006
+ ## The size of maximum user NV variable space.<BR><BR>
+ # Note that this value must be less than (PcdFlashNvStorageVariableSize -
EFI_FIRMWARE_VOLUME_HEADER.HeaderLength - sizeof (VARIABLE_STORE_HEADER) -
PcdHwErrStorageSize).<BR>
+ # If the value is 0, it means user variable share the same NV storage with
system variable,
+ # this is designed to keep the compatibility for the platform that does not
allocate special region for user variable.<BR>
+ # If the value is non-0, the below 4 types of variables will be regarded as
System Variable, their property could be got by VarCheck protocol,
+ # otherwise the variable will be regarded as user variable.<BR>
+ # 1) UEFI defined variables (gEfiGlobalVariableGuid and
gEfiImageSecurityDatabaseGuid(auth variable) variables at least).<BR>
+ # 2) Variables managed by Variable driver internally.<BR>
+ # 3) Variables need to be locked, they MUST be set by VariableLock
protocol.<BR>
+ # 4) Important during platform boot, their property SHOULD be set by
VarCheck protocol.<BR>
+ # The PCD is used to guarantee the space of system variable and not
populated by user variable.<BR>
+ # @Prompt Maximum user NV variable space size.
+
gEfiMdeModulePkgTokenSpaceGuid.PcdMaxUserNvVariableSpaceSize|0x00|UINT32|0x00000009
+
+ ## The size of NV variable space reserved at UEFI boottime.<BR><BR>
+ # Note that this value must be less than (PcdFlashNvStorageVariableSize -
EFI_FIRMWARE_VOLUME_HEADER.HeaderLength - sizeof (VARIABLE_STORE_HEADER) -
PcdHwErrStorageSize).<BR>
+ # In EdkII implementation, variable driver can reserved some NV storage
region for boottime settings.
+ # So at UEFI runtime, the variable service consumer can not exhaust full NV
storage region.<BR>
+ # Then the common NV variable space size at boottime will be
+ # (PcdFlashNvStorageVariableSize - EFI_FIRMWARE_VOLUME_HEADER.HeaderLength
- sizeof (VARIABLE_STORE_HEADER) - PcdHwErrStorageSize),<BR>
+ # and the common NV variable space size at runtime will be
+ # (PcdFlashNvStorageVariableSize - EFI_FIRMWARE_VOLUME_HEADER.HeaderLength
- sizeof (VARIABLE_STORE_HEADER) - PcdHwErrStorageSize) -
PcdBoottimeReservedNvVariableSpaceSize.<BR>
+ # @Prompt Boottime reserved NV variable space size.
+
gEfiMdeModulePkgTokenSpaceGuid.PcdBoottimeReservedNvVariableSpaceSize|0x00|UINT32|0x30000007
+
## The size of volatile buffer. This buffer is used to store VOLATILE
attribute variables.
# @Prompt Variable storage size.
gEfiMdeModulePkgTokenSpaceGuid.PcdVariableStoreSize|0x10000|UINT32|0x30000005
Modified: trunk/edk2/MdeModulePkg/MdeModulePkg.uni
===================================================================
--- trunk/edk2/MdeModulePkg/MdeModulePkg.uni 2015-01-27 08:42:01 UTC (rev
16668)
+++ trunk/edk2/MdeModulePkg/MdeModulePkg.uni 2015-01-27 08:42:47 UTC (rev
16669)
@@ -10,7 +10,7 @@
- @@ -200,6 +200,58 @@
++++++++++++++++++++++++++ Modified:
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c
===================================================================
--- trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c
2015-01-27 08:42:01 UTC (rev 16668)
+++ trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VarCheck.c
2015-01-27 08:42:47 UTC (rev 16669)
@@ -48,14 +48,6 @@
INTERNAL_VAR_CHECK_FUNCTION CheckFunction;
} UEFI_DEFINED_VARIABLE_ENTRY;
-typedef struct _EFI_LOAD_OPTION {
- UINT32 Attributes;
- UINT16 FilePathListLength;
-//CHAR16 Description[];
-//EFI_DEVICE_PATH_PROTOCOL FilePathList[];
-//UINT8 OptionalData[];
-} EFI_LOAD_OPTION;
-
/**
Internal check for load option.
@@ -75,16 +67,16 @@
IN VOID *Data
)
{
- EFI_LOAD_OPTION *LoadOption;
+ UINT16 FilePathListLength;
CHAR16 *Description;
EFI_DEVICE_PATH_PROTOCOL *FilePathList;
- LoadOption = (EFI_LOAD_OPTION *) Data;
+ FilePathListLength = *((UINT16 *) ((UINTN) Data + sizeof (UINT32)));
//
// Check Description
//
- Description = (CHAR16 *) ((UINTN) Data + sizeof (EFI_LOAD_OPTION));
+ Description = (CHAR16 *) ((UINTN) Data + sizeof (UINT32) + sizeof (UINT16));
while (Description < (CHAR16 *) ((UINTN) Data + DataSize)) {
if (*Description == L'\0') {
break;
@@ -100,16 +92,16 @@
// Check FilePathList
//
FilePathList = (EFI_DEVICE_PATH_PROTOCOL *) Description;
- if ((UINTN) FilePathList > (MAX_ADDRESS - LoadOption->FilePathListLength)) {
+ if ((UINTN) FilePathList > (MAX_ADDRESS - FilePathListLength)) {
return EFI_INVALID_PARAMETER;
}
- if (((UINTN) FilePathList + LoadOption->FilePathListLength) > ((UINTN) Data
+ DataSize)) {
+ if (((UINTN) FilePathList + FilePathListLength) > ((UINTN) Data + DataSize))
{
return EFI_INVALID_PARAMETER;
}
- if (LoadOption->FilePathListLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
+ if (FilePathListLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
return EFI_INVALID_PARAMETER;
}
- if (!IsDevicePathValid (FilePathList, LoadOption->FilePathListLength)) {
+ if (!IsDevicePathValid (FilePathList, FilePathListLength)) {
return EFI_INVALID_PARAMETER;
}
@@ -573,7 +565,7 @@
VAR_CHECK_VARIABLE_PROPERTY_REVISION,
0,
VARIABLE_ATTRIBUTE_NV_BS_RT,
- sizeof (EFI_LOAD_OPTION),
+ sizeof (UINT32) + sizeof (UINT16),
MAX_UINTN
},
InternalVarCheckLoadOption
@@ -584,7 +576,7 @@
VAR_CHECK_VARIABLE_PROPERTY_REVISION,
0,
VARIABLE_ATTRIBUTE_NV_BS_RT,
- sizeof (EFI_LOAD_OPTION),
+ sizeof (UINT32) + sizeof (UINT16),
MAX_UINTN
},
InternalVarCheckLoadOption
@@ -602,6 +594,26 @@
},
};
+typedef struct {
+ EFI_GUID *Guid;
+ CHAR16 *Name;
+ VAR_CHECK_VARIABLE_PROPERTY VariableProperty;
+} VARIABLE_DRIVER_VARIABLE_ENTRY;
+
+VARIABLE_DRIVER_VARIABLE_ENTRY mVariableDriverVariableList[] = {
+ {
+ &gEdkiiVarErrorFlagGuid,
+ VAR_ERROR_FLAG_NAME,
+ {
+ VAR_CHECK_VARIABLE_PROPERTY_REVISION,
+ VAR_CHECK_VARIABLE_PROPERTY_READ_ONLY,
+ VARIABLE_ATTRIBUTE_NV_BS_RT,
+ sizeof (VAR_ERROR_FLAG),
+ sizeof (VAR_ERROR_FLAG),
+ }
+ },
+};
+
/**
Get UEFI defined global variable property.
The code will check if variable guid is global variable guid first.
@@ -661,14 +673,13 @@
*VariableProperty = &mGlobalVariableList2[Index].VariableProperty;
return EFI_SUCCESS;
}
- } else {
- if (StrCmp (mGlobalVariableList2[Index].Name, VariableName) == 0) {
- if (VarCheckFunction != NULL) {
- *VarCheckFunction = mGlobalVariableList2[Index].CheckFunction;
- }
- *VariableProperty = &mGlobalVariableList2[Index].VariableProperty;
- return EFI_SUCCESS;
+ }
+ if (StrCmp (mGlobalVariableList2[Index].Name, VariableName) == 0) {
+ if (VarCheckFunction != NULL) {
+ *VarCheckFunction = mGlobalVariableList2[Index].CheckFunction;
}
+ *VariableProperty = &mGlobalVariableList2[Index].VariableProperty;
+ return EFI_SUCCESS;
}
}
@@ -685,6 +696,32 @@
}
/**
+ Get variable property for variables managed by Varaible driver.
+
+ @param[in] VariableName Pointer to variable name.
+ @param[in] VendorGuid Variable Vendor Guid.
+
+ @return Pointer to variable property.
+
+**/
+VAR_CHECK_VARIABLE_PROPERTY *
+GetVariableDriverVariableProperty (
+ IN CHAR16 *VariableName,
+ IN EFI_GUID *VendorGuid
+ )
+{
+ UINTN Index;
+
+ for (Index = 0; Index < sizeof (mVariableDriverVariableList)/sizeof
(mVariableDriverVariableList[0]); Index++) {
+ if ((CompareGuid (mVariableDriverVariableList[Index].Guid, VendorGuid)) &&
(StrCmp (mVariableDriverVariableList[Index].Name, VariableName) == 0)) {
+ return &mVariableDriverVariableList[Index].VariableProperty;
+ }
+ }
+
+ return NULL;
+}
+
+/**
Internal SetVariable check.
@param[in] VariableName Name of Variable to set.
@@ -694,7 +731,7 @@
@param[in] Data Data pointer.
@retval EFI_SUCCESS The SetVariable check result was success.
- @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits,
name, and GUID were supplied,
+ @retval EFI_INVALID_PARAMETER An invalid combination of attribute bits,
name, and GUID was supplied,
or the DataSize exceeds the minimum or maximum
allowed,
or the Data value is not following UEFI spec
for UEFI defined variables.
@retval EFI_WRITE_PROTECTED The variable in question is read-only.
@@ -727,23 +764,27 @@
}
Property = NULL;
- Status = GetUefiDefinedVariableProperty (VariableName, VendorGuid, TRUE,
&Property, &VarCheckFunction);
- if (EFI_ERROR (Status)) {
- DEBUG ((EFI_D_INFO, "[Variable]: Var Check UEFI defined variable fail %r -
%g:%s\n", Status, VendorGuid, VariableName));
- return Status;
+ VarCheckFunction = NULL;
+
+ for ( Link = GetFirstNode (&mVarCheckVariableList)
+ ; !IsNull (&mVarCheckVariableList, Link)
+ ; Link = GetNextNode (&mVarCheckVariableList, Link)
+ ) {
+ Entry = BASE_CR (Link, VAR_CHECK_VARIABLE_ENTRY, Link);
+ Name = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));
+ if (CompareGuid (&Entry->Guid, VendorGuid) && (StrCmp (Name, VariableName)
== 0)) {
+ Property = &Entry->VariableProperty;
+ break;
+ }
}
if (Property == NULL) {
- VarCheckFunction = NULL;
- for ( Link = GetFirstNode (&mVarCheckVariableList)
- ; !IsNull (&mVarCheckVariableList, Link)
- ; Link = GetNextNode (&mVarCheckVariableList, Link)
- ) {
- Entry = BASE_CR (Link, VAR_CHECK_VARIABLE_ENTRY, Link);
- Name = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));
- if (CompareGuid (&Entry->Guid, VendorGuid) && (StrCmp (Name,
VariableName) == 0)) {
- Property = &Entry->VariableProperty;
- break;
- }
+ Property = GetVariableDriverVariableProperty (VariableName, VendorGuid);
+ }
+ if (Property == NULL) {
+ Status = GetUefiDefinedVariableProperty (VariableName, VendorGuid, TRUE,
&Property, &VarCheckFunction);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((EFI_D_INFO, "[Variable]: Var Check UEFI defined variable fail %r
- %g:%s\n", Status, VendorGuid, VariableName));
+ return Status;
}
}
if (Property != NULL) {
@@ -751,30 +792,29 @@
DEBUG ((EFI_D_INFO, "[Variable]: Var Check ReadOnly variable fail %r -
%g:%s\n", EFI_WRITE_PROTECTED, VendorGuid, VariableName));
return EFI_WRITE_PROTECTED;
}
- if ((DataSize == 0) || (Attributes == 0)) {
+ if (!((DataSize == 0) || (Attributes == 0))) {
//
- // Do not check delete variable.
+ // Not to delete variable.
//
- return EFI_SUCCESS;
- }
- if (Attributes != Property->Attributes) {
- DEBUG ((EFI_D_INFO, "[Variable]: Var Check Attributes fail %r -
%g:%s\n", EFI_INVALID_PARAMETER, VendorGuid, VariableName));
- return EFI_INVALID_PARAMETER;
- }
- if ((DataSize < Property->MinSize) || (DataSize > Property->MaxSize)) {
- DEBUG ((EFI_D_INFO, "[Variable]: Var Check DataSize fail %r - %g:%s\n",
EFI_INVALID_PARAMETER, VendorGuid, VariableName));
- return EFI_INVALID_PARAMETER;
- }
- if (VarCheckFunction != NULL) {
- Status = VarCheckFunction (
- Property,
- DataSize,
- Data
- );
- if (EFI_ERROR (Status)) {
- DEBUG ((EFI_D_INFO, "[Variable]: Internal Var Check function fail %r -
%g:%s\n", Status, VendorGuid, VariableName));
- return Status;
+ if (Attributes != Property->Attributes) {
+ DEBUG ((EFI_D_INFO, "[Variable]: Var Check Attributes(0x%08x to
0x%08x) fail %r - %g:%s\n", Property->Attributes, Attributes,
EFI_INVALID_PARAMETER, VendorGuid, VariableName));
+ return EFI_INVALID_PARAMETER;
}
+ if ((DataSize < Property->MinSize) || (DataSize > Property->MaxSize)) {
+ DEBUG ((EFI_D_INFO, "[Variable]: Var Check DataSize fail(0x%x not in
0x%x - 0x%x) %r - %g:%s\n", DataSize, Property->MinSize, Property->MaxSize,
EFI_INVALID_PARAMETER, VendorGuid, VariableName));
+ return EFI_INVALID_PARAMETER;
+ }
+ if (VarCheckFunction != NULL) {
+ Status = VarCheckFunction (
+ Property,
+ DataSize,
+ Data
+ );
+ if (EFI_ERROR (Status)) {
+ DEBUG ((EFI_D_INFO, "[Variable]: Internal Var Check function fail %r
- %g:%s\n", Status, VendorGuid, VariableName));
+ return Status;
+ }
+ }
}
}
@@ -888,18 +928,20 @@
}
/**
- Internal variable property get.
+ Variable property get function.
- @param[in] Name Pointer to the variable name.
- @param[in] Guid Pointer to the vendor GUID.
+ @param[in] Name Pointer to the variable name.
+ @param[in] Guid Pointer to the vendor GUID.
+ @param[in] WildcardMatch Try wildcard match or not.
@return Pointer to the property of variable specified by the Name and Guid.
**/
VAR_CHECK_VARIABLE_PROPERTY *
-InternalVarCheckVariablePropertyGet (
- IN CHAR16 *Name,
- IN EFI_GUID *Guid
+VariablePropertyGetFunction (
+ IN CHAR16 *Name,
+ IN EFI_GUID *Guid,
+ IN BOOLEAN WildcardMatch
)
{
LIST_ENTRY *Link;
@@ -907,24 +949,23 @@
CHAR16 *VariableName;
VAR_CHECK_VARIABLE_PROPERTY *Property;
- Property = NULL;
- GetUefiDefinedVariableProperty (Name, Guid, FALSE, &Property, NULL);
- if (Property != NULL) {
- return Property;
- } else {
- for ( Link = GetFirstNode (&mVarCheckVariableList)
- ; !IsNull (&mVarCheckVariableList, Link)
- ; Link = GetNextNode (&mVarCheckVariableList, Link)
- ) {
- Entry = BASE_CR (Link, VAR_CHECK_VARIABLE_ENTRY, Link);
- VariableName = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));
- if (CompareGuid (&Entry->Guid, Guid) && (StrCmp (VariableName, Name) ==
0)) {
- return &Entry->VariableProperty;
- }
+ for ( Link = GetFirstNode (&mVarCheckVariableList)
+ ; !IsNull (&mVarCheckVariableList, Link)
+ ; Link = GetNextNode (&mVarCheckVariableList, Link)
+ ) {
+ Entry = BASE_CR (Link, VAR_CHECK_VARIABLE_ENTRY, Link);
+ VariableName = (CHAR16 *) ((UINTN) Entry + sizeof (*Entry));
+ if (CompareGuid (&Entry->Guid, Guid) && (StrCmp (VariableName, Name) ==
0)) {
+ return &Entry->VariableProperty;
}
}
- return NULL;
+ Property = GetVariableDriverVariableProperty (Name, Guid);
+ if (Property == NULL) {
+ GetUefiDefinedVariableProperty (Name, Guid, WildcardMatch, &Property,
NULL);
+ }
+
+ return Property;
}
/**
@@ -975,7 +1016,7 @@
AcquireLockOnlyAtBootTime
(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
- Property = InternalVarCheckVariablePropertyGet (Name, Guid);
+ Property = VariablePropertyGetFunction (Name, Guid, FALSE);
if (Property != NULL) {
CopyMem (Property, VariableProperty, sizeof (*VariableProperty));
} else {
@@ -998,20 +1039,19 @@
}
/**
- Variable property get.
+ Internal variable property get.
@param[in] Name Pointer to the variable name.
@param[in] Guid Pointer to the vendor GUID.
@param[out] VariableProperty Pointer to the output variable property.
@retval EFI_SUCCESS The property of variable specified by the Name
and Guid was got successfully.
- @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or
Name is an empty string.
@retval EFI_NOT_FOUND The property of variable specified by the Name
and Guid was not found.
**/
EFI_STATUS
EFIAPI
-VarCheckVariablePropertyGet (
+InternalVarCheckVariablePropertyGet (
IN CHAR16 *Name,
IN EFI_GUID *Guid,
OUT VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
@@ -1023,19 +1063,9 @@
BOOLEAN Found;
VAR_CHECK_VARIABLE_PROPERTY *Property;
- if (Name == NULL || Name[0] == 0 || Guid == NULL) {
- return EFI_INVALID_PARAMETER;
- }
-
- if (VariableProperty == NULL) {
- return EFI_INVALID_PARAMETER;
- }
-
Found = FALSE;
- AcquireLockOnlyAtBootTime
(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
-
- Property = InternalVarCheckVariablePropertyGet (Name, Guid);
+ Property = VariablePropertyGetFunction (Name, Guid, TRUE);
if (Property != NULL) {
CopyMem (VariableProperty, Property, sizeof (*VariableProperty));
Found = TRUE;
@@ -1056,8 +1086,45 @@
}
}
+ return (Found ? EFI_SUCCESS : EFI_NOT_FOUND);
+}
+
+/**
+ Variable property get.
+
+ @param[in] Name Pointer to the variable name.
+ @param[in] Guid Pointer to the vendor GUID.
+ @param[out] VariableProperty Pointer to the output variable property.
+
+ @retval EFI_SUCCESS The property of variable specified by the Name
and Guid was got successfully.
+ @retval EFI_INVALID_PARAMETER Name, Guid or VariableProperty is NULL, or
Name is an empty string.
+ @retval EFI_NOT_FOUND The property of variable specified by the Name
and Guid was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+VarCheckVariablePropertyGet (
+ IN CHAR16 *Name,
+ IN EFI_GUID *Guid,
+ OUT VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
+ )
+{
+ EFI_STATUS Status;
+
+ if (Name == NULL || Name[0] == 0 || Guid == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (VariableProperty == NULL) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ AcquireLockOnlyAtBootTime
(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
+
+ Status = InternalVarCheckVariablePropertyGet (Name, Guid, VariableProperty);
+
ReleaseLockOnlyAtBootTime
(&mVariableModuleGlobal->VariableGlobal.VariableServicesLock);
- return (Found ? EFI_SUCCESS : EFI_NOT_FOUND);
+ return Status;
}
Modified: trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
===================================================================
--- trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
2015-01-27 08:42:01 UTC (rev 16668)
+++ trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
2015-01-27 08:42:47 UTC (rev 16669)
@@ -524,9 +524,217 @@
return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader +
VarStoreHeader->Size);
}
+/**
+ Record variable error flag.
+ @param[in] Flag Variable error flag to record.
+ @param[in] VariableName Name of variable.
+ @param[in] VendorGuid Guid of variable.
+ @param[in] Attributes Attributes of the variable.
+ @param[in] VariableSize Size of the variable.
+
+**/
+VOID
+RecordVarErrorFlag (
+ IN VAR_ERROR_FLAG Flag,
+ IN CHAR16 *VariableName,
+ IN EFI_GUID *VendorGuid,
+ IN UINT32 Attributes,
+ IN UINTN VariableSize
+ )
+{
+ EFI_STATUS Status;
+ VARIABLE_POINTER_TRACK Variable;
+ VAR_ERROR_FLAG *VarErrFlag;
+ VAR_ERROR_FLAG TempFlag;
+
+ DEBUG_CODE (
+ DEBUG ((EFI_D_ERROR, "RecordVarErrorFlag (0x%02x) %s:%g - 0x%08x -
0x%x\n", Flag, VariableName, VendorGuid, Attributes, VariableSize));
+ if (Flag == VAR_ERROR_FLAG_SYSTEM_ERROR) {
+ if (AtRuntime ()) {
+ DEBUG ((EFI_D_ERROR, "CommonRuntimeVariableSpace = 0x%x -
CommonVariableTotalSize = 0x%x\n",
mVariableModuleGlobal->CommonRuntimeVariableSpace,
mVariableModuleGlobal->CommonVariableTotalSize));
+ } else {
+ DEBUG ((EFI_D_ERROR, "CommonVariableSpace = 0x%x -
CommonVariableTotalSize = 0x%x\n", mVariableModuleGlobal->CommonVariableSpace,
mVariableModuleGlobal->CommonVariableTotalSize));
+ }
+ } else {
+ DEBUG ((EFI_D_ERROR, "CommonMaxUserVariableSpace = 0x%x -
CommonUserVariableTotalSize = 0x%x\n",
mVariableModuleGlobal->CommonMaxUserVariableSpace,
mVariableModuleGlobal->CommonUserVariableTotalSize));
+ }
+ );
+
+ //
+ // Record error flag (it should have be initialized).
+ //
+ Status = FindVariable (
+ VAR_ERROR_FLAG_NAME,
+ &gEdkiiVarErrorFlagGuid,
+ &Variable,
+ &mVariableModuleGlobal->VariableGlobal,
+ FALSE
+ );
+ if (!EFI_ERROR (Status)) {
+ VarErrFlag = (VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr);
+ TempFlag = *VarErrFlag;
+ TempFlag &= Flag;
+ if (TempFlag == *VarErrFlag) {
+ return;
+ }
+ Status = UpdateVariableStore (
+ &mVariableModuleGlobal->VariableGlobal,
+ FALSE,
+ FALSE,
+ mVariableModuleGlobal->FvbInstance,
+ (UINTN) VarErrFlag - (UINTN) mNvVariableCache + (UINTN)
mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
+ sizeof (TempFlag),
+ &TempFlag
+ );
+ if (!EFI_ERROR (Status)) {
+ //
+ // Update the data in NV cache.
+ //
+ *VarErrFlag = Flag;
+ }
+ }
+}
+
/**
+ Initialize variable error flag.
+ Before EndOfDxe, the variable indicates the last boot variable error flag,
+ then it means the last boot variable error flag must be got before EndOfDxe.
+ After EndOfDxe, the variable indicates the current boot variable error flag,
+ then it means the current boot variable error flag must be got after
EndOfDxe.
+
+**/
+VOID
+InitializeVarErrorFlag (
+ VOID
+ )
+{
+ EFI_STATUS Status;
+ VARIABLE_POINTER_TRACK Variable;
+ VAR_ERROR_FLAG Flag;
+ VAR_ERROR_FLAG VarErrFlag;
+
+ if (!mEndOfDxe) {
+ return;
+ }
+
+ Flag = VAR_ERROR_FLAG_NO_ERROR;
+ DEBUG ((EFI_D_INFO, "Initialize variable error flag (%02x)\n", Flag));
+
+ Status = FindVariable (
+ VAR_ERROR_FLAG_NAME,
+ &gEdkiiVarErrorFlagGuid,
+ &Variable,
+ &mVariableModuleGlobal->VariableGlobal,
+ FALSE
+ );
+ if (!EFI_ERROR (Status)) {
+ VarErrFlag = *((VAR_ERROR_FLAG *) GetVariableDataPtr (Variable.CurrPtr));
+ if (VarErrFlag == Flag) {
+ return;
+ }
+ }
+
+ UpdateVariable (
+ VAR_ERROR_FLAG_NAME,
+ &gEdkiiVarErrorFlagGuid,
+ &Flag,
+ sizeof (Flag),
+ VARIABLE_ATTRIBUTE_NV_BS_RT,
+ &Variable
+ );
+}
+
+/**
+ Is user variable?
+
+ @param[in] Variable Pointer to variable header.
+
+ @retval TRUE User variable.
+ @retval FALSE System variable.
+
+**/
+BOOLEAN
+IsUserVariable (
+ IN VARIABLE_HEADER *Variable
+ )
+{
+ VAR_CHECK_VARIABLE_PROPERTY Property;
+
+ //
+ // Only after End Of Dxe, the variables belong to system variable are fixed.
+ // If PcdMaxUserNvStorageVariableSize is 0, it means user variable share the
same NV storage with system variable,
+ // then no need to check if the variable is user variable or not specially.
+ //
+ if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace !=
mVariableModuleGlobal->CommonVariableSpace)) {
+ if (InternalVarCheckVariablePropertyGet (GetVariableNamePtr (Variable),
&Variable->VendorGuid, &Property) == EFI_NOT_FOUND) {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/**
+ Calculate common user variable total size.
+
+**/
+VOID
+CalculateCommonUserVariableTotalSize (
+ VOID
+ )
+{
+ VARIABLE_HEADER *Variable;
+ VARIABLE_HEADER *NextVariable;
+ UINTN VariableSize;
+ VAR_CHECK_VARIABLE_PROPERTY Property;
+
+ //
+ // Only after End Of Dxe, the variables belong to system variable are fixed.
+ // If PcdMaxUserNvStorageVariableSize is 0, it means user variable share the
same NV storage with system variable,
+ // then no need to calculate the common user variable total size specially.
+ //
+ if (mEndOfDxe && (mVariableModuleGlobal->CommonMaxUserVariableSpace !=
mVariableModuleGlobal->CommonVariableSpace)) {
+ Variable = GetStartPointer (mNvVariableCache);
+ while (IsValidVariableHeader (Variable, GetEndPointer (mNvVariableCache)))
{
+ NextVariable = GetNextVariablePtr (Variable);
+ VariableSize = (UINTN) NextVariable - (UINTN) Variable;
+ if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) !=
EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
+ if (InternalVarCheckVariablePropertyGet (GetVariableNamePtr
(Variable), &Variable->VendorGuid, &Property) == EFI_NOT_FOUND) {
+ //
+ // No property, it is user variable.
+ //
+ mVariableModuleGlobal->CommonUserVariableTotalSize += VariableSize;
+ }
+ }
+
+ Variable = NextVariable;
+ }
+ }
+}
+
+/**
+ Initialize variable quota.
+
+**/
+VOID
+InitializeVariableQuota (
+ VOID
+ )
+{
+ STATIC BOOLEAN Initialized;
+
+ if (!mEndOfDxe || Initialized) {
+ return;
+ }
+ Initialized = TRUE;
+
+ InitializeVarErrorFlag ();
+ CalculateCommonUserVariableTotalSize ();
+}
+
+/**
+
Variable store garbage collection and reclaim operation.
@param VariableBase Base address of variable store.
@@ -567,6 +775,7 @@
BOOLEAN FoundAdded;
EFI_STATUS Status;
UINTN CommonVariableTotalSize;
+ UINTN CommonUserVariableTotalSize;
UINTN HwErrVariableTotalSize;
VARIABLE_HEADER *UpdatingVariable;
VARIABLE_HEADER *UpdatingInDeletedTransition;
@@ -581,6 +790,7 @@
VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);
CommonVariableTotalSize = 0;
+ CommonUserVariableTotalSize = 0;
HwErrVariableTotalSize = 0;
if (IsVolatile) {
@@ -650,6 +860,9 @@
HwErrVariableTotalSize += VariableSize;
} else if ((!IsVolatile) && ((Variable->Attributes &
EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
CommonVariableTotalSize += VariableSize;
+ if (IsUserVariable (Variable)) {
+ CommonUserVariableTotalSize += VariableSize;
+ }
}
}
Variable = NextVariable;
@@ -698,6 +911,9 @@
HwErrVariableTotalSize += VariableSize;
} else if ((!IsVolatile) && ((Variable->Attributes &
EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
CommonVariableTotalSize += VariableSize;
+ if (IsUserVariable (Variable)) {
+ CommonUserVariableTotalSize += VariableSize;
+ }
}
}
}
@@ -721,9 +937,13 @@
HwErrVariableTotalSize += NewVariableSize;
} else if ((NewVariable->Attributes &
EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
CommonVariableTotalSize += NewVariableSize;
+ if (IsUserVariable (NewVariable)) {
+ CommonUserVariableTotalSize += NewVariableSize;
+ }
}
if ((HwErrVariableTotalSize > PcdGet32 (PcdHwErrStorageSize)) ||
- (CommonVariableTotalSize > VariableStoreHeader->Size - sizeof
(VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize))) {
+ (CommonVariableTotalSize >
mVariableModuleGlobal->CommonVariableSpace) ||
+ (CommonUserVariableTotalSize >
mVariableModuleGlobal->CommonMaxUserVariableSpace)) {
//
// No enough space to store the new variable by NV or NV+HR attribute.
//
@@ -761,19 +981,24 @@
*LastVariableOffset = (UINTN) (CurrPtr - ValidBuffer);
mVariableModuleGlobal->HwErrVariableTotalSize = HwErrVariableTotalSize;
mVariableModuleGlobal->CommonVariableTotalSize = CommonVariableTotalSize;
+ mVariableModuleGlobal->CommonUserVariableTotalSize =
CommonUserVariableTotalSize;
} else {
- NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER
*)(UINTN)VariableBase);
- while (IsValidVariableHeader (NextVariable, GetEndPointer
((VARIABLE_STORE_HEADER *)(UINTN)VariableBase))) {
- VariableSize = NextVariable->NameSize + NextVariable->DataSize +
sizeof (VARIABLE_HEADER);
+ Variable = GetStartPointer ((VARIABLE_STORE_HEADER
*)(UINTN)VariableBase);
+ while (IsValidVariableHeader (Variable, GetEndPointer
((VARIABLE_STORE_HEADER *)(UINTN)VariableBase))) {
+ NextVariable = GetNextVariablePtr (Variable);
+ VariableSize = (UINTN) NextVariable - (UINTN) Variable;
if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) ==
EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
- mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN
(VariableSize);
+ mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;
} else if ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD)
!= EFI_VARIABLE_HARDWARE_ERROR_RECORD) {
- mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN
(VariableSize);
+ mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;
+ if (IsUserVariable (Variable)) {
+ mVariableModuleGlobal->CommonUserVariableTotalSize += VariableSize;
+ }
}
- NextVariable = GetNextVariablePtr (NextVariable);
+ Variable = NextVariable;
}
- *LastVariableOffset = (UINTN) NextVariable - (UINTN) VariableBase;
+ *LastVariableOffset = (UINTN) Variable - (UINTN) VariableBase;
}
}
@@ -1627,7 +1852,6 @@
EFI_STATUS Status;
VARIABLE_HEADER *NextVariable;
UINTN ScratchSize;
- UINTN NonVolatileVarableStoreSize;
UINTN VarNameOffset;
UINTN VarDataOffset;
UINTN VarNameSize;
@@ -1639,6 +1863,8 @@
VARIABLE_POINTER_TRACK NvVariable;
VARIABLE_STORE_HEADER *VariableStoreHeader;
UINTN CacheOffset;
+ BOOLEAN IsCommonVariable;
+ BOOLEAN IsCommonUserVariable;
if ((mVariableModuleGlobal->FvbInstance == NULL) && ((Attributes &
EFI_VARIABLE_NON_VOLATILE) != 0)) {
//
@@ -1856,12 +2082,25 @@
// Create a nonvolatile variable.
//
Volatile = FALSE;
- NonVolatileVarableStoreSize = ((VARIABLE_STORE_HEADER
*)(UINTN)(mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase))->Size;
- if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0)
+
+ IsCommonVariable = FALSE;
+ IsCommonUserVariable = FALSE;
+ if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0) {
+ IsCommonVariable = TRUE;
+ IsCommonUserVariable = IsUserVariable (NextVariable);
+ }
+ if ((((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0)
&& ((VarSize + mVariableModuleGlobal->HwErrVariableTotalSize) > PcdGet32
(PcdHwErrStorageSize)))
- || (((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == 0)
- && ((VarSize + mVariableModuleGlobal->CommonVariableTotalSize) >
NonVolatileVarableStoreSize - sizeof (VARIABLE_STORE_HEADER) - PcdGet32
(PcdHwErrStorageSize)))) {
+ || (IsCommonVariable && ((VarSize +
mVariableModuleGlobal->CommonVariableTotalSize) >
mVariableModuleGlobal->CommonVariableSpace))
+ || (IsCommonVariable && AtRuntime () && ((VarSize +
mVariableModuleGlobal->CommonVariableTotalSize) >
mVariableModuleGlobal->CommonRuntimeVariableSpace))
+ || (IsCommonUserVariable && ((VarSize +
mVariableModuleGlobal->CommonUserVariableTotalSize) >
mVariableModuleGlobal->CommonMaxUserVariableSpace))) {
if (AtRuntime ()) {
+ if (IsCommonUserVariable && ((VarSize +
mVariableModuleGlobal->CommonUserVariableTotalSize) >
mVariableModuleGlobal->CommonMaxUserVariableSpace)) {
+ RecordVarErrorFlag (VAR_ERROR_FLAG_USER_ERROR, VariableName,
VendorGuid, Attributes, VarSize);
+ }
+ if (IsCommonVariable && ((VarSize +
mVariableModuleGlobal->CommonVariableTotalSize) >
mVariableModuleGlobal->CommonRuntimeVariableSpace)) {
+ RecordVarErrorFlag (VAR_ERROR_FLAG_SYSTEM_ERROR, VariableName,
VendorGuid, Attributes, VarSize);
+ }
Status = EFI_OUT_OF_RESOURCES;
goto Done;
}
@@ -1880,6 +2119,13 @@
}
UpdateVariableInfo (VariableName, VendorGuid, FALSE, FALSE, TRUE,
FALSE, FALSE);
FlushHobVariableToFlash (VariableName, VendorGuid);
+ } else {
+ if (IsCommonUserVariable && ((VarSize +
mVariableModuleGlobal->CommonUserVariableTotalSize) >
mVariableModuleGlobal->CommonMaxUserVariableSpace)) {
+ RecordVarErrorFlag (VAR_ERROR_FLAG_USER_ERROR, VariableName,
VendorGuid, Attributes, VarSize);
+ }
+ if (IsCommonVariable && ((VarSize +
mVariableModuleGlobal->CommonVariableTotalSize) >
mVariableModuleGlobal->CommonVariableSpace)) {
+ RecordVarErrorFlag (VAR_ERROR_FLAG_SYSTEM_ERROR, VariableName,
VendorGuid, Attributes, VarSize);
+ }
}
goto Done;
}
@@ -1965,6 +2211,9 @@
mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN (VarSize);
} else {
mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN (VarSize);
+ if (IsCommonUserVariable) {
+ mVariableModuleGlobal->CommonUserVariableTotalSize += HEADER_ALIGN
(VarSize);
+ }
}
//
// update the memory copy of Flash region.
@@ -2579,7 +2828,7 @@
// 2. The only attribute differing is EFI_VARIABLE_APPEND_WRITE
//
Status = EFI_INVALID_PARAMETER;
- DEBUG ((EFI_D_INFO, "[Variable]: Rewritten a preexisting variable with
different attributes - %g:%s\n", VendorGuid, VariableName));
+ DEBUG ((EFI_D_INFO, "[Variable]: Rewritten a preexisting
variable(0x%08x) with different attributes(0x%08x) - %g:%s\n",
Variable.CurrPtr->Attributes, Attributes, VendorGuid, VariableName));
goto Done;
}
}
@@ -2672,8 +2921,11 @@
*MaximumVariableSize = PcdGet32 (PcdMaxHardwareErrorVariableSize) - sizeof
(VARIABLE_HEADER);
} else {
if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {
- ASSERT (PcdGet32 (PcdHwErrStorageSize) < VariableStoreHeader->Size);
- *MaximumVariableStorageSize = VariableStoreHeader->Size - sizeof
(VARIABLE_STORE_HEADER) - PcdGet32 (PcdHwErrStorageSize);
+ if (AtRuntime ()) {
+ *MaximumVariableStorageSize =
mVariableModuleGlobal->CommonRuntimeVariableSpace;
+ } else {
+ *MaximumVariableStorageSize =
mVariableModuleGlobal->CommonVariableSpace;
+ }
}
//
@@ -2749,8 +3001,12 @@
if ((Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) ==
EFI_VARIABLE_HARDWARE_ERROR_RECORD){
*RemainingVariableStorageSize = *MaximumVariableStorageSize -
HwErrVariableTotalSize;
- }else {
- *RemainingVariableStorageSize = *MaximumVariableStorageSize -
CommonVariableTotalSize;
+ } else {
+ if (*MaximumVariableStorageSize < CommonVariableTotalSize) {
+ *RemainingVariableStorageSize = 0;
+ } else {
+ *RemainingVariableStorageSize = *MaximumVariableStorageSize -
CommonVariableTotalSize;
+ }
}
if (*RemainingVariableStorageSize < sizeof (VARIABLE_HEADER)) {
@@ -2851,22 +3107,23 @@
)
{
EFI_STATUS Status;
- UINTN CommonVariableSpace;
- UINTN RemainingCommonVariableSpace;
+ UINTN RemainingCommonRuntimeVariableSpace;
UINTN RemainingHwErrVariableSpace;
- Status = EFI_SUCCESS;
+ Status = EFI_SUCCESS;
- CommonVariableSpace = ((VARIABLE_STORE_HEADER *) ((UINTN)
(mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase)))->Size -
sizeof (VARIABLE_STORE_HEADER) - PcdGet32(PcdHwErrStorageSize); //Allowable max
size of common variable storage space
+ if (mVariableModuleGlobal->CommonRuntimeVariableSpace <
mVariableModuleGlobal->CommonVariableTotalSize) {
+ RemainingCommonRuntimeVariableSpace = 0;
+ } else {
+ RemainingCommonRuntimeVariableSpace =
mVariableModuleGlobal->CommonRuntimeVariableSpace -
mVariableModuleGlobal->CommonVariableTotalSize;
+ }
- RemainingCommonVariableSpace = CommonVariableSpace -
mVariableModuleGlobal->CommonVariableTotalSize;
-
RemainingHwErrVariableSpace = PcdGet32 (PcdHwErrStorageSize) -
mVariableModuleGlobal->HwErrVariableTotalSize;
//
- // Check if the free area is blow a threshold.
+ // Check if the free area is below a threshold.
//
- if ((RemainingCommonVariableSpace < PcdGet32 (PcdMaxVariableSize))
- || ((PcdGet32 (PcdHwErrStorageSize) != 0) &&
+ if ((RemainingCommonRuntimeVariableSpace < PcdGet32 (PcdMaxVariableSize))
+ || ((PcdGet32 (PcdHwErrStorageSize) != 0) &&
(RemainingHwErrVariableSpace < PcdGet32
(PcdMaxHardwareErrorVariableSize)))){
Status = Reclaim (
mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,
@@ -2894,6 +3151,7 @@
)
{
EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
+ VARIABLE_HEADER *Variable;
VARIABLE_HEADER *NextVariable;
EFI_PHYSICAL_ADDRESS VariableStoreBase;
UINT64 VariableStoreLength;
@@ -2905,18 +3163,13 @@
FAULT_TOLERANT_WRITE_LAST_WRITE_DATA *FtwLastWriteData;
UINT32 BackUpOffset;
UINT32 BackUpSize;
+ UINT32 HwErrStorageSize;
+ UINT32 MaxUserNvVariableSpaceSize;
+ UINT32 BoottimeReservedNvVariableSpaceSize;
mVariableModuleGlobal->FvbInstance = NULL;
//
- // Note that in EdkII variable driver implementation, Hardware Error Record
type variable
- // is stored with common variable in the same NV region. So the platform
integrator should
- // ensure that the value of PcdHwErrStorageSize is less than or equal to the
value of
- // PcdFlashNvStorageVariableSize.
- //
- ASSERT (PcdGet32 (PcdHwErrStorageSize) <= PcdGet32
(PcdFlashNvStorageVariableSize));
-
- //
// Allocate runtime memory used for a memory copy of the FLASH region.
// Keep the memory and the FLASH in sync as updates occur.
//
@@ -2985,7 +3238,38 @@
}
ASSERT(mNvVariableCache->Size == VariableStoreLength);
+
+ ASSERT (sizeof (VARIABLE_STORE_HEADER) <= VariableStoreLength);
+
+ HwErrStorageSize = PcdGet32 (PcdHwErrStorageSize);
+ MaxUserNvVariableSpaceSize = PcdGet32 (PcdMaxUserNvVariableSpaceSize);
+ BoottimeReservedNvVariableSpaceSize = PcdGet32
(PcdBoottimeReservedNvVariableSpaceSize);
+
//
+ // Note that in EdkII variable driver implementation, Hardware Error Record
type variable
+ // is stored with common variable in the same NV region. So the platform
integrator should
+ // ensure that the value of PcdHwErrStorageSize is less than the value of
+ // VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)).
+ //
+ ASSERT (HwErrStorageSize < (VariableStoreLength - sizeof
(VARIABLE_STORE_HEADER)));
+ //
+ // Ensure that the value of PcdMaxUserNvVariableSpaceSize is less than the
value of
+ // VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)) - PcdGet32
(PcdHwErrStorageSize).
+ //
+ ASSERT (MaxUserNvVariableSpaceSize < (VariableStoreLength - sizeof
(VARIABLE_STORE_HEADER) - HwErrStorageSize));
+ //
+ // Ensure that the value of PcdBoottimeReservedNvVariableSpaceSize is less
than the value of
+ // VariableStoreLength - sizeof (VARIABLE_STORE_HEADER)) - PcdGet32
(PcdHwErrStorageSize).
+ //
+ ASSERT (BoottimeReservedNvVariableSpaceSize < (VariableStoreLength - sizeof
(VARIABLE_STORE_HEADER) - HwErrStorageSize));
+
+ mVariableModuleGlobal->CommonVariableSpace = ((UINTN) VariableStoreLength -
sizeof (VARIABLE_STORE_HEADER) - HwErrStorageSize);
+ mVariableModuleGlobal->CommonMaxUserVariableSpace =
((MaxUserNvVariableSpaceSize != 0) ? MaxUserNvVariableSpaceSize :
mVariableModuleGlobal->CommonVariableSpace);
+ mVariableModuleGlobal->CommonRuntimeVariableSpace =
mVariableModuleGlobal->CommonVariableSpace -
BoottimeReservedNvVariableSpaceSize;
+
+ DEBUG ((EFI_D_INFO, "Variable driver common space: 0x%x 0x%x 0x%x\n",
mVariableModuleGlobal->CommonVariableSpace,
mVariableModuleGlobal->CommonMaxUserVariableSpace,
mVariableModuleGlobal->CommonRuntimeVariableSpace));
+
+ //
// The max variable or hardware error variable size should be < variable
store size.
//
ASSERT(MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32
(PcdMaxHardwareErrorVariableSize)) < VariableStoreLength);
@@ -2993,18 +3277,19 @@
//
// Parse non-volatile variable data and get last variable offset.
//
- NextVariable = GetStartPointer ((VARIABLE_STORE_HEADER
*)(UINTN)VariableStoreBase);
- while (IsValidVariableHeader (NextVariable, GetEndPointer
((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase))) {
- VariableSize = NextVariable->NameSize + NextVariable->DataSize + sizeof
(VARIABLE_HEADER);
- if ((NextVariable->Attributes & (EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
- mVariableModuleGlobal->HwErrVariableTotalSize += HEADER_ALIGN
(VariableSize);
+ Variable = GetStartPointer ((VARIABLE_STORE_HEADER
*)(UINTN)VariableStoreBase);
+ while (IsValidVariableHeader (Variable, GetEndPointer
((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase))) {
+ NextVariable = GetNextVariablePtr (Variable);
+ VariableSize = (UINTN) NextVariable - (UINTN) Variable;
+ if ((Variable->Attributes & (EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_HARDWARE_ERROR_RECORD)) == (EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {
+ mVariableModuleGlobal->HwErrVariableTotalSize += VariableSize;
} else {
- mVariableModuleGlobal->CommonVariableTotalSize += HEADER_ALIGN
(VariableSize);
+ mVariableModuleGlobal->CommonVariableTotalSize += VariableSize;
}
- NextVariable = GetNextVariablePtr (NextVariable);
+ Variable = NextVariable;
}
- mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) NextVariable
- (UINTN) VariableStoreBase;
+ mVariableModuleGlobal->NonVolatileLastVariableOffset = (UINTN) Variable -
(UINTN) VariableStoreBase;
return EFI_SUCCESS;
}
Modified: trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
===================================================================
--- trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
2015-01-27 08:42:01 UTC (rev 16668)
+++ trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
2015-01-27 08:42:47 UTC (rev 16669)
@@ -42,6 +42,7 @@
#include <Guid/SystemNvDataGuid.h>
#include <Guid/FaultTolerantWrite.h>
#include <Guid/HardwareErrorVariable.h>
+#include <Guid/VarErrorFlag.h>
#define VARIABLE_ATTRIBUTE_BS_RT (EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_RUNTIME_ACCESS)
#define VARIABLE_ATTRIBUTE_NV_BS_RT (VARIABLE_ATTRIBUTE_BS_RT |
EFI_VARIABLE_NON_VOLATILE)
@@ -85,7 +86,11 @@
VARIABLE_GLOBAL VariableGlobal;
UINTN VolatileLastVariableOffset;
UINTN NonVolatileLastVariableOffset;
+ UINTN CommonVariableSpace;
+ UINTN CommonMaxUserVariableSpace;
+ UINTN CommonRuntimeVariableSpace;
UINTN CommonVariableTotalSize;
+ UINTN CommonUserVariableTotalSize;
UINTN HwErrVariableTotalSize;
CHAR8 *PlatformLangCodes;
CHAR8 *LangCodes;
@@ -361,7 +366,42 @@
);
/**
+ Finds variable in storage blocks of volatile and non-volatile storage areas.
+ This code finds variable in storage blocks of volatile and non-volatile
storage areas.
+ If VariableName is an empty string, then we just return the first
+ qualified variable without comparing VariableName and VendorGuid.
+ If IgnoreRtCheck is TRUE, then we ignore the EFI_VARIABLE_RUNTIME_ACCESS
attribute check
+ at runtime when searching existing variable, only VariableName and
VendorGuid are compared.
+ Otherwise, variables without EFI_VARIABLE_RUNTIME_ACCESS are not visible at
runtime.
+
+ @param VariableName Name of the variable to be found.
+ @param VendorGuid Vendor GUID to be found.
+ @param PtrTrack VARIABLE_POINTER_TRACK structure for
output,
+ including the range searched and the
target position.
+ @param Global Pointer to VARIABLE_GLOBAL structure,
including
+ base of volatile variable storage area,
base of
+ NV variable storage area, and a lock.
+ @param IgnoreRtCheck Ignore EFI_VARIABLE_RUNTIME_ACCESS
attribute
+ check at runtime when searching variable.
+
+ @retval EFI_INVALID_PARAMETER If VariableName is not an empty string,
while
+ VendorGuid is NULL.
+ @retval EFI_SUCCESS Variable successfully found.
+ @retval EFI_NOT_FOUND Variable not found
+
+**/
+EFI_STATUS
+FindVariable (
+ IN CHAR16 *VariableName,
+ IN EFI_GUID *VendorGuid,
+ OUT VARIABLE_POINTER_TRACK *PtrTrack,
+ IN VARIABLE_GLOBAL *Global,
+ IN BOOLEAN IgnoreRtCheck
+ );
+
+/**
+
This code finds variable in storage blocks (Volatile or Non-Volatile).
@param VariableName Name of Variable to be found.
@@ -616,6 +656,25 @@
);
/**
+ Internal variable property get.
+
+ @param[in] Name Pointer to the variable name.
+ @param[in] Guid Pointer to the vendor GUID.
+ @param[out] VariableProperty Pointer to the output variable property.
+
+ @retval EFI_SUCCESS The property of variable specified by the Name
and Guid was got successfully.
+ @retval EFI_NOT_FOUND The property of variable specified by the Name
and Guid was not found.
+
+**/
+EFI_STATUS
+EFIAPI
+InternalVarCheckVariablePropertyGet (
+ IN CHAR16 *Name,
+ IN EFI_GUID *Guid,
+ OUT VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
+ );
+
+/**
Variable property get.
@param[in] Name Pointer to the variable name.
@@ -635,6 +694,15 @@
OUT VAR_CHECK_VARIABLE_PROPERTY *VariableProperty
);
+/**
+ Initialize variable quota.
+
+**/
+VOID
+InitializeVariableQuota (
+ VOID
+ );
+
extern VARIABLE_MODULE_GLOBAL *mVariableModuleGlobal;
#endif
Modified: trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c
===================================================================
--- trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c
2015-01-27 08:42:01 UTC (rev 16668)
+++ trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableDxe.c
2015-01-27 08:42:47 UTC (rev 16669)
@@ -282,6 +282,10 @@
// Set the End Of DXE bit in case the EFI_END_OF_DXE_EVENT_GROUP_GUID event
is not signaled.
//
mEndOfDxe = TRUE;
+ //
+ // The initialization for variable quota.
+ //
+ InitializeVariableQuota ();
ReclaimForOS ();
if (FeaturePcdGet (PcdVariableCollectStatistics)) {
gBS->InstallConfigurationTable (&gEfiVariableGuid, gVariableInfo);
@@ -305,6 +309,10 @@
)
{
mEndOfDxe = TRUE;
+ //
+ // The initialization for variable quota.
+ //
+ InitializeVariableQuota ();
}
/**
Modified:
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
===================================================================
---
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
2015-01-27 08:42:01 UTC (rev 16668)
+++
trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
2015-01-27 08:42:47 UTC (rev 16669)
@@ -91,6 +91,7 @@
gEfiEndOfDxeEventGroupGuid ## CONSUMES ##
Event
## SOMETIMES_CONSUMES ## HOB
gEdkiiFaultTolerantWriteGuid
+ gEdkiiVarErrorFlagGuid ## CONSUMES ## GUID
[Pcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize ## CONSUMES
@@ -100,6 +101,8 @@
gEfiMdeModulePkgTokenSpaceGuid.PcdMaxHardwareErrorVariableSize ## CONSUMES
gEfiMdeModulePkgTokenSpaceGuid.PcdVariableStoreSize ## CONSUMES
gEfiMdeModulePkgTokenSpaceGuid.PcdHwErrStorageSize ## CONSUMES
+ gEfiMdeModulePkgTokenSpaceGuid.PcdMaxUserNvVariableSpaceSize ##
CONSUMES
+ gEfiMdeModulePkgTokenSpaceGuid.PcdBoottimeReservedNvVariableSpaceSize ##
CONSUMES
[FeaturePcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdVariableCollectStatistics ## CONSUMES #
statistic the information of variable.
Modified: trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c
===================================================================
--- trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c
2015-01-27 08:42:01 UTC (rev 16668)
+++ trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.c
2015-01-27 08:42:47 UTC (rev 16669)
@@ -693,6 +693,10 @@
case SMM_VARIABLE_FUNCTION_READY_TO_BOOT:
mEndOfDxe = TRUE;
+ //
+ // The initialization for variable quota.
+ //
+ InitializeVariableQuota ();
if (AtRuntime()) {
Status = EFI_UNSUPPORTED;
break;
@@ -824,6 +828,10 @@
{
DEBUG ((EFI_D_INFO, "[Variable]END_OF_DXE is signaled\n"));
mEndOfDxe = TRUE;
+ //
+ // The initialization for variable quota.
+ //
+ InitializeVariableQuota ();
return EFI_SUCCESS;
}
Modified: trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf
===================================================================
--- trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf
2015-01-27 08:42:01 UTC (rev 16668)
+++ trunk/edk2/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmm.inf
2015-01-27 08:42:47 UTC (rev 16669)
@@ -93,6 +93,7 @@
gEfiHardwareErrorVariableGuid ## SOMETIMES_CONSUMES ##
Variable:L"HwErrRec####"
## SOMETIMES_CONSUMES ## HOB
gEdkiiFaultTolerantWriteGuid
+ gEdkiiVarErrorFlagGuid ## CONSUMES ## GUID
[Pcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize ## CONSUMES
@@ -102,6 +103,8 @@
gEfiMdeModulePkgTokenSpaceGuid.PcdMaxHardwareErrorVariableSize ## CONSUMES
gEfiMdeModulePkgTokenSpaceGuid.PcdVariableStoreSize ## CONSUMES
gEfiMdeModulePkgTokenSpaceGuid.PcdHwErrStorageSize ## CONSUMES
+ gEfiMdeModulePkgTokenSpaceGuid.PcdMaxUserNvVariableSpaceSize ##
CONSUMES
+ gEfiMdeModulePkgTokenSpaceGuid.PcdBoottimeReservedNvVariableSpaceSize ##
CONSUMES
[FeaturePcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdVariableCollectStatistics ## CONSUMES #
statistic the information of variable.
------------------------------------------------------------------------------
Dive into the World of Parallel Programming. The Go Parallel Website,
sponsored by Intel and developed in partnership with Slashdot Media, is your
hub for all things parallel software development, from weekly thought
leadership blogs to news, videos, case studies, tutorials and more. Take a
look and join the conversation now. http://goparallel.sourceforge.net/
_______________________________________________
edk2-commits mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/edk2-commits
