GdbStubInternal.h

Go to the documentation of this file.

 
#ifndef __GDB_STUB_INTERNAL__
#define __GDB_STUB_INTERNAL__
 
#include <Uefi.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/PcdLib.h>
#include <Library/GdbSerialLib.h>
#include <Library/PrintLib.h>
 
#include <Protocol/DebugSupport.h>
#include <Protocol/SerialIo.h>
#include <Protocol/LoadedImage.h>
#include <Protocol/LoadedImage.h>
#include <Guid/DebugImageInfoTable.h>
#include <IndustryStandard/PeImage.h>
 
extern CONST CHAR8  mHexToStr[];
 
// maximum size of input and output buffers
// This value came from the show remote command of the gdb we tested against
#define MAX_BUF_SIZE  2000
 
// maximum size of address buffer
#define MAX_ADDR_SIZE  32
 
// maximum size of register number buffer
#define MAX_REG_NUM_BUF_SIZE  32
 
// maximum size of length buffer
#define MAX_LENGTH_SIZE  32
 
// maximum size of T signal members
#define MAX_T_SIGNAL_SIZE  64
 
// the mask used to clear all the cache
#define TF_BIT  0x00000100
 
//
// GDB Signal definitions - generic names for interrupts
//
#define GDB_SIGILL   4     // Illegal instruction
#define GDB_SIGTRAP  5     // Trace Trap (Breakpoint and SingleStep)
#define GDB_SIGEMT   7     // Emulator Trap
#define GDB_SIGFPE   8     // Floating point exception
#define GDB_SIGSEGV  11    // Segment violation, page fault
 
//
// GDB File I/O Error values, zero means no error
// Includes all general GDB Unix like error values
//
#define GDB_EBADMEMADDRBUFSIZE    11  // the buffer that stores memory Address to be read from/written to is not the right size
#define GDB_EBADMEMLENGBUFSIZE    12  // the buffer that stores Length is not the right size
#define GDB_EBADMEMLENGTH         13  // Length, the given number of bytes to read or write, is not the right size
#define GDB_EBADMEMDATA           14  // one of the bytes or nibbles of the memory is less than 0
#define GDB_EBADMEMDATASIZE       15  // the memory data, 'XX..', is too short or too long
#define GDB_EBADBUFSIZE           21  // the buffer created is not the correct size
#define GDB_EINVALIDARG           31  // argument is invalid
#define GDB_ENOSPACE              41  //
#define GDB_EINVALIDBRKPOINTTYPE  51  // the breakpoint type is not recognized
#define GDB_EINVALIDREGNUM        61  // given register number is not valid: either <0 or >=Number of Registers
#define GDB_EUNKNOWN              255 // unknown
 
//
// These devices are open by GDB so we can just read and write to them
//
#define GDB_STDIN   0x00
#define GDB_STDOUT  0x01
#define GDB_STDERR  0x02
 
//
// Define Register size for different architectures
//
#if defined (MDE_CPU_IA32)
#define REG_SIZE  32
#elif defined (MDE_CPU_X64)
#define REG_SIZE  64
#elif defined (MDE_CPU_ARM)
#define REG_SIZE  32
#endif
 
#define GDB_SERIAL_DEV_SIGNATURE  SIGNATURE_32 ('g', 'd', 'b', 's')
 
typedef struct {
  VENDOR_DEVICE_PATH          VendorDevice;
  UINT32                      Index;                    // Support more than one
  EFI_DEVICE_PATH_PROTOCOL    End;
} GDB_SERIAL_DEVICE_PATH;
 
//
//  Name:   SERIAL_DEV
//  Purpose:  To provide device specific information
//  Fields:
//      Signature UINTN: The identity of the serial device
//      SerialIo  SERIAL_IO_PROTOCOL: Serial I/O protocol interface
//      SerialMode  SERIAL_IO_MODE:
//      DevicePath  EFI_DEVICE_PATH_PROTOCOL *: Device path of the serial device
//
typedef struct {
  UINTN                     Signature;
  EFI_HANDLE                Handle;
  EFI_SERIAL_IO_PROTOCOL    SerialIo;
  EFI_SERIAL_IO_MODE        SerialMode;
  GDB_SERIAL_DEVICE_PATH    DevicePath;
  INTN                      InFileDescriptor;
  INTN                      OutFileDescriptor;
} GDB_SERIAL_DEV;
 
#define GDB_SERIAL_DEV_FROM_THIS(a)  CR (a, GDB_SERIAL_DEV, SerialIo, GDB_SERIAL_DEV_SIGNATURE)
 
