kdpacket.c File Reference

#include "kdgdb.h"

Include dependency graph for kdpacket.c:

Go to the source code of this file.

Functions
static VOID	FirstSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static VOID	GetContextSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static KDSTATUS	GetContextManipulateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static VOID	SetContextSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
KDSTATUS	SetContextManipulateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static void	send_kd_state_change (DBGKD_ANY_WAIT_STATE_CHANGE *StateChange)
static void	send_kd_debug_io (_In_ DBGKD_DEBUG_IO *DebugIO, _In_ PSTRING String)
static void	send_kd_state_manipulate (_In_ DBGKD_MANIPULATE_STATE64 *State, _In_ PSTRING MessageData)
KDSTATUS	ContinueManipulateStateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
static VOID	GetVersionSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)
static KDSTATUS	GetVersionManipulateStateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)
KDSTATUS NTAPI	KdReceivePacket (_In_ ULONG PacketType, _Out_ PSTRING MessageHeader, _Out_ PSTRING MessageData, _Out_ PULONG DataLength, _Inout_ PKD_CONTEXT KdContext)
VOID NTAPI	KdSendPacket (IN ULONG PacketType, IN PSTRING MessageHeader, IN PSTRING MessageData, IN OUT PKD_CONTEXT KdContext)

Variables
static BOOLEAN	InException = FALSE
DBGKD_GET_VERSION64	KdVersion
KDDEBUGGER_DATA64 *	KdDebuggerDataBlock
LIST_ENTRY *	ProcessListHead
LIST_ENTRY *	ModuleListHead
KDP_SEND_HANDLER	KdpSendPacketHandler = FirstSendHandler
KDP_MANIPULATESTATE_HANDLER	KdpManipulateStateHandler = NULL
DBGKD_ANY_WAIT_STATE_CHANGE	CurrentStateChange
CONTEXT	CurrentContext
PEPROCESS	TheIdleProcess
PETHREAD	TheIdleThread

Function Documentation

ContinueManipulateStateHandler()

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

Definition at line 212 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(), handle_gdb_C(), and handle_gdb_s().

FirstSendHandler()

static VOID FirstSendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 292 of file kdpacket.c.

{
    DBGKD_ANY_WAIT_STATE_CHANGE* StateChange = (DBGKD_ANY_WAIT_STATE_CHANGE*)MessageHeader->Buffer;
    PETHREAD Thread;

    if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
    {
        /* This is not the packet we are waiting for */
        send_kd_debug_io((DBGKD_DEBUG_IO*)MessageHeader->Buffer, MessageData);
        return;
    }

    if (PacketType != PACKET_TYPE_KD_STATE_CHANGE64)
    {
        KDDBGPRINT("First KD packet is not a state change!\n");
        /* FIXME: What should we send back to KD ? */
        while(1);
    }

    KDDBGPRINT("KDGDB: START!\n");

    Thread = (PETHREAD)(ULONG_PTR)StateChange->Thread;

    /* Set up the current state */
    CurrentStateChange = *StateChange;
    gdb_dbg_tid = handle_to_gdb_tid(PsGetThreadId(Thread));
#if MONOPROCESS
    gdb_dbg_pid = 0;
#else
    gdb_dbg_pid = handle_to_gdb_pid(PsGetThreadProcessId(Thread));
#endif
    /* This is the idle process. Save it! */
    TheIdleThread = Thread;
    TheIdleProcess = (PEPROCESS)Thread->Tcb.ApcState.Process;

    KDDBGPRINT("Pid Tid of the first message: %" PRIxPTR", %" PRIxPTR ".\n", gdb_dbg_pid, gdb_dbg_tid);

    /* The next receive call will be asking for the version data */
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = GetVersionManipulateStateHandler;
}

GetContextManipulateHandler()

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

static

Definition at line 62 of file kdpacket.c.

{
    State->ApiNumber = DbgKdGetContextApi;
    State->Processor = CurrentStateChange.Processor;
    State->ReturnStatus = STATUS_SUCCESS;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    MessageData->Length = 0;

    /* Update the send <-> receive loop handler */
    KdpSendPacketHandler = GetContextSendHandler;
    KdpManipulateStateHandler = NULL;

    return KdPacketReceived;
}

Referenced by GetVersionSendHandler(), and send_kd_state_change().

GetContextSendHandler()

static VOID GetContextSendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 37 of file kdpacket.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
    const CONTEXT* Context = (const CONTEXT*)MessageData->Buffer;

    if ((PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
            || (State->ApiNumber != DbgKdGetContextApi)
            || (MessageData->Length < sizeof(*Context)))
    {
        /* Should we bugcheck ? */
        KDDBGPRINT("ERROR: Received wrong packet from KD.\n");
        while (1);
    }

    /* Just copy it */
    RtlCopyMemory(&CurrentContext, Context, sizeof(*Context));
    KdpSendPacketHandler = NULL;
}

Referenced by GetContextManipulateHandler().

