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

OvmfPkg NvVarsFileLib: Leverage SerializeVariablesLib 

Utilize SerializeVariablesLib to simplify this library's
implementation.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11286 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
jljusten 2011-01-30 19:50:08 +00:00
parent b043ebc219
commit 59b1946970
4 changed files with 94 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
OvmfPkg/Library/NvVarsFileLib/FsAccess.c
View File

@ -1,7 +1,7 @@
/** @file /** @file
File System Access for NvVarsFileLib File System Access for NvVarsFileLib
Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR> Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
@ -233,6 +233,7 @@ ReadNvVarsFile (
UINTN FileSize; UINTN FileSize;
BOOLEAN FileExists; BOOLEAN FileExists;
VOID *FileContents; VOID *FileContents;
EFI_HANDLE SerializedVariables;
Status = GetNvVarsFile (FsHandle, TRUE, &File); Status = GetNvVarsFile (FsHandle, TRUE, &File);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
@ -258,7 +259,14 @@ ReadNvVarsFile (
FileSize FileSize
)); ));
Status = SetVariablesFromBuffer (FileContents, FileSize); Status = SerializeVariablesNewInstanceFromBuffer (
&SerializedVariables,
FileContents,
FileSize
);
if (!RETURN_ERROR (Status)) {
Status = SerializeVariablesSetSerializedVariables (SerializedVariables);
}
FreePool (FileContents); FreePool (FileContents);
FileHandleClose (File); FileHandleClose (File);
@ -346,6 +354,40 @@ LoadNvVarsFromFs (
} }
STATIC
RETURN_STATUS
EFIAPI
IterateVariablesCallbackAddAllNvVariables (
IN VOID *Context,
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data
)
{
EFI_HANDLE Instance;
Instance = (EFI_HANDLE) Context;
//
// Only save non-volatile variables
//
if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
return RETURN_SUCCESS;
}
return SerializeVariablesAddVariable (
Instance,
VariableName,
VendorGuid,
Attributes,
DataSize,
Data
);
}
/** /**
Saves the non-volatile variables into the NvVars file on the Saves the non-volatile variables into the NvVars file on the
given file system. given file system.
@ -362,15 +404,49 @@ SaveNvVarsToFs (
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_FILE_HANDLE File; EFI_FILE_HANDLE File;
UINTN VariableNameBufferSize; UINTN WriteSize;
UINTN VariableNameSize;
CHAR16 *VariableName;
EFI_GUID VendorGuid;
UINTN VariableDataBufferSize;
UINTN VariableDataSize; UINTN VariableDataSize;
VOID *VariableData; VOID *VariableData;
UINT32 VariableAttributes; EFI_HANDLE SerializedVariables;
VOID *NewBuffer;
Status = SerializeVariablesNewInstance (&SerializedVariables);
if (EFI_ERROR (Status)) {
return Status;
}
Status = SerializeVariablesIterateSystemVariables (
IterateVariablesCallbackAddAllNvVariables,
(VOID*) SerializedVariables
);
if (EFI_ERROR (Status)) {
return Status;
}
VariableData = NULL;
VariableDataSize = 0;
Status = SerializeVariablesToBuffer (
SerializedVariables,
NULL,
&VariableDataSize
);
if (Status == RETURN_BUFFER_TOO_SMALL) {
VariableData = AllocatePool (VariableDataSize);
if (VariableData == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
Status = SerializeVariablesToBuffer (
SerializedVariables,
VariableData,
&VariableDataSize
);
}
}
SerializeVariablesFreeInstance (SerializedVariables);
if (EFI_ERROR (Status)) {
return Status;
}
// //
// Open the NvVars file for writing. // Open the NvVars file for writing.
@ -390,141 +466,10 @@ SaveNvVarsToFs (
return Status; return Status;
} }
// WriteSize = VariableDataSize;
// Initialize the variable name and data buffer variables. Status = FileHandleWrite (File, &WriteSize, VariableData);
// if (EFI_ERROR (Status)) {
VariableNameBufferSize = sizeof (CHAR16); return Status;
VariableName = AllocateZeroPool (VariableNameBufferSize);
VariableDataBufferSize = 0;
VariableData = NULL;
for (;;) {
//
// Get the next variable name and guid
//
VariableNameSize = VariableNameBufferSize;
Status = gRT->GetNextVariableName (
&VariableNameSize,
VariableName,
&VendorGuid
);
if (Status == EFI_BUFFER_TOO_SMALL) {
//
// The currently allocated VariableName buffer is too small,
// so we allocate a larger buffer, and copy the old buffer
// to it.
//
NewBuffer = AllocatePool (VariableNameSize);
if (NewBuffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
break;
}
CopyMem (NewBuffer, VariableName, VariableNameBufferSize);
if (VariableName != NULL) {
FreePool (VariableName);
}
VariableName = NewBuffer;
VariableNameBufferSize = VariableNameSize;
//
// Try to get the next variable name again with the larger buffer.
//
Status = gRT->GetNextVariableName (
&VariableNameSize,
VariableName,
&VendorGuid
);
}
if (EFI_ERROR (Status)) {
if (Status == EFI_NOT_FOUND) {
Status = EFI_SUCCESS;
}
break;
}
//
// Get the variable data and attributes
//
VariableDataSize = VariableDataBufferSize;
Status = gRT->GetVariable (
VariableName,
&VendorGuid,
&VariableAttributes,
&VariableDataSize,
VariableData
);
if (Status == EFI_BUFFER_TOO_SMALL) {
//
// The currently allocated VariableData buffer is too small,
// so we allocate a larger buffer.
//
if (VariableDataBufferSize != 0) {
FreePool (VariableData);
VariableData = NULL;
VariableDataBufferSize = 0;
}
VariableData = AllocatePool (VariableDataSize);
if (VariableData == NULL) {
Status = EFI_OUT_OF_RESOURCES;
break;
}
VariableDataBufferSize = VariableDataSize;
//
// Try to read the variable again with the larger buffer.
//
Status = gRT->GetVariable (
VariableName,
&VendorGuid,
&VariableAttributes,
&VariableDataSize,
VariableData
);
}
if (EFI_ERROR (Status)) {
break;
}
//
// Skip volatile variables. We only preserve non-volatile variables.
//
if ((VariableAttributes & EFI_VARIABLE_NON_VOLATILE) == 0) {
continue;
}
DEBUG ((
EFI_D_INFO,
"Saving variable %g:%s to file\n",
&VendorGuid,
VariableName
));
//
// Write the variable information out to the file
//
Status = PackVariableIntoFile (
File,
VariableName,
(UINT32) VariableNameSize,
&VendorGuid,
VariableAttributes,
VariableData,
(UINT32) VariableDataSize
);
if (EFI_ERROR (Status)) {
break;
}
}
if (VariableName != NULL) {
FreePool (VariableName);
}
if (VariableData != NULL) {
FreePool (VariableData);
} }
FileHandleClose (File); FileHandleClose (File);

46
OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.h
View File

@ -1,7 +1,7 @@
/** @file /** @file
Save Non-Volatile Variables to a file system. Save Non-Volatile Variables to a file system.
Copyright (c) 2009, Intel Corporation. All rights reserved.<BR> Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
@ -23,6 +23,7 @@
#include <Library/BaseLib.h> #include <Library/BaseLib.h>
#include <Library/FileHandleLib.h> #include <Library/FileHandleLib.h>
#include <Library/SerializeVariablesLib.h>
#include <Library/UefiBootServicesTableLib.h> #include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h> #include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/UefiLib.h> #include <Library/UefiLib.h>
@ -56,48 +57,5 @@ SaveNvVarsToFs (
EFI_HANDLE FsHandle EFI_HANDLE FsHandle
); );
/**
Examines the NvVars file contents, and updates variables based on it.
@param[in] VarsBuffer - Buffer with NvVars data
@param[in] VarsBufferSize - Size of VarsBuffer in bytes
@return EFI_STATUS based on the success or failure of the operation
**/
EFI_STATUS
SetVariablesFromBuffer (
IN VOID *VarsBuffer,
IN UINTN VarsBufferSize
);
/**
Writes the variable into the file so it can be restored from
the file on future boots of the system.
@param[in] File - The file to write to
@param[in] Name - Variable name string
@param[in] NameSize - Size of Name in bytes
@param[in] Guid - GUID of variable
@param[in] Attributes - Attributes of variable
@param[in] Data - Buffer containing Data for variable
@param[in] DataSize - Size of Data in bytes
@return EFI_STATUS based on the success or failure of the operation
**/
EFI_STATUS
PackVariableIntoFile (
IN EFI_FILE_HANDLE File,
IN CHAR16 *Name,
IN UINT32 NameSize,
IN EFI_GUID *Guid,
IN UINT32 Attributes,
IN VOID *Data,
IN UINT32 DataSize
);
#endif #endif

