ResetUtility.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/ResetSystemLib.h>
 
#pragma pack(1)
typedef struct {
  CHAR16    NullTerminator;
  GUID      ResetSubtype;
} RESET_UTILITY_GUID_SPECIFIC_RESET_DATA;
#pragma pack()
 
STATIC_ASSERT (
  sizeof (RESET_UTILITY_GUID_SPECIFIC_RESET_DATA) == 18,
  "sizeof (RESET_UTILITY_GUID_SPECIFIC_RESET_DATA) is expected to be 18 bytes"
  );
 
VOID
EFIAPI
ResetSystemWithSubtype (
  IN EFI_RESET_TYPE  ResetType,
  IN CONST  GUID     *ResetSubtype
  )
{
  RESET_UTILITY_GUID_SPECIFIC_RESET_DATA  ResetData;
 
  ResetData.NullTerminator = CHAR_NULL;
  CopyGuid (
    (GUID *)((UINT8 *)&ResetData + OFFSET_OF (RESET_UTILITY_GUID_SPECIFIC_RESET_DATA, ResetSubtype)),
    ResetSubtype
    );
 
  ResetSystem (ResetType, EFI_SUCCESS, sizeof (ResetData), &ResetData);
}
 
VOID
EFIAPI
ResetPlatformSpecificGuid (
  IN CONST  GUID  *ResetSubtype
  )
{
  ResetSystemWithSubtype (EfiResetPlatformSpecific, ResetSubtype);
}
 
GUID *
EFIAPI
GetResetPlatformSpecificGuid (
  IN UINTN       DataSize,
  IN CONST VOID  *ResetData
  )
{
  UINTN  ResetDataStringSize;
  GUID   *ResetSubtypeGuid;
 
  //
  // Make sure parameters are valid
  //
  if ((ResetData == NULL) || (DataSize < sizeof (GUID))) {
    return NULL;
  }
 
  //
  // Determine the number of bytes in the Null-terminated Unicode string
  // at the beginning of ResetData including the Null terminator.
  //
  ResetDataStringSize = StrnSizeS (ResetData, (DataSize / sizeof (CHAR16)));
 
  //
  // Now, assuming that we have enough data for a GUID after the string, the
  // GUID should be immediately after the string itself.
  //
  if ((ResetDataStringSize < DataSize) && ((DataSize - ResetDataStringSize) >= sizeof (GUID))) {
    ResetSubtypeGuid = (GUID *)((UINT8 *)ResetData + ResetDataStringSize);
    DEBUG ((DEBUG_VERBOSE, "%a - Detected reset subtype %g...\n", __func__, ResetSubtypeGuid));
    return ResetSubtypeGuid;
  }
 
  return NULL;
}
 
RETURN_STATUS
EFIAPI
BuildResetData (
  IN OUT   UINTN   *ResetDataSize,
  IN OUT   VOID    *ResetData,
  IN CONST GUID    *ResetSubtype  OPTIONAL,
  IN CONST CHAR16  *ResetString   OPTIONAL,
  IN       UINTN   ExtraDataSize  OPTIONAL,
  IN CONST VOID    *ExtraData     OPTIONAL
  )
{
  UINTN  ResetStringSize;
  UINTN  ResetDataBufferSize;
  UINT8  *Data;
 
  //
  // If the size return pointer is NULL.
  //
  if (ResetDataSize == NULL) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // If extra data is indicated, but pointer is NULL.
  //
  if ((ExtraDataSize > 0) && (ExtraData == NULL)) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // If extra data is indicated, but no subtype GUID is supplied.
  //
  if ((ResetSubtype == NULL) && (ExtraDataSize > 0)) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Determine the final string.
  //
  if (ResetString == NULL) {
    ResetString = L"";     // Use an empty string.
  }
 
  //
  // Calculate the total buffer required for ResetData.
  //
  ResetStringSize     = StrnSizeS (ResetString, MAX_UINT16);
  ResetDataBufferSize = ResetStringSize + ExtraDataSize;
  if (ResetSubtype != NULL) {
    ResetDataBufferSize += sizeof (GUID);
  }
 
  //
  // At this point, if the buffer isn't large enough (or if
  // the buffer is NULL) we cannot proceed.
  //
  if (*ResetDataSize < ResetDataBufferSize) {
    *ResetDataSize = ResetDataBufferSize;
    return RETURN_BUFFER_TOO_SMALL;
  }
 
  *ResetDataSize = ResetDataBufferSize;
  if (ResetData == NULL) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Fill in ResetData with ResetString, the ResetSubtype GUID, and extra data
  //
  Data = (UINT8 *)ResetData;
  CopyMem (Data, ResetString, ResetStringSize);
  Data += ResetStringSize;
  if (ResetSubtype != NULL) {
    CopyMem (Data, ResetSubtype, sizeof (GUID));
    Data += sizeof (GUID);
  }
 
  if (ExtraDataSize > 0) {
    CopyMem (Data, ExtraData, ExtraDataSize);
  }
 
  return RETURN_SUCCESS;
}