typedef struct {
  EFI_EXCEPTION_TYPE    Exception;
  UINT8                 SignalNo;
} EFI_EXCEPTION_TYPE_ENTRY;
 
#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
 
//
// Byte packed structure for DR6
// 32-bits on IA-32
// 64-bits on X64.  The upper 32-bits on X64 are reserved
//
typedef union {
  struct {
    UINT32    B0         : 1;  // Breakpoint condition detected
    UINT32    B1         : 1;  // Breakpoint condition detected
    UINT32    B2         : 1;  // Breakpoint condition detected
    UINT32    B3         : 1;  // Breakpoint condition detected
    UINT32    Reserved_1 : 9;  // Reserved
    UINT32    BD         : 1;  // Debug register access detected
    UINT32    BS         : 1;  // Single step
    UINT32    BT         : 1;  // Task switch
    UINT32    Reserved_2 : 16; // Reserved
  } Bits;
  UINTN    UintN;
} IA32_DR6;
 
//
// Byte packed structure for DR7
// 32-bits on IA-32
// 64-bits on X64.  The upper 32-bits on X64 are reserved
//
typedef union {
  struct {
    UINT32    L0         : 1; // Local breakpoint enable
    UINT32    G0         : 1; // Global breakpoint enable
    UINT32    L1         : 1; // Local breakpoint enable
    UINT32    G1         : 1; // Global breakpoint enable
    UINT32    L2         : 1; // Local breakpoint enable
    UINT32    G2         : 1; // Global breakpoint enable
    UINT32    L3         : 1; // Local breakpoint enable
    UINT32    G3         : 1; // Global breakpoint enable
    UINT32    LE         : 1; // Local exact breakpoint enable
    UINT32    GE         : 1; // Global exact breakpoint enable
    UINT32    Reserved_1 : 3; // Reserved
    UINT32    GD         : 1; // Global detect enable
    UINT32    Reserved_2 : 2; // Reserved
    UINT32    RW0        : 2; // Read/Write field
    UINT32    LEN0       : 2; // Length field
    UINT32    RW1        : 2; // Read/Write field
    UINT32    LEN1       : 2; // Length field
    UINT32    RW2        : 2; // Read/Write field
    UINT32    LEN2       : 2; // Length field
    UINT32    RW3        : 2; // Read/Write field
    UINT32    LEN3       : 2; // Length field
  } Bits;
  UINTN    UintN;
} IA32_DR7;
 
#endif /* if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) */
 
typedef enum {
  InstructionExecution,   // Hardware breakpoint
  DataWrite,              // watch
  DataRead,               // rwatch
  DataReadWrite,          // awatch
  SoftwareBreakpoint,     // Software breakpoint
  NotSupported
} BREAK_TYPE;
 
//
// Array of exception types that need to be hooked by the debugger
//
extern EFI_EXCEPTION_TYPE_ENTRY  gExceptionType[];
 
//
// Set TRUE if F Reply package signals a ctrl-c. We can not process the Ctrl-c
// here we need to wait for the periodic callback to do this.
//
extern BOOLEAN  gCtrlCBreakFlag;
 
//
// If the periodic callback is called while we are processing an F packet we need
// to let the callback know to not read from the serial stream as it could steal
// characters from the F response packet
//
extern BOOLEAN  gProcessingFPacket;
 
// The offsets of registers SystemContext.
// The fields in the array are in the gdb ordering.
//
extern UINTN  gRegisterOffsets[];
 
UINTN
MaxEfiException (
  VOID
  );
 
UINTN
MaxRegisterCount (
  VOID
  );
 
BOOLEAN
CheckIsa (
  IN    EFI_INSTRUCTION_SET_ARCHITECTURE  Isa
  );
 
VOID
GdbSendTSignal (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINT8               GdbExceptionType
  );
 
UINT8
ConvertEFItoGDBtype (
  IN  EFI_EXCEPTION_TYPE  EFIExceptionType
  );
 
VOID
EmptyBuffer (
  IN CHAR8  *Buf
  );
 
INTN
HexCharToInt (
  IN  CHAR8  Char
  );
 
VOID
EFIAPI
SendError (
  IN  UINT8  ErrorNum
  );
 
VOID
EFIAPI
SendSuccess (
  VOID
  );
 
VOID
EFIAPI
SendNotSupported (
  VOID
  );
 
VOID
ReadNthRegister (
  IN    EFI_SYSTEM_CONTEXT  SystemContext,
  IN    CHAR8               *InBuffer
  );
 
