[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
  SPDX-License-Identifier: BSD-2-Clause-Patent\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
  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
  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
  {\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
\r
      AlignedName = AllocatePool (NameSize);\r
    }\r
\r
    if (AlignedName == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\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
  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
      DEBUG_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
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
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
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 ((\r
      DEBUG_WARN,\r
      "%a: setting authenticated variable \"%s\" "\r
      "failed with EFI_SECURITY_VIOLATION, ignoring\n",\r
      __FUNCTION__,\r
      VariableName\r
      ));\r
    Status = EFI_SUCCESS;\r
  } else if (Status == EFI_WRITE_PROTECTED) {\r
    DEBUG ((\r
      DEBUG_WARN,\r
      "%a: setting ReadOnly variable \"%s\" "\r
      "failed with EFI_WRITE_PROTECTED, ignoring\n",\r
      __FUNCTION__,\r
      VariableName\r
      ));\r
    Status = EFI_SUCCESS;\r
  }\r
\r
  return Status;\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
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
  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
  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
  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
  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
\r
      CopyMem (NewBuffer, VariableName, VariableNameBufferSize);\r
      if (VariableName != NULL) {\r
        FreePool (VariableName);\r
      }\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
\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
\r
      VariableData = AllocatePool (VariableDataSize);\r
      if (VariableData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        break;\r
      }\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
\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
  if (VariableName != NULL) {\r
    FreePool (VariableName);\r
  }\r
\r
  if (VariableData != NULL) {\r
    FreePool (VariableData);\r
  }\r
\r
  return Status;\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
  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
  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
\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
  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