i386_sup.c File Reference

#include "kdgdb.h"

Include dependency graph for i386_sup.c:

Go to the source code of this file.

Enumerations
enum	reg_name {   RAX , RBX , RCX , RDX ,   RSI , RDI , RBP , RSP ,   R8 , R9 , R10 , R11 ,   R12 , R13 , R14 , R15 ,   RIP , EFLAGS , CS , SS ,   DS , ES , FS , GS ,   ST0 , ST1 , ST2 , ST3 ,   ST4 , ST5 , ST6 , ST7 ,   FCTRL , FSTAT , FTAG , FISEG ,   FIOFF , FOSEG , FOOFF , FOP ,   EAX , ECX , EDX , EBX ,   ESP , EBP , ESI , EDI ,   EIP , EFLAGS , CS , SS ,   DS , ES , FS , GS ,   ST0 , ST1 , ST2 , ST3 ,   ST4 , ST5 , ST6 , ST7 ,   FCTRL , FSTAT , FTAG , FISEG ,   FIOFF , FOSEG , FOOFF , FOP ,   XMM0 , XMM1 , XMM2 , XMM3 ,   XMM4 , XMM5 , XMM6 , XMM7 ,   MXCSR }

Functions
static void *	ctx_to_reg (CONTEXT *ctx, enum reg_name name, unsigned short *size)
static void *	thread_to_reg (PETHREAD Thread, enum reg_name reg_name, unsigned short *size)
KDSTATUS	gdb_send_registers (void)
KDSTATUS	gdb_send_register (void)

Enumeration Type Documentation

reg_name

enum reg_name

Enumerator
RAX
RBX
RCX
RDX
RSI
RDI
RBP
RSP
R8
R9
R10
R11
R12
R13
R14
R15
RIP
EFLAGS
CS
SS
DS
ES
FS
GS
ST0
ST1
ST2
ST3
ST4
ST5
ST6
ST7
FCTRL
FSTAT
FTAG
FISEG
FIOFF
FOSEG
FOOFF
FOP
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
EIP
EFLAGS
CS
SS
DS
ES
FS
GS
ST0
ST1
ST2
ST3
ST4
ST5
ST6
ST7
FCTRL
FSTAT
FTAG
FISEG
FIOFF
FOSEG
FOOFF
FOP
XMM0
XMM1
XMM2
XMM3
XMM4
XMM5
XMM6
XMM7
MXCSR

Definition at line 10 of file i386_sup.c.

{
    EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
    EIP,
    EFLAGS,
    CS, SS, DS, ES, FS, GS,
    ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7,
    FCTRL, FSTAT, FTAG, FISEG, FIOFF, FOSEG, FOOFF, FOP,
    XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
    MXCSR
};

Function Documentation

ctx_to_reg()

static void * ctx_to_reg ( CONTEXT *  ctx, enum reg_name  name, unsigned short *  size  )

static

Definition at line 24 of file i386_sup.c.