VOID
EFIAPI
ReadGeneralRegisters (
  IN    EFI_SYSTEM_CONTEXT  SystemContext
  );
 
VOID
EFIAPI
WriteNthRegister (
  IN    EFI_SYSTEM_CONTEXT  SystemContext,
  IN    CHAR8               *InBuffer
  );
 
VOID
EFIAPI
WriteGeneralRegisters (
  IN    EFI_SYSTEM_CONTEXT  SystemContext,
  IN    CHAR8               *InBuffer
  );
 
VOID
EFIAPI
ReadFromMemory (
  IN  CHAR8  *PacketData
  );
 
VOID
EFIAPI
WriteToMemory (
  IN CHAR8  *PacketData
  );
 
VOID
EFIAPI
ContinueAtAddress (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  CHAR8               *PacketData
  );
 
VOID
EFIAPI
SingleStep (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  CHAR8               *PacketData
  );
 
VOID
AddSingleStep (
  IN  EFI_SYSTEM_CONTEXT  SystemContext
  );
 
VOID
RemoveSingleStep (
  IN  EFI_SYSTEM_CONTEXT  SystemContext
  );
 
VOID
EFIAPI
InsertBreakPoint (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  CHAR8               *PacketData
  );
 
VOID
EFIAPI
RemoveBreakPoint (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  CHAR8               *PacketData
  );
 
VOID
EFIAPI
GdbExceptionHandler (
  IN     EFI_EXCEPTION_TYPE  ExceptionType,
  IN OUT EFI_SYSTEM_CONTEXT  SystemContext
  );
 
VOID
EFIAPI
GdbPeriodicCallBack (
  IN OUT EFI_SYSTEM_CONTEXT  SystemContext
  );
 
VOID
GdbInitializeSerialConsole (
  VOID
  );
 
UINTN
SendPacket (
  IN  CHAR8  *PacketData
  );
 
UINTN
ReceivePacket (
  OUT  CHAR8  *PacketData,
  IN   UINTN  PacketDataSize
  );
 
INTN
GdbRead (
  IN  INTN   FileDescriptor,
  OUT VOID   *Buffer,
  IN  UINTN  Count
  );
 
INTN
GdbWrite (
  IN  INTN        FileDescriptor,
  OUT CONST VOID  *Buffer,
  IN  UINTN       Count
  );
 
UINTN *
FindPointerToRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               RegNumber
  );
 
CHAR8 *
BasicReadRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               RegNumber,
  IN  CHAR8               *OutBufPtr
  );
 
VOID
TransferFromInBufToMem (
  IN  UINTN  Length,
  IN  UINT8  *Address,
  IN  CHAR8  *NewData
  );
 
VOID
TransferFromMemToOutBufAndSend (
  IN  UINTN  Length,
  IN  UINT8  *Address
  );
 
CHAR8 *
BasicWriteRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               RegNumber,
  IN  CHAR8               *InBufPtr
  );
 
VOID
PrintReg (
  EFI_SYSTEM_CONTEXT  SystemContext
  );
 
UINTN
ParseBreakpointPacket (
  IN  CHAR8  *PacketData,
  OUT UINTN  *Type,
  OUT UINTN  *Address,
  OUT UINTN  *Length
  );
 
UINTN
GetBreakpointDataAddress (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               BreakpointNumber
  );
 
UINTN
GetBreakpointDetected (
  IN  EFI_SYSTEM_CONTEXT  SystemContext
  );
 
BREAK_TYPE
GetBreakpointType (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               BreakpointNumber
  );
 
UINTN
ConvertLengthData (
  IN  UINTN  Length
  );
 
EFI_STATUS
FindNextFreeDebugRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  OUT UINTN               *Register
  );
 
EFI_STATUS
EnableDebugRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               Register,
  IN  UINTN               Address,
  IN  UINTN               Length,
  IN  UINTN               Type
  );
 
EFI_STATUS
FindMatchingDebugRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               Address,
  IN  UINTN               Length,
  IN  UINTN               Type,
  OUT UINTN               *Register
  );
 
EFI_STATUS
DisableDebugRegister (
  IN  EFI_SYSTEM_CONTEXT  SystemContext,
  IN  UINTN               Register
  );
 
VOID
InitializeProcessor (
  VOID
  );
 
BOOLEAN
ValidateAddress (
  IN  VOID  *Address
  );
 
BOOLEAN
ValidateException (
  IN  EFI_EXCEPTION_TYPE     ExceptionType,
  IN OUT EFI_SYSTEM_CONTEXT  SystemContext
  );
 
#endif