Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-01 12:26:32 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/drivers/base/kdgdb/kdgdb.h

153 lines
4.9 KiB
C
Raw Normal View History

[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
/*
* COPYRIGHT: GPL, see COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: drivers/base/kddll/kddll.h
* PURPOSE: Base definitions for the kernel debugger.
*/
#ifndef _KDGDB_H_
#define _KDGDB_H_
#define NOEXTAPI
#include <ntifs.h>
#include <halfuncs.h>
#include <stdio.h>
#include <arc/arc.h>
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
#include <inttypes.h>
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
#include <windbgkd.h>
#include <kddll.h>
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
#include <pstypes.h>
[KDGDB] Remove debugging leftover
2021-04-28 12:52:05 +00:00
// #define KDDEBUG /* uncomment to enable debugging this dll */
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
[KDGDB] - Turn this thing into something useful - Pretend we are only one process to GDB (making it a kernel-only debugger...) until the GDB team sorts this out - This is a kernel debugger stub you know. You didn't seriously pretend that recursive functions would be fine, did you ? [NTOS:KD64] - Fix build Pix or it din't happen : https://jira.reactos.org/secure/attachment/36322/source_level_debugging_ros.png svn path=/trunk/; revision=72077
2016-08-01 22:16:58 +00:00
/* To undefine once https://sourceware.org/bugzilla/show_bug.cgi?id=17397 is resolved */
#define MONOPROCESS 1
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
#ifndef KDDEBUG
#define KDDBGPRINT(...)
#else
extern ULONG KdpDbgPrint(const char* Format, ...);
#define KDDBGPRINT KdpDbgPrint
#endif
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
/* GDB doesn't like pid - tid 0, so +1 them */
FORCEINLINE HANDLE gdb_tid_to_handle(UINT_PTR Tid)
{
return (HANDLE)(Tid - 1);
}
#define gdb_pid_to_handle gdb_tid_to_handle
[KDGDB] - Turn this thing into something useful - Pretend we are only one process to GDB (making it a kernel-only debugger...) until the GDB team sorts this out - This is a kernel debugger stub you know. You didn't seriously pretend that recursive functions would be fine, did you ? [NTOS:KD64] - Fix build Pix or it din't happen : https://jira.reactos.org/secure/attachment/36322/source_level_debugging_ros.png svn path=/trunk/; revision=72077
2016-08-01 22:16:58 +00:00
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
FORCEINLINE UINT_PTR handle_to_gdb_tid(HANDLE Handle)
{
return (UINT_PTR)Handle + 1;
}
#define handle_to_gdb_pid handle_to_gdb_tid
[KDGDB] - Always pass down the result of gdb_receive_packet up to KD, so that it knows when a breakin packet was received. (CTRL-C) now works! - Generalize the use of the Send <-> ManipulateState callbacks for a better code reading. - Get the exception context as soon as it is thrown (instead of playing with the PRCB) - Improve the way we attach to GDB: on the first KD call, we set KdContext->ControlCPending so that KD throws an exception. That way we can first initialize our KD stuff, and then quietly attach to GDB - Implement the 'p' (get one register) GDB request. GDB is now much more reliable. svn path=/trunk/; revision=64154
2014-09-14 20:45:30 +00:00
FORCEINLINE
VOID
InitManipulateFromStateChange(
_In_ ULONG ApiNumber,
_In_ const DBGKD_ANY_WAIT_STATE_CHANGE* StateChange,
_Out_ DBGKD_MANIPULATE_STATE64* Manipulate)
{
Manipulate->ApiNumber = ApiNumber;
Manipulate->Processor = StateChange->Processor;
Manipulate->ProcessorLevel = StateChange->ProcessorLevel;
}
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
/* Callbacks to simulate a KdReceive <-> KdSend loop without GDB being aware of it */
[KDGDB] Avoid looping for ever when something unexpected happens
2021-04-23 13:26:33 +00:00
typedef BOOLEAN (*KDP_SEND_HANDLER)(
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
_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
);
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
/* gdb_input.c */
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
extern UINT_PTR gdb_dbg_tid;
extern UINT_PTR gdb_dbg_pid;
[KDGDB] - Always pass down the result of gdb_receive_packet up to KD, so that it knows when a breakin packet was received. (CTRL-C) now works! - Generalize the use of the Send <-> ManipulateState callbacks for a better code reading. - Get the exception context as soon as it is thrown (instead of playing with the PRCB) - Improve the way we attach to GDB: on the first KD call, we set KdContext->ControlCPending so that KD throws an exception. That way we can first initialize our KD stuff, and then quietly attach to GDB - Implement the 'p' (get one register) GDB request. GDB is now much more reliable. svn path=/trunk/; revision=64154
2014-09-14 20:45:30 +00:00
extern KDSTATUS gdb_receive_and_interpret_packet(_Out_ DBGKD_MANIPULATE_STATE64* State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext);
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
/* gdb_receive.c */
extern CHAR gdb_input[];
KDSTATUS NTAPI gdb_receive_packet(_Inout_ PKD_CONTEXT KdContext);
char hex_value(char ch);
/* gdb_send.c */
[KDGDB] - Better report kernel stack (real back traces for all threads!) - Support reporting loaded libraries (== drivers, hal, etc.). You can even debug KDGDB inside KDGDB :-) - A few improvements here and there CORE-8531 svn path=/trunk/; revision=72533
2016-09-01 22:58:15 +00:00
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);
[KDGDB] - Improve the 'm' (read memory) gdb request svn path=/trunk/; revision=64145
2014-09-14 14:27:58 +00:00
void send_gdb_ntstatus(_In_ NTSTATUS Status);
[KDGDB] - Fix an embarassing works-for-me but uncommited cast. - Add support for reading registers and memory from foreign threads. Highly experimental and nearly untested, use at your own risk. svn path=/trunk/; revision=64156
2014-09-14 22:50:10 +00:00
extern const char hex_chars[];
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
/* kdcom.c */
KDSTATUS NTAPI KdpPollBreakIn(VOID);
VOID NTAPI KdpSendByte(_In_ UCHAR Byte);
KDSTATUS NTAPI KdpReceiveByte(_Out_ PUCHAR OutByte);
[KDGDB] Various fixes and improvements
2020-03-20 10:32:19 +00:00
KDSTATUS NTAPI KdpPollByte(OUT PUCHAR OutByte);
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
/* kdpacket.c */
extern DBGKD_ANY_WAIT_STATE_CHANGE CurrentStateChange;
[KDGDB] - Always pass down the result of gdb_receive_packet up to KD, so that it knows when a breakin packet was received. (CTRL-C) now works! - Generalize the use of the Send <-> ManipulateState callbacks for a better code reading. - Get the exception context as soon as it is thrown (instead of playing with the PRCB) - Improve the way we attach to GDB: on the first KD call, we set KdContext->ControlCPending so that KD throws an exception. That way we can first initialize our KD stuff, and then quietly attach to GDB - Implement the 'p' (get one register) GDB request. GDB is now much more reliable. svn path=/trunk/; revision=64154
2014-09-14 20:45:30 +00:00
extern CONTEXT CurrentContext;
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
extern DBGKD_GET_VERSION64 KdVersion;
extern KDDEBUGGER_DATA64* KdDebuggerDataBlock;
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
extern LIST_ENTRY* ProcessListHead;
[KDGDB] - Better report kernel stack (real back traces for all threads!) - Support reporting loaded libraries (== drivers, hal, etc.). You can even debug KDGDB inside KDGDB :-) - A few improvements here and there CORE-8531 svn path=/trunk/; revision=72533
2016-09-01 22:58:15 +00:00
extern LIST_ENTRY* ModuleListHead;
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
extern KDP_SEND_HANDLER KdpSendPacketHandler;
extern KDP_MANIPULATESTATE_HANDLER KdpManipulateStateHandler;
[DRIVERS] Spelling fixes by Josh Soref. CORE-12286 svn path=/trunk/; revision=73226
2016-11-13 15:31:39 +00:00
/* Common ManipulateState handlers */
[KDGDB] - Always pass down the result of gdb_receive_packet up to KD, so that it knows when a breakin packet was received. (CTRL-C) now works! - Generalize the use of the Send <-> ManipulateState callbacks for a better code reading. - Get the exception context as soon as it is thrown (instead of playing with the PRCB) - Improve the way we attach to GDB: on the first KD call, we set KdContext->ControlCPending so that KD throws an exception. That way we can first initialize our KD stuff, and then quietly attach to GDB - Implement the 'p' (get one register) GDB request. GDB is now much more reliable. svn path=/trunk/; revision=64154
2014-09-14 20:45:30 +00:00
extern KDSTATUS ContinueManipulateStateHandler(_Out_ DBGKD_MANIPULATE_STATE64* State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext);
extern KDSTATUS SetContextManipulateHandler(_Out_ DBGKD_MANIPULATE_STATE64* State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext);
[KDGDB] - As pid and tid 0 have a special meaning in GDB, use off-by-one thread and process ID when communicating with it - Properly read registers and memory from foreign thread and processes. (This time it was tested and proved to work reliably. __writecr3 ftw!) - Loop the list of processes and threads when trying to find them from ID, as PsLookupProessByThreadId and friends can't be used since we can be at any IRQL. - Add a few more debug prints to help diagnosing problems. CORE-8531 svn path=/trunk/; revision=64166
2014-09-15 22:05:21 +00:00
extern PEPROCESS TheIdleProcess;
extern PETHREAD TheIdleThread;
/* utils.c */
extern PEPROCESS find_process( _In_ UINT_PTR Pid);
extern PETHREAD find_thread(_In_ UINT_PTR Pid, _In_ UINT_PTR Tid);
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
/* arch_sup.c */
[KDGDB] - Better report kernel stack (real back traces for all threads!) - Support reporting loaded libraries (== drivers, hal, etc.). You can even debug KDGDB inside KDGDB :-) - A few improvements here and there CORE-8531 svn path=/trunk/; revision=72533
2016-09-01 22:58:15 +00:00
extern KDSTATUS gdb_send_register(void);
extern KDSTATUS gdb_send_registers(void);
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
/* Architecture specific defines. See ntoskrnl/include/internal/arch/ke.h */
#ifdef _M_IX86
[KDGDB] - Implement setting and removing breakpoints - Implement single-stepping - Only get past the breakpoint instruction when it comes from RtlpBreakWithStatus - Implement writing to memory - Always send the thread raising the exception to GDB to avoid confusing it - Let GDB find the program counter alone by querying the registers (support was already there before.) - Properly escape special characters on input Ladies and gentlemen : the almost-fully functional GDB stub. (still no real multi-process support :-( ) To enable , in CMakeCache.txt : - Set GDB:BOOL=TRUE - Set _WINKD_:BOOL=TRUE - Set KDBG:BOOL=FALSE To do : give GDB the list of loaded drivers. Loading ntoskrnl.exe symbols at 0x80801000 already does a good enough job. Default output is on COM1. Can be configure to any othe COM port with usual kernel options. Hope you'll like it as much as I do ;-) svn path=/trunk/; revision=72435
2016-08-22 22:24:30 +00:00
/* Handling passing over the breakpoint instruction */
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
# define KdpGetContextPc(Context) \
((Context)->Eip)
# define KdpSetContextPc(Context, ProgramCounter) \
((Context)->Eip = (ProgramCounter))
[KDGDB] - Add a ugly and grotesque hack to give "o" back to RtlAssert so that we actually break on ASSERTs - Check for the breakpoint instruction for deciding when to move forward the ProgramCounter. This is OK since KD removes all breakpoints set when hitting a soft BP svn path=/trunk/; revision=72467
2016-08-26 21:07:27 +00:00
# define KD_BREAKPOINT_TYPE UCHAR
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
# define KD_BREAKPOINT_SIZE sizeof(UCHAR)
[KDGDB] - Add a ugly and grotesque hack to give "o" back to RtlAssert so that we actually break on ASSERTs - Check for the breakpoint instruction for deciding when to move forward the ProgramCounter. This is OK since KD removes all breakpoints set when hitting a soft BP svn path=/trunk/; revision=72467
2016-08-26 21:07:27 +00:00
# define KD_BREAKPOINT_VALUE 0xCC
[KDGDB] - Implement setting and removing breakpoints - Implement single-stepping - Only get past the breakpoint instruction when it comes from RtlpBreakWithStatus - Implement writing to memory - Always send the thread raising the exception to GDB to avoid confusing it - Let GDB find the program counter alone by querying the registers (support was already there before.) - Properly escape special characters on input Ladies and gentlemen : the almost-fully functional GDB stub. (still no real multi-process support :-( ) To enable , in CMakeCache.txt : - Set GDB:BOOL=TRUE - Set _WINKD_:BOOL=TRUE - Set KDBG:BOOL=FALSE To do : give GDB the list of loaded drivers. Loading ntoskrnl.exe symbols at 0x80801000 already does a good enough job. Default output is on COM1. Can be configure to any othe COM port with usual kernel options. Hope you'll like it as much as I do ;-) svn path=/trunk/; revision=72435
2016-08-22 22:24:30 +00:00
/* Single step mode */
[KDGDB] Adapt to amd64
2021-04-14 11:36:17 +00:00
# define KdpSetSingleStep(Context) \
((Context)->EFlags |= EFLAGS_TF)
#elif defined(_M_AMD64)
# define KdpGetContextPc(Context) \
((Context)->Rip)
# define KdpSetContextPc(Context, ProgramCounter) \
((Context)->Rip = (ProgramCounter))
# define KD_BREAKPOINT_TYPE UCHAR
# define KD_BREAKPOINT_SIZE sizeof(UCHAR)
# define KD_BREAKPOINT_VALUE 0xCC
/* Single step mode */
[KDGDB] - Implement setting and removing breakpoints - Implement single-stepping - Only get past the breakpoint instruction when it comes from RtlpBreakWithStatus - Implement writing to memory - Always send the thread raising the exception to GDB to avoid confusing it - Let GDB find the program counter alone by querying the registers (support was already there before.) - Properly escape special characters on input Ladies and gentlemen : the almost-fully functional GDB stub. (still no real multi-process support :-( ) To enable , in CMakeCache.txt : - Set GDB:BOOL=TRUE - Set _WINKD_:BOOL=TRUE - Set KDBG:BOOL=FALSE To do : give GDB the list of loaded drivers. Loading ntoskrnl.exe symbols at 0x80801000 already does a good enough job. Default output is on COM1. Can be configure to any othe COM port with usual kernel options. Hope you'll like it as much as I do ;-) svn path=/trunk/; revision=72435
2016-08-22 22:24:30 +00:00
# define KdpSetSingleStep(Context) \
((Context)->EFlags |= EFLAGS_TF)
[KDGDB] - Add a callback mechanism permitting to "simulate" KD send <-> receive loop without having to actually communicate to GDB - Use that to update the program counter when cont'ing a breakpoint Now cont'ing an assertion failure is possible, since we actually get beyond the int 3 instruction svn path=/trunk/; revision=64127
2014-09-12 20:23:08 +00:00
#else
# error "Please define relevant macros for your architecture"
#endif
[KDGDB] - introduce KDGDB, a KDCOM-like DLL, wrapping the KD protocol and the GDB remote protocol together. It is not fully functional, but for now it permits source-level debugging in some modules. More will be added as I feel the need and find the time to work a bit more on it. (That is, unless an angel comes and resume the work) To use it, set GDB and _WINKD_ to TRUE in your CMakeCache.txt. Using separate debug symbols is also a good idea. svn path=/trunk/; revision=64121
2014-09-11 20:55:42 +00:00
#endif /* _KDGDB_H_ */
Reference in a new issue Copy permalink