GetVersionManipulateStateHandler()

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

static

Definition at line 272 of file kdpacket.c.

{
    /* Ask for the version data */
    State->ApiNumber = DbgKdGetVersionApi;
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;

    /* The next send call will serve this query */
    KdpSendPacketHandler = GetVersionSendHandler;
    KdpManipulateStateHandler = NULL;

    return KdPacketReceived;
}

Referenced by FirstSendHandler().

GetVersionSendHandler()

static VOID GetVersionSendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 240 of file kdpacket.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
    LIST_ENTRY* DebuggerDataList;

    /* Confirm that all went well */
    if ((PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
            || (State->ApiNumber != DbgKdGetVersionApi)
            || !NT_SUCCESS(State->ReturnStatus))
    {
        /* FIXME: should detach from KD and go along without debugging */
        KDDBGPRINT("Wrong packet received after asking for data.\n");
        while(1);
    }

    /* Copy the relevant data */
    RtlCopyMemory(&KdVersion, &State->u.GetVersion64, sizeof(KdVersion));
    DebuggerDataList = (LIST_ENTRY*)(ULONG_PTR)KdVersion.DebuggerDataList;
    KdDebuggerDataBlock = CONTAINING_RECORD(DebuggerDataList->Flink, KDDEBUGGER_DATA64, Header.List);
    ProcessListHead = (LIST_ENTRY*)KdDebuggerDataBlock->PsActiveProcessHead.Pointer;
    ModuleListHead = (LIST_ENTRY*)KdDebuggerDataBlock->PsLoadedModuleList.Pointer;

    /* Now we can get the context for the current state */
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = GetContextManipulateHandler;
}

Referenced by GetVersionManipulateStateHandler().

KdReceivePacket()

