#include <ntifs.h>
#include <halfuncs.h>
#include <stdio.h>
#include <arc/arc.h>
#include <inttypes.h>
#include <windbgkd.h>
#include <kddll.h>
#include <pstypes.h>

Include dependency graph for kdgdb.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	NOEXTAPI

#define	MONOPROCESS 1

#define	KDDBGPRINT(...)

#define	gdb_pid_to_handle gdb_tid_to_handle

#define	handle_to_gdb_pid handle_to_gdb_tid

Typedefs
typedef BOOLEAN(*	KDP_SEND_HANDLER) (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)

typedef KDSTATUS(*	KDP_MANIPULATESTATE_HANDLER) (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

Functions
FORCEINLINE HANDLE	gdb_tid_to_handle (UINT_PTR Tid)

FORCEINLINE UINT_PTR	handle_to_gdb_tid (HANDLE Handle)

FORCEINLINE VOID	InitManipulateFromStateChange (_In_ ULONG ApiNumber, _In_ const DBGKD_ANY_WAIT_STATE_CHANGE StateChange, _Out_ DBGKD_MANIPULATE_STATE64 Manipulate)

KDSTATUS	gdb_receive_and_interpret_packet (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

KDSTATUS NTAPI	gdb_receive_packet (_Inout_ PKD_CONTEXT KdContext)

char	hex_value (char ch)

KDSTATUS	send_gdb_packet (_In_ const CHAR *Buffer)

void	start_gdb_packet (void)

void	send_gdb_partial_packet (_In_ const CHAR *Buffer)

KDSTATUS	finish_gdb_packet (void)

KDSTATUS	send_gdb_memory (_In_ const VOID *Buffer, size_t Length)

void	send_gdb_partial_memory (_In_ const VOID *Buffer, _In_ size_t Length)

ULONG	send_gdb_partial_binary (_In_ const VOID *Buffer, _In_ size_t Length)

KDSTATUS	gdb_send_debug_io (_In_ PSTRING String, _In_ BOOLEAN WithPrefix)

KDSTATUS	gdb_send_exception (void)

void	send_gdb_ntstatus (_In_ NTSTATUS Status)

KDSTATUS NTAPI	KdpPollBreakIn (VOID)

VOID NTAPI	KdpSendByte (_In_ UCHAR Byte)

KDSTATUS NTAPI	KdpReceiveByte (_Out_ PUCHAR OutByte)

KDSTATUS NTAPI	KdpPollByte (OUT PUCHAR OutByte)

KDSTATUS	ContinueManipulateStateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

KDSTATUS	SetContextManipulateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

PEPROCESS	find_process (_In_ UINT_PTR Pid)

PETHREAD	find_thread (_In_ UINT_PTR Pid, _In_ UINT_PTR Tid)

KDSTATUS	gdb_send_register (void)

KDSTATUS	gdb_send_registers (void)

Macro Definition Documentation

◆ gdb_pid_to_handle

#define gdb_pid_to_handle gdb_tid_to_handle

Definition at line 39 of file kdgdb.h.

◆ handle_to_gdb_pid

#define handle_to_gdb_pid handle_to_gdb_tid

Definition at line 45 of file kdgdb.h.

◆ KDDBGPRINT

#define KDDBGPRINT ( ... )

Definition at line 28 of file kdgdb.h.

◆ MONOPROCESS

#define MONOPROCESS 1

Definition at line 25 of file kdgdb.h.

◆ NOEXTAPI

#define NOEXTAPI

Definition at line 11 of file kdgdb.h.

Typedef Documentation

◆ KDP_MANIPULATESTATE_HANDLER

typedef KDSTATUS(* KDP_MANIPULATESTATE_HANDLER) (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

Definition at line 65 of file kdgdb.h.

◆ KDP_SEND_HANDLER

typedef BOOLEAN(* KDP_SEND_HANDLER) (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)

Definition at line 60 of file kdgdb.h.

Function Documentation

◆ ContinueManipulateStateHandler()

KDSTATUS ContinueManipulateStateHandler	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 213 of file kdpacket.c.

{
    /* Let's go on */
    State->ApiNumber = DbgKdContinueApi;
    State->ReturnStatus = STATUS_SUCCESS; /* ? */
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    if (MessageData)
        MessageData->Length = 0;
    *MessageLength = 0;
    State->u.Continue.ContinueStatus = STATUS_SUCCESS;
 
    /* We definitely are at the end of the send <-> receive loop, if any */
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = NULL;
    /* We're not handling an exception anymore */
    InException = FALSE;
 
    return KdPacketReceived;
}

Referenced by handle_gdb_c(), and handle_gdb_s().

◆ find_process()

PEPROCESS find_process ( _In_ UINT_PTR Pid )

Definition at line 16 of file utils.c.

{
    HANDLE ProcessId = gdb_pid_to_handle(Pid);
    LIST_ENTRY* ProcessEntry;
    PEPROCESS Process;
 
    /* Special case for idle process */
    if (ProcessId == NULL)
        return TheIdleProcess;
 
    for (ProcessEntry = ProcessListHead->Flink;
            ProcessEntry != ProcessListHead;
            ProcessEntry = ProcessEntry->Flink)
    {
        Process = CONTAINING_RECORD(ProcessEntry, EPROCESS, ActiveProcessLinks);
 
        if (Process->UniqueProcessId == ProcessId)
            return Process;
    }
 
    return NULL;
}

Referenced by find_thread(), handle_gdb_query(), handle_gdb_read_mem(), and handle_gdb_write_mem().

◆ find_thread()

PETHREAD find_thread	(	_In_ UINT_PTR	Pid,
		_In_ UINT_PTR	Tid
	)

Definition at line 41 of file utils.c.

{
    HANDLE ThreadId = gdb_tid_to_handle(Tid);
    PETHREAD Thread;
    PEPROCESS Process;
    LIST_ENTRY* ThreadEntry;
#if MONOPROCESS
    LIST_ENTRY* ProcessEntry;
#endif
 
    if (
#if !MONOPROCESS
    (Pid == 0) &&
#endif
    (Tid == 0))
    {
        /* Zero means any, so use the current one */
        return (PETHREAD)(ULONG_PTR)CurrentStateChange.Thread;
    }
 
#if MONOPROCESS
 
    /* Special case for the idle thread */
    if (Tid == 1)
        return TheIdleThread;
 
    for (ProcessEntry = ProcessListHead->Flink;
        ProcessEntry != ProcessListHead;
        ProcessEntry = ProcessEntry->Flink)
    {
        Process = CONTAINING_RECORD(ProcessEntry, EPROCESS, ActiveProcessLinks);
#else
 
    Process = find_process(Pid);
 
    /* Special case for the idle thread */
    if ((Process == TheIdleProcess) && (Tid == 1))
        return TheIdleThread;
 
    if (!Process)
        return NULL;
 
#endif
 
    for (ThreadEntry = Process->ThreadListHead.Flink;
            ThreadEntry != &Process->ThreadListHead;
            ThreadEntry = ThreadEntry->Flink)
    {
        Thread = CONTAINING_RECORD(ThreadEntry, ETHREAD, ThreadListEntry);
        /* For GDB, Tid == 0 means any thread */
        if ((Thread->Cid.UniqueThread == ThreadId) || (Tid == 0))
        {
            return Thread;
        }
    }
 
#if MONOPROCESS
    }
#endif
 
    return NULL;
}

Referenced by gdb_send_register(), gdb_send_registers(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_thread_alive(), handle_gdb_write_mem(), xmlGetThreadId(), xmlIsMainThread(), xmlMutexLock(), xmlMutexUnlock(), xmlRMutexLock(), and xmlRMutexUnlock().

◆ finish_gdb_packet()

KDSTATUS finish_gdb_packet ( void )

Definition at line 74 of file gdb_send.c.

{
    UCHAR ack;
    KDSTATUS Status;
 
    /* Send finish byte and append checksum */
    KdpSendByte('#');
    KdpSendByte(hex_chars[(currentChecksum >> 4) & 0xf]);
    KdpSendByte(hex_chars[currentChecksum & 0xf]);
 
    /* Wait for acknowledgement */
    Status = KdpReceiveByte(&ack);
 
    if (Status != KdPacketReceived)
    {
        KD_DEBUGGER_NOT_PRESENT = TRUE;
        return Status;
    }
 
    if (ack != '+')
        return KdPacketNeedsResend;
 
    return KdPacketReceived;
}

Referenced by gdb_send_debug_io(), gdb_send_register(), gdb_send_registers(), handle_gdb_query(), send_gdb_memory(), and send_gdb_packet().

◆ gdb_receive_and_interpret_packet()

KDSTATUS gdb_receive_and_interpret_packet	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 994 of file gdb_input.c.

{
    KDSTATUS Status;
 
    do
    {
        KDDBGPRINT("KDGBD: Receiving packet.\n");
        Status = gdb_receive_packet(KdContext);
        KDDBGPRINT("KDGBD: Packet \"%s\" received with status %u\n", gdb_input, Status);
 
        if (Status != KdPacketReceived)
            return Status;
 
        Status = (KDSTATUS)-1;
 
        switch (gdb_input[0])
        {
        case '?':
            /* Send the Status */
            Status = LOOP_IF_SUCCESS(gdb_send_exception());
            break;
        case '!':
            Status = LOOP_IF_SUCCESS(send_gdb_packet("OK"));
            break;
        case 'c':
        case 'C':
            Status = handle_gdb_c(State, MessageData, MessageLength, KdContext);
            break;
        case 'g':
            Status = LOOP_IF_SUCCESS(gdb_send_registers());
            break;
        case 'H':
            Status = LOOP_IF_SUCCESS(handle_gdb_set_thread());
            break;
        case 'm':
            Status = handle_gdb_read_mem(State, MessageData, MessageLength, KdContext);
            break;
        case 'p':
            Status = LOOP_IF_SUCCESS(gdb_send_register());
            break;
        case 'q':
            Status = LOOP_IF_SUCCESS(handle_gdb_query());
            break;
        case 's':
            Status = handle_gdb_s(State, MessageData, MessageLength, KdContext);
            break;
        case 'T':
            Status = LOOP_IF_SUCCESS(handle_gdb_thread_alive());
            break;
        case 'v':
            Status = handle_gdb_v(State, MessageData, MessageLength, KdContext);
            break;
        case 'X':
            Status = handle_gdb_write_mem(State, MessageData, MessageLength, KdContext);
            break;
        case 'z':
            Status = handle_gdb_remove_breakpoint(State, MessageData, MessageLength, KdContext);
            break;
        case 'Z':
            Status = handle_gdb_insert_breakpoint(State, MessageData, MessageLength, KdContext);
            break;
        default:
            /* We don't know how to handle this request. */
            KDDBGPRINT("Unsupported GDB command: %s.\n", gdb_input);
            Status = LOOP_IF_SUCCESS(send_gdb_packet(""));
        }
    } while (Status == (KDSTATUS)-1);
 
    return Status;
}

Referenced by KdReceivePacket().

◆ gdb_receive_packet()

KDSTATUS NTAPI gdb_receive_packet ( _Inout_ PKD_CONTEXT KdContext )

Definition at line 31 of file gdb_receive.c.

{
    UCHAR* ByteBuffer;
    UCHAR Byte;
    KDSTATUS Status;
    CHAR CheckSum, ReceivedCheckSum;
 
    do
    {
        Status = KdpReceiveByte(&Byte);
        if (Status != KdPacketReceived)
            return Status;
    } while (Byte != '$');
 
get_packet:
    CheckSum = 0;
    ByteBuffer = (UCHAR*)gdb_input;
 
    while (TRUE)
    {
        /* Try to get a byte from the port */
        Status = KdpReceiveByte(&Byte);
        if (Status != KdPacketReceived)
            return Status;
 
        if (Byte == '#')
        {
            *ByteBuffer = '\0';
            break;
        }
        CheckSum += (CHAR)Byte;
 
        /* See if we should escape */
        if (Byte == 0x7d)
        {
            Status = KdpReceiveByte(&Byte);
            if (Status != KdPacketReceived)
                return Status;
            CheckSum += (CHAR)Byte;
            Byte ^= 0x20;
        }
        *ByteBuffer++ = Byte;
    }
 
    /* Get Check sum (two bytes) */
    Status = KdpReceiveByte(&Byte);
    if (Status != KdPacketReceived)
        goto end;
    ReceivedCheckSum = hex_value(Byte) << 4;
 
    Status = KdpReceiveByte(&Byte);
    if (Status != KdPacketReceived)
        goto end;
    ReceivedCheckSum += hex_value(Byte);
 
end:
    if (ReceivedCheckSum != CheckSum)
    {
        /* Do not acknowledge to GDB */
        KDDBGPRINT("Check sums don't match!");
        KdpSendByte('-');
        return KdPacketNeedsResend;
    }
 
    /* Ensure there is nothing left in the pipe */
    while (KdpPollByte(&Byte) == KdPacketReceived)
    {
        switch (Byte)
        {
            case '$':
                KDDBGPRINT("Received new packet just after %s.\n", gdb_input);
                goto get_packet;
            case 0x03:
                KdContext->KdpControlCPending = TRUE;
                break;
        }
    }
 
    /* Acknowledge */
    KdpSendByte('+');
 
    return KdPacketReceived;
}

Referenced by gdb_receive_and_interpret_packet().

◆ gdb_send_debug_io()

KDSTATUS gdb_send_debug_io	(	_In_ PSTRING	String,
		_In_ BOOLEAN	WithPrefix
	)

Definition at line 168 of file gdb_send.c.

{
    CHAR gdb_out[3];
    CHAR* ptr = String->Buffer;
    USHORT Length = String->Length;
 
    gdb_out[2] = '\0';
 
    start_gdb_packet();
 
    if (WithPrefix)
    {
        send_gdb_partial_packet("O");
    }
 
    /* Send the data */
    while (Length--)
    {
        gdb_out[0] = hex_chars[(*ptr >> 4) & 0xf];
        gdb_out[1] = hex_chars[*ptr++ & 0xf];
        send_gdb_partial_packet(gdb_out);
    }
 
    return finish_gdb_packet();
}

Referenced by handle_gdb_query(), and send_kd_debug_io().

◆ gdb_send_exception()

KDSTATUS gdb_send_exception ( void )

Definition at line 197 of file gdb_send.c.

{
    char gdb_out[1024];
    char* ptr = gdb_out;
    PETHREAD Thread = (PETHREAD)(ULONG_PTR)CurrentStateChange.Thread;
 
    /* Report to GDB */
    *ptr++ = 'T';
 
    if (CurrentStateChange.NewState == DbgKdExceptionStateChange)
    {
        EXCEPTION_RECORD64* ExceptionRecord = &CurrentStateChange.u.Exception.ExceptionRecord;
        ptr = exception_code_to_gdb(ExceptionRecord->ExceptionCode, ptr);
    }
    else
        ptr += sprintf(ptr, "05");
 
    if (CurrentStateChange.NewState == DbgKdLoadSymbolsStateChange)
        ptr += sprintf(ptr, "library:");
 
#if MONOPROCESS
    ptr += sprintf(ptr, "thread:%" PRIxPTR ";",
        handle_to_gdb_tid(PsGetThreadId(Thread)));
#else
    ptr += sprintf(ptr, "thread:p%" PRIxPTR ".%" PRIxPTR ";",
        handle_to_gdb_pid(PsGetThreadProcessId(Thread)),
        handle_to_gdb_tid(PsGetThreadId(Thread)));
#endif
 
    ptr += sprintf(ptr, "core:%x;", CurrentStateChange.Processor);
    return send_gdb_packet(gdb_out);
}

Referenced by gdb_receive_and_interpret_packet(), and send_kd_state_change().

◆ gdb_send_register()

KDSTATUS gdb_send_register ( void )

Definition at line 219 of file amd64_sup.c.

{
    enum reg_name reg_name;
    void *ptr;
 
    /* 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);
    }
    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);
    }
 
    if (!ptr)
    {
        unsigned char size = reg_size[reg_name];
        start_gdb_packet();
        while (size--)
            send_gdb_partial_packet("xx");
        return finish_gdb_packet();
    }
    else
    {
        KDDBGPRINT("KDDBG : Sending registers as memory.\n");
        return send_gdb_memory(ptr, reg_size[reg_name]);
    }
}

Referenced by gdb_receive_and_interpret_packet().

◆ gdb_send_registers()

KDSTATUS gdb_send_registers ( void )

Definition at line 144 of file amd64_sup.c.

{
    CHAR RegisterStr[17];
    UCHAR* RegisterPtr;
    unsigned short i;
    unsigned short size;
 
    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 < 24; i++)
        {
            RegisterPtr = ctx_to_reg(&CurrentContext, i);
            size = reg_size[i] * 2;
            RegisterStr[size] = 0;
            while (size)
            {
                size--;
                RegisterStr[size] = hex_chars[RegisterPtr[size/2] & 0xF];
                size--;
                RegisterStr[size] = hex_chars[RegisterPtr[size/2] >> 4];
            }
 
            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 < 24; i++)
        {
            RegisterPtr = thread_to_reg(DbgThread, i);
            size = reg_size[i] * 2;
            RegisterStr[size] = 0;
 
            while (size)
            {
                if (RegisterPtr)
                {
                    size--;
                    RegisterStr[size] = hex_chars[RegisterPtr[size/2] & 0xF];
                    size--;
                    RegisterStr[size] = hex_chars[RegisterPtr[size/2] >> 4];
                }
                else
                {
                    size--;
                    RegisterStr[size] = 'x';
                    size--;
                    RegisterStr[size] = 'x';
                }
            }
 
            send_gdb_partial_packet(RegisterStr);
        }
    }
 
    return finish_gdb_packet();
}

Referenced by gdb_receive_and_interpret_packet(), and send_kd_state_manipulate().

◆ gdb_tid_to_handle()

FORCEINLINE HANDLE gdb_tid_to_handle ( UINT_PTR Tid )

Definition at line 35 of file kdgdb.h.

{
    return (HANDLE)(Tid - 1);
}

Referenced by find_thread(), gdb_send_register(), gdb_send_registers(), handle_gdb_read_mem(), and handle_gdb_write_mem().

◆ handle_to_gdb_tid()

FORCEINLINE UINT_PTR handle_to_gdb_tid ( HANDLE Handle )

Definition at line 41 of file kdgdb.h.

{
    return (UINT_PTR)Handle + 1;
}

Referenced by FirstSendHandler(), gdb_send_exception(), handle_gdb_query(), and send_kd_state_change().

◆ hex_value()

char hex_value ( char ch )

Definition at line 15 of file gdb_receive.c.

{
    if ((ch >= '0') && (ch <= '9'))
        return (ch - '0');
 
    if ((ch >= 'a') && (ch <= 'f'))
        return (ch - 'a' + 10);
 
    if ((ch >= 'A') && (ch <= 'F'))
        return (ch - 'A' + 10);
 
    return -1;
}

Referenced by gdb_receive_packet(), gdb_send_register(), hex_to_address(), and hex_to_tid().

◆ InitManipulateFromStateChange()

FORCEINLINE VOID InitManipulateFromStateChange	(	_In_ ULONG	ApiNumber,
		_In_ const DBGKD_ANY_WAIT_STATE_CHANGE *	StateChange,
		_Out_ DBGKD_MANIPULATE_STATE64 *	Manipulate
	)

Definition at line 49 of file kdgdb.h.

{
    Manipulate->ApiNumber = ApiNumber;
    Manipulate->Processor = StateChange->Processor;
    Manipulate->ProcessorLevel = StateChange->ProcessorLevel;
}

◆ KdpPollBreakIn()

KDSTATUS NTAPI KdpPollBreakIn ( VOID )

Definition at line 343 of file kdcom.c.

{
    KDP_STATUS KdStatus;
    UCHAR Byte;
 
    KdStatus = KdpPollByte(&Byte);
    if ((KdStatus == KDP_PACKET_RECEIVED) && (Byte == BREAKIN_PACKET_BYTE))
    {
        return KDP_PACKET_RECEIVED;
    }
    return KDP_PACKET_TIMEOUT;
}

Referenced by KdReceivePacket().

◆ KdpPollByte()

KDSTATUS NTAPI KdpPollByte ( OUT PUCHAR OutByte )

Definition at line 299 of file kdcom.c.

{
    USHORT Status;
 
    /* Poll the byte */
    Status = CpGetByte(&KdComPort, OutByte, FALSE, FALSE);
    switch (Status)
    {
        case CP_GET_SUCCESS:
            return KDP_PACKET_RECEIVED;
 
        case CP_GET_NODATA:
            return KDP_PACKET_TIMEOUT;
 
        case CP_GET_ERROR:
        default:
            return KDP_PACKET_RESEND;
    }
}

Referenced by gdb_receive_packet(), and KdpPollBreakIn().

◆ KdpReceiveByte()

KDSTATUS NTAPI KdpReceiveByte ( _Out_ PUCHAR OutByte )

Definition at line 306 of file kdcom.c.

{
    USHORT CpStatus;
 
    do
    {
        CpStatus = CpGetByte(&KdComPort, OutByte, TRUE, FALSE);
    } while (CpStatus == CP_GET_NODATA);
 
    /* Get the byte */
    if (CpStatus == CP_GET_SUCCESS)
    {
        return KdPacketReceived;
    }
 
    return KdPacketTimedOut;
}

◆ KdpSendByte()

VOID NTAPI KdpSendByte ( _In_ UCHAR Byte )

Definition at line 283 of file kdcom.c.

{
    /* Send the byte */
    CpPutByte(&KdComPort, Byte);
}

◆ send_gdb_memory()

KDSTATUS send_gdb_memory	(	_In_ const VOID *	Buffer,
		size_t	Length
	)

◆ send_gdb_ntstatus()

void send_gdb_ntstatus ( _In_ NTSTATUS Status )

Definition at line 231 of file gdb_send.c.

{
    /* Just build a EXX packet and send it */
    char gdb_out[4];
    gdb_out[0] = 'E';
    exception_code_to_gdb(Status, &gdb_out[1]);
    gdb_out[3] = '\0';
    send_gdb_packet(gdb_out);
}

Referenced by ReadMemorySendHandler(), WriteBreakPointSendHandler(), and WriteMemorySendHandler().

◆ send_gdb_packet()

KDSTATUS send_gdb_packet ( _In_ const CHAR * Buffer )

Definition at line 100 of file gdb_send.c.

{
    start_gdb_packet();
    send_gdb_partial_packet(Buffer);
    return finish_gdb_packet();
}

Referenced by gdb_receive_and_interpret_packet(), gdb_send_exception(), gdb_send_register(), handle_gdb_c(), handle_gdb_insert_breakpoint(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), handle_gdb_set_thread(), handle_gdb_thread_alive(), handle_gdb_v(), handle_gdb_write_mem(), RestoreBreakPointSendHandler(), send_gdb_ntstatus(), WriteBreakPointSendHandler(), and WriteMemorySendHandler().

◆ send_gdb_partial_binary()

ULONG send_gdb_partial_binary	(	_In_ const VOID *	Buffer,
		_In_ size_t	Length
	)

Definition at line 108 of file gdb_send.c.

{
    const UCHAR* ptr = Buffer;
    ULONG Sent = Length;
 
    while(Length--)
    {
        UCHAR Byte = *ptr++;
 
        switch (Byte)
        {
            case 0x7d:
            case 0x23:
            case 0x24:
            case 0x2a:
                currentChecksum += 0x7d;
                KdpSendByte(0x7d);
                Byte ^= 0x20;
                Sent++;
            /* Fall-through */
            default:
                currentChecksum += Byte;
                KdpSendByte(Byte);
        }
    }
 
    return Sent;
}

Referenced by handle_gdb_query().

◆ send_gdb_partial_memory()

void send_gdb_partial_memory	(	_In_ const VOID *	Buffer,
		_In_ size_t	Length
	)

Definition at line 140 of file gdb_send.c.

{
    const UCHAR* ptr = Buffer;
    CHAR gdb_out[3];
 
    gdb_out[2] = '\0';
 
    while(Length--)
    {
        gdb_out[0] = hex_chars[(*ptr >> 4) & 0xf];
        gdb_out[1] = hex_chars[*ptr++ & 0xf];
        send_gdb_partial_packet(gdb_out);
    }
}

Referenced by send_gdb_memory().

◆ send_gdb_partial_packet()

void send_gdb_partial_packet ( _In_ const CHAR * Buffer )

Definition at line 60 of file gdb_send.c.

{
    const CHAR* ptr = Buffer;
 
    /* Update check sum and send */
    while (*ptr)
    {
        currentChecksum += *ptr;
        KdpSendByte(*ptr++);
    }
}

Referenced by gdb_send_debug_io(), gdb_send_register(), gdb_send_registers(), handle_gdb_query(), send_gdb_packet(), and send_gdb_partial_memory().

◆ SetContextManipulateHandler()

KDSTATUS SetContextManipulateHandler	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 107 of file kdpacket.c.

{
    State->ApiNumber = DbgKdSetContextApi;
    State->Processor = CurrentStateChange.Processor;
    State->ReturnStatus = STATUS_SUCCESS;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    MessageData->Length = sizeof(CurrentContext);
 
    if (MessageData->MaximumLength < sizeof(CurrentContext))
    {
        KDDBGPRINT("Wrong message length %u.\n", MessageData->MaximumLength);
        while (1);
    }
 
    RtlCopyMemory(MessageData->Buffer, &CurrentContext, sizeof(CurrentContext));
 
    /* Update the send <-> receive loop handlers */
    KdpSendPacketHandler = SetContextSendHandler;
    KdpManipulateStateHandler = NULL;
 
    return KdPacketReceived;
}

Referenced by handle_gdb_c(), and handle_gdb_s().

◆ start_gdb_packet()

void start_gdb_packet ( void )

Definition at line 52 of file gdb_send.c.

{
    /* Start the start byte and begin checksum calculation */
    KdpSendByte('$');
    currentChecksum = 0;
}

Referenced by gdb_send_debug_io(), gdb_send_register(), gdb_send_registers(), handle_gdb_query(), send_gdb_memory(), and send_gdb_packet().

Variable Documentation

◆ CurrentContext

CONTEXT CurrentContext

extern

Definition at line 29 of file kdpacket.c.

Referenced by gdb_send_register(), gdb_send_registers(), GetContextSendHandler(), handle_gdb_c(), handle_gdb_s(), and SetContextManipulateHandler().

◆ CurrentStateChange

DBGKD_ANY_WAIT_STATE_CHANGE CurrentStateChange

extern

Definition at line 28 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), find_thread(), FirstSendHandler(), gdb_send_exception(), gdb_send_register(), gdb_send_registers(), GetContextManipulateHandler(), GetVersionManipulateStateHandler(), handle_gdb_c(), handle_gdb_insert_breakpoint(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), handle_gdb_write_mem(), send_kd_state_change(), and SetContextManipulateHandler().

◆ gdb_dbg_pid

UINT_PTR gdb_dbg_pid

extern

Definition at line 20 of file gdb_input.c.

Referenced by FirstSendHandler(), gdb_send_register(), gdb_send_registers(), handle_gdb_read_mem(), handle_gdb_set_thread(), handle_gdb_write_mem(), ReadMemorySendHandler(), send_kd_state_change(), and WriteMemorySendHandler().

◆ gdb_dbg_tid

UINT_PTR gdb_dbg_tid

extern

Definition at line 21 of file gdb_input.c.

Referenced by FirstSendHandler(), gdb_send_register(), gdb_send_registers(), handle_gdb_read_mem(), handle_gdb_set_thread(), handle_gdb_write_mem(), ReadMemorySendHandler(), send_kd_state_change(), and WriteMemorySendHandler().

◆ gdb_input

CHAR gdb_input[]

extern

Definition at line 11 of file gdb_receive.c.

Referenced by gdb_receive_and_interpret_packet(), gdb_receive_packet(), gdb_send_register(), handle_gdb_insert_breakpoint(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), handle_gdb_set_thread(), handle_gdb_thread_alive(), handle_gdb_v(), and handle_gdb_write_mem().

◆ hex_chars

const char hex_chars[]

extern

Definition at line 11 of file gdb_send.c.

Referenced by exception_code_to_gdb(), finish_gdb_packet(), gdb_send_debug_io(), gdb_send_registers(), and send_gdb_partial_memory().

◆ KdDebuggerDataBlock

KDDEBUGGER_DATA64* KdDebuggerDataBlock

extern

Definition at line 21 of file kdpacket.c.

Referenced by KdInitSystem(), KdUpdateDataBlock(), and KeBugCheckWithTf().

◆ KdpManipulateStateHandler

KDP_MANIPULATESTATE_HANDLER KdpManipulateStateHandler

extern

Definition at line 26 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), FirstSendHandler(), GetContextManipulateHandler(), GetVersionManipulateStateHandler(), GetVersionSendHandler(), handle_gdb_c(), handle_gdb_s(), KdReceivePacket(), ReadMemorySendHandler(), RestoreBreakPointSendHandler(), send_kd_state_change(), SetContextManipulateHandler(), WriteBreakPointSendHandler(), and WriteMemorySendHandler().

◆ KdpSendPacketHandler

◆ KdVersion

DBGKD_GET_VERSION64 KdVersion

extern

Definition at line 20 of file kdpacket.c.

Referenced by GetVersionSendHandler().

◆ ModuleListHead

LIST_ENTRY* ModuleListHead

extern

Definition at line 23 of file kdpacket.c.

Referenced by GetModuleFileNameW(), GetVersionSendHandler(), handle_gdb_query(), LdrQueryProcessModuleInformationEx(), LoadBootDeviceDriver(), MmCallDllInitialize(), PeLdrAllocateDataTableEntry(), PeLdrCheckForLoadedDll(), PeLdrpBindImportName(), PeLdrpLoadAndScanReferencedDll(), PeLdrpScanImportAddressTable(), PeLdrScanImportDescriptorTable(), RtlPcToFileHeader(), and UserpGetClientFileName().

◆ ProcessListHead

LIST_ENTRY* ProcessListHead

extern

Definition at line 22 of file kdpacket.c.

Referenced by find_process(), find_thread(), GetVersionSendHandler(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_write_mem(), ReadMemorySendHandler(), and WriteMemorySendHandler().

◆ TheIdleProcess

PEPROCESS TheIdleProcess

extern

Definition at line 30 of file kdpacket.c.

Referenced by find_process(), find_thread(), FirstSendHandler(), and QSI_DEF().

◆ TheIdleThread

PETHREAD TheIdleThread

extern

Definition at line 31 of file kdpacket.c.

Referenced by find_thread(), and FirstSendHandler().

Variables
UINT_PTR	gdb_dbg_tid

UINT_PTR	gdb_dbg_pid

CHAR	gdb_input []

const char	hex_chars []

DBGKD_ANY_WAIT_STATE_CHANGE	CurrentStateChange

CONTEXT	CurrentContext

DBGKD_GET_VERSION64	KdVersion

KDDEBUGGER_DATA64 *	KdDebuggerDataBlock

LIST_ENTRY *	ProcessListHead

LIST_ENTRY *	ModuleListHead

KDP_SEND_HANDLER	KdpSendPacketHandler

KDP_MANIPULATESTATE_HANDLER	KdpManipulateStateHandler

PEPROCESS	TheIdleProcess

PETHREAD	TheIdleThread

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ gdb_pid_to_handle

◆ handle_to_gdb_pid

◆ KDDBGPRINT

◆ MONOPROCESS

◆ NOEXTAPI

Typedef Documentation

◆ KDP_MANIPULATESTATE_HANDLER

◆ KDP_SEND_HANDLER

Function Documentation

◆ ContinueManipulateStateHandler()

◆ find_process()

◆ find_thread()

◆ finish_gdb_packet()

◆ gdb_receive_and_interpret_packet()

◆ gdb_receive_packet()

◆ gdb_send_debug_io()

◆ gdb_send_exception()

◆ gdb_send_register()

◆ gdb_send_registers()

◆ gdb_tid_to_handle()

◆ handle_to_gdb_tid()

◆ hex_value()

◆ InitManipulateFromStateChange()

◆ KdpPollBreakIn()

◆ KdpPollByte()

◆ KdpReceiveByte()

◆ KdpSendByte()

◆ send_gdb_memory()

◆ send_gdb_ntstatus()

◆ send_gdb_packet()

◆ send_gdb_partial_binary()

◆ send_gdb_partial_memory()

◆ send_gdb_partial_packet()

◆ SetContextManipulateHandler()

◆ start_gdb_packet()

Variable Documentation

◆ CurrentContext

◆ CurrentStateChange

◆ gdb_dbg_pid

◆ gdb_dbg_tid

◆ gdb_input

◆ hex_chars

◆ KdDebuggerDataBlock

◆ KdpManipulateStateHandler

◆ KdpSendPacketHandler

◆ KdVersion

◆ ModuleListHead

◆ ProcessListHead

◆ TheIdleProcess

◆ TheIdleThread