{
    /* For general registers: 32bits */
    *size = 4;
    switch (name)
    {
    case EAX: return &ctx->Eax;
    case EBX: return &ctx->Ebx;
    case ECX: return &ctx->Ecx;
    case EDX: return &ctx->Edx;
    case ESP: return &ctx->Esp;
    case EBP: return &ctx->Ebp;
    case ESI: return &ctx->Esi;
    case EDI: return &ctx->Edi;
    case EIP: return &ctx->Eip;
    case EFLAGS: return &ctx->EFlags;
    case CS: return &ctx->SegCs;
    case DS: return &ctx->SegDs;
    case ES: return &ctx->SegEs;
    case FS: return &ctx->SegFs;
    case GS: return &ctx->SegGs;
    case SS: return &ctx->SegSs;
    /* 80 bits */
    case ST0:
    case ST1:
    case ST2:
    case ST3:
    case ST4:
    case ST5:
    case ST6:
    case ST7:
        *size = 10;
        return &ctx->FloatSave.RegisterArea[10 * (name - ST0)];
    /* X87 registers */
    case FCTRL: return &ctx->FloatSave.ControlWord;
    case FSTAT: return &ctx->FloatSave.StatusWord;
    case FTAG: return &ctx->FloatSave.TagWord;
    case FISEG: return &ctx->FloatSave.DataSelector;
    case FIOFF: return &ctx->FloatSave.DataOffset;
    case FOSEG: return &ctx->FloatSave.ErrorSelector;
    case FOOFF: return &ctx->FloatSave.ErrorOffset;
    case FOP: return &ctx->FloatSave.Cr0NpxState;
    /* SSE */
    case XMM0:
    case XMM1:
    case XMM2:
    case XMM3:
    case XMM4:
    case XMM5:
    case XMM6:
    case XMM7:
        *size = 16;
        return &ctx->ExtendedRegisters[160 + (name - XMM0)*16];
    case MXCSR: return &ctx->ExtendedRegisters[24];
    }
    return 0;
}

Referenced by gdb_send_register(), and gdb_send_registers().

gdb_send_register()

KDSTATUS gdb_send_register

(

void

)

Definition at line 223 of file i386_sup.c.

{
    enum reg_name reg_name;
    void *ptr;
    unsigned short size;
 
    /* Get the GDB register name (gdb_input = "pXX") */
    reg_name = (hex_value(gdb_input[1]) << 4) | hex_value(gdb_input[2]);
 
    if (((gdb_dbg_pid == 0) && (gdb_dbg_tid == 0)) ||
            gdb_tid_to_handle(gdb_dbg_tid) == PsGetThreadId((PETHREAD)(ULONG_PTR)CurrentStateChange.Thread))
    {
        /* We can get it from the context of the current exception */
        ptr = ctx_to_reg(&CurrentContext, reg_name, &size);
    }
    else
    {
        PETHREAD DbgThread;
 
        DbgThread = find_thread(gdb_dbg_pid, gdb_dbg_tid);
 
        if (DbgThread == NULL)
        {
            /* Thread is dead */
            return send_gdb_packet("E03");
        }
 
        ptr = thread_to_reg(DbgThread, reg_name, &size);
    }
 
    if (!ptr)
    {
        /* Undefined. Let's assume 32 bit register */
        return send_gdb_packet("xxxxxxxx");
    }
    else
    {
        KDDBGPRINT("KDDBG : Sending registers as memory.\n");
        return send_gdb_memory(ptr, size);
    }
}

gdb_send_registers()

KDSTATUS gdb_send_registers

(

void

)

Definition at line 152 of file i386_sup.c.