KDSTATUS NTAPI KdReceivePacket	(	_In_ ULONG	PacketType,
		_Out_ PSTRING	MessageHeader,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	DataLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 356 of file kdpacket.c.

{
    KDDBGPRINT("KdReceivePacket --> ");

    if (PacketType == PACKET_TYPE_KD_POLL_BREAKIN)
    {
        static BOOLEAN firstTime = TRUE;
        KDDBGPRINT("Polling break in.\n");
        if (firstTime)
        {
            /* Force debug break on init */
            firstTime = FALSE;
            return KdPacketReceived;
        }

        return KdpPollBreakIn();
    }

    if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
    {
        KDDBGPRINT("Debug prompt.\n");
        /* HACK ! RtlAssert asks for (boipt), always say "o" --> break once. */
        MessageData->Length = 1;
        MessageData->Buffer[0] = 'o';
        return KdPacketReceived;
    }

    if (PacketType == PACKET_TYPE_KD_STATE_MANIPULATE)
    {
        DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;

        KDDBGPRINT("State manipulation: ");

        /* Maybe we are in a send<->receive loop that GDB doesn't need to know about */
        if (KdpManipulateStateHandler != NULL)
        {
            KDDBGPRINT("We have a manipulate state handler.\n");
            return KdpManipulateStateHandler(State, MessageData, DataLength, KdContext);
        }

        /* Receive data from GDB  and interpret it */
        KDDBGPRINT("Receiving data from GDB.\n");
        return gdb_receive_and_interpret_packet(State, MessageData, DataLength, KdContext);
    }

    /* What should we do ? */
    while (1);
    return KdPacketNeedsResend;
}

KdSendPacket()

VOID NTAPI KdSendPacket	(	IN ULONG	PacketType,
		IN PSTRING	MessageHeader,
		IN PSTRING	MessageData,
		IN OUT PKD_CONTEXT	KdContext
	)

Definition at line 413 of file kdpacket.c.

{
    /* Override if we have some debug print from KD. */
    if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
    {
        send_kd_debug_io((DBGKD_DEBUG_IO*)MessageHeader->Buffer, MessageData);
        return;
    }

    /* Maybe we are in a send <-> receive loop that GDB doesn't need to know about */
    if (KdpSendPacketHandler)
    {
        KdpSendPacketHandler(PacketType, MessageHeader, MessageData);
        return;
    }

    switch (PacketType)
    {
    case PACKET_TYPE_KD_STATE_CHANGE64:
        send_kd_state_change((DBGKD_ANY_WAIT_STATE_CHANGE*)MessageHeader->Buffer);
        return;
    case PACKET_TYPE_KD_DEBUG_IO:
        send_kd_debug_io((DBGKD_DEBUG_IO*)MessageHeader->Buffer, MessageData);
        break;
    case PACKET_TYPE_KD_STATE_MANIPULATE:
        send_kd_state_manipulate((DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer, MessageData);
        break;
    default:
        KDDBGPRINT("Unknown packet type %u.\n", PacketType);
        while (1);
    }
}

send_kd_debug_io()

static void send_kd_debug_io ( _In_ DBGKD_DEBUG_IO *  DebugIO, _In_ PSTRING  String  )

static

Definition at line 172 of file kdpacket.c.

{
    if (InException)
        return;

    switch (DebugIO->ApiNumber)
    {
    case DbgKdPrintStringApi:
    case DbgKdGetStringApi:
        gdb_send_debug_io(String, TRUE);
        break;
    default:
        KDDBGPRINT("Unknown ApiNumber %u.\n", DebugIO->ApiNumber);
        while (1);
    }
}

Referenced by FirstSendHandler(), and KdSendPacket().

send_kd_state_change()

static void send_kd_state_change ( DBGKD_ANY_WAIT_STATE_CHANGE *  StateChange )

static

Definition at line 136 of file kdpacket.c.

{
    InException = TRUE;

    switch (StateChange->NewState)
    {
    case DbgKdLoadSymbolsStateChange:
    case DbgKdExceptionStateChange:
    {
        PETHREAD Thread = (PETHREAD)(ULONG_PTR)StateChange->Thread;
        /* Save current state for later GDB queries */
        CurrentStateChange = *StateChange;
        KDDBGPRINT("Exception 0x%08x in thread p%p.%p.\n",
            StateChange->u.Exception.ExceptionRecord.ExceptionCode,
            PsGetThreadProcessId(Thread),
            PsGetThreadId(Thread));
        /* Set the current debugged process/thread accordingly */
        gdb_dbg_tid = handle_to_gdb_tid(PsGetThreadId(Thread));
#if MONOPROCESS
        gdb_dbg_pid = 0;
#else
        gdb_dbg_pid = handle_to_gdb_pid(PsGetThreadProcessId(Thread));
#endif
        gdb_send_exception();
        /* Next receive call will ask for the context */
        KdpManipulateStateHandler = GetContextManipulateHandler;
        break;
    }
    default:
        KDDBGPRINT("Unknown StateChange %u.\n", StateChange->NewState);
        while (1);
    }
}

Referenced by KdSendPacket().

send_kd_state_manipulate()

static void send_kd_state_manipulate ( _In_ DBGKD_MANIPULATE_STATE64 *  State, _In_ PSTRING  MessageData  )

static

Definition at line 193 of file kdpacket.c.

{
    switch (State->ApiNumber)
    {
#if 0
    case DbgKdGetContextApi:
        /* This is an answer to a 'g' GDB request */
        gdb_send_registers((CONTEXT*)MessageData->Buffer);
        return;
#endif
    default:
        KDDBGPRINT("Unknown ApiNumber %u.\n", State->ApiNumber);
        while (1);
    }
}

Referenced by KdSendPacket().

SetContextManipulateHandler()

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

Definition at line 106 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().

SetContextSendHandler()

static VOID SetContextSendHandler ( _In_ ULONG  PacketType, _In_ PSTRING  MessageHeader, _In_ PSTRING  MessageData  )

static

Definition at line 84 of file kdpacket.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;

    /* We just confirm that all went well */
    if ((PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
            || (State->ApiNumber != DbgKdSetContextApi)
            || (State->ReturnStatus != STATUS_SUCCESS))
    {
        /* Should we bugcheck ? */
        KDDBGPRINT("BAD BAD BAD not manipulating state for sending context.\n");
        while (1);
    }

    KdpSendPacketHandler = NULL;
}

Referenced by SetContextManipulateHandler().

Variable Documentation

CurrentContext

CONTEXT CurrentContext

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

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_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().

InException

BOOLEAN InException = FALSE

static

Definition at line 17 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), send_kd_debug_io(), and send_kd_state_change().

KdDebuggerDataBlock

KDDEBUGGER_DATA64* KdDebuggerDataBlock

Definition at line 21 of file kdpacket.c.

Referenced by GetVersionSendHandler().

KdpManipulateStateHandler

KDP_MANIPULATESTATE_HANDLER KdpManipulateStateHandler = NULL

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

KDP_SEND_HANDLER KdpSendPacketHandler = FirstSendHandler

Definition at line 25 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), FirstSendHandler(), GetContextManipulateHandler(), GetContextSendHandler(), GetVersionManipulateStateHandler(), GetVersionSendHandler(), handle_gdb_insert_breakpoint(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), handle_gdb_write_mem(), KdSendPacket(), ReadMemorySendHandler(), RestoreBreakPointSendHandler(), SetContextManipulateHandler(), SetContextSendHandler(), WriteBreakPointSendHandler(), and WriteMemorySendHandler().

KdVersion

DBGKD_GET_VERSION64 KdVersion

Definition at line 20 of file kdpacket.c.

Referenced by GetVersionSendHandler().

ModuleListHead

LIST_ENTRY* ModuleListHead

Definition at line 23 of file kdpacket.c.

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

ProcessListHead

LIST_ENTRY* ProcessListHead

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

Definition at line 30 of file kdpacket.c.

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

TheIdleThread

PETHREAD TheIdleThread

Definition at line 31 of file kdpacket.c.

Referenced by find_thread(), and FirstSendHandler().