#include "kdgdb.h"

Include dependency graph for kdpacket.c:

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)

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(), 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.\n");
 
     if (PacketType == PACKET_TYPE_KD_POLL_BREAKIN)
     {
         return KdpPollBreakIn();
     }
 
     if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
     {
         /* 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;
 
         /* Maybe we are in a send<->receive loop that GDB doesn't need to know about */
         if (KdpManipulateStateHandler != NULL)
         {
             KDDBGPRINT("KDGBD: We have a manipulate state handler.\n");
             return KdpManipulateStateHandler(State, MessageData, DataLength, KdContext);
         }
 
         /* Receive data from GDB  and interpret it */
         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 400 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_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

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

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

Functions

Variables

Function Documentation

◆ ContinueManipulateStateHandler()

◆ FirstSendHandler()

◆ GetContextManipulateHandler()

◆ GetContextSendHandler()

◆ GetVersionManipulateStateHandler()

◆ GetVersionSendHandler()

◆ KdReceivePacket()

◆ KdSendPacket()

◆ send_kd_debug_io()

◆ send_kd_state_change()

◆ send_kd_state_manipulate()

◆ SetContextManipulateHandler()

◆ SetContextSendHandler()

Variable Documentation

◆ CurrentContext

◆ CurrentStateChange

◆ InException

◆ KdDebuggerDataBlock

◆ KdpManipulateStateHandler

◆ KdpSendPacketHandler

◆ KdVersion

◆ ModuleListHead

◆ ProcessListHead

◆ TheIdleProcess

◆ TheIdleThread