6
OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.inf
View File

@ -1,10 +1,10 @@
## @file ## @file
# NvVarsFileLib # NvVarsFileLib
# #
# This kibrary saves and restores non-volatile variables in a # This library saves and restores non-volatile variables in a
# file within a file system. # file within a file system.
# #
# Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
# #
# This program and the accompanying materials # This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License # are licensed and made available under the terms and conditions of the BSD License
@ -33,7 +33,6 @@
[Sources] [Sources]
FsAccess.c FsAccess.c
NvVarsFileLib.c NvVarsFileLib.c
VarBuffer.c
[Packages] [Packages]
MdePkg/MdePkg.dec MdePkg/MdePkg.dec
@ -47,6 +46,7 @@
DebugLib DebugLib
FileHandleLib FileHandleLib
MemoryAllocationLib MemoryAllocationLib
SerializeVariablesLib
[Protocols] [Protocols]
gEfiSimpleFileSystemProtocolGuid ## CONSUMES gEfiSimpleFileSystemProtocolGuid ## CONSUMES

345
OvmfPkg/Library/NvVarsFileLib/VarBuffer.c
View File

@ -1,345 +0,0 @@
/** @file
File System Access
Copyright (c) 2004 - 2009, 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.
**/
#include "NvVarsFileLib.h"
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
/**
Writes the variable into the file so it can be restored from
the file on future boots of the system.
@param[in] File - The file to write to
@param[in] Name - Variable name string
@param[in] NameSize - Size of Name in bytes
@param[in] Guid - GUID of variable
@param[in] Attributes - Attributes of variable
@param[in] Data - Buffer containing Data for variable
@param[in] DataSize - Size of Data in bytes
@return EFI_STATUS based on the success or failure of the operation
**/
EFI_STATUS
PackVariableIntoFile (
IN EFI_FILE_HANDLE File,
IN CHAR16 *Name,
IN UINT32 NameSize,
IN EFI_GUID *Guid,
IN UINT32 Attributes,
IN VOID *Data,
IN UINT32 DataSize
)
{
EFI_STATUS Status;
UINTN WriteSize;
WriteSize = sizeof (NameSize);
Status = FileHandleWrite (File, &WriteSize, &NameSize);
if (EFI_ERROR (Status)) {
return Status;
}
WriteSize = NameSize;
Status = FileHandleWrite (File, &WriteSize, (VOID*) Name);
if (EFI_ERROR (Status)) {
return Status;
}
WriteSize = sizeof (*Guid);
Status = FileHandleWrite (File, &WriteSize, (VOID*) Guid);
if (EFI_ERROR (Status)) {
return Status;
}
WriteSize = sizeof (Attributes);
Status = FileHandleWrite (File, &WriteSize, &Attributes);
if (EFI_ERROR (Status)) {
return Status;
}
WriteSize = sizeof (DataSize);
Status = FileHandleWrite (File, &WriteSize, &DataSize);
if (EFI_ERROR (Status)) {
return Status;
}
WriteSize = DataSize;
Status = FileHandleWrite (File, &WriteSize, Data);
return Status;
}
/**
Unpacks the next variable from the NvVars file data
@param[in] Buffer - Buffer pointing to the next variable instance
On subsequent calls, the pointer should be incremented
by the returned SizeUsed value.
@param[in] MaxSize - Max allowable size for the variable data
On subsequent calls, this should be decremented
by the returned SizeUsed value.
@param[out] Name - Variable name string (address in Buffer)
@param[out] NameSize - Size of Name in bytes
@param[out] Guid - GUID of variable (address in Buffer)
@param[out] Attributes - Attributes of variable
@param[out] Data - Buffer containing Data for variable (address in Buffer)
@param[out] DataSize - Size of Data in bytes
@param[out] SizeUsed - Total size used for this variable instance in Buffer
@return EFI_STATUS based on the success or failure of the operation
**/
EFI_STATUS
UnpackVariableFromBuffer (
IN VOID *Buffer,
IN UINTN MaxSize,
OUT CHAR16 **Name,
OUT UINT32 *NameSize,
OUT EFI_GUID **Guid,
OUT UINT32 *Attributes,
OUT UINT32 *DataSize,
OUT VOID **Data,
OUT UINTN *SizeUsed
)
{
UINT8 *BytePtr;
UINTN Offset;
BytePtr = (UINT8*)Buffer;
Offset = 0;
*NameSize = *(UINT32*) (BytePtr + Offset);
Offset = Offset + sizeof (UINT32);
if (Offset > MaxSize) {
return EFI_INVALID_PARAMETER;
}
*Name = (CHAR16*) (BytePtr + Offset);
Offset = Offset + *(UINT32*)BytePtr;
if (Offset > MaxSize) {
return EFI_INVALID_PARAMETER;
}
*Guid = (EFI_GUID*) (BytePtr + Offset);
Offset = Offset + sizeof (EFI_GUID);
if (Offset > MaxSize) {
return EFI_INVALID_PARAMETER;
}
*Attributes = *(UINT32*) (BytePtr + Offset);
Offset = Offset + sizeof (UINT32);
if (Offset > MaxSize) {
return EFI_INVALID_PARAMETER;
}
*DataSize = *(UINT32*) (BytePtr + Offset);
Offset = Offset + sizeof (UINT32);
if (Offset > MaxSize) {
return EFI_INVALID_PARAMETER;
}
*Data = (VOID*) (BytePtr + Offset);
Offset = Offset + *DataSize;
if (Offset > MaxSize) {
return EFI_INVALID_PARAMETER;
}
*SizeUsed = Offset;
return EFI_SUCCESS;
}
/**
Examines the NvVars file contents, and updates variables based on it.
@param[in] Buffer - Buffer with NvVars data
@param[in] MaxSize - Size of Buffer in bytes
@param[in] DryRun - If TRUE, then no variable modifications should be made
(If TRUE, the Buffer is still parsed for validity.)
@return EFI_STATUS based on the success or failure of the operation
**/
EFI_STATUS
UnpackVariablesFromBuffer (
IN VOID *Buffer,
IN UINTN MaxSize,
IN BOOLEAN DryRun
)
{
EFI_STATUS Status;
UINTN Count;
UINTN TotalSizeUsed;
UINTN SizeUsed;
CHAR16 *Name;
UINT32 NameSize;
CHAR16 *AlignedName;
UINT32 AlignedNameMaxSize;
EFI_GUID *Guid;
UINT32 Attributes;
UINT32 DataSize;
VOID *Data;
AlignedName = NULL;
AlignedNameMaxSize = 0;
for (
Status = EFI_SUCCESS, Count = 0, TotalSizeUsed = 0;
!EFI_ERROR (Status) && (TotalSizeUsed < MaxSize);
) {
Status = UnpackVariableFromBuffer (
(VOID*) ((UINT8*) Buffer + TotalSizeUsed),
(MaxSize - TotalSizeUsed),
&Name,
&NameSize,
&Guid,
&Attributes,
&DataSize,
&Data,
&SizeUsed
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// We copy the name to a separately allocated buffer,
// to be sure it is 16-bit aligned.
//
if (NameSize > AlignedNameMaxSize) {
if (AlignedName != NULL) {
FreePool (AlignedName);
}
AlignedName = AllocatePool (NameSize);
}
if (AlignedName == NULL) {
return EFI_OUT_OF_RESOURCES;
}
CopyMem (AlignedName, Name, NameSize);
DEBUG ((
EFI_D_INFO,
"Unpacked variable %g:%s\n",
Guid,
AlignedName
));
TotalSizeUsed = TotalSizeUsed + SizeUsed;
DEBUG ((
EFI_D_INFO,
"TotalSizeUsed(%d); MaxSize(%d)\n",
TotalSizeUsed,
MaxSize
));
if (!DryRun) {
//
// Set the variable contents
//
gRT->SetVariable (
AlignedName,
Guid,
Attributes,
DataSize,
Data
);
Count++;
DEBUG ((
EFI_D_INFO,
"Restored variable %g:%s\n",
Guid,
AlignedName
));
}
}
if (AlignedName != NULL) {
FreePool (AlignedName);
}
//
// Make sure the entire buffer was used, or else return an error
//
if (TotalSizeUsed != MaxSize) {
DEBUG ((
EFI_D_INFO,
"TotalSizeUsed(%d) != MaxSize(%d)\n",
TotalSizeUsed,
MaxSize
));
return EFI_INVALID_PARAMETER;
}
if (Count > 0) {
DEBUG ((
EFI_D_INFO,
"Restored %d Variables\n",
Count
));
}
return EFI_SUCCESS;
}
/**
Examines the NvVars file contents, and updates variables based on it.
@param[in] VarsBuffer - Buffer with NvVars data
@param[in] VarsBufferSize - Size of VarsBuffer in bytes
@return EFI_STATUS based on the success or failure of the operation
**/
EFI_STATUS
SetVariablesFromBuffer (
IN VOID *VarsBuffer,
IN UINTN VarsBufferSize
)
{
EFI_STATUS Status;
//
// First test to make sure the entire buffer is in a good state
//
Status = UnpackVariablesFromBuffer (VarsBuffer, VarsBufferSize, TRUE);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_INFO, "NvVars buffer format was invalid\n"));
return Status;
}
//
// Now, actually restore the variables.
//
Status = UnpackVariablesFromBuffer (VarsBuffer, VarsBufferSize, FALSE);
if (EFI_ERROR (Status)) {
return Status;
}
return Status;
}