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

4 files changed, 94 insertions, 536 deletions

diff --git a/OvmfPkg/Library/NvVarsFileLib/FsAccess.c b/OvmfPkg/Library/NvVarsFileLib/FsAccess.c
index f1694051ab..190a56497f 100644
--- a/OvmfPkg/Library/NvVarsFileLib/FsAccess.c
+++ b/OvmfPkg/Library/NvVarsFileLib/FsAccess.c
@@ -1,7 +1,7 @@
 /** @file
   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
   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
@@ -233,6 +233,7 @@ ReadNvVarsFile (
   UINTN                       FileSize;
   BOOLEAN                     FileExists;
   VOID                        *FileContents;
+  EFI_HANDLE                  SerializedVariables;
 
   Status = GetNvVarsFile (FsHandle, TRUE, &File);
   if (EFI_ERROR (Status)) {
@@ -258,7 +259,14 @@ ReadNvVarsFile (
     FileSize
     ));
 
-  Status = SetVariablesFromBuffer (FileContents, FileSize);
+  Status = SerializeVariablesNewInstanceFromBuffer (
+             &SerializedVariables,
+             FileContents,
+             FileSize
+             );
+  if (!RETURN_ERROR (Status)) {
+    Status = SerializeVariablesSetSerializedVariables (SerializedVariables);
+  }
 
   FreePool (FileContents);
   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
   given file system.
@@ -362,15 +404,49 @@ SaveNvVarsToFs (
 {
   EFI_STATUS                  Status;
   EFI_FILE_HANDLE             File;
-  UINTN                       VariableNameBufferSize;
-  UINTN                       VariableNameSize;
-  CHAR16                      *VariableName;
-  EFI_GUID                    VendorGuid;
-  UINTN                       VariableDataBufferSize;
+  UINTN                       WriteSize;
   UINTN                       VariableDataSize;
   VOID                        *VariableData;
-  UINT32                      VariableAttributes;
-  VOID                        *NewBuffer;
+  EFI_HANDLE                  SerializedVariables;
+
+  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.
@@ -390,141 +466,10 @@ SaveNvVarsToFs (
     return Status;
   }
 
-  //
-  // Initialize the variable name and data buffer variables.
-  //
-  VariableNameBufferSize = sizeof (CHAR16);
-  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);
+  WriteSize = VariableDataSize;
+  Status = FileHandleWrite (File, &WriteSize, VariableData);
+  if (EFI_ERROR (Status)) {
+    return Status;
   }
 
   FileHandleClose (File);
diff --git a/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.h b/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.h
index b34d4fb6fb..ac3a3d6363 100644
--- a/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.h
+++ b/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.h
@@ -1,7 +1,7 @@
 /** @file
   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
   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
@@ -23,6 +23,7 @@
 
 #include <Library/BaseLib.h>
 #include <Library/FileHandleLib.h>
+#include <Library/SerializeVariablesLib.h>
 #include <Library/UefiBootServicesTableLib.h>
 #include <Library/UefiRuntimeServicesTableLib.h>
 #include <Library/UefiLib.h>
@@ -56,48 +57,5 @@ SaveNvVarsToFs (
   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
 
diff --git a/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.inf b/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.inf
index dfead8bfd1..76fbae0870 100644
--- a/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.inf
+++ b/OvmfPkg/Library/NvVarsFileLib/NvVarsFileLib.inf
@@ -1,10 +1,10 @@
 ## @file

 #  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.

 #

-#  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

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -33,7 +33,6 @@
 [Sources]

   FsAccess.c

   NvVarsFileLib.c

-  VarBuffer.c

 

 [Packages]

   MdePkg/MdePkg.dec

@@ -47,6 +46,7 @@
   DebugLib

   FileHandleLib

   MemoryAllocationLib

+  SerializeVariablesLib

 

 [Protocols]

   gEfiSimpleFileSystemProtocolGuid              ## CONSUMES

diff --git a/OvmfPkg/Library/NvVarsFileLib/VarBuffer.c b/OvmfPkg/Library/NvVarsFileLib/VarBuffer.c
deleted file mode 100644
index 7f42b4304e..0000000000
--- a/OvmfPkg/Library/NvVarsFileLib/VarBuffer.c
+++ /dev/null
@@ -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;
-}
-