[mirror_edk2.git] / OvmfPkg / Library / SerializeVariablesLib / SerializeVariablesLib.c

/** @file\r
  Serialize Variables Library implementation\r
\r
  Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "SerializeVariablesLib.h"\r
\r
/**\r
  Serialization format:\r
\r
  The SerializeVariablesLib interface does not specify a format\r
  for the serialization of the variable data.  This library uses\r
  a packed array of a non-uniformly sized data structure elements.\r
\r
  Each variable is stored (packed) as:\r
    UINT32   VendorNameSize;  // Name size in bytes\r
    CHAR16   VendorName[?];   // The variable unicode name including the\r
                              // null terminating character.\r
    EFI_GUID VendorGuid;      // The variable GUID\r
    UINT32   DataSize;        // The size of variable data in bytes\r
    UINT8    Data[?];         // The variable data\r
\r
**/\r
\r
\r
/**\r
  Unpacks the next variable from the buffer\r
\r
  @param[in]  Buffer - Buffer pointing to the next variable instance\r
                On subsequent calls, the pointer should be incremented\r
                by the returned SizeUsed value.\r
  @param[in]  MaxSize - Max allowable size for the variable data\r
                On subsequent calls, this should be decremented\r
                by the returned SizeUsed value.\r
  @param[out] Name - Variable name string (address in Buffer)\r
  @param[out] NameSize - Size of Name in bytes\r
  @param[out] Guid - GUID of variable (address in Buffer)\r
  @param[out] Attributes - Attributes of variable\r
  @param[out] Data - Buffer containing Data for variable (address in Buffer)\r
  @param[out] DataSize - Size of Data in bytes\r
  @param[out] SizeUsed - Total size used for this variable instance in Buffer\r
\r
  @return     EFI_STATUS based on the success or failure of the operation\r
\r
**/\r
STATIC\r
EFI_STATUS\r
UnpackVariableFromBuffer (\r
  IN  VOID     *Buffer,\r
  IN  UINTN    MaxSize,\r
  OUT CHAR16   **Name,\r
  OUT UINT32   *NameSize,\r
  OUT EFI_GUID **Guid,\r
  OUT UINT32   *Attributes,\r
  OUT UINT32   *DataSize,\r
  OUT VOID     **Data,\r
  OUT UINTN    *SizeUsed\r
  )\r
{\r
  UINT8  *BytePtr;\r
  UINTN  Offset;\r
\r
  BytePtr = (UINT8*)Buffer;\r
  Offset = 0;\r
\r
  *NameSize = *(UINT32*) (BytePtr + Offset);\r
  Offset = Offset + sizeof (UINT32);\r
\r
  if (Offset > MaxSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *Name = (CHAR16*) (BytePtr + Offset);\r
  Offset = Offset + *(UINT32*)BytePtr;\r
  if (Offset > MaxSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *Guid = (EFI_GUID*) (BytePtr + Offset);\r
  Offset = Offset + sizeof (EFI_GUID);\r
  if (Offset > MaxSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *Attributes = *(UINT32*) (BytePtr + Offset);\r
  Offset = Offset + sizeof (UINT32);\r
  if (Offset > MaxSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *DataSize = *(UINT32*) (BytePtr + Offset);\r
  Offset = Offset + sizeof (UINT32);\r
  if (Offset > MaxSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *Data = (VOID*) (BytePtr + Offset);\r
  Offset = Offset + *DataSize;\r
  if (Offset > MaxSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *SizeUsed = Offset;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Iterates through the variables in the buffer, and calls a callback\r
  function for each variable found.\r
\r
  @param[in]  CallbackFunction - Function called for each variable instance\r
  @param[in]  Context - Passed to each call of CallbackFunction\r
  @param[in]  Buffer - Buffer containing serialized variables\r
  @param[in]  MaxSize - Size of Buffer in bytes\r
\r
  @return     EFI_STATUS based on the success or failure of the operation\r
\r
**/\r
STATIC\r
EFI_STATUS\r
IterateVariablesInBuffer (\r
  IN VARIABLE_SERIALIZATION_ITERATION_CALLBACK  CallbackFunction,\r
  IN VOID                                       *CallbackContext,\r
  IN VOID                                       *Buffer,\r
  IN UINTN                                      MaxSize\r
  )\r
{\r
  RETURN_STATUS Status;\r
  UINTN         TotalSizeUsed;\r
  UINTN         SizeUsed;\r
\r
  CHAR16        *Name;\r
  UINT32        NameSize;\r
  CHAR16        *AlignedName;\r
  UINT32        AlignedNameMaxSize;\r
  EFI_GUID      *Guid;\r
  UINT32        Attributes;\r
  UINT32        DataSize;\r
  VOID          *Data;\r
\r
  SizeUsed = 0;\r
  AlignedName = NULL;\r
  AlignedNameMaxSize = 0;\r
  Name = NULL;\r
  Guid = NULL;\r
  Attributes = 0;\r
  DataSize = 0;\r
  Data = NULL;\r
\r
  for (\r
    Status = EFI_SUCCESS, TotalSizeUsed = 0;\r
    !EFI_ERROR (Status) && (TotalSizeUsed < MaxSize);\r
    ) {\r
    Status = UnpackVariableFromBuffer (\r
               (VOID*) ((UINT8*) Buffer + TotalSizeUsed),\r
               (MaxSize - TotalSizeUsed),\r
               &Name,\r
               &NameSize,\r
               &Guid,\r
               &Attributes,\r
               &DataSize,\r
               &Data,\r
               &SizeUsed\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // We copy the name to a separately allocated buffer,\r
    // to be sure it is 16-bit aligned.\r
    //\r
    if (NameSize > AlignedNameMaxSize) {\r
      if (AlignedName != NULL) {\r
        FreePool (AlignedName);\r
      }\r
      AlignedName = AllocatePool (NameSize);\r
    }\r
    if (AlignedName == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    CopyMem (AlignedName, Name, NameSize);\r
\r
    TotalSizeUsed = TotalSizeUsed + SizeUsed;\r
\r
    //\r
    // Run the callback function\r
    //\r
    Status = (*CallbackFunction) (\r
               CallbackContext,\r
               AlignedName,\r
               Guid,\r
               Attributes,\r
               DataSize,\r
               Data\r
               );\r
\r
  }\r
\r
  if (AlignedName != NULL) {\r
    FreePool (AlignedName);\r
  }\r
\r
  //\r
  // Make sure the entire buffer was used, or else return an error\r
  //\r
  if (TotalSizeUsed != MaxSize) {\r
    DEBUG ((\r
      EFI_D_ERROR,\r
      "Deserialize variables error: TotalSizeUsed(%Lu) != MaxSize(%Lu)\n",\r
      (UINT64)TotalSizeUsed,\r
      (UINT64)MaxSize\r
      ));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
STATIC\r
RETURN_STATUS\r
EFIAPI\r
IterateVariablesCallbackNop (\r
  IN  VOID                         *Context,\r
  IN  CHAR16                       *VariableName,\r
  IN  EFI_GUID                     *VendorGuid,\r
  IN  UINT32                       Attributes,\r
  IN  UINTN                        DataSize,\r
  IN  VOID                         *Data\r
  )\r
{\r
  return RETURN_SUCCESS;\r
}\r
\r
\r
STATIC\r
RETURN_STATUS\r
EFIAPI\r
IterateVariablesCallbackSetInInstance (\r
  IN  VOID                         *Context,\r
  IN  CHAR16                       *VariableName,\r
  IN  EFI_GUID                     *VendorGuid,\r
  IN  UINT32                       Attributes,\r
  IN  UINTN                        DataSize,\r
  IN  VOID                         *Data\r
  )\r
{\r
  EFI_HANDLE  Instance;\r
\r
  Instance = (EFI_HANDLE) Context;\r
\r
  return SerializeVariablesAddVariable (\r
           Instance,\r
           VariableName,\r
           VendorGuid,\r
           Attributes,\r
           DataSize,\r
           Data\r
           );\r
}\r
\r
\r
STATIC\r
RETURN_STATUS\r
EFIAPI\r
IterateVariablesCallbackSetSystemVariable (\r
  IN  VOID                         *Context,\r
  IN  CHAR16                       *VariableName,\r
  IN  EFI_GUID                     *VendorGuid,\r
  IN  UINT32                       Attributes,\r
  IN  UINTN                        DataSize,\r
  IN  VOID                         *Data\r
  )\r
{\r
  EFI_STATUS          Status;\r
  STATIC CONST UINT32 AuthMask =\r
                        EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS |\r
                        EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
\r
  Status = gRT->SetVariable (\r
             VariableName,\r
             VendorGuid,\r
             Attributes,\r
             DataSize,\r
             Data\r
             );\r
\r
  if (Status == EFI_SECURITY_VIOLATION && (Attributes & AuthMask) != 0) {\r
    DEBUG ((DEBUG_WARN, "%a: setting authenticated variable \"%s\" "\r
            "failed with EFI_SECURITY_VIOLATION, ignoring\n", __FUNCTION__,\r
            VariableName));\r
    Status = EFI_SUCCESS;\r
  }\r
  return Status;\r
}\r
\r
\r
STATIC\r
RETURN_STATUS\r
EnsureExtraBufferSpace (\r
  IN  SV_INSTANCE  *Instance,\r
  IN  UINTN        Size\r
  )\r
{\r
  VOID *NewBuffer;\r
  UINTN NewSize;\r
\r
  NewSize = Instance->DataSize + Size;\r
  if (NewSize <= Instance->BufferSize) {\r
    return RETURN_SUCCESS;\r
  }\r
\r
  //\r
  // Double the required size to lessen the need to re-allocate in the future\r
  //\r
  NewSize = 2 * NewSize;\r
\r
  NewBuffer = AllocatePool (NewSize);\r
  if (NewBuffer == NULL) {\r
    return RETURN_OUT_OF_RESOURCES;\r
  }\r
\r
  if (Instance->BufferPtr != NULL) {\r
    CopyMem (NewBuffer, Instance->BufferPtr, Instance->DataSize);\r
    FreePool (Instance->BufferPtr);\r
  }\r
\r
  Instance->BufferPtr = NewBuffer;\r
  Instance->BufferSize = NewSize;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
\r
STATIC\r
VOID\r
AppendToBuffer (\r
  IN  SV_INSTANCE  *Instance,\r
  IN  VOID         *Data,\r
  IN  UINTN        Size\r
  )\r
{\r
  UINTN NewSize;\r
\r
  ASSERT (Instance != NULL);\r
  ASSERT (Data != NULL);\r
\r
  NewSize = Instance->DataSize + Size;\r
  ASSERT ((Instance->DataSize + Size) <= Instance->BufferSize);\r
\r
  CopyMem (\r
    (VOID*) (((UINT8*) (Instance->BufferPtr)) + Instance->DataSize),\r
    Data,\r
    Size\r
    );\r
\r
  Instance->DataSize = NewSize;\r
}\r
\r
\r
/**\r
  Creates a new variable serialization instance\r
\r
  @param[out]  Handle - Handle for a variable serialization instance\r
\r
  @retval      RETURN_SUCCESS - The variable serialization instance was\r
                 successfully created.\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 create the variable serialization instance.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesNewInstance (\r
  OUT EFI_HANDLE                      *Handle\r
  )\r
{\r
  SV_INSTANCE  *New;\r
\r
  New = AllocateZeroPool (sizeof (*New));\r
  if (New == NULL) {\r
    return RETURN_OUT_OF_RESOURCES;\r
  }\r
\r
  New->Signature = SV_SIGNATURE;\r
\r
  *Handle = (EFI_HANDLE) New;\r
  return RETURN_SUCCESS;\r
}\r
\r
\r
/**\r
  Free memory associated with a variable serialization instance\r
\r
  @param[in]  Handle - Handle for a variable serialization instance\r
\r
  @retval      RETURN_SUCCESS - The variable serialization instance was\r
                 successfully freed.\r
  @retval      RETURN_INVALID_PARAMETER - Handle was not a valid\r
                 variable serialization instance.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesFreeInstance (\r
  IN EFI_HANDLE Handle\r
  )\r
{\r
  SV_INSTANCE    *Instance;\r
\r
  Instance = SV_FROM_HANDLE (Handle);\r
\r
  if (Instance->Signature != SV_SIGNATURE) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  Instance->Signature = 0;\r
\r
  if (Instance->BufferPtr != NULL) {\r
    FreePool (Instance->BufferPtr);\r
  }\r
\r
  FreePool (Instance);\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
\r
/**\r
  Creates a new variable serialization instance using the given\r
  binary representation of the variables to fill the new instance\r
\r
  @param[out] Handle - Handle for a variable serialization instance\r
  @param[in]  Buffer - A buffer with the serialized representation\r
                of the variables.  Must be the same format as produced\r
                by SerializeVariablesToBuffer.\r
  @param[in]  Size - This is the size of the binary representation\r
                of the variables.\r
\r
  @retval      RETURN_SUCCESS - The binary representation was successfully\r
                 imported into a new variable serialization instance\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 create the new variable serialization instance\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesNewInstanceFromBuffer (\r
  OUT EFI_HANDLE                          *Handle,\r
  IN  VOID                                *Buffer,\r
  IN  UINTN                               Size\r
  )\r
{\r
  RETURN_STATUS Status;\r
\r
  Status = SerializeVariablesNewInstance (Handle);\r
  if (RETURN_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = IterateVariablesInBuffer (\r
             IterateVariablesCallbackNop,\r
             NULL,\r
             Buffer,\r
             Size\r
             );\r
  if (RETURN_ERROR (Status)) {\r
    SerializeVariablesFreeInstance (*Handle);\r
    return Status;\r
  }\r
\r
  Status = IterateVariablesInBuffer (\r
             IterateVariablesCallbackSetInInstance,\r
             (VOID*) *Handle,\r
             Buffer,\r
             Size\r
             );\r
  if (RETURN_ERROR (Status)) {\r
    SerializeVariablesFreeInstance (*Handle);\r
    return Status;\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Iterates all variables found with RuntimeServices GetNextVariableName\r
\r
  @param[in]   CallbackFunction - Function called for each variable instance\r
  @param[in]   Context - Passed to each call of CallbackFunction\r
\r
  @retval      RETURN_SUCCESS - All variables were iterated without the\r
                 CallbackFunction returning an error\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 iterate through the variables\r
  @return      Any of RETURN_ERROR indicates an error reading the variable\r
                 or an error was returned from CallbackFunction\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesIterateSystemVariables (\r
  IN VARIABLE_SERIALIZATION_ITERATION_CALLBACK CallbackFunction,\r
  IN VOID                                      *Context\r
  )\r
{\r
  RETURN_STATUS               Status;\r
  UINTN                       VariableNameBufferSize;\r
  UINTN                       VariableNameSize;\r
  CHAR16                      *VariableName;\r
  EFI_GUID                    VendorGuid;\r
  UINTN                       VariableDataBufferSize;\r
  UINTN                       VariableDataSize;\r
  VOID                        *VariableData;\r
  UINT32                      VariableAttributes;\r
  VOID                        *NewBuffer;\r
\r
  //\r
  // Initialize the variable name and data buffer variables.\r
  //\r
  VariableNameBufferSize = sizeof (CHAR16);\r
  VariableName = AllocateZeroPool (VariableNameBufferSize);\r
\r
  VariableDataBufferSize = 0;\r
  VariableData = NULL;\r
\r
  for (;;) {\r
    //\r
    // Get the next variable name and guid\r
    //\r
    VariableNameSize = VariableNameBufferSize;\r
    Status = gRT->GetNextVariableName (\r
                    &VariableNameSize,\r
                    VariableName,\r
                    &VendorGuid\r
                    );\r
    if (Status == EFI_BUFFER_TOO_SMALL) {\r
      //\r
      // The currently allocated VariableName buffer is too small,\r
      // so we allocate a larger buffer, and copy the old buffer\r
      // to it.\r
      //\r
      NewBuffer = AllocatePool (VariableNameSize);\r
      if (NewBuffer == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        break;\r
      }\r
      CopyMem (NewBuffer, VariableName, VariableNameBufferSize);\r
      if (VariableName != NULL) {\r
        FreePool (VariableName);\r
      }\r
      VariableName = NewBuffer;\r
      VariableNameBufferSize = VariableNameSize;\r
\r
      //\r
      // Try to get the next variable name again with the larger buffer.\r
      //\r
      Status = gRT->GetNextVariableName (\r
                      &VariableNameSize,\r
                      VariableName,\r
                      &VendorGuid\r
                      );\r
    }\r
\r
    if (EFI_ERROR (Status)) {\r
      if (Status == EFI_NOT_FOUND) {\r
        Status = EFI_SUCCESS;\r
      }\r
      break;\r
    }\r
\r
    //\r
    // Get the variable data and attributes\r
    //\r
    VariableDataSize = VariableDataBufferSize;\r
    Status = gRT->GetVariable (\r
                    VariableName,\r
                    &VendorGuid,\r
                    &VariableAttributes,\r
                    &VariableDataSize,\r
                    VariableData\r
                    );\r
    if (Status == EFI_BUFFER_TOO_SMALL) {\r
      //\r
      // The currently allocated VariableData buffer is too small,\r
      // so we allocate a larger buffer.\r
      //\r
      if (VariableDataBufferSize != 0) {\r
        FreePool (VariableData);\r
        VariableData = NULL;\r
        VariableDataBufferSize = 0;\r
      }\r
      VariableData = AllocatePool (VariableDataSize);\r
      if (VariableData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        break;\r
      }\r
      VariableDataBufferSize = VariableDataSize;\r
\r
      //\r
      // Try to read the variable again with the larger buffer.\r
      //\r
      Status = gRT->GetVariable (\r
                      VariableName,\r
                      &VendorGuid,\r
                      &VariableAttributes,\r
                      &VariableDataSize,\r
                      VariableData\r
                      );\r
    }\r
    if (EFI_ERROR (Status)) {\r
      break;\r
    }\r
\r
    //\r
    // Run the callback function\r
    //\r
    Status = (*CallbackFunction) (\r
               Context,\r
               VariableName,\r
               &VendorGuid,\r
               VariableAttributes,\r
               VariableDataSize,\r
               VariableData\r
               );\r
    if (EFI_ERROR (Status)) {\r
      break;\r
    }\r
\r
  }\r
\r
  if (VariableName != NULL) {\r
    FreePool (VariableName);\r
  }\r
\r
  if (VariableData != NULL) {\r
    FreePool (VariableData);\r
  }\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Iterates all variables found in the variable serialization instance\r
\r
  @param[in]   Handle - Handle for a variable serialization instance\r
  @param[in]   CallbackFunction - Function called for each variable instance\r
  @param[in]   Context - Passed to each call of CallbackFunction\r
\r
  @retval      RETURN_SUCCESS - All variables were iterated without the\r
                 CallbackFunction returning an error\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 iterate through the variables\r
  @return      Any of RETURN_ERROR indicates an error reading the variable\r
                 or an error was returned from CallbackFunction\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesIterateInstanceVariables (\r
  IN EFI_HANDLE                                Handle,\r
  IN VARIABLE_SERIALIZATION_ITERATION_CALLBACK CallbackFunction,\r
  IN VOID                                      *Context\r
  )\r
{\r
  SV_INSTANCE    *Instance;\r
\r
  Instance = SV_FROM_HANDLE (Handle);\r
\r
  if ((Instance->BufferPtr != NULL) && (Instance->DataSize != 0)) {\r
    return IterateVariablesInBuffer (\r
             CallbackFunction,\r
             Context,\r
             Instance->BufferPtr,\r
             Instance->DataSize\r
             );\r
  } else {\r
    return RETURN_SUCCESS;\r
  }\r
}\r
\r
\r
/**\r
  Sets all variables found in the variable serialization instance\r
\r
  @param[in]   Handle - Handle for a variable serialization instance\r
\r
  @retval      RETURN_SUCCESS - All variables were set successfully\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 set all the variables\r
  @return      Any of RETURN_ERROR indicates an error reading the variables\r
                 or in attempting to set a variable\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesSetSerializedVariables (\r
  IN EFI_HANDLE                       Handle\r
  )\r
{\r
  return SerializeVariablesIterateInstanceVariables (\r
           Handle,\r
           IterateVariablesCallbackSetSystemVariable,\r
           NULL\r
           );\r
}\r
\r
\r
/**\r
  Adds a variable to the variable serialization instance\r
\r
  @param[in] Handle - Handle for a variable serialization instance\r
  @param[in] VariableName - Refer to RuntimeServices GetVariable\r
  @param[in] VendorGuid - Refer to RuntimeServices GetVariable\r
  @param[in] Attributes - Refer to RuntimeServices GetVariable\r
  @param[in] DataSize - Refer to RuntimeServices GetVariable\r
  @param[in] Data - Refer to RuntimeServices GetVariable\r
\r
  @retval      RETURN_SUCCESS - All variables were set successfully\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 add the variable\r
  @retval      RETURN_INVALID_PARAMETER - Handle was not a valid\r
                 variable serialization instance or\r
                 VariableName, VariableGuid or Data are NULL.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesAddVariable (\r
  IN EFI_HANDLE                   Handle,\r
  IN CHAR16                       *VariableName,\r
  IN EFI_GUID                     *VendorGuid,\r
  IN UINT32                       Attributes,\r
  IN UINTN                        DataSize,\r
  IN VOID                         *Data\r
  )\r
{\r
  RETURN_STATUS  Status;\r
  SV_INSTANCE    *Instance;\r
  UINT32         SerializedNameSize;\r
  UINT32         SerializedDataSize;\r
  UINTN          SerializedSize;\r
\r
  Instance = SV_FROM_HANDLE (Handle);\r
\r
  if ((Instance->Signature != SV_SIGNATURE) ||\r
      (VariableName == NULL) || (VendorGuid == NULL) || (Data == NULL)) {\r
  }\r
\r
  SerializedNameSize = (UINT32) StrSize (VariableName);\r
\r
  SerializedSize =\r
    sizeof (SerializedNameSize) +\r
    SerializedNameSize +\r
    sizeof (*VendorGuid) +\r
    sizeof (Attributes) +\r
    sizeof (SerializedDataSize) +\r
    DataSize;\r
\r
  Status = EnsureExtraBufferSpace (\r
             Instance,\r
             SerializedSize\r
             );\r
  if (RETURN_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Add name size (UINT32)\r
  //\r
  AppendToBuffer (Instance, (VOID*) &SerializedNameSize, sizeof (SerializedNameSize));\r
\r
  //\r
  // Add variable unicode name string\r
  //\r
  AppendToBuffer (Instance, (VOID*) VariableName, SerializedNameSize);\r
\r
  //\r
  // Add variable GUID\r
  //\r
  AppendToBuffer (Instance, (VOID*) VendorGuid, sizeof (*VendorGuid));\r
\r
  //\r
  // Add variable attributes\r
  //\r
  AppendToBuffer (Instance, (VOID*) &Attributes, sizeof (Attributes));\r
\r
  //\r
  // Add variable data size (UINT32)\r
  //\r
  SerializedDataSize = (UINT32) DataSize;\r
  AppendToBuffer (Instance, (VOID*) &SerializedDataSize, sizeof (SerializedDataSize));\r
\r
  //\r
  // Add variable data\r
  //\r
  AppendToBuffer (Instance, Data, DataSize);\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
\r
/**\r
  Serializes the variables known to this instance into the\r
  provided buffer.\r
\r
  @param[in]     Handle - Handle for a variable serialization instance\r
  @param[out]    Buffer - A buffer to store the binary representation\r
                   of the variables.\r
  @param[in,out] Size - On input this is the size of the buffer.\r
                   On output this is the size of the binary representation\r
                   of the variables.\r
\r
  @retval      RETURN_SUCCESS - The binary representation was successfully\r
                 completed and returned in the buffer.\r
  @retval      RETURN_OUT_OF_RESOURCES - There we not enough resources to\r
                 save the variables to the buffer.\r
  @retval      RETURN_INVALID_PARAMETER - Handle was not a valid\r
                 variable serialization instance or\r
                 Size or Buffer were NULL.\r
  @retval      RETURN_BUFFER_TOO_SMALL - The Buffer size as indicated by\r
                 the Size parameter was too small for the serialized\r
                 variable data.  Size is returned with the required size.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
SerializeVariablesToBuffer (\r
  IN     EFI_HANDLE                       Handle,\r
  OUT    VOID                             *Buffer,\r
  IN OUT UINTN                            *Size\r
  )\r
{\r
  SV_INSTANCE    *Instance;\r
\r
  Instance = SV_FROM_HANDLE (Handle);\r
\r
  if (Size == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  if (*Size < Instance->DataSize) {\r
    *Size = Instance->DataSize;\r
    return RETURN_BUFFER_TOO_SMALL;\r
  }\r
\r
  if (Buffer == NULL) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  *Size = Instance->DataSize;\r
  CopyMem (Buffer, Instance->BufferPtr, Instance->DataSize);\r
\r
  return RETURN_SUCCESS;\r
}\r
\r