DebugLib.c

Go to the documentation of this file.

 
#include <Base.h>
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/PrintLib.h>
#include <Library/PcdLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/SerialPortLib.h>
#include <Library/DebugDeviceLib.h>
#include <Library/DebugPrintErrorLevelLib.h>
 
//
// Define the maximum debug and assert message length that this library supports
//
#define MAX_DEBUG_MESSAGE_LENGTH  0x100
 
CONST CHAR8  *mHexTable = "0123456789ABCDEF";
 
//
// VA_LIST can not initialize to NULL for all compiler, so we use this to
// indicate a null VA_LIST
//
VA_LIST  mVaListNull;
 
UINTN *
EFIAPI
GetStackFramePointer (
  VOID
  );
 
VOID
EFIAPI
DebugPrint (
  IN  UINTN        ErrorLevel,
  IN  CONST CHAR8  *Format,
  ...
  )
{
  VA_LIST  Marker;
 
  VA_START (Marker, Format);
  DebugVPrint (ErrorLevel, Format, Marker);
  VA_END (Marker);
}
 
VOID
DebugPrintMarker (
  IN  UINTN        ErrorLevel,
  IN  CONST CHAR8  *Format,
  IN  VA_LIST      VaListMarker,
  IN  BASE_LIST    BaseListMarker
  )
{
  CHAR8  Buffer[MAX_DEBUG_MESSAGE_LENGTH];
 
  //
  // If Format is NULL, then ASSERT().
  //
  if (!GetDebugPrintDeviceEnable ()) {
    return;
  }
 
  //
  // Check driver debug mask value and global mask
  //
  if ((ErrorLevel & GetDebugPrintErrorLevel ()) == 0) {
    return;
  }
 
  //
  // If Format is NULL, then ASSERT().
  //
  ASSERT (Format != NULL);
 
  //
  // Convert the DEBUG() message to an ASCII String
  //
  if (BaseListMarker == NULL) {
    AsciiVSPrint (Buffer, sizeof (Buffer), Format, VaListMarker);
  } else {
    AsciiBSPrint (Buffer, sizeof (Buffer), Format, BaseListMarker);
  }
 
  //
  // Send the print string to a Serial Port
  //
  SerialPortWrite ((UINT8 *)Buffer, AsciiStrLen (Buffer));
}
 
VOID
EFIAPI
DebugVPrint (
  IN  UINTN        ErrorLevel,
  IN  CONST CHAR8  *Format,
  IN  VA_LIST      VaListMarker
  )
{
  DebugPrintMarker (ErrorLevel, Format, VaListMarker, NULL);
}
 
VOID
EFIAPI
DebugBPrint (
  IN  UINTN        ErrorLevel,
  IN  CONST CHAR8  *Format,
  IN  BASE_LIST    BaseListMarker
  )
{
  DebugPrintMarker (ErrorLevel, Format, mVaListNull, BaseListMarker);
}
 
VOID
FillHex (
  UINTN  Value,
  CHAR8  *Buffer
  )
{
  INTN  Idx;
 
  for (Idx = (sizeof (UINTN) * 2) - 1; Idx >= 0; Idx--) {
    Buffer[Idx] = mHexTable[Value & 0x0F];
    Value     >>= 4;
  }
}
 
VOID
DebugAssertInternal (
  VOID
  )
{
  CHAR8  Buffer[MAX_DEBUG_MESSAGE_LENGTH];
  UINTN  *Frame;
 
  Frame = (UINTN *)GetStackFramePointer ();
 
  //
  // Generate the ASSERT() message in Ascii format
  //
  if (sizeof (UINTN) == sizeof (UINT32)) {
    AsciiStrnCpyS (
      Buffer,
      sizeof (Buffer) / sizeof (CHAR8),
      "-> EBP:0x00000000  EIP:0x00000000\n",
      sizeof (Buffer) / sizeof (CHAR8) - 1
      );
  } else {
    AsciiStrnCpyS (
      Buffer,
      sizeof (Buffer) / sizeof (CHAR8),
      "-> RBP:0x0000000000000000  RIP:0x0000000000000000\n",
      sizeof (Buffer) / sizeof (CHAR8) - 1
      );
  }
 
  SerialPortWrite ((UINT8 *)"ASSERT DUMP:\n", 13);
  while (Frame != NULL) {
    FillHex ((UINTN)Frame, Buffer + 9);
    FillHex (Frame[1], Buffer + 9 + (sizeof (UINTN) * 2) + 8);
    SerialPortWrite ((UINT8 *)Buffer, AsciiStrLen (Buffer));
    if ((Frame[0] > (UINTN)Frame) && (Frame[0] < (UINTN)Frame + 0x00100000)) {
      Frame = (UINTN *)Frame[0];
    } else {
      Frame = NULL;
    }
  }
 
  //
  // Dead loop
  //
  CpuDeadLoop ();
}
 
VOID
EFIAPI
DebugAssert (
  IN CONST CHAR8  *FileName,
  IN UINTN        LineNumber,
  IN CONST CHAR8  *Description
  )
{
  DebugAssertInternal ();
}
 
VOID *
EFIAPI
DebugClearMemory (
  OUT VOID  *Buffer,
  IN UINTN  Length
  )
{
  return Buffer;
}
 
BOOLEAN
EFIAPI
DebugAssertEnabled (
  VOID
  )
{
  return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
}
 
BOOLEAN
EFIAPI
DebugPrintEnabled (
  VOID
  )
{
  return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
}
 
BOOLEAN
EFIAPI
DebugCodeEnabled (
  VOID
  )
{
  return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
}
 
BOOLEAN
EFIAPI
DebugClearMemoryEnabled (
  VOID
  )
{
  return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
}
 
BOOLEAN
EFIAPI
DebugPrintLevelEnabled (
  IN  CONST UINTN  ErrorLevel
  )
{
  return (BOOLEAN)((ErrorLevel & PcdGet32 (PcdFixedDebugPrintErrorLevel)) != 0);
}