{
    CHAR RegisterStr[9];
    UCHAR* RegisterPtr;
    unsigned i;
    unsigned short size;
 
    RegisterStr[8] = '\0';
 
    start_gdb_packet();
 
    KDDBGPRINT("Sending registers of thread %" PRIxPTR ".\n", gdb_dbg_tid);
    KDDBGPRINT("Current thread_id: %p.\n", PsGetThreadId((PETHREAD)(ULONG_PTR)CurrentStateChange.Thread));
    if (((gdb_dbg_pid == 0) && (gdb_dbg_tid == 0)) ||
            gdb_tid_to_handle(gdb_dbg_tid) == PsGetThreadId((PETHREAD)(ULONG_PTR)CurrentStateChange.Thread))
    {
        for(i=0; i < 16; i++)
        {
            RegisterPtr = ctx_to_reg(&CurrentContext, i, &size);
            RegisterStr[0] = hex_chars[RegisterPtr[0] >> 4];
            RegisterStr[1] = hex_chars[RegisterPtr[0] & 0xF];
            RegisterStr[2] = hex_chars[RegisterPtr[1] >> 4];
            RegisterStr[3] = hex_chars[RegisterPtr[1] & 0xF];
            RegisterStr[4] = hex_chars[RegisterPtr[2] >> 4];
            RegisterStr[5] = hex_chars[RegisterPtr[2] & 0xF];
            RegisterStr[6] = hex_chars[RegisterPtr[3] >> 4];
            RegisterStr[7] = hex_chars[RegisterPtr[3] & 0xF];
 
            send_gdb_partial_packet(RegisterStr);
        }
    }
    else
    {
        PETHREAD DbgThread;
 
        DbgThread = find_thread(gdb_dbg_pid, gdb_dbg_tid);
 
        if (DbgThread == NULL)
        {
            /* Thread is dead */
            send_gdb_partial_packet("E03");
            return finish_gdb_packet();
        }
 
        for(i=0; i < 16; i++)
        {
            RegisterPtr = thread_to_reg(DbgThread, i, &size);
            if (RegisterPtr)
            {
                RegisterStr[0] = hex_chars[RegisterPtr[0] >> 4];
                RegisterStr[1] = hex_chars[RegisterPtr[0] & 0xF];
                RegisterStr[2] = hex_chars[RegisterPtr[1] >> 4];
                RegisterStr[3] = hex_chars[RegisterPtr[1] & 0xF];
                RegisterStr[4] = hex_chars[RegisterPtr[2] >> 4];
                RegisterStr[5] = hex_chars[RegisterPtr[2] & 0xF];
                RegisterStr[6] = hex_chars[RegisterPtr[3] >> 4];
                RegisterStr[7] = hex_chars[RegisterPtr[3] & 0xF];
 
                send_gdb_partial_packet(RegisterStr);
            }
            else
            {
                send_gdb_partial_packet("xxxxxxxx");
            }
        }
    }
 
    return finish_gdb_packet();
}

thread_to_reg()

static void * thread_to_reg ( PETHREAD  Thread, enum reg_name  reg_name, unsigned short *  size  )

static

Definition at line 84 of file i386_sup.c.

{
    static const void* NullValue = NULL;
 
    if (!Thread->Tcb.InitialStack)
    {
        /* Terminated thread ? */
        switch (reg_name)
        {
            case ESP:
            case EBP:
            case EIP:
                KDDBGPRINT("Returning NULL for register %d.\n", reg_name);
                *size = 4;
                return &NullValue;
            default:
                return NULL;
        }
    }
#if 0
    else if (Thread->Tcb.TrapFrame)
    {
        PKTRAP_FRAME TrapFrame = Thread->Tcb.TrapFrame;
 
        *size = 4;
        switch (reg_name)
        {
            case EAX: return &TrapFrame->Eax;
            case ECX: return &TrapFrame->Ecx;
            case EDX: return &TrapFrame->Edx;
            case EBX: return &TrapFrame->Ebx;
            case ESP: return (TrapFrame->PreviousPreviousMode == KernelMode) ?
                    &TrapFrame->TempEsp : &TrapFrame->HardwareEsp;
            case EBP: return &TrapFrame->Ebp;
            case ESI: return &TrapFrame->Esi;
            case EDI: return &TrapFrame->Edi;
            case EIP: return &TrapFrame->Eip;
            case EFLAGS: return &TrapFrame->EFlags;
            case CS: return &TrapFrame->SegCs;
            case SS: return &TrapFrame->HardwareSegSs;
            case DS: return &TrapFrame->SegDs;
            case ES: return &TrapFrame->SegEs;
            case FS: return &TrapFrame->SegFs;
            case GS: return &TrapFrame->SegGs;
            default:
                KDDBGPRINT("Unhandled regname: %d.\n", reg_name);
        }
    }
#endif
    else
    {
        static PULONG Esp;
        Esp = Thread->Tcb.KernelStack;
        *size = 4;
        switch(reg_name)
        {
            case EBP: return &Esp[3];
            case ESP: return &Esp;
            case EIP: return &NullValue;
            default:
                return NULL;
        }
    }
 
    return NULL;
}

Referenced by gdb_send_register(), and gdb_send_registers().