[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
/**\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
      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
\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
  } else if (Status == EFI_WRITE_PROTECTED) {\r
    DEBUG ((DEBUG_WARN, "%a: setting ReadOnly variable \"%s\" "\r
            "failed with EFI_WRITE_PROTECTED, 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