modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Windows/Inc/dbgeng.h

15771 lines
509 KiB
C
Raw Normal View History

RDK 1.1
2008-03-05 09:52:00 -05:00
//----------------------------------------------------------------------------
//
// Debugger engine interfaces.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//----------------------------------------------------------------------------
#ifndef __DBGENG_H__
#define __DBGENG_H__
#include <stdarg.h>
#include <objbase.h>
#ifndef _WDBGEXTS_
typedef struct _WINDBG_EXTENSION_APIS32* PWINDBG_EXTENSION_APIS32;
typedef struct _WINDBG_EXTENSION_APIS64* PWINDBG_EXTENSION_APIS64;
#endif
#ifndef _CRASHLIB_
typedef struct _MEMORY_BASIC_INFORMATION64* PMEMORY_BASIC_INFORMATION64;
#endif
#ifndef __in
// Should include SpecStrings.h to get proper definitions.
#define __in
#define __in_opt
#define __in_bcount(x)
#define __in_bcount_opt(x)
#define __in_ecount(x)
#define __in_ecount_opt(x)
#define __out
#define __out_opt
#define __out_bcount(x)
#define __out_bcount_opt(x)
#define __out_ecount(x)
#define __out_ecount_opt(x)
#endif
#ifdef __cplusplus
extern "C" {
#endif
//----------------------------------------------------------------------------
//
// GUIDs and interface forward declarations.
//
//----------------------------------------------------------------------------
/* f2df5f53-071f-47bd-9de6-5734c3fed689 */
DEFINE_GUID(IID_IDebugAdvanced, 0xf2df5f53, 0x071f, 0x47bd,
0x9d, 0xe6, 0x57, 0x34, 0xc3, 0xfe, 0xd6, 0x89);
/* 716d14c9-119b-4ba5-af1f-0890e672416a */
DEFINE_GUID(IID_IDebugAdvanced2, 0x716d14c9, 0x119b, 0x4ba5,
0xaf, 0x1f, 0x08, 0x90, 0xe6, 0x72, 0x41, 0x6a);
/* cba4abb4-84c4-444d-87ca-a04e13286739 */
DEFINE_GUID(IID_IDebugAdvanced3, 0xcba4abb4, 0x84c4, 0x444d,
0x87, 0xca, 0xa0, 0x4e, 0x13, 0x28, 0x67, 0x39);
/* 5bd9d474-5975-423a-b88b-65a8e7110e65 */
DEFINE_GUID(IID_IDebugBreakpoint, 0x5bd9d474, 0x5975, 0x423a,
0xb8, 0x8b, 0x65, 0xa8, 0xe7, 0x11, 0x0e, 0x65);
/* 1b278d20-79f2-426e-a3f9-c1ddf375d48e */
DEFINE_GUID(IID_IDebugBreakpoint2, 0x1b278d20, 0x79f2, 0x426e,
0xa3, 0xf9, 0xc1, 0xdd, 0xf3, 0x75, 0xd4, 0x8e);
/* 27fe5639-8407-4f47-8364-ee118fb08ac8 */
DEFINE_GUID(IID_IDebugClient, 0x27fe5639, 0x8407, 0x4f47,
0x83, 0x64, 0xee, 0x11, 0x8f, 0xb0, 0x8a, 0xc8);
/* edbed635-372e-4dab-bbfe-ed0d2f63be81 */
DEFINE_GUID(IID_IDebugClient2, 0xedbed635, 0x372e, 0x4dab,
0xbb, 0xfe, 0xed, 0x0d, 0x2f, 0x63, 0xbe, 0x81);
/* dd492d7f-71b8-4ad6-a8dc-1c887479ff91 */
DEFINE_GUID(IID_IDebugClient3, 0xdd492d7f, 0x71b8, 0x4ad6,
0xa8, 0xdc, 0x1c, 0x88, 0x74, 0x79, 0xff, 0x91);
/* ca83c3de-5089-4cf8-93c8-d892387f2a5e */
DEFINE_GUID(IID_IDebugClient4, 0xca83c3de, 0x5089, 0x4cf8,
0x93, 0xc8, 0xd8, 0x92, 0x38, 0x7f, 0x2a, 0x5e);
/* e3acb9d7-7ec2-4f0c-a0da-e81e0cbbe628 */
DEFINE_GUID(IID_IDebugClient5, 0xe3acb9d7, 0x7ec2, 0x4f0c,
0xa0, 0xda, 0xe8, 0x1e, 0x0c, 0xbb, 0xe6, 0x28);
/* 5182e668-105e-416e-ad92-24ef800424ba */
DEFINE_GUID(IID_IDebugControl, 0x5182e668, 0x105e, 0x416e,
0xad, 0x92, 0x24, 0xef, 0x80, 0x04, 0x24, 0xba);
/* d4366723-44df-4bed-8c7e-4c05424f4588 */
DEFINE_GUID(IID_IDebugControl2, 0xd4366723, 0x44df, 0x4bed,
0x8c, 0x7e, 0x4c, 0x05, 0x42, 0x4f, 0x45, 0x88);
/* 7df74a86-b03f-407f-90ab-a20dadcead08 */
DEFINE_GUID(IID_IDebugControl3, 0x7df74a86, 0xb03f, 0x407f,
0x90, 0xab, 0xa2, 0x0d, 0xad, 0xce, 0xad, 0x08);
/* 94e60ce9-9b41-4b19-9fc0-6d9eb35272b3 */
DEFINE_GUID(IID_IDebugControl4, 0x94e60ce9, 0x9b41, 0x4b19,
0x9f, 0xc0, 0x6d, 0x9e, 0xb3, 0x52, 0x72, 0xb3);
/* 88f7dfab-3ea7-4c3a-aefb-c4e8106173aa */
DEFINE_GUID(IID_IDebugDataSpaces, 0x88f7dfab, 0x3ea7, 0x4c3a,
0xae, 0xfb, 0xc4, 0xe8, 0x10, 0x61, 0x73, 0xaa);
/* 7a5e852f-96e9-468f-ac1b-0b3addc4a049 */
DEFINE_GUID(IID_IDebugDataSpaces2, 0x7a5e852f, 0x96e9, 0x468f,
0xac, 0x1b, 0x0b, 0x3a, 0xdd, 0xc4, 0xa0, 0x49);
/* 23f79d6c-8aaf-4f7c-a607-9995f5407e63 */
DEFINE_GUID(IID_IDebugDataSpaces3, 0x23f79d6c, 0x8aaf, 0x4f7c,
0xa6, 0x07, 0x99, 0x95, 0xf5, 0x40, 0x7e, 0x63);
/* d98ada1f-29e9-4ef5-a6c0-e53349883212 */
DEFINE_GUID(IID_IDebugDataSpaces4, 0xd98ada1f, 0x29e9, 0x4ef5,
0xa6, 0xc0, 0xe5, 0x33, 0x49, 0x88, 0x32, 0x12);
/* 337be28b-5036-4d72-b6bf-c45fbb9f2eaa */
DEFINE_GUID(IID_IDebugEventCallbacks, 0x337be28b, 0x5036, 0x4d72,
0xb6, 0xbf, 0xc4, 0x5f, 0xbb, 0x9f, 0x2e, 0xaa);
/* 0690e046-9c23-45ac-a04f-987ac29ad0d3 */
DEFINE_GUID(IID_IDebugEventCallbacksWide, 0x0690e046, 0x9c23, 0x45ac,
0xa0, 0x4f, 0x98, 0x7a, 0xc2, 0x9a, 0xd0, 0xd3);
/* 9f50e42c-f136-499e-9a97-73036c94ed2d */
DEFINE_GUID(IID_IDebugInputCallbacks, 0x9f50e42c, 0xf136, 0x499e,
0x9a, 0x97, 0x73, 0x03, 0x6c, 0x94, 0xed, 0x2d);
/* 4bf58045-d654-4c40-b0af-683090f356dc */
DEFINE_GUID(IID_IDebugOutputCallbacks, 0x4bf58045, 0xd654, 0x4c40,
0xb0, 0xaf, 0x68, 0x30, 0x90, 0xf3, 0x56, 0xdc);
/* 4c7fd663-c394-4e26-8ef1-34ad5ed3764c */
DEFINE_GUID(IID_IDebugOutputCallbacksWide, 0x4c7fd663, 0xc394, 0x4e26,
0x8e, 0xf1, 0x34, 0xad, 0x5e, 0xd3, 0x76, 0x4c);
/* ce289126-9e84-45a7-937e-67bb18691493 */
DEFINE_GUID(IID_IDebugRegisters, 0xce289126, 0x9e84, 0x45a7,
0x93, 0x7e, 0x67, 0xbb, 0x18, 0x69, 0x14, 0x93);
/* 1656afa9-19c6-4e3a-97e7-5dc9160cf9c4 */
DEFINE_GUID(IID_IDebugRegisters2, 0x1656afa9, 0x19c6, 0x4e3a,
0x97, 0xe7, 0x5d, 0xc9, 0x16, 0x0c, 0xf9, 0xc4);
/* f2528316-0f1a-4431-aeed-11d096e1e2ab */
DEFINE_GUID(IID_IDebugSymbolGroup, 0xf2528316, 0x0f1a, 0x4431,
0xae, 0xed, 0x11, 0xd0, 0x96, 0xe1, 0xe2, 0xab);
/* 6a7ccc5f-fb5e-4dcc-b41c-6c20307bccc7 */
DEFINE_GUID(IID_IDebugSymbolGroup2, 0x6a7ccc5f, 0xfb5e, 0x4dcc,
0xb4, 0x1c, 0x6c, 0x20, 0x30, 0x7b, 0xcc, 0xc7);
/* 8c31e98c-983a-48a5-9016-6fe5d667a950 */
DEFINE_GUID(IID_IDebugSymbols, 0x8c31e98c, 0x983a, 0x48a5,
0x90, 0x16, 0x6f, 0xe5, 0xd6, 0x67, 0xa9, 0x50);
/* 3a707211-afdd-4495-ad4f-56fecdf8163f */
DEFINE_GUID(IID_IDebugSymbols2, 0x3a707211, 0xafdd, 0x4495,
0xad, 0x4f, 0x56, 0xfe, 0xcd, 0xf8, 0x16, 0x3f);
/* f02fbecc-50ac-4f36-9ad9-c975e8f32ff8 */
DEFINE_GUID(IID_IDebugSymbols3, 0xf02fbecc, 0x50ac, 0x4f36,
0x9a, 0xd9, 0xc9, 0x75, 0xe8, 0xf3, 0x2f, 0xf8);
/* 6b86fe2c-2c4f-4f0c-9da2-174311acc327 */
DEFINE_GUID(IID_IDebugSystemObjects, 0x6b86fe2c, 0x2c4f, 0x4f0c,
0x9d, 0xa2, 0x17, 0x43, 0x11, 0xac, 0xc3, 0x27);
/* 0ae9f5ff-1852-4679-b055-494bee6407ee */
DEFINE_GUID(IID_IDebugSystemObjects2, 0x0ae9f5ff, 0x1852, 0x4679,
0xb0, 0x55, 0x49, 0x4b, 0xee, 0x64, 0x07, 0xee);
/* e9676e2f-e286-4ea3-b0f9-dfe5d9fc330e */
DEFINE_GUID(IID_IDebugSystemObjects3, 0xe9676e2f, 0xe286, 0x4ea3,
0xb0, 0xf9, 0xdf, 0xe5, 0xd9, 0xfc, 0x33, 0x0e);
/* 489468e6-7d0f-4af5-87ab-25207454d553 */
DEFINE_GUID(IID_IDebugSystemObjects4, 0x489468e6, 0x7d0f, 0x4af5,
0x87, 0xab, 0x25, 0x20, 0x74, 0x54, 0xd5, 0x53);
typedef interface DECLSPEC_UUID("f2df5f53-071f-47bd-9de6-5734c3fed689")
IDebugAdvanced* PDEBUG_ADVANCED;
typedef interface DECLSPEC_UUID("716d14c9-119b-4ba5-af1f-0890e672416a")
IDebugAdvanced2* PDEBUG_ADVANCED2;
typedef interface DECLSPEC_UUID("cba4abb4-84c4-444d-87ca-a04e13286739")
IDebugAdvanced3* PDEBUG_ADVANCED3;
typedef interface DECLSPEC_UUID("5bd9d474-5975-423a-b88b-65a8e7110e65")
IDebugBreakpoint* PDEBUG_BREAKPOINT;
typedef interface DECLSPEC_UUID("1b278d20-79f2-426e-a3f9-c1ddf375d48e")
IDebugBreakpoint2* PDEBUG_BREAKPOINT2;
typedef interface DECLSPEC_UUID("27fe5639-8407-4f47-8364-ee118fb08ac8")
IDebugClient* PDEBUG_CLIENT;
typedef interface DECLSPEC_UUID("edbed635-372e-4dab-bbfe-ed0d2f63be81")
IDebugClient2* PDEBUG_CLIENT2;
typedef interface DECLSPEC_UUID("dd492d7f-71b8-4ad6-a8dc-1c887479ff91")
IDebugClient3* PDEBUG_CLIENT3;
typedef interface DECLSPEC_UUID("ca83c3de-5089-4cf8-93c8-d892387f2a5e")
IDebugClient4* PDEBUG_CLIENT4;
typedef interface DECLSPEC_UUID("e3acb9d7-7ec2-4f0c-a0da-e81e0cbbe628")
IDebugClient5* PDEBUG_CLIENT5;
typedef interface DECLSPEC_UUID("5182e668-105e-416e-ad92-24ef800424ba")
IDebugControl* PDEBUG_CONTROL;
typedef interface DECLSPEC_UUID("d4366723-44df-4bed-8c7e-4c05424f4588")
IDebugControl2* PDEBUG_CONTROL2;
typedef interface DECLSPEC_UUID("7df74a86-b03f-407f-90ab-a20dadcead08")
IDebugControl3* PDEBUG_CONTROL3;
typedef interface DECLSPEC_UUID("94e60ce9-9b41-4b19-9fc0-6d9eb35272b3")
IDebugControl4* PDEBUG_CONTROL4;
typedef interface DECLSPEC_UUID("88f7dfab-3ea7-4c3a-aefb-c4e8106173aa")
IDebugDataSpaces* PDEBUG_DATA_SPACES;
typedef interface DECLSPEC_UUID("7a5e852f-96e9-468f-ac1b-0b3addc4a049")
IDebugDataSpaces2* PDEBUG_DATA_SPACES2;
typedef interface DECLSPEC_UUID("23f79d6c-8aaf-4f7c-a607-9995f5407e63")
IDebugDataSpaces3* PDEBUG_DATA_SPACES3;
typedef interface DECLSPEC_UUID("d98ada1f-29e9-4ef5-a6c0-e53349883212")
IDebugDataSpaces4* PDEBUG_DATA_SPACES4;
typedef interface DECLSPEC_UUID("337be28b-5036-4d72-b6bf-c45fbb9f2eaa")
IDebugEventCallbacks* PDEBUG_EVENT_CALLBACKS;
typedef interface DECLSPEC_UUID("0690e046-9c23-45ac-a04f-987ac29ad0d3")
IDebugEventCallbacksWide* PDEBUG_EVENT_CALLBACKS_WIDE;
typedef interface DECLSPEC_UUID("9f50e42c-f136-499e-9a97-73036c94ed2d")
IDebugInputCallbacks* PDEBUG_INPUT_CALLBACKS;
typedef interface DECLSPEC_UUID("4bf58045-d654-4c40-b0af-683090f356dc")
IDebugOutputCallbacks* PDEBUG_OUTPUT_CALLBACKS;
typedef interface DECLSPEC_UUID("4c7fd663-c394-4e26-8ef1-34ad5ed3764c")
IDebugOutputCallbacksWide* PDEBUG_OUTPUT_CALLBACKS_WIDE;
typedef interface DECLSPEC_UUID("ce289126-9e84-45a7-937e-67bb18691493")
IDebugRegisters* PDEBUG_REGISTERS;
typedef interface DECLSPEC_UUID("1656afa9-19c6-4e3a-97e7-5dc9160cf9c4")
IDebugRegisters2* PDEBUG_REGISTERS2;
typedef interface DECLSPEC_UUID("f2528316-0f1a-4431-aeed-11d096e1e2ab")
IDebugSymbolGroup* PDEBUG_SYMBOL_GROUP;
typedef interface DECLSPEC_UUID("6a7ccc5f-fb5e-4dcc-b41c-6c20307bccc7")
IDebugSymbolGroup2* PDEBUG_SYMBOL_GROUP2;
typedef interface DECLSPEC_UUID("8c31e98c-983a-48a5-9016-6fe5d667a950")
IDebugSymbols* PDEBUG_SYMBOLS;
typedef interface DECLSPEC_UUID("3a707211-afdd-4495-ad4f-56fecdf8163f")
IDebugSymbols2* PDEBUG_SYMBOLS2;
typedef interface DECLSPEC_UUID("f02fbecc-50ac-4f36-9ad9-c975e8f32ff8")
IDebugSymbols3* PDEBUG_SYMBOLS3;
typedef interface DECLSPEC_UUID("6b86fe2c-2c4f-4f0c-9da2-174311acc327")
IDebugSystemObjects* PDEBUG_SYSTEM_OBJECTS;
typedef interface DECLSPEC_UUID("0ae9f5ff-1852-4679-b055-494bee6407ee")
IDebugSystemObjects2* PDEBUG_SYSTEM_OBJECTS2;
typedef interface DECLSPEC_UUID("e9676e2f-e286-4ea3-b0f9-dfe5d9fc330e")
IDebugSystemObjects3* PDEBUG_SYSTEM_OBJECTS3;
typedef interface DECLSPEC_UUID("489468e6-7d0f-4af5-87ab-25207454d553")
IDebugSystemObjects4* PDEBUG_SYSTEM_OBJECTS4;
//----------------------------------------------------------------------------
//
// Macros.
//
//----------------------------------------------------------------------------
// Extends a 32-bit address into a 64-bit address.
#define DEBUG_EXTEND64(Addr) ((ULONG64)(LONG64)(LONG)(Addr))
//----------------------------------------------------------------------------
//
// Client creation functions.
//
//----------------------------------------------------------------------------
// RemoteOptions specifies connection types and
// their parameters. Supported strings are:
// npipe:Server=<Machine>,Pipe=<Pipe name>
// tcp:Server=<Machine>,Port=<IP port>
STDAPI
DebugConnect(
__in PCSTR RemoteOptions,
__in REFIID InterfaceId,
__out PVOID* Interface
);
STDAPI
DebugConnectWide(
__in PCWSTR RemoteOptions,
__in REFIID InterfaceId,
__out PVOID* Interface
);
STDAPI
DebugCreate(
__in REFIID InterfaceId,
__out PVOID* Interface
);
//----------------------------------------------------------------------------
//
// IDebugAdvanced.
//
//----------------------------------------------------------------------------
typedef struct _DEBUG_OFFSET_REGION
{
ULONG64 Base;
ULONG64 Size;
} DEBUG_OFFSET_REGION, *PDEBUG_OFFSET_REGION;
#undef INTERFACE
#define INTERFACE IDebugAdvanced
DECLARE_INTERFACE_(IDebugAdvanced, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugAdvanced.
// Get/SetThreadContext offer control over
// the full processor context for a thread.
// Higher-level functions, such as the
// IDebugRegisters interface, allow similar
// access in simpler and more generic ways.
// Get/SetThreadContext are useful when
// large amounts of thread context must
// be changed and processor-specific code
// is not a problem.
STDMETHOD(GetThreadContext)(
THIS_
__out_bcount(ContextSize) /* align_is(16) */ PVOID Context,
__in ULONG ContextSize
) PURE;
STDMETHOD(SetThreadContext)(
THIS_
__in_bcount(ContextSize) /* align_is(16) */ PVOID Context,
__in ULONG ContextSize
) PURE;
};
typedef struct _DEBUG_READ_USER_MINIDUMP_STREAM
{
IN ULONG StreamType;
IN ULONG Flags;
IN ULONG64 Offset;
OUT PVOID Buffer;
IN ULONG BufferSize;
OUT ULONG BufferUsed;
} DEBUG_READ_USER_MINIDUMP_STREAM, *PDEBUG_READ_USER_MINIDUMP_STREAM;
//
// Request requests.
//
// InBuffer - Unused.
// OutBuffer - Unused.
#define DEBUG_REQUEST_SOURCE_PATH_HAS_SOURCE_SERVER 0
// InBuffer - Unused.
// OutBuffer - Machine-specific CONTEXT.
#define DEBUG_REQUEST_TARGET_EXCEPTION_CONTEXT 1
// InBuffer - Unused.
// OutBuffer - ULONG system ID of thread.
#define DEBUG_REQUEST_TARGET_EXCEPTION_THREAD 2
// InBuffer - Unused.
// OutBuffer - EXCEPTION_RECORD64.
#define DEBUG_REQUEST_TARGET_EXCEPTION_RECORD 3
// InBuffer - Unused.
// OutBuffer - DEBUG_CREATE_PROCESS_OPTIONS.
#define DEBUG_REQUEST_GET_ADDITIONAL_CREATE_OPTIONS 4
// InBuffer - DEBUG_CREATE_PROCESS_OPTIONS.
// OutBuffer - Unused.
#define DEBUG_REQUEST_SET_ADDITIONAL_CREATE_OPTIONS 5
// InBuffer - Unused.
// OutBuffer - ULONG[2] major/minor.
#define DEBUG_REQUEST_GET_WIN32_MAJOR_MINOR_VERSIONS 6
// InBuffer - DEBUG_READ_USER_MINIDUMP_STREAM.
// OutBuffer - Unused.
#define DEBUG_REQUEST_READ_USER_MINIDUMP_STREAM 7
// InBuffer - Unused.
// OutBuffer - Unused.
#define DEBUG_REQUEST_TARGET_CAN_DETACH 8
// InBuffer - PTSTR.
// OutBuffer - Unused.
#define DEBUG_REQUEST_SET_LOCAL_IMPLICIT_COMMAND_LINE 9
//
// GetSourceFileInformation requests.
//
// Arg64 - Module base.
// Arg32 - Unused.
#define DEBUG_SRCFILE_SYMBOL_TOKEN 0
// Arg64 - Module base.
// Arg32 - Unused.
#define DEBUG_SRCFILE_SYMBOL_TOKEN_SOURCE_COMMAND_WIDE 1
//
// GetSymbolInformation requests.
//
// Arg64 - Unused.
// Arg32 - Breakpoint ID.
// Buffer - ULONG line number.
// String - File name.
#define DEBUG_SYMINFO_BREAKPOINT_SOURCE_LINE 0
// Arg64 - Module base.
// Arg32 - Unused.
// Buffer - IMAGEHLP_MODULEW64.
// String - Unused.
#define DEBUG_SYMINFO_IMAGEHLP_MODULEW64 1
//
// GetSystemObjectInformation requests.
//
// Arg64 - Unused.
// Arg32 - Debugger thread ID.
#define DEBUG_SYSOBJINFO_THREAD_BASIC_INFORMATION 0
#define DEBUG_TBINFO_EXIT_STATUS 0x00000001
#define DEBUG_TBINFO_PRIORITY_CLASS 0x00000002
#define DEBUG_TBINFO_PRIORITY 0x00000004
#define DEBUG_TBINFO_TIMES 0x00000008
#define DEBUG_TBINFO_START_OFFSET 0x00000010
#define DEBUG_TBINFO_AFFINITY 0x00000020
#define DEBUG_TBINFO_ALL 0x0000003f
typedef struct _DEBUG_THREAD_BASIC_INFORMATION
{
// Valid members have a DEBUG_TBINFO bit set in Valid.
ULONG Valid;
ULONG ExitStatus;
ULONG PriorityClass;
ULONG Priority;
ULONG64 CreateTime;
ULONG64 ExitTime;
ULONG64 KernelTime;
ULONG64 UserTime;
ULONG64 StartOffset;
ULONG64 Affinity;
} DEBUG_THREAD_BASIC_INFORMATION, *PDEBUG_THREAD_BASIC_INFORMATION;
#undef INTERFACE
#define INTERFACE IDebugAdvanced2
DECLARE_INTERFACE_(IDebugAdvanced2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugAdvanced.
// Get/SetThreadContext offer control over
// the full processor context for a thread.
// Higher-level functions, such as the
// IDebugRegisters interface, allow similar
// access in simpler and more generic ways.
// Get/SetThreadContext are useful when
// large amounts of thread context must
// be changed and processor-specific code
// is not a problem.
STDMETHOD(GetThreadContext)(
THIS_
__out_bcount(ContextSize) /* align_is(16) */ PVOID Context,
__in ULONG ContextSize
) PURE;
STDMETHOD(SetThreadContext)(
THIS_
__in_bcount(ContextSize) /* align_is(16) */ PVOID Context,
__in ULONG ContextSize
) PURE;
// IDebugAdvanced2.
//
// Generalized open-ended methods for querying
// and manipulation. The open-ended nature of
// these methods makes it easy to add new requests,
// although at a cost in convenience of calling.
// Sufficiently common requests may have more specific,
// simpler methods elsewhere.
//
STDMETHOD(Request)(
THIS_
__in ULONG Request,
__in_bcount_opt(InBufferSize) PVOID InBuffer,
__in ULONG InBufferSize,
__out_bcount_opt(OutBufferSize) PVOID OutBuffer,
__in ULONG OutBufferSize,
__out_opt PULONG OutSize
) PURE;
STDMETHOD(GetSourceFileInformation)(
THIS_
__in ULONG Which,
__in PSTR SourceFile,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize
) PURE;
STDMETHOD(FindSourceFileAndToken)(
THIS_
__in ULONG StartElement,
__in ULONG64 ModAddr,
__in PCSTR File,
__in ULONG Flags,
__in_bcount_opt(FileTokenSize) PVOID FileToken,
__in ULONG FileTokenSize,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
STDMETHOD(GetSymbolInformation)(
THIS_
__in ULONG Which,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize,
__out_ecount_opt(StringBufferSize) PSTR StringBuffer,
__in ULONG StringBufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(GetSystemObjectInformation)(
THIS_
__in ULONG Which,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugAdvanced3
DECLARE_INTERFACE_(IDebugAdvanced3, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugAdvanced.
// Get/SetThreadContext offer control over
// the full processor context for a thread.
// Higher-level functions, such as the
// IDebugRegisters interface, allow similar
// access in simpler and more generic ways.
// Get/SetThreadContext are useful when
// large amounts of thread context must
// be changed and processor-specific code
// is not a problem.
STDMETHOD(GetThreadContext)(
THIS_
__out_bcount(ContextSize) /* align_is(16) */ PVOID Context,
__in ULONG ContextSize
) PURE;
STDMETHOD(SetThreadContext)(
THIS_
__in_bcount(ContextSize) /* align_is(16) */ PVOID Context,
__in ULONG ContextSize
) PURE;
// IDebugAdvanced2.
//
// Generalized open-ended methods for querying
// and manipulation. The open-ended nature of
// these methods makes it easy to add new requests,
// although at a cost in convenience of calling.
// Sufficiently common requests may have more specific,
// simpler methods elsewhere.
//
STDMETHOD(Request)(
THIS_
__in ULONG Request,
__in_bcount_opt(InBufferSize) PVOID InBuffer,
__in ULONG InBufferSize,
__out_bcount_opt(OutBufferSize) PVOID OutBuffer,
__in ULONG OutBufferSize,
__out_opt PULONG OutSize
) PURE;
STDMETHOD(GetSourceFileInformation)(
THIS_
__in ULONG Which,
__in PSTR SourceFile,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize
) PURE;
STDMETHOD(FindSourceFileAndToken)(
THIS_
__in ULONG StartElement,
__in ULONG64 ModAddr,
__in PCSTR File,
__in ULONG Flags,
__in_bcount_opt(FileTokenSize) PVOID FileToken,
__in ULONG FileTokenSize,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
STDMETHOD(GetSymbolInformation)(
THIS_
__in ULONG Which,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize,
__out_ecount_opt(StringBufferSize) PSTR StringBuffer,
__in ULONG StringBufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(GetSystemObjectInformation)(
THIS_
__in ULONG Which,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize
) PURE;
// IDebugAdvanced3.
STDMETHOD(GetSourceFileInformationWide)(
THIS_
__in ULONG Which,
__in PWSTR SourceFile,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize
) PURE;
STDMETHOD(FindSourceFileAndTokenWide)(
THIS_
__in ULONG StartElement,
__in ULONG64 ModAddr,
__in PCWSTR File,
__in ULONG Flags,
__in_bcount_opt(FileTokenSize) PVOID FileToken,
__in ULONG FileTokenSize,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
STDMETHOD(GetSymbolInformationWide)(
THIS_
__in ULONG Which,
__in ULONG64 Arg64,
__in ULONG Arg32,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize,
__out_ecount_opt(StringBufferSize) PWSTR StringBuffer,
__in ULONG StringBufferSize,
__out_opt PULONG StringSize
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugBreakpoint.
//
//----------------------------------------------------------------------------
// Types of breakpoints.
#define DEBUG_BREAKPOINT_CODE 0
#define DEBUG_BREAKPOINT_DATA 1
// Breakpoint flags.
// Go-only breakpoints are only active when
// the engine is in unrestricted execution
// mode. They do not fire when the engine
// is stepping.
#define DEBUG_BREAKPOINT_GO_ONLY 0x00000001
// A breakpoint is flagged as deferred as long as
// its offset expression cannot be evaluated.
// A deferred breakpoint is not active.
#define DEBUG_BREAKPOINT_DEFERRED 0x00000002
#define DEBUG_BREAKPOINT_ENABLED 0x00000004
// The adder-only flag does not affect breakpoint
// operation. It is just a marker to restrict
// output and notifications for the breakpoint to
// the client that added the breakpoint. Breakpoint
// callbacks for adder-only breaks will only be delivered
// to the adding client. The breakpoint can not
// be enumerated and accessed by other clients.
#define DEBUG_BREAKPOINT_ADDER_ONLY 0x00000008
// One-shot breakpoints automatically clear themselves
// the first time they are hit.
#define DEBUG_BREAKPOINT_ONE_SHOT 0x00000010
// Data breakpoint access types.
// Different architectures support different
// sets of these bits.
#define DEBUG_BREAK_READ 0x00000001
#define DEBUG_BREAK_WRITE 0x00000002
#define DEBUG_BREAK_EXECUTE 0x00000004
#define DEBUG_BREAK_IO 0x00000008
// Structure for querying breakpoint information
// all at once.
typedef struct _DEBUG_BREAKPOINT_PARAMETERS
{
ULONG64 Offset;
ULONG Id;
ULONG BreakType;
ULONG ProcType;
ULONG Flags;
ULONG DataSize;
ULONG DataAccessType;
ULONG PassCount;
ULONG CurrentPassCount;
ULONG MatchThread;
ULONG CommandSize;
ULONG OffsetExpressionSize;
} DEBUG_BREAKPOINT_PARAMETERS, *PDEBUG_BREAKPOINT_PARAMETERS;
#undef INTERFACE
#define INTERFACE IDebugBreakpoint
DECLARE_INTERFACE_(IDebugBreakpoint, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugBreakpoint.
// Retrieves debugger engine unique ID
// for the breakpoint. This ID is
// fixed as long as the breakpoint exists
// but after that may be reused.
STDMETHOD(GetId)(
THIS_
__out PULONG Id
) PURE;
// Retrieves the type of break and
// processor type for the breakpoint.
STDMETHOD(GetType)(
THIS_
__out PULONG BreakType,
__out PULONG ProcType
) PURE;
// Returns the client that called AddBreakpoint.
STDMETHOD(GetAdder)(
THIS_
__out PDEBUG_CLIENT* Adder
) PURE;
STDMETHOD(GetFlags)(
THIS_
__out PULONG Flags
) PURE;
// Only certain flags can be changed. Flags
// are: GO_ONLY, ENABLE.
// Sets the given flags.
STDMETHOD(AddFlags)(
THIS_
__in ULONG Flags
) PURE;
// Clears the given flags.
STDMETHOD(RemoveFlags)(
THIS_
__in ULONG Flags
) PURE;
// Sets the flags.
STDMETHOD(SetFlags)(
THIS_
__in ULONG Flags
) PURE;
// Controls the offset of the breakpoint. The
// interpretation of the offset value depends on
// the type of breakpoint and its settings. It
// may be a code address, a data address, an
// I/O port, etc.
STDMETHOD(GetOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetOffset)(
THIS_
__in ULONG64 Offset
) PURE;
// Data breakpoint methods will fail if the
// target platform does not support the
// parameters used.
// These methods only function for breakpoints
// created as data breakpoints.
STDMETHOD(GetDataParameters)(
THIS_
__out PULONG Size,
__out PULONG AccessType
) PURE;
STDMETHOD(SetDataParameters)(
THIS_
__in ULONG Size,
__in ULONG AccessType
) PURE;
// Pass count defaults to one.
STDMETHOD(GetPassCount)(
THIS_
__out PULONG Count
) PURE;
STDMETHOD(SetPassCount)(
THIS_
__in ULONG Count
) PURE;
// Gets the current number of times
// the breakpoint has been hit since
// it was last triggered.
STDMETHOD(GetCurrentPassCount)(
THIS_
__out PULONG Count
) PURE;
// If a match thread is set this breakpoint will
// only trigger if it occurs on the match thread.
// Otherwise it triggers for all threads.
// Thread restrictions are not currently supported
// in kernel mode.
STDMETHOD(GetMatchThreadId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetMatchThreadId)(
THIS_
__in ULONG Thread
) PURE;
// The command for a breakpoint is automatically
// executed by the engine before the event
// is propagated. If the breakpoint continues
// execution the event will begin with a continue
// status. If the breakpoint does not continue
// the event will begin with a break status.
// This allows breakpoint commands to participate
// in the normal event status voting.
// Breakpoint commands are only executed until
// the first command that alters the execution
// status, such as g, p and t.
STDMETHOD(GetCommand)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetCommand)(
THIS_
__in PCSTR Command
) PURE;
// Offset expressions are evaluated immediately
// and at module load and unload events. If the
// evaluation is successful the breakpoints
// offset is updated and the breakpoint is
// handled normally. If the expression cannot
// be evaluated the breakpoint is deferred.
// Currently the only offset expression
// supported is a module-relative symbol
// of the form <Module>!<Symbol>.
STDMETHOD(GetOffsetExpression)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExpressionSize
) PURE;
STDMETHOD(SetOffsetExpression)(
THIS_
__in PCSTR Expression
) PURE;
STDMETHOD(GetParameters)(
THIS_
__out PDEBUG_BREAKPOINT_PARAMETERS Params
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugBreakpoint2
DECLARE_INTERFACE_(IDebugBreakpoint2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugBreakpoint.
// Retrieves debugger engine unique ID
// for the breakpoint. This ID is
// fixed as long as the breakpoint exists
// but after that may be reused.
STDMETHOD(GetId)(
THIS_
__out PULONG Id
) PURE;
// Retrieves the type of break and
// processor type for the breakpoint.
STDMETHOD(GetType)(
THIS_
__out PULONG BreakType,
__out PULONG ProcType
) PURE;
// Returns the client that called AddBreakpoint.
STDMETHOD(GetAdder)(
THIS_
__out PDEBUG_CLIENT* Adder
) PURE;
STDMETHOD(GetFlags)(
THIS_
__out PULONG Flags
) PURE;
// Only certain flags can be changed. Flags
// are: GO_ONLY, ENABLE.
// Sets the given flags.
STDMETHOD(AddFlags)(
THIS_
__in ULONG Flags
) PURE;
// Clears the given flags.
STDMETHOD(RemoveFlags)(
THIS_
__in ULONG Flags
) PURE;
// Sets the flags.
STDMETHOD(SetFlags)(
THIS_
__in ULONG Flags
) PURE;
// Controls the offset of the breakpoint. The
// interpretation of the offset value depends on
// the type of breakpoint and its settings. It
// may be a code address, a data address, an
// I/O port, etc.
STDMETHOD(GetOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetOffset)(
THIS_
__in ULONG64 Offset
) PURE;
// Data breakpoint methods will fail if the
// target platform does not support the
// parameters used.
// These methods only function for breakpoints
// created as data breakpoints.
STDMETHOD(GetDataParameters)(
THIS_
__out PULONG Size,
__out PULONG AccessType
) PURE;
STDMETHOD(SetDataParameters)(
THIS_
__in ULONG Size,
__in ULONG AccessType
) PURE;
// Pass count defaults to one.
STDMETHOD(GetPassCount)(
THIS_
__out PULONG Count
) PURE;
STDMETHOD(SetPassCount)(
THIS_
__in ULONG Count
) PURE;
// Gets the current number of times
// the breakpoint has been hit since
// it was last triggered.
STDMETHOD(GetCurrentPassCount)(
THIS_
__out PULONG Count
) PURE;
// If a match thread is set this breakpoint will
// only trigger if it occurs on the match thread.
// Otherwise it triggers for all threads.
// Thread restrictions are not currently supported
// in kernel mode.
STDMETHOD(GetMatchThreadId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetMatchThreadId)(
THIS_
__in ULONG Thread
) PURE;
// The command for a breakpoint is automatically
// executed by the engine before the event
// is propagated. If the breakpoint continues
// execution the event will begin with a continue
// status. If the breakpoint does not continue
// the event will begin with a break status.
// This allows breakpoint commands to participate
// in the normal event status voting.
// Breakpoint commands are only executed until
// the first command that alters the execution
// status, such as g, p and t.
STDMETHOD(GetCommand)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetCommand)(
THIS_
__in PCSTR Command
) PURE;
// Offset expressions are evaluated immediately
// and at module load and unload events. If the
// evaluation is successful the breakpoints
// offset is updated and the breakpoint is
// handled normally. If the expression cannot
// be evaluated the breakpoint is deferred.
// Currently the only offset expression
// supported is a module-relative symbol
// of the form <Module>!<Symbol>.
STDMETHOD(GetOffsetExpression)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExpressionSize
) PURE;
STDMETHOD(SetOffsetExpression)(
THIS_
__in PCSTR Expression
) PURE;
STDMETHOD(GetParameters)(
THIS_
__out PDEBUG_BREAKPOINT_PARAMETERS Params
) PURE;
// IDebugBreakpoint2.
STDMETHOD(GetCommandWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetCommandWide)(
THIS_
__in PCWSTR Command
) PURE;
STDMETHOD(GetOffsetExpressionWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExpressionSize
) PURE;
STDMETHOD(SetOffsetExpressionWide)(
THIS_
__in PCWSTR Expression
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugClient.
//
//----------------------------------------------------------------------------
// Kernel attach flags.
#define DEBUG_ATTACH_KERNEL_CONNECTION 0x00000000
// Attach to the local machine. If this flag is not set
// a connection is made to a separate target machine using
// the given connection options.
#define DEBUG_ATTACH_LOCAL_KERNEL 0x00000001
// Attach to an eXDI driver.
#define DEBUG_ATTACH_EXDI_DRIVER 0x00000002
// GetRunningProcessSystemIdByExecutableName flags.
// By default the match allows a tail match on
// just the filename. The match returns the first hit
// even if multiple matches exist.
#define DEBUG_GET_PROC_DEFAULT 0x00000000
// The name must match fully.
#define DEBUG_GET_PROC_FULL_MATCH 0x00000001
// The match must be the only match.
#define DEBUG_GET_PROC_ONLY_MATCH 0x00000002
// GetRunningProcessDescription flags.
#define DEBUG_PROC_DESC_DEFAULT 0x00000000
// Return only filenames, not full paths.
#define DEBUG_PROC_DESC_NO_PATHS 0x00000001
// Dont look up service names.
#define DEBUG_PROC_DESC_NO_SERVICES 0x00000002
// Dont look up MTS package names.
#define DEBUG_PROC_DESC_NO_MTS_PACKAGES 0x00000004
// Dont retrieve the command line.
#define DEBUG_PROC_DESC_NO_COMMAND_LINE 0x00000008
//
// Attach flags.
//
// Call DebugActiveProcess when attaching.
#define DEBUG_ATTACH_DEFAULT 0x00000000
// When attaching to a process just examine
// the process state and suspend the threads.
// DebugActiveProcess is not called so the process
// is not actually being debugged. This is useful
// for debugging processes holding locks which
// interfere with the operation of DebugActiveProcess
// or in situations where it is not desirable to
// actually set up as a debugger.
#define DEBUG_ATTACH_NONINVASIVE 0x00000001
// Attempt to attach to a process that was abandoned
// when being debugged. This is only supported in
// some system versions.
// This flag also allows multiple debuggers to
// attach to the same process, which can result
// in numerous problems unless very carefully
// managed.
#define DEBUG_ATTACH_EXISTING 0x00000002
// When attaching non-invasively, do not suspend
// threads. It is the callers responsibility
// to either suspend the threads itself or be
// aware that the attach state may not reflect
// the current state of the process if threads
// are still running.
#define DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND 0x00000004
// When doing an invasive attach do not inject
// a break-in thread to generate the initial break-in
// event. This can be useful to save resources when
// an initial break is not necessary or when injecting
// a thread might affect the debuggee's state. This
// option is only supported on Windows XP and above.
#define DEBUG_ATTACH_INVASIVE_NO_INITIAL_BREAK 0x00000008
// When doing an invasive attach resume all threads at the
// time of attach. This makes it possible to attach
// to a process created suspended and cause it to start running.
#define DEBUG_ATTACH_INVASIVE_RESUME_PROCESS 0x00000010
//
// Process creation flags to merge with Win32 flags.
//
// On Windows XP this flag prevents the debug
// heap from being used in the new process.
#define DEBUG_CREATE_PROCESS_NO_DEBUG_HEAP CREATE_UNICODE_ENVIRONMENT
// Indicates that the native NT RTL process creation
// routines should be used instead of Win32. This
// is only meaningful for special processes that run
// as NT native processes.
#define DEBUG_CREATE_PROCESS_THROUGH_RTL STACK_SIZE_PARAM_IS_A_RESERVATION
//
// Process creation flags specific to the debugger engine.
//
#define DEBUG_ECREATE_PROCESS_DEFAULT 0x00000000
#define DEBUG_ECREATE_PROCESS_INHERIT_HANDLES 0x00000001
#define DEBUG_ECREATE_PROCESS_USE_VERIFIER_FLAGS 0x00000002
#define DEBUG_ECREATE_PROCESS_USE_IMPLICIT_COMMAND_LINE 0x00000004
typedef struct _DEBUG_CREATE_PROCESS_OPTIONS
{
// Win32 create flags.
ULONG CreateFlags;
// DEBUG_ECREATE_PROCESS_* flags.
ULONG EngCreateFlags;
// Application Verifier flags,
// if DEBUG_ECREATE_PROCESS_USE_VERIFIER_FLAGS is set.
ULONG VerifierFlags;
// Must be zero.
ULONG Reserved;
} DEBUG_CREATE_PROCESS_OPTIONS, *PDEBUG_CREATE_PROCESS_OPTIONS;
//
// Process options.
//
// Indicates that the debuggee process should be
// automatically detached when the debugger exits.
// A debugger can explicitly detach on exit or this
// flag can be set so that detach occurs regardless
// of how the debugger exits.
// This is only supported on some system versions.
#define DEBUG_PROCESS_DETACH_ON_EXIT 0x00000001
// Indicates that processes created by the current
// process should not be debugged.
// Modifying this flag is only supported on some
// system versions.
#define DEBUG_PROCESS_ONLY_THIS_PROCESS 0x00000002
// ConnectSession flags.
// Default connect.
#define DEBUG_CONNECT_SESSION_DEFAULT 0x00000000
// Do not output the debugger version.
#define DEBUG_CONNECT_SESSION_NO_VERSION 0x00000001
// Do not announce the connection.
#define DEBUG_CONNECT_SESSION_NO_ANNOUNCE 0x00000002
// OutputServers flags.
// Debugger servers from StartSever.
#define DEBUG_SERVERS_DEBUGGER 0x00000001
// Process servers from StartProcessServer.
#define DEBUG_SERVERS_PROCESS 0x00000002
#define DEBUG_SERVERS_ALL 0x00000003
// EndSession flags.
// Perform cleanup for the session.
#define DEBUG_END_PASSIVE 0x00000000
// Actively terminate the session and then perform cleanup.
#define DEBUG_END_ACTIVE_TERMINATE 0x00000001
// If possible, detach from all processes and then perform cleanup.
#define DEBUG_END_ACTIVE_DETACH 0x00000002
// Perform whatever cleanup is possible that doesn't require
// acquiring any locks. This is useful for situations where
// a thread is currently using the engine but the application
// needs to exit and still wants to give the engine
// the opportunity to clean up as much as possible.
// This may leave the engine in an indeterminate state so
// further engine calls should not be made.
// When making a reentrant EndSession call from a remote
// client it is the callers responsibility to ensure
// that the server can process the request. It is best
// to avoid making such calls.
#define DEBUG_END_REENTRANT 0x00000003
// Notify a server that a remote client is disconnecting.
// This isnt required but if it isnt called then
// no disconnect messages will be generated by the server.
#define DEBUG_END_DISCONNECT 0x00000004
// Output mask bits.
// Normal output.
#define DEBUG_OUTPUT_NORMAL 0x00000001
// Error output.
#define DEBUG_OUTPUT_ERROR 0x00000002
// Warnings.
#define DEBUG_OUTPUT_WARNING 0x00000004
// Additional output.
#define DEBUG_OUTPUT_VERBOSE 0x00000008
// Prompt output.
#define DEBUG_OUTPUT_PROMPT 0x00000010
// Register dump before prompt.
#define DEBUG_OUTPUT_PROMPT_REGISTERS 0x00000020
// Warnings specific to extension operation.
#define DEBUG_OUTPUT_EXTENSION_WARNING 0x00000040
// Debuggee debug output, such as from OutputDebugString.
#define DEBUG_OUTPUT_DEBUGGEE 0x00000080
// Debuggee-generated prompt, such as from DbgPrompt.
#define DEBUG_OUTPUT_DEBUGGEE_PROMPT 0x00000100
// Symbol messages, such as for !sym noisy.
#define DEBUG_OUTPUT_SYMBOLS 0x00000200
// Internal debugger output, used mainly
// for debugging the debugger. Output
// may only occur in debug builds.
// KD protocol output.
#define DEBUG_IOUTPUT_KD_PROTOCOL 0x80000000
// Remoting output.
#define DEBUG_IOUTPUT_REMOTING 0x40000000
// Breakpoint output.
#define DEBUG_IOUTPUT_BREAKPOINT 0x20000000
// Event output.
#define DEBUG_IOUTPUT_EVENT 0x10000000
// OutputIdentity flags.
#define DEBUG_OUTPUT_IDENTITY_DEFAULT 0x00000000
#undef INTERFACE
#define INTERFACE IDebugClient
DECLARE_INTERFACE_(IDebugClient, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugClient.
// The following set of methods start
// the different kinds of debuggees.
// Begins a debug session using the kernel
// debugging protocol. This method selects
// the protocol as the debuggee communication
// mechanism but does not initiate the communication
// itself.
STDMETHOD(AttachKernel)(
THIS_
__in ULONG Flags,
__in_opt PCSTR ConnectOptions
) PURE;
STDMETHOD(GetKernelConnectionOptions)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG OptionsSize
) PURE;
// Updates the connection options for a live
// kernel connection. This can only be used
// to modify parameters for the connection, not
// to switch to a completely different kind of
// connection.
// This method is reentrant.
STDMETHOD(SetKernelConnectionOptions)(
THIS_
__in PCSTR Options
) PURE;
// Starts a process server for remote
// user-mode process control.
// The local process server is server zero.
STDMETHOD(StartProcessServer)(
THIS_
__in ULONG Flags,
__in PCSTR Options,
__in __reserved PVOID Reserved
) PURE;
STDMETHOD(ConnectProcessServer)(
THIS_
__in PCSTR RemoteOptions,
__out PULONG64 Server
) PURE;
STDMETHOD(DisconnectProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Enumerates and describes processes
// accessible through the given process server.
STDMETHOD(GetRunningProcessSystemIds)(
THIS_
__in ULONG64 Server,
__out_ecount_opt(Count) PULONG Ids,
__in ULONG Count,
__out_opt PULONG ActualCount
) PURE;
STDMETHOD(GetRunningProcessSystemIdByExecutableName)(
THIS_
__in ULONG64 Server,
__in PCSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescription)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
// Attaches to a running user-mode process.
STDMETHOD(AttachProcess)(
THIS_
__in ULONG64 Server,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Creates a new user-mode process for debugging.
// CreateFlags are as given to Win32s CreateProcess.
// One of DEBUG_PROCESS or DEBUG_ONLY_THIS_PROCESS
// must be specified.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 Server,
__in PSTR CommandLine,
__in ULONG CreateFlags
) PURE;
// Creates or attaches to a user-mode process, or both.
// If CommandLine is NULL this method operates as
// AttachProcess does. If ProcessId is zero it
// operates as CreateProcess does. If CommandLine is
// non-NULL and ProcessId is non-zero the method first
// starts a process with the given information but
// in a suspended state. The engine then attaches to
// the indicated process. Once the attach is successful
// the suspended process is resumed. This provides
// synchronization between the new process and the
// attachment.
STDMETHOD(CreateProcessAndAttach)(
THIS_
__in ULONG64 Server,
__in_opt PSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Gets and sets process control flags.
STDMETHOD(GetProcessOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetProcessOptions)(
THIS_
__in ULONG Options
) PURE;
// Opens any kind of user- or kernel-mode dump file
// and begins a debug session with the information
// contained within it.
STDMETHOD(OpenDumpFile)(
THIS_
__in PCSTR DumpFile
) PURE;
// Writes a dump file from the current session information.
// The kind of dump file written is determined by the
// kind of session and the type qualifier given.
// For example, if the current session is a kernel
// debug session (DEBUG_CLASS_KERNEL) and the qualifier
// is DEBUG_DUMP_SMALL a small kernel dump will be written.
STDMETHOD(WriteDumpFile)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier
) PURE;
// Indicates that a remote client is ready to
// begin participating in the current session.
// HistoryLimit gives a character limit on
// the amount of output history to be sent.
STDMETHOD(ConnectSession)(
THIS_
__in ULONG Flags,
__in ULONG HistoryLimit
) PURE;
// Indicates that the engine should start accepting
// remote connections. Options specifies connection types
// and their parameters. Supported strings are:
// npipe:Pipe=<Pipe name>
// tcp:Port=<IP port>
STDMETHOD(StartServer)(
THIS_
__in PCSTR Options
) PURE;
// List the servers running on the given machine.
// Uses the line prefix.
STDMETHOD(OutputServers)(
THIS_
__in ULONG OutputControl,
__in PCSTR Machine,
__in ULONG Flags
) PURE;
// Attempts to terminate all processes in the debuggers list.
STDMETHOD(TerminateProcesses)(
THIS
) PURE;
// Attempts to detach from all processes in the debuggers list.
// This requires OS support for debugger detach.
STDMETHOD(DetachProcesses)(
THIS
) PURE;
// Stops the current debug session. If a process
// was created or attached an active EndSession can
// terminate or detach from it.
// If a kernel connection was opened it will be closed but the
// target machine is otherwise unaffected.
STDMETHOD(EndSession)(
THIS_
__in ULONG Flags
) PURE;
// If a process was started and ran to completion
// this method can be used to retrieve its exit code.
STDMETHOD(GetExitCode)(
THIS_
__out PULONG Code
) PURE;
// Client event callbacks are called on the thread
// of the client. In order to give thread
// execution to the engine for callbacks all
// client threads should call DispatchCallbacks
// when they are idle. Callbacks are only
// received when a thread calls DispatchCallbacks
// or WaitForEvent. WaitForEvent can only be
// called by the thread that started the debug
// session so all other client threads should
// call DispatchCallbacks when possible.
// DispatchCallbacks returns when ExitDispatch is used
// to interrupt dispatch or when the timeout expires.
// DispatchCallbacks dispatches callbacks for all
// clients associated with the thread calling
// DispatchCallbacks.
// DispatchCallbacks returns S_FALSE when the
// timeout expires.
STDMETHOD(DispatchCallbacks)(
THIS_
__in ULONG Timeout
) PURE;
// ExitDispatch can be used to interrupt callback
// dispatch when a client thread is needed by the
// client. This method is reentrant and can
// be called from any thread.
STDMETHOD(ExitDispatch)(
THIS_
__in PDEBUG_CLIENT Client
) PURE;
// Clients are specific to the thread that
// created them. Calls from other threads
// fail immediately. The CreateClient method
// is a notable exception; it allows creation
// of a new client for a new thread.
STDMETHOD(CreateClient)(
THIS_
__out PDEBUG_CLIENT* Client
) PURE;
STDMETHOD(GetInputCallbacks)(
THIS_
__out PDEBUG_INPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetInputCallbacks)(
THIS_
__in PDEBUG_INPUT_CALLBACKS Callbacks
) PURE;
// Output callback interfaces are described separately.
STDMETHOD(GetOutputCallbacks)(
THIS_
__out PDEBUG_OUTPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetOutputCallbacks)(
THIS_
__in PDEBUG_OUTPUT_CALLBACKS Callbacks
) PURE;
// Output flags provide control over
// the distribution of output among clients.
// Output masks select which output streams
// should be sent to the output callbacks.
// Only Output calls with a mask that
// contains one of the output mask bits
// will be sent to the output callbacks.
// These methods are reentrant.
// If such access is not synchronized
// disruptions in output may occur.
STDMETHOD(GetOutputMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetOutputMask)(
THIS_
__in ULONG Mask
) PURE;
// These methods allow access to another clients
// output mask. They are necessary for changing
// a clients output mask when it is
// waiting for events. These methods are reentrant
// and can be called from any thread.
STDMETHOD(GetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__out PULONG Mask
) PURE;
STDMETHOD(SetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__in ULONG Mask
) PURE;
// Control the width of an output line for
// commands which produce formatted output.
// This setting is just a suggestion.
STDMETHOD(GetOutputWidth)(
THIS_
__out PULONG Columns
) PURE;
STDMETHOD(SetOutputWidth)(
THIS_
__in ULONG Columns
) PURE;
// Some of the engines output commands produce
// multiple lines of output. A prefix can be
// set that the engine will automatically output
// for each line in that case, allowing a caller
// to control indentation or identifying marks.
// This is not a general setting for any output
// with a newline in it. Methods which use
// the line prefix are marked in their documentation.
STDMETHOD(GetOutputLinePrefix)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PrefixSize
) PURE;
STDMETHOD(SetOutputLinePrefix)(
THIS_
__in_opt PCSTR Prefix
) PURE;
// Returns a string describing the machine
// and user this client represents. The
// specific content of the string varies
// with operating system. If the client is
// remotely connected some network information
// may also be present.
STDMETHOD(GetIdentity)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG IdentitySize
) PURE;
// Format is a printf-like format string
// with one %s where the identity string should go.
STDMETHOD(OutputIdentity)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in PCSTR Format
) PURE;
// Event callbacks allow a client to
// receive notification about changes
// during the debug session.
STDMETHOD(GetEventCallbacks)(
THIS_
__out PDEBUG_EVENT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetEventCallbacks)(
THIS_
__in PDEBUG_EVENT_CALLBACKS Callbacks
) PURE;
// The engine sometimes merges compatible callback
// requests to reduce callback overhead. This is
// most noticeable with output as small pieces of
// output are collected into larger groups to
// reduce the overall number of output callback calls.
// A client can use this method to force all pending
// callbacks to be delivered. This is rarely necessary.
STDMETHOD(FlushCallbacks)(
THIS
) PURE;
};
// Per-dump-format control flags.
#define DEBUG_FORMAT_DEFAULT 0x00000000
// Write dump to a temporary file, then package it
// into a CAB file and delete the temporary file.
#define DEBUG_FORMAT_WRITE_CAB 0x20000000
// When creating a CAB add secondary files such as
// current symbols and mapped images.
#define DEBUG_FORMAT_CAB_SECONDARY_FILES 0x40000000
// Don't overwrite existing files.
#define DEBUG_FORMAT_NO_OVERWRITE 0x80000000
#define DEBUG_FORMAT_USER_SMALL_FULL_MEMORY 0x00000001
#define DEBUG_FORMAT_USER_SMALL_HANDLE_DATA 0x00000002
#define DEBUG_FORMAT_USER_SMALL_UNLOADED_MODULES 0x00000004
#define DEBUG_FORMAT_USER_SMALL_INDIRECT_MEMORY 0x00000008
#define DEBUG_FORMAT_USER_SMALL_DATA_SEGMENTS 0x00000010
#define DEBUG_FORMAT_USER_SMALL_FILTER_MEMORY 0x00000020
#define DEBUG_FORMAT_USER_SMALL_FILTER_PATHS 0x00000040
#define DEBUG_FORMAT_USER_SMALL_PROCESS_THREAD_DATA 0x00000080
#define DEBUG_FORMAT_USER_SMALL_PRIVATE_READ_WRITE_MEMORY 0x00000100
#define DEBUG_FORMAT_USER_SMALL_NO_OPTIONAL_DATA 0x00000200
#define DEBUG_FORMAT_USER_SMALL_FULL_MEMORY_INFO 0x00000400
#define DEBUG_FORMAT_USER_SMALL_THREAD_INFO 0x00000800
#define DEBUG_FORMAT_USER_SMALL_CODE_SEGMENTS 0x00001000
//
// Dump information file types.
//
// Base dump file, returned when querying for dump files.
#define DEBUG_DUMP_FILE_BASE 0xffffffff
// Single file containing packed page file information.
#define DEBUG_DUMP_FILE_PAGE_FILE_DUMP 0x00000000
#undef INTERFACE
#define INTERFACE IDebugClient2
DECLARE_INTERFACE_(IDebugClient2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugClient.
// The following set of methods start
// the different kinds of debuggees.
// Begins a debug session using the kernel
// debugging protocol. This method selects
// the protocol as the debuggee communication
// mechanism but does not initiate the communication
// itself.
STDMETHOD(AttachKernel)(
THIS_
__in ULONG Flags,
__in_opt PCSTR ConnectOptions
) PURE;
STDMETHOD(GetKernelConnectionOptions)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG OptionsSize
) PURE;
// Updates the connection options for a live
// kernel connection. This can only be used
// to modify parameters for the connection, not
// to switch to a completely different kind of
// connection.
// This method is reentrant.
STDMETHOD(SetKernelConnectionOptions)(
THIS_
__in PCSTR Options
) PURE;
// Starts a process server for remote
// user-mode process control.
// The local process server is server zero.
STDMETHOD(StartProcessServer)(
THIS_
__in ULONG Flags,
__in PCSTR Options,
__in __reserved PVOID Reserved
) PURE;
STDMETHOD(ConnectProcessServer)(
THIS_
__in PCSTR RemoteOptions,
__out PULONG64 Server
) PURE;
STDMETHOD(DisconnectProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Enumerates and describes processes
// accessible through the given process server.
STDMETHOD(GetRunningProcessSystemIds)(
THIS_
__in ULONG64 Server,
__out_ecount_opt(Count) PULONG Ids,
__in ULONG Count,
__out_opt PULONG ActualCount
) PURE;
STDMETHOD(GetRunningProcessSystemIdByExecutableName)(
THIS_
__in ULONG64 Server,
__in PCSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescription)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
// Attaches to a running user-mode process.
STDMETHOD(AttachProcess)(
THIS_
__in ULONG64 Server,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Creates a new user-mode process for debugging.
// CreateFlags are as given to Win32s CreateProcess.
// One of DEBUG_PROCESS or DEBUG_ONLY_THIS_PROCESS
// must be specified.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 Server,
__in PSTR CommandLine,
__in ULONG CreateFlags
) PURE;
// Creates or attaches to a user-mode process, or both.
// If CommandLine is NULL this method operates as
// AttachProcess does. If ProcessId is zero it
// operates as CreateProcess does. If CommandLine is
// non-NULL and ProcessId is non-zero the method first
// starts a process with the given information but
// in a suspended state. The engine then attaches to
// the indicated process. Once the attach is successful
// the suspended process is resumed. This provides
// synchronization between the new process and the
// attachment.
STDMETHOD(CreateProcessAndAttach)(
THIS_
__in ULONG64 Server,
__in_opt PSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Gets and sets process control flags.
STDMETHOD(GetProcessOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetProcessOptions)(
THIS_
__in ULONG Options
) PURE;
// Opens any kind of user- or kernel-mode dump file
// and begins a debug session with the information
// contained within it.
STDMETHOD(OpenDumpFile)(
THIS_
__in PCSTR DumpFile
) PURE;
// Writes a dump file from the current session information.
// The kind of dump file written is determined by the
// kind of session and the type qualifier given.
// For example, if the current session is a kernel
// debug session (DEBUG_CLASS_KERNEL) and the qualifier
// is DEBUG_DUMP_SMALL a small kernel dump will be written.
STDMETHOD(WriteDumpFile)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier
) PURE;
// Indicates that a remote client is ready to
// begin participating in the current session.
// HistoryLimit gives a character limit on
// the amount of output history to be sent.
STDMETHOD(ConnectSession)(
THIS_
__in ULONG Flags,
__in ULONG HistoryLimit
) PURE;
// Indicates that the engine should start accepting
// remote connections. Options specifies connection types
// and their parameters. Supported strings are:
// npipe:Pipe=<Pipe name>
// tcp:Port=<IP port>
STDMETHOD(StartServer)(
THIS_
__in PCSTR Options
) PURE;
// List the servers running on the given machine.
// Uses the line prefix.
STDMETHOD(OutputServers)(
THIS_
__in ULONG OutputControl,
__in PCSTR Machine,
__in ULONG Flags
) PURE;
// Attempts to terminate all processes in the debuggers list.
STDMETHOD(TerminateProcesses)(
THIS
) PURE;
// Attempts to detach from all processes in the debuggers list.
// This requires OS support for debugger detach.
STDMETHOD(DetachProcesses)(
THIS
) PURE;
// Stops the current debug session. If a process
// was created or attached an active EndSession can
// terminate or detach from it.
// If a kernel connection was opened it will be closed but the
// target machine is otherwise unaffected.
STDMETHOD(EndSession)(
THIS_
__in ULONG Flags
) PURE;
// If a process was started and ran to completion
// this method can be used to retrieve its exit code.
STDMETHOD(GetExitCode)(
THIS_
__out PULONG Code
) PURE;
// Client event callbacks are called on the thread
// of the client. In order to give thread
// execution to the engine for callbacks all
// client threads should call DispatchCallbacks
// when they are idle. Callbacks are only
// received when a thread calls DispatchCallbacks
// or WaitForEvent. WaitForEvent can only be
// called by the thread that started the debug
// session so all other client threads should
// call DispatchCallbacks when possible.
// DispatchCallbacks returns when ExitDispatch is used
// to interrupt dispatch or when the timeout expires.
// DispatchCallbacks dispatches callbacks for all
// clients associated with the thread calling
// DispatchCallbacks.
// DispatchCallbacks returns S_FALSE when the
// timeout expires.
STDMETHOD(DispatchCallbacks)(
THIS_
__in ULONG Timeout
) PURE;
// ExitDispatch can be used to interrupt callback
// dispatch when a client thread is needed by the
// client. This method is reentrant and can
// be called from any thread.
STDMETHOD(ExitDispatch)(
THIS_
__in PDEBUG_CLIENT Client
) PURE;
// Clients are specific to the thread that
// created them. Calls from other threads
// fail immediately. The CreateClient method
// is a notable exception; it allows creation
// of a new client for a new thread.
STDMETHOD(CreateClient)(
THIS_
__out PDEBUG_CLIENT* Client
) PURE;
STDMETHOD(GetInputCallbacks)(
THIS_
__out PDEBUG_INPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetInputCallbacks)(
THIS_
__in PDEBUG_INPUT_CALLBACKS Callbacks
) PURE;
// Output callback interfaces are described separately.
STDMETHOD(GetOutputCallbacks)(
THIS_
__out PDEBUG_OUTPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetOutputCallbacks)(
THIS_
__in PDEBUG_OUTPUT_CALLBACKS Callbacks
) PURE;
// Output flags provide control over
// the distribution of output among clients.
// Output masks select which output streams
// should be sent to the output callbacks.
// Only Output calls with a mask that
// contains one of the output mask bits
// will be sent to the output callbacks.
// These methods are reentrant.
// If such access is not synchronized
// disruptions in output may occur.
STDMETHOD(GetOutputMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetOutputMask)(
THIS_
__in ULONG Mask
) PURE;
// These methods allow access to another clients
// output mask. They are necessary for changing
// a clients output mask when it is
// waiting for events. These methods are reentrant
// and can be called from any thread.
STDMETHOD(GetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__out PULONG Mask
) PURE;
STDMETHOD(SetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__in ULONG Mask
) PURE;
// Control the width of an output line for
// commands which produce formatted output.
// This setting is just a suggestion.
STDMETHOD(GetOutputWidth)(
THIS_
__out PULONG Columns
) PURE;
STDMETHOD(SetOutputWidth)(
THIS_
__in ULONG Columns
) PURE;
// Some of the engines output commands produce
// multiple lines of output. A prefix can be
// set that the engine will automatically output
// for each line in that case, allowing a caller
// to control indentation or identifying marks.
// This is not a general setting for any output
// with a newline in it. Methods which use
// the line prefix are marked in their documentation.
STDMETHOD(GetOutputLinePrefix)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PrefixSize
) PURE;
STDMETHOD(SetOutputLinePrefix)(
THIS_
__in_opt PCSTR Prefix
) PURE;
// Returns a string describing the machine
// and user this client represents. The
// specific content of the string varies
// with operating system. If the client is
// remotely connected some network information
// may also be present.
STDMETHOD(GetIdentity)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG IdentitySize
) PURE;
// Format is a printf-like format string
// with one %s where the identity string should go.
STDMETHOD(OutputIdentity)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in PCSTR Format
) PURE;
// Event callbacks allow a client to
// receive notification about changes
// during the debug session.
STDMETHOD(GetEventCallbacks)(
THIS_
__out PDEBUG_EVENT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetEventCallbacks)(
THIS_
__in PDEBUG_EVENT_CALLBACKS Callbacks
) PURE;
// The engine sometimes merges compatible callback
// requests to reduce callback overhead. This is
// most noticeable with output as small pieces of
// output are collected into larger groups to
// reduce the overall number of output callback calls.
// A client can use this method to force all pending
// callbacks to be delivered. This is rarely necessary.
STDMETHOD(FlushCallbacks)(
THIS
) PURE;
// IDebugClient2.
// Functions similarly to WriteDumpFile with
// the addition of the ability to specify
// per-dump-format write control flags.
// Comment is not supported in all formats.
STDMETHOD(WriteDumpFile2)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier,
__in ULONG FormatFlags,
__in_opt PCSTR Comment
) PURE;
// Registers additional files of supporting information
// for a dump file open. This method must be called
// before OpenDumpFile is called.
// The files registered may be opened at the time
// this method is called but generally will not
// be used until OpenDumpFile is called.
STDMETHOD(AddDumpInformationFile)(
THIS_
__in PCSTR InfoFile,
__in ULONG Type
) PURE;
// Requests that the remote process server shut down.
STDMETHOD(EndProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Waits for a started process server to
// exit. Allows an application running a
// process server to monitor the process
// server so that it can tell when a remote
// client has asked for it to exit.
// Returns S_OK if the process server has
// shut down and S_FALSE for a timeout.
STDMETHOD(WaitForProcessServerEnd)(
THIS_
__in ULONG Timeout
) PURE;
// Returns S_OK if the system is configured
// to allow kernel debugging.
STDMETHOD(IsKernelDebuggerEnabled)(
THIS
) PURE;
// Attempts to terminate the current process.
// Exit process events for the process may be generated.
STDMETHOD(TerminateCurrentProcess)(
THIS
) PURE;
// Attempts to detach from the current process.
// This requires OS support for debugger detach.
STDMETHOD(DetachCurrentProcess)(
THIS
) PURE;
// Removes the process from the debuggers process
// list without making any other changes. The process
// will still be marked as being debugged and will
// not run. This allows a debugger to be shut down
// and a new debugger attached without taking the
// process out of the debugged state.
// This is only supported on some system versions.
STDMETHOD(AbandonCurrentProcess)(
THIS
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugClient3
DECLARE_INTERFACE_(IDebugClient3, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugClient.
// The following set of methods start
// the different kinds of debuggees.
// Begins a debug session using the kernel
// debugging protocol. This method selects
// the protocol as the debuggee communication
// mechanism but does not initiate the communication
// itself.
STDMETHOD(AttachKernel)(
THIS_
__in ULONG Flags,
__in_opt PCSTR ConnectOptions
) PURE;
STDMETHOD(GetKernelConnectionOptions)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG OptionsSize
) PURE;
// Updates the connection options for a live
// kernel connection. This can only be used
// to modify parameters for the connection, not
// to switch to a completely different kind of
// connection.
// This method is reentrant.
STDMETHOD(SetKernelConnectionOptions)(
THIS_
__in PCSTR Options
) PURE;
// Starts a process server for remote
// user-mode process control.
// The local process server is server zero.
STDMETHOD(StartProcessServer)(
THIS_
__in ULONG Flags,
__in PCSTR Options,
__in __reserved PVOID Reserved
) PURE;
STDMETHOD(ConnectProcessServer)(
THIS_
__in PCSTR RemoteOptions,
__out PULONG64 Server
) PURE;
STDMETHOD(DisconnectProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Enumerates and describes processes
// accessible through the given process server.
STDMETHOD(GetRunningProcessSystemIds)(
THIS_
__in ULONG64 Server,
__out_ecount_opt(Count) PULONG Ids,
__in ULONG Count,
__out_opt PULONG ActualCount
) PURE;
STDMETHOD(GetRunningProcessSystemIdByExecutableName)(
THIS_
__in ULONG64 Server,
__in PCSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescription)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
// Attaches to a running user-mode process.
STDMETHOD(AttachProcess)(
THIS_
__in ULONG64 Server,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Creates a new user-mode process for debugging.
// CreateFlags are as given to Win32s CreateProcess.
// One of DEBUG_PROCESS or DEBUG_ONLY_THIS_PROCESS
// must be specified.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 Server,
__in PSTR CommandLine,
__in ULONG CreateFlags
) PURE;
// Creates or attaches to a user-mode process, or both.
// If CommandLine is NULL this method operates as
// AttachProcess does. If ProcessId is zero it
// operates as CreateProcess does. If CommandLine is
// non-NULL and ProcessId is non-zero the method first
// starts a process with the given information but
// in a suspended state. The engine then attaches to
// the indicated process. Once the attach is successful
// the suspended process is resumed. This provides
// synchronization between the new process and the
// attachment.
STDMETHOD(CreateProcessAndAttach)(
THIS_
__in ULONG64 Server,
__in_opt PSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Gets and sets process control flags.
STDMETHOD(GetProcessOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetProcessOptions)(
THIS_
__in ULONG Options
) PURE;
// Opens any kind of user- or kernel-mode dump file
// and begins a debug session with the information
// contained within it.
STDMETHOD(OpenDumpFile)(
THIS_
__in PCSTR DumpFile
) PURE;
// Writes a dump file from the current session information.
// The kind of dump file written is determined by the
// kind of session and the type qualifier given.
// For example, if the current session is a kernel
// debug session (DEBUG_CLASS_KERNEL) and the qualifier
// is DEBUG_DUMP_SMALL a small kernel dump will be written.
STDMETHOD(WriteDumpFile)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier
) PURE;
// Indicates that a remote client is ready to
// begin participating in the current session.
// HistoryLimit gives a character limit on
// the amount of output history to be sent.
STDMETHOD(ConnectSession)(
THIS_
__in ULONG Flags,
__in ULONG HistoryLimit
) PURE;
// Indicates that the engine should start accepting
// remote connections. Options specifies connection types
// and their parameters. Supported strings are:
// npipe:Pipe=<Pipe name>
// tcp:Port=<IP port>
STDMETHOD(StartServer)(
THIS_
__in PCSTR Options
) PURE;
// List the servers running on the given machine.
// Uses the line prefix.
STDMETHOD(OutputServers)(
THIS_
__in ULONG OutputControl,
__in PCSTR Machine,
__in ULONG Flags
) PURE;
// Attempts to terminate all processes in the debuggers list.
STDMETHOD(TerminateProcesses)(
THIS
) PURE;
// Attempts to detach from all processes in the debuggers list.
// This requires OS support for debugger detach.
STDMETHOD(DetachProcesses)(
THIS
) PURE;
// Stops the current debug session. If a process
// was created or attached an active EndSession can
// terminate or detach from it.
// If a kernel connection was opened it will be closed but the
// target machine is otherwise unaffected.
STDMETHOD(EndSession)(
THIS_
__in ULONG Flags
) PURE;
// If a process was started and ran to completion
// this method can be used to retrieve its exit code.
STDMETHOD(GetExitCode)(
THIS_
__out PULONG Code
) PURE;
// Client event callbacks are called on the thread
// of the client. In order to give thread
// execution to the engine for callbacks all
// client threads should call DispatchCallbacks
// when they are idle. Callbacks are only
// received when a thread calls DispatchCallbacks
// or WaitForEvent. WaitForEvent can only be
// called by the thread that started the debug
// session so all other client threads should
// call DispatchCallbacks when possible.
// DispatchCallbacks returns when ExitDispatch is used
// to interrupt dispatch or when the timeout expires.
// DispatchCallbacks dispatches callbacks for all
// clients associated with the thread calling
// DispatchCallbacks.
// DispatchCallbacks returns S_FALSE when the
// timeout expires.
STDMETHOD(DispatchCallbacks)(
THIS_
__in ULONG Timeout
) PURE;
// ExitDispatch can be used to interrupt callback
// dispatch when a client thread is needed by the
// client. This method is reentrant and can
// be called from any thread.
STDMETHOD(ExitDispatch)(
THIS_
__in PDEBUG_CLIENT Client
) PURE;
// Clients are specific to the thread that
// created them. Calls from other threads
// fail immediately. The CreateClient method
// is a notable exception; it allows creation
// of a new client for a new thread.
STDMETHOD(CreateClient)(
THIS_
__out PDEBUG_CLIENT* Client
) PURE;
STDMETHOD(GetInputCallbacks)(
THIS_
__out PDEBUG_INPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetInputCallbacks)(
THIS_
__in PDEBUG_INPUT_CALLBACKS Callbacks
) PURE;
// Output callback interfaces are described separately.
STDMETHOD(GetOutputCallbacks)(
THIS_
__out PDEBUG_OUTPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetOutputCallbacks)(
THIS_
__in PDEBUG_OUTPUT_CALLBACKS Callbacks
) PURE;
// Output flags provide control over
// the distribution of output among clients.
// Output masks select which output streams
// should be sent to the output callbacks.
// Only Output calls with a mask that
// contains one of the output mask bits
// will be sent to the output callbacks.
// These methods are reentrant.
// If such access is not synchronized
// disruptions in output may occur.
STDMETHOD(GetOutputMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetOutputMask)(
THIS_
__in ULONG Mask
) PURE;
// These methods allow access to another clients
// output mask. They are necessary for changing
// a clients output mask when it is
// waiting for events. These methods are reentrant
// and can be called from any thread.
STDMETHOD(GetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__out PULONG Mask
) PURE;
STDMETHOD(SetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__in ULONG Mask
) PURE;
// Control the width of an output line for
// commands which produce formatted output.
// This setting is just a suggestion.
STDMETHOD(GetOutputWidth)(
THIS_
__out PULONG Columns
) PURE;
STDMETHOD(SetOutputWidth)(
THIS_
__in ULONG Columns
) PURE;
// Some of the engines output commands produce
// multiple lines of output. A prefix can be
// set that the engine will automatically output
// for each line in that case, allowing a caller
// to control indentation or identifying marks.
// This is not a general setting for any output
// with a newline in it. Methods which use
// the line prefix are marked in their documentation.
STDMETHOD(GetOutputLinePrefix)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PrefixSize
) PURE;
STDMETHOD(SetOutputLinePrefix)(
THIS_
__in_opt PCSTR Prefix
) PURE;
// Returns a string describing the machine
// and user this client represents. The
// specific content of the string varies
// with operating system. If the client is
// remotely connected some network information
// may also be present.
STDMETHOD(GetIdentity)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG IdentitySize
) PURE;
// Format is a printf-like format string
// with one %s where the identity string should go.
STDMETHOD(OutputIdentity)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in PCSTR Format
) PURE;
// Event callbacks allow a client to
// receive notification about changes
// during the debug session.
STDMETHOD(GetEventCallbacks)(
THIS_
__out PDEBUG_EVENT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetEventCallbacks)(
THIS_
__in PDEBUG_EVENT_CALLBACKS Callbacks
) PURE;
// The engine sometimes merges compatible callback
// requests to reduce callback overhead. This is
// most noticeable with output as small pieces of
// output are collected into larger groups to
// reduce the overall number of output callback calls.
// A client can use this method to force all pending
// callbacks to be delivered. This is rarely necessary.
STDMETHOD(FlushCallbacks)(
THIS
) PURE;
// IDebugClient2.
// Functions similarly to WriteDumpFile with
// the addition of the ability to specify
// per-dump-format write control flags.
// Comment is not supported in all formats.
STDMETHOD(WriteDumpFile2)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier,
__in ULONG FormatFlags,
__in_opt PCSTR Comment
) PURE;
// Registers additional files of supporting information
// for a dump file open. This method must be called
// before OpenDumpFile is called.
// The files registered may be opened at the time
// this method is called but generally will not
// be used until OpenDumpFile is called.
STDMETHOD(AddDumpInformationFile)(
THIS_
__in PCSTR InfoFile,
__in ULONG Type
) PURE;
// Requests that the remote process server shut down.
STDMETHOD(EndProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Waits for a started process server to
// exit. Allows an application running a
// process server to monitor the process
// server so that it can tell when a remote
// client has asked for it to exit.
// Returns S_OK if the process server has
// shut down and S_FALSE for a timeout.
STDMETHOD(WaitForProcessServerEnd)(
THIS_
__in ULONG Timeout
) PURE;
// Returns S_OK if the system is configured
// to allow kernel debugging.
STDMETHOD(IsKernelDebuggerEnabled)(
THIS
) PURE;
// Attempts to terminate the current process.
// Exit process events for the process may be generated.
STDMETHOD(TerminateCurrentProcess)(
THIS
) PURE;
// Attempts to detach from the current process.
// This requires OS support for debugger detach.
STDMETHOD(DetachCurrentProcess)(
THIS
) PURE;
// Removes the process from the debuggers process
// list without making any other changes. The process
// will still be marked as being debugged and will
// not run. This allows a debugger to be shut down
// and a new debugger attached without taking the
// process out of the debugged state.
// This is only supported on some system versions.
STDMETHOD(AbandonCurrentProcess)(
THIS
) PURE;
// IDebugClient3.
STDMETHOD(GetRunningProcessSystemIdByExecutableNameWide)(
THIS_
__in ULONG64 Server,
__in PCWSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescriptionWide)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PWSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PWSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
STDMETHOD(CreateProcessWide)(
THIS_
__in ULONG64 Server,
__in PWSTR CommandLine,
__in ULONG CreateFlags
) PURE;
STDMETHOD(CreateProcessAndAttachWide)(
THIS_
__in ULONG64 Server,
__in_opt PWSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
};
//
// Special indices for GetDumpFile to return
// alternate filenames.
//
// Special index that returns the name of the last .dmp file
// that failed to load (whether directly or from inside a
// .cab file).
#define DEBUG_DUMP_FILE_LOAD_FAILED_INDEX 0xffffffff
// Index that returns last cab file opened, this is needed to
// get the name of original CAB file since debugger returns the
// extracted dump file in the GetDumpFile method.
#define DEBUG_DUMP_FILE_ORIGINAL_CAB_INDEX 0xfffffffe
#undef INTERFACE
#define INTERFACE IDebugClient4
DECLARE_INTERFACE_(IDebugClient4, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugClient.
// The following set of methods start
// the different kinds of debuggees.
// Begins a debug session using the kernel
// debugging protocol. This method selects
// the protocol as the debuggee communication
// mechanism but does not initiate the communication
// itself.
STDMETHOD(AttachKernel)(
THIS_
__in ULONG Flags,
__in_opt PCSTR ConnectOptions
) PURE;
STDMETHOD(GetKernelConnectionOptions)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG OptionsSize
) PURE;
// Updates the connection options for a live
// kernel connection. This can only be used
// to modify parameters for the connection, not
// to switch to a completely different kind of
// connection.
// This method is reentrant.
STDMETHOD(SetKernelConnectionOptions)(
THIS_
__in PCSTR Options
) PURE;
// Starts a process server for remote
// user-mode process control.
// The local process server is server zero.
STDMETHOD(StartProcessServer)(
THIS_
__in ULONG Flags,
__in PCSTR Options,
__in __reserved PVOID Reserved
) PURE;
STDMETHOD(ConnectProcessServer)(
THIS_
__in PCSTR RemoteOptions,
__out PULONG64 Server
) PURE;
STDMETHOD(DisconnectProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Enumerates and describes processes
// accessible through the given process server.
STDMETHOD(GetRunningProcessSystemIds)(
THIS_
__in ULONG64 Server,
__out_ecount_opt(Count) PULONG Ids,
__in ULONG Count,
__out_opt PULONG ActualCount
) PURE;
STDMETHOD(GetRunningProcessSystemIdByExecutableName)(
THIS_
__in ULONG64 Server,
__in PCSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescription)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
// Attaches to a running user-mode process.
STDMETHOD(AttachProcess)(
THIS_
__in ULONG64 Server,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Creates a new user-mode process for debugging.
// CreateFlags are as given to Win32s CreateProcess.
// One of DEBUG_PROCESS or DEBUG_ONLY_THIS_PROCESS
// must be specified.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 Server,
__in PSTR CommandLine,
__in ULONG CreateFlags
) PURE;
// Creates or attaches to a user-mode process, or both.
// If CommandLine is NULL this method operates as
// AttachProcess does. If ProcessId is zero it
// operates as CreateProcess does. If CommandLine is
// non-NULL and ProcessId is non-zero the method first
// starts a process with the given information but
// in a suspended state. The engine then attaches to
// the indicated process. Once the attach is successful
// the suspended process is resumed. This provides
// synchronization between the new process and the
// attachment.
STDMETHOD(CreateProcessAndAttach)(
THIS_
__in ULONG64 Server,
__in_opt PSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Gets and sets process control flags.
STDMETHOD(GetProcessOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetProcessOptions)(
THIS_
__in ULONG Options
) PURE;
// Opens any kind of user- or kernel-mode dump file
// and begins a debug session with the information
// contained within it.
STDMETHOD(OpenDumpFile)(
THIS_
__in PCSTR DumpFile
) PURE;
// Writes a dump file from the current session information.
// The kind of dump file written is determined by the
// kind of session and the type qualifier given.
// For example, if the current session is a kernel
// debug session (DEBUG_CLASS_KERNEL) and the qualifier
// is DEBUG_DUMP_SMALL a small kernel dump will be written.
STDMETHOD(WriteDumpFile)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier
) PURE;
// Indicates that a remote client is ready to
// begin participating in the current session.
// HistoryLimit gives a character limit on
// the amount of output history to be sent.
STDMETHOD(ConnectSession)(
THIS_
__in ULONG Flags,
__in ULONG HistoryLimit
) PURE;
// Indicates that the engine should start accepting
// remote connections. Options specifies connection types
// and their parameters. Supported strings are:
// npipe:Pipe=<Pipe name>
// tcp:Port=<IP port>
STDMETHOD(StartServer)(
THIS_
__in PCSTR Options
) PURE;
// List the servers running on the given machine.
// Uses the line prefix.
STDMETHOD(OutputServers)(
THIS_
__in ULONG OutputControl,
__in PCSTR Machine,
__in ULONG Flags
) PURE;
// Attempts to terminate all processes in the debuggers list.
STDMETHOD(TerminateProcesses)(
THIS
) PURE;
// Attempts to detach from all processes in the debuggers list.
// This requires OS support for debugger detach.
STDMETHOD(DetachProcesses)(
THIS
) PURE;
// Stops the current debug session. If a process
// was created or attached an active EndSession can
// terminate or detach from it.
// If a kernel connection was opened it will be closed but the
// target machine is otherwise unaffected.
STDMETHOD(EndSession)(
THIS_
__in ULONG Flags
) PURE;
// If a process was started and ran to completion
// this method can be used to retrieve its exit code.
STDMETHOD(GetExitCode)(
THIS_
__out PULONG Code
) PURE;
// Client event callbacks are called on the thread
// of the client. In order to give thread
// execution to the engine for callbacks all
// client threads should call DispatchCallbacks
// when they are idle. Callbacks are only
// received when a thread calls DispatchCallbacks
// or WaitForEvent. WaitForEvent can only be
// called by the thread that started the debug
// session so all other client threads should
// call DispatchCallbacks when possible.
// DispatchCallbacks returns when ExitDispatch is used
// to interrupt dispatch or when the timeout expires.
// DispatchCallbacks dispatches callbacks for all
// clients associated with the thread calling
// DispatchCallbacks.
// DispatchCallbacks returns S_FALSE when the
// timeout expires.
STDMETHOD(DispatchCallbacks)(
THIS_
__in ULONG Timeout
) PURE;
// ExitDispatch can be used to interrupt callback
// dispatch when a client thread is needed by the
// client. This method is reentrant and can
// be called from any thread.
STDMETHOD(ExitDispatch)(
THIS_
__in PDEBUG_CLIENT Client
) PURE;
// Clients are specific to the thread that
// created them. Calls from other threads
// fail immediately. The CreateClient method
// is a notable exception; it allows creation
// of a new client for a new thread.
STDMETHOD(CreateClient)(
THIS_
__out PDEBUG_CLIENT* Client
) PURE;
STDMETHOD(GetInputCallbacks)(
THIS_
__out PDEBUG_INPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetInputCallbacks)(
THIS_
__in PDEBUG_INPUT_CALLBACKS Callbacks
) PURE;
// Output callback interfaces are described separately.
STDMETHOD(GetOutputCallbacks)(
THIS_
__out PDEBUG_OUTPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetOutputCallbacks)(
THIS_
__in PDEBUG_OUTPUT_CALLBACKS Callbacks
) PURE;
// Output flags provide control over
// the distribution of output among clients.
// Output masks select which output streams
// should be sent to the output callbacks.
// Only Output calls with a mask that
// contains one of the output mask bits
// will be sent to the output callbacks.
// These methods are reentrant.
// If such access is not synchronized
// disruptions in output may occur.
STDMETHOD(GetOutputMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetOutputMask)(
THIS_
__in ULONG Mask
) PURE;
// These methods allow access to another clients
// output mask. They are necessary for changing
// a clients output mask when it is
// waiting for events. These methods are reentrant
// and can be called from any thread.
STDMETHOD(GetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__out PULONG Mask
) PURE;
STDMETHOD(SetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__in ULONG Mask
) PURE;
// Control the width of an output line for
// commands which produce formatted output.
// This setting is just a suggestion.
STDMETHOD(GetOutputWidth)(
THIS_
__out PULONG Columns
) PURE;
STDMETHOD(SetOutputWidth)(
THIS_
__in ULONG Columns
) PURE;
// Some of the engines output commands produce
// multiple lines of output. A prefix can be
// set that the engine will automatically output
// for each line in that case, allowing a caller
// to control indentation or identifying marks.
// This is not a general setting for any output
// with a newline in it. Methods which use
// the line prefix are marked in their documentation.
STDMETHOD(GetOutputLinePrefix)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PrefixSize
) PURE;
STDMETHOD(SetOutputLinePrefix)(
THIS_
__in_opt PCSTR Prefix
) PURE;
// Returns a string describing the machine
// and user this client represents. The
// specific content of the string varies
// with operating system. If the client is
// remotely connected some network information
// may also be present.
STDMETHOD(GetIdentity)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG IdentitySize
) PURE;
// Format is a printf-like format string
// with one %s where the identity string should go.
STDMETHOD(OutputIdentity)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in PCSTR Format
) PURE;
// Event callbacks allow a client to
// receive notification about changes
// during the debug session.
STDMETHOD(GetEventCallbacks)(
THIS_
__out PDEBUG_EVENT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetEventCallbacks)(
THIS_
__in PDEBUG_EVENT_CALLBACKS Callbacks
) PURE;
// The engine sometimes merges compatible callback
// requests to reduce callback overhead. This is
// most noticeable with output as small pieces of
// output are collected into larger groups to
// reduce the overall number of output callback calls.
// A client can use this method to force all pending
// callbacks to be delivered. This is rarely necessary.
STDMETHOD(FlushCallbacks)(
THIS
) PURE;
// IDebugClient2.
// Functions similarly to WriteDumpFile with
// the addition of the ability to specify
// per-dump-format write control flags.
// Comment is not supported in all formats.
STDMETHOD(WriteDumpFile2)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier,
__in ULONG FormatFlags,
__in_opt PCSTR Comment
) PURE;
// Registers additional files of supporting information
// for a dump file open. This method must be called
// before OpenDumpFile is called.
// The files registered may be opened at the time
// this method is called but generally will not
// be used until OpenDumpFile is called.
STDMETHOD(AddDumpInformationFile)(
THIS_
__in PCSTR InfoFile,
__in ULONG Type
) PURE;
// Requests that the remote process server shut down.
STDMETHOD(EndProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Waits for a started process server to
// exit. Allows an application running a
// process server to monitor the process
// server so that it can tell when a remote
// client has asked for it to exit.
// Returns S_OK if the process server has
// shut down and S_FALSE for a timeout.
STDMETHOD(WaitForProcessServerEnd)(
THIS_
__in ULONG Timeout
) PURE;
// Returns S_OK if the system is configured
// to allow kernel debugging.
STDMETHOD(IsKernelDebuggerEnabled)(
THIS
) PURE;
// Attempts to terminate the current process.
// Exit process events for the process may be generated.
STDMETHOD(TerminateCurrentProcess)(
THIS
) PURE;
// Attempts to detach from the current process.
// This requires OS support for debugger detach.
STDMETHOD(DetachCurrentProcess)(
THIS
) PURE;
// Removes the process from the debuggers process
// list without making any other changes. The process
// will still be marked as being debugged and will
// not run. This allows a debugger to be shut down
// and a new debugger attached without taking the
// process out of the debugged state.
// This is only supported on some system versions.
STDMETHOD(AbandonCurrentProcess)(
THIS
) PURE;
// IDebugClient3.
STDMETHOD(GetRunningProcessSystemIdByExecutableNameWide)(
THIS_
__in ULONG64 Server,
__in PCWSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescriptionWide)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PWSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PWSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
STDMETHOD(CreateProcessWide)(
THIS_
__in ULONG64 Server,
__in PWSTR CommandLine,
__in ULONG CreateFlags
) PURE;
STDMETHOD(CreateProcessAndAttachWide)(
THIS_
__in ULONG64 Server,
__in_opt PWSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// IDebugClient4.
// In the following methods both a filename and a file
// handle can be passed in. If a file handle is given
// the filename may be omitted, although providing it
// allows the debugger to properly report the name when
// queried.
// File handles cannot be used in remote calls.
STDMETHOD(OpenDumpFileWide)(
THIS_
__in_opt PCWSTR FileName,
__in ULONG64 FileHandle
) PURE;
STDMETHOD(WriteDumpFileWide)(
THIS_
__in_opt PCWSTR FileName,
__in ULONG64 FileHandle,
__in ULONG Qualifier,
__in ULONG FormatFlags,
__in_opt PCWSTR Comment
) PURE;
STDMETHOD(AddDumpInformationFileWide)(
THIS_
__in_opt PCWSTR FileName,
__in ULONG64 FileHandle,
__in ULONG Type
) PURE;
// These methods can be used to retrieve
// file information for all targets that
// involve files.
STDMETHOD(GetNumberDumpFiles)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetDumpFile)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Handle,
__out PULONG Type
) PURE;
STDMETHOD(GetDumpFileWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Handle,
__out PULONG Type
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugClient5
DECLARE_INTERFACE_(IDebugClient5, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugClient.
// The following set of methods start
// the different kinds of debuggees.
// Begins a debug session using the kernel
// debugging protocol. This method selects
// the protocol as the debuggee communication
// mechanism but does not initiate the communication
// itself.
STDMETHOD(AttachKernel)(
THIS_
__in ULONG Flags,
__in_opt PCSTR ConnectOptions
) PURE;
STDMETHOD(GetKernelConnectionOptions)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG OptionsSize
) PURE;
// Updates the connection options for a live
// kernel connection. This can only be used
// to modify parameters for the connection, not
// to switch to a completely different kind of
// connection.
// This method is reentrant.
STDMETHOD(SetKernelConnectionOptions)(
THIS_
__in PCSTR Options
) PURE;
// Starts a process server for remote
// user-mode process control.
// The local process server is server zero.
STDMETHOD(StartProcessServer)(
THIS_
__in ULONG Flags,
__in PCSTR Options,
__in __reserved PVOID Reserved
) PURE;
STDMETHOD(ConnectProcessServer)(
THIS_
__in PCSTR RemoteOptions,
__out PULONG64 Server
) PURE;
STDMETHOD(DisconnectProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Enumerates and describes processes
// accessible through the given process server.
STDMETHOD(GetRunningProcessSystemIds)(
THIS_
__in ULONG64 Server,
__out_ecount_opt(Count) PULONG Ids,
__in ULONG Count,
__out_opt PULONG ActualCount
) PURE;
STDMETHOD(GetRunningProcessSystemIdByExecutableName)(
THIS_
__in ULONG64 Server,
__in PCSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescription)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
// Attaches to a running user-mode process.
STDMETHOD(AttachProcess)(
THIS_
__in ULONG64 Server,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Creates a new user-mode process for debugging.
// CreateFlags are as given to Win32s CreateProcess.
// One of DEBUG_PROCESS or DEBUG_ONLY_THIS_PROCESS
// must be specified.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 Server,
__in PSTR CommandLine,
__in ULONG CreateFlags
) PURE;
// Creates or attaches to a user-mode process, or both.
// If CommandLine is NULL this method operates as
// AttachProcess does. If ProcessId is zero it
// operates as CreateProcess does. If CommandLine is
// non-NULL and ProcessId is non-zero the method first
// starts a process with the given information but
// in a suspended state. The engine then attaches to
// the indicated process. Once the attach is successful
// the suspended process is resumed. This provides
// synchronization between the new process and the
// attachment.
STDMETHOD(CreateProcessAndAttach)(
THIS_
__in ULONG64 Server,
__in_opt PSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Gets and sets process control flags.
STDMETHOD(GetProcessOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveProcessOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetProcessOptions)(
THIS_
__in ULONG Options
) PURE;
// Opens any kind of user- or kernel-mode dump file
// and begins a debug session with the information
// contained within it.
STDMETHOD(OpenDumpFile)(
THIS_
__in PCSTR DumpFile
) PURE;
// Writes a dump file from the current session information.
// The kind of dump file written is determined by the
// kind of session and the type qualifier given.
// For example, if the current session is a kernel
// debug session (DEBUG_CLASS_KERNEL) and the qualifier
// is DEBUG_DUMP_SMALL a small kernel dump will be written.
STDMETHOD(WriteDumpFile)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier
) PURE;
// Indicates that a remote client is ready to
// begin participating in the current session.
// HistoryLimit gives a character limit on
// the amount of output history to be sent.
STDMETHOD(ConnectSession)(
THIS_
__in ULONG Flags,
__in ULONG HistoryLimit
) PURE;
// Indicates that the engine should start accepting
// remote connections. Options specifies connection types
// and their parameters. Supported strings are:
// npipe:Pipe=<Pipe name>
// tcp:Port=<IP port>
STDMETHOD(StartServer)(
THIS_
__in PCSTR Options
) PURE;
// List the servers running on the given machine.
// Uses the line prefix.
STDMETHOD(OutputServers)(
THIS_
__in ULONG OutputControl,
__in PCSTR Machine,
__in ULONG Flags
) PURE;
// Attempts to terminate all processes in the debuggers list.
STDMETHOD(TerminateProcesses)(
THIS
) PURE;
// Attempts to detach from all processes in the debuggers list.
// This requires OS support for debugger detach.
STDMETHOD(DetachProcesses)(
THIS
) PURE;
// Stops the current debug session. If a process
// was created or attached an active EndSession can
// terminate or detach from it.
// If a kernel connection was opened it will be closed but the
// target machine is otherwise unaffected.
STDMETHOD(EndSession)(
THIS_
__in ULONG Flags
) PURE;
// If a process was started and ran to completion
// this method can be used to retrieve its exit code.
STDMETHOD(GetExitCode)(
THIS_
__out PULONG Code
) PURE;
// Client event callbacks are called on the thread
// of the client. In order to give thread
// execution to the engine for callbacks all
// client threads should call DispatchCallbacks
// when they are idle. Callbacks are only
// received when a thread calls DispatchCallbacks
// or WaitForEvent. WaitForEvent can only be
// called by the thread that started the debug
// session so all other client threads should
// call DispatchCallbacks when possible.
// DispatchCallbacks returns when ExitDispatch is used
// to interrupt dispatch or when the timeout expires.
// DispatchCallbacks dispatches callbacks for all
// clients associated with the thread calling
// DispatchCallbacks.
// DispatchCallbacks returns S_FALSE when the
// timeout expires.
STDMETHOD(DispatchCallbacks)(
THIS_
__in ULONG Timeout
) PURE;
// ExitDispatch can be used to interrupt callback
// dispatch when a client thread is needed by the
// client. This method is reentrant and can
// be called from any thread.
STDMETHOD(ExitDispatch)(
THIS_
__in PDEBUG_CLIENT Client
) PURE;
// Clients are specific to the thread that
// created them. Calls from other threads
// fail immediately. The CreateClient method
// is a notable exception; it allows creation
// of a new client for a new thread.
STDMETHOD(CreateClient)(
THIS_
__out PDEBUG_CLIENT* Client
) PURE;
STDMETHOD(GetInputCallbacks)(
THIS_
__out PDEBUG_INPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetInputCallbacks)(
THIS_
__in PDEBUG_INPUT_CALLBACKS Callbacks
) PURE;
// Output callback interfaces are described separately.
STDMETHOD(GetOutputCallbacks)(
THIS_
__out PDEBUG_OUTPUT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetOutputCallbacks)(
THIS_
__in PDEBUG_OUTPUT_CALLBACKS Callbacks
) PURE;
// Output flags provide control over
// the distribution of output among clients.
// Output masks select which output streams
// should be sent to the output callbacks.
// Only Output calls with a mask that
// contains one of the output mask bits
// will be sent to the output callbacks.
// These methods are reentrant.
// If such access is not synchronized
// disruptions in output may occur.
STDMETHOD(GetOutputMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetOutputMask)(
THIS_
__in ULONG Mask
) PURE;
// These methods allow access to another clients
// output mask. They are necessary for changing
// a clients output mask when it is
// waiting for events. These methods are reentrant
// and can be called from any thread.
STDMETHOD(GetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__out PULONG Mask
) PURE;
STDMETHOD(SetOtherOutputMask)(
THIS_
__in PDEBUG_CLIENT Client,
__in ULONG Mask
) PURE;
// Control the width of an output line for
// commands which produce formatted output.
// This setting is just a suggestion.
STDMETHOD(GetOutputWidth)(
THIS_
__out PULONG Columns
) PURE;
STDMETHOD(SetOutputWidth)(
THIS_
__in ULONG Columns
) PURE;
// Some of the engines output commands produce
// multiple lines of output. A prefix can be
// set that the engine will automatically output
// for each line in that case, allowing a caller
// to control indentation or identifying marks.
// This is not a general setting for any output
// with a newline in it. Methods which use
// the line prefix are marked in their documentation.
STDMETHOD(GetOutputLinePrefix)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PrefixSize
) PURE;
STDMETHOD(SetOutputLinePrefix)(
THIS_
__in_opt PCSTR Prefix
) PURE;
// Returns a string describing the machine
// and user this client represents. The
// specific content of the string varies
// with operating system. If the client is
// remotely connected some network information
// may also be present.
STDMETHOD(GetIdentity)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG IdentitySize
) PURE;
// Format is a printf-like format string
// with one %s where the identity string should go.
STDMETHOD(OutputIdentity)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in PCSTR Format
) PURE;
// Event callbacks allow a client to
// receive notification about changes
// during the debug session.
STDMETHOD(GetEventCallbacks)(
THIS_
__out PDEBUG_EVENT_CALLBACKS* Callbacks
) PURE;
STDMETHOD(SetEventCallbacks)(
THIS_
__in PDEBUG_EVENT_CALLBACKS Callbacks
) PURE;
// The engine sometimes merges compatible callback
// requests to reduce callback overhead. This is
// most noticeable with output as small pieces of
// output are collected into larger groups to
// reduce the overall number of output callback calls.
// A client can use this method to force all pending
// callbacks to be delivered. This is rarely necessary.
STDMETHOD(FlushCallbacks)(
THIS
) PURE;
// IDebugClient2.
// Functions similarly to WriteDumpFile with
// the addition of the ability to specify
// per-dump-format write control flags.
// Comment is not supported in all formats.
STDMETHOD(WriteDumpFile2)(
THIS_
__in PCSTR DumpFile,
__in ULONG Qualifier,
__in ULONG FormatFlags,
__in_opt PCSTR Comment
) PURE;
// Registers additional files of supporting information
// for a dump file open. This method must be called
// before OpenDumpFile is called.
// The files registered may be opened at the time
// this method is called but generally will not
// be used until OpenDumpFile is called.
STDMETHOD(AddDumpInformationFile)(
THIS_
__in PCSTR InfoFile,
__in ULONG Type
) PURE;
// Requests that the remote process server shut down.
STDMETHOD(EndProcessServer)(
THIS_
__in ULONG64 Server
) PURE;
// Waits for a started process server to
// exit. Allows an application running a
// process server to monitor the process
// server so that it can tell when a remote
// client has asked for it to exit.
// Returns S_OK if the process server has
// shut down and S_FALSE for a timeout.
STDMETHOD(WaitForProcessServerEnd)(
THIS_
__in ULONG Timeout
) PURE;
// Returns S_OK if the system is configured
// to allow kernel debugging.
STDMETHOD(IsKernelDebuggerEnabled)(
THIS
) PURE;
// Attempts to terminate the current process.
// Exit process events for the process may be generated.
STDMETHOD(TerminateCurrentProcess)(
THIS
) PURE;
// Attempts to detach from the current process.
// This requires OS support for debugger detach.
STDMETHOD(DetachCurrentProcess)(
THIS
) PURE;
// Removes the process from the debuggers process
// list without making any other changes. The process
// will still be marked as being debugged and will
// not run. This allows a debugger to be shut down
// and a new debugger attached without taking the
// process out of the debugged state.
// This is only supported on some system versions.
STDMETHOD(AbandonCurrentProcess)(
THIS
) PURE;
// IDebugClient3.
STDMETHOD(GetRunningProcessSystemIdByExecutableNameWide)(
THIS_
__in ULONG64 Server,
__in PCWSTR ExeName,
__in ULONG Flags,
__out PULONG Id
) PURE;
STDMETHOD(GetRunningProcessDescriptionWide)(
THIS_
__in ULONG64 Server,
__in ULONG SystemId,
__in ULONG Flags,
__out_ecount_opt(ExeNameSize) PWSTR ExeName,
__in ULONG ExeNameSize,
__out_opt PULONG ActualExeNameSize,
__out_ecount_opt(DescriptionSize) PWSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG ActualDescriptionSize
) PURE;
STDMETHOD(CreateProcessWide)(
THIS_
__in ULONG64 Server,
__in PWSTR CommandLine,
__in ULONG CreateFlags
) PURE;
STDMETHOD(CreateProcessAndAttachWide)(
THIS_
__in ULONG64 Server,
__in_opt PWSTR CommandLine,
__in ULONG CreateFlags,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// IDebugClient4.
// In the following methods both a filename and a file
// handle can be passed in. If a file handle is given
// the filename may be omitted, although providing it
// allows the debugger to properly report the name when
// queried.
// File handles cannot be used in remote calls.
STDMETHOD(OpenDumpFileWide)(
THIS_
__in_opt PCWSTR FileName,
__in ULONG64 FileHandle
) PURE;
STDMETHOD(WriteDumpFileWide)(
THIS_
__in_opt PCWSTR FileName,
__in ULONG64 FileHandle,
__in ULONG Qualifier,
__in ULONG FormatFlags,
__in_opt PCWSTR Comment
) PURE;
STDMETHOD(AddDumpInformationFileWide)(
THIS_
__in_opt PCWSTR FileName,
__in ULONG64 FileHandle,
__in ULONG Type
) PURE;
// These methods can be used to retrieve
// file information for all targets that
// involve files.
STDMETHOD(GetNumberDumpFiles)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetDumpFile)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Handle,
__out PULONG Type
) PURE;
STDMETHOD(GetDumpFileWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Handle,
__out PULONG Type
) PURE;
// IDebugClient5.
STDMETHOD(AttachKernelWide)(
THIS_
__in ULONG Flags,
__in_opt PCWSTR ConnectOptions
) PURE;
STDMETHOD(GetKernelConnectionOptionsWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG OptionsSize
) PURE;
STDMETHOD(SetKernelConnectionOptionsWide)(
THIS_
__in PCWSTR Options
) PURE;
STDMETHOD(StartProcessServerWide)(
THIS_
__in ULONG Flags,
__in PCWSTR Options,
__in __reserved PVOID Reserved
) PURE;
STDMETHOD(ConnectProcessServerWide)(
THIS_
__in PCWSTR RemoteOptions,
__out PULONG64 Server
) PURE;
STDMETHOD(StartServerWide)(
THIS_
__in PCWSTR Options
) PURE;
STDMETHOD(OutputServersWide)(
THIS_
__in ULONG OutputControl,
__in PCWSTR Machine,
__in ULONG Flags
) PURE;
STDMETHOD(GetOutputCallbacksWide)(
THIS_
__out PDEBUG_OUTPUT_CALLBACKS_WIDE* Callbacks
) PURE;
STDMETHOD(SetOutputCallbacksWide)(
THIS_
__in PDEBUG_OUTPUT_CALLBACKS_WIDE Callbacks
) PURE;
STDMETHOD(GetOutputLinePrefixWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PrefixSize
) PURE;
STDMETHOD(SetOutputLinePrefixWide)(
THIS_
__in_opt PCWSTR Prefix
) PURE;
STDMETHOD(GetIdentityWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG IdentitySize
) PURE;
STDMETHOD(OutputIdentityWide)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in PCWSTR Format
) PURE;
STDMETHOD(GetEventCallbacksWide)(
THIS_
__out PDEBUG_EVENT_CALLBACKS_WIDE* Callbacks
) PURE;
STDMETHOD(SetEventCallbacksWide)(
THIS_
__in PDEBUG_EVENT_CALLBACKS_WIDE Callbacks
) PURE;
STDMETHOD(CreateProcess2)(
THIS_
__in ULONG64 Server,
__in PSTR CommandLine,
__in_bcount(OptionsBufferSize) PVOID OptionsBuffer,
__in ULONG OptionsBufferSize,
__in_opt PCSTR InitialDirectory,
__in_opt PCSTR Environment
) PURE;
STDMETHOD(CreateProcess2Wide)(
THIS_
__in ULONG64 Server,
__in PWSTR CommandLine,
__in_bcount(OptionsBufferSize) PVOID OptionsBuffer,
__in ULONG OptionsBufferSize,
__in_opt PCWSTR InitialDirectory,
__in_opt PCWSTR Environment
) PURE;
STDMETHOD(CreateProcessAndAttach2)(
THIS_
__in ULONG64 Server,
__in_opt PSTR CommandLine,
__in_bcount(OptionsBufferSize) PVOID OptionsBuffer,
__in ULONG OptionsBufferSize,
__in_opt PCSTR InitialDirectory,
__in_opt PCSTR Environment,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
STDMETHOD(CreateProcessAndAttach2Wide)(
THIS_
__in ULONG64 Server,
__in_opt PWSTR CommandLine,
__in_bcount(OptionsBufferSize) PVOID OptionsBuffer,
__in ULONG OptionsBufferSize,
__in_opt PCWSTR InitialDirectory,
__in_opt PCWSTR Environment,
__in ULONG ProcessId,
__in ULONG AttachFlags
) PURE;
// Helpers for saving and restoring the
// current output line prefix.
STDMETHOD(PushOutputLinePrefix)(
THIS_
__in_opt PCSTR NewPrefix,
__out PULONG64 Handle
) PURE;
STDMETHOD(PushOutputLinePrefixWide)(
THIS_
__in_opt PCWSTR NewPrefix,
__out PULONG64 Handle
) PURE;
STDMETHOD(PopOutputLinePrefix)(
THIS_
__in ULONG64 Handle
) PURE;
// Queries to determine if any clients
// could potentially respond to the given callback.
STDMETHOD(GetNumberInputCallbacks)(
THIS_
__out PULONG Count
) PURE;
STDMETHOD(GetNumberOutputCallbacks)(
THIS_
__out PULONG Count
) PURE;
STDMETHOD(GetNumberEventCallbacks)(
THIS_
__in ULONG EventFlags,
__out PULONG Count
) PURE;
// Control over locking the session against
// undesired quits. The quit lock string
// cannot be retrieved from a secure session.
STDMETHOD(GetQuitLockString)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(SetQuitLockString)(
THIS_
__in PCSTR String
) PURE;
STDMETHOD(GetQuitLockStringWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(SetQuitLockStringWide)(
THIS_
__in PCWSTR String
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugControl.
//
//----------------------------------------------------------------------------
// Execution status codes used for waiting,
// for returning current status and for
// event method return values.
#define DEBUG_STATUS_NO_CHANGE 0
#define DEBUG_STATUS_GO 1
#define DEBUG_STATUS_GO_HANDLED 2
#define DEBUG_STATUS_GO_NOT_HANDLED 3
#define DEBUG_STATUS_STEP_OVER 4
#define DEBUG_STATUS_STEP_INTO 5
#define DEBUG_STATUS_BREAK 6
#define DEBUG_STATUS_NO_DEBUGGEE 7
#define DEBUG_STATUS_STEP_BRANCH 8
#define DEBUG_STATUS_IGNORE_EVENT 9
#define DEBUG_STATUS_RESTART_REQUESTED 10
#define DEBUG_STATUS_MASK 0xf
// This bit is added in DEBUG_CES_EXECUTION_STATUS
// notifications when the engines execution status
// is changing due to operations performed during
// a wait, such as making synchronous callbacks. If
// the bit is not set the execution status is changing
// due to a wait being satisfied.
#define DEBUG_STATUS_INSIDE_WAIT 0x100000000
// Output control flags.
// Output generated by methods called by this
// client will be sent only to this clients
// output callbacks.
#define DEBUG_OUTCTL_THIS_CLIENT 0x00000000
// Output will be sent to all clients.
#define DEBUG_OUTCTL_ALL_CLIENTS 0x00000001
// Output will be sent to all clients except
// the client generating the output.
#define DEBUG_OUTCTL_ALL_OTHER_CLIENTS 0x00000002
// Output will be discarded immediately and will not
// be logged or sent to callbacks.
#define DEBUG_OUTCTL_IGNORE 0x00000003
// Output will be logged but not sent to callbacks.
#define DEBUG_OUTCTL_LOG_ONLY 0x00000004
// All send control bits.
#define DEBUG_OUTCTL_SEND_MASK 0x00000007
// Do not place output from this client in
// the global log file.
#define DEBUG_OUTCTL_NOT_LOGGED 0x00000008
// Send output to clients regardless of whether the
// mask allows it or not.
#define DEBUG_OUTCTL_OVERRIDE_MASK 0x00000010
// Special value which means leave the output settings
// unchanged.
#define DEBUG_OUTCTL_AMBIENT 0xffffffff
// Interrupt types.
// Force a break in if the debuggee is running.
#define DEBUG_INTERRUPT_ACTIVE 0
// Notify but do not force a break in.
#define DEBUG_INTERRUPT_PASSIVE 1
// Try and get the current engine operation to
// complete so that the engine will be available
// again. If no wait is active this is the same
// as a passive interrupt. If a wait is active
// this will try to cause the wait to fail without
// breaking in to the debuggee. There is
// no guarantee that issuing an exit interrupt
// will cause the engine to become available
// as not all operations are arbitrarily
// interruptible.
#define DEBUG_INTERRUPT_EXIT 2
// OutputCurrentState flags. These flags
// allow a particular type of information
// to be displayed but do not guarantee
// that it will be displayed. Other global
// settings may override these flags or
// the particular state may not be available.
// For example, source line information may
// not be present so source line information
// may not be displayed.
#define DEBUG_CURRENT_DEFAULT 0x0000000f
#define DEBUG_CURRENT_SYMBOL 0x00000001
#define DEBUG_CURRENT_DISASM 0x00000002
#define DEBUG_CURRENT_REGISTERS 0x00000004
#define DEBUG_CURRENT_SOURCE_LINE 0x00000008
//
// Disassemble flags.
//
// Compute the effective address from current register
// information and display it.
#define DEBUG_DISASM_EFFECTIVE_ADDRESS 0x00000001
// If the current disassembly offset has an exact
// symbol match output the symbol.
#define DEBUG_DISASM_MATCHING_SYMBOLS 0x00000002
// Output the source line number for each disassembly offset.
#define DEBUG_DISASM_SOURCE_LINE_NUMBER 0x00000004
// Output the source file name (no path) for each disassembly offset.
#define DEBUG_DISASM_SOURCE_FILE_NAME 0x00000008
// Code interpretation levels for stepping
// and other operations.
#define DEBUG_LEVEL_SOURCE 0
#define DEBUG_LEVEL_ASSEMBLY 1
// Engine control flags.
#define DEBUG_ENGOPT_IGNORE_DBGHELP_VERSION 0x00000001
#define DEBUG_ENGOPT_IGNORE_EXTENSION_VERSIONS 0x00000002
// If neither allow nor disallow is specified
// the engine will pick one based on what kind
// of debugging is going on.
#define DEBUG_ENGOPT_ALLOW_NETWORK_PATHS 0x00000004
#define DEBUG_ENGOPT_DISALLOW_NETWORK_PATHS 0x00000008
#define DEBUG_ENGOPT_NETWORK_PATHS (0x00000004 | 0x00000008)
// Ignore loader-generated first-chance exceptions.
#define DEBUG_ENGOPT_IGNORE_LOADER_EXCEPTIONS 0x00000010
// Break in on a debuggees initial event. In user-mode
// this will break at the initial system breakpoint
// for every created process. In kernel-mode it
// will attempt break in on the target at the first
// WaitForEvent.
#define DEBUG_ENGOPT_INITIAL_BREAK 0x00000020
// Break in on the first module load for a debuggee.
#define DEBUG_ENGOPT_INITIAL_MODULE_BREAK 0x00000040
// Break in on a debuggees final event. In user-mode
// this will break on process exit for every process.
// In kernel-mode it currently does nothing.
#define DEBUG_ENGOPT_FINAL_BREAK 0x00000080
// By default Execute will repeat the last command
// if it is given an empty string. The flags to
// Execute can override this behavior for a single
// command or this engine option can be used to
// change the default globally.
#define DEBUG_ENGOPT_NO_EXECUTE_REPEAT 0x00000100
// Disable places in the engine that have fallback
// code when presented with incomplete information.
// 1. Fails minidump module loads unless matching
// executables can be mapped.
#define DEBUG_ENGOPT_FAIL_INCOMPLETE_INFORMATION 0x00000200
// Allow the debugger to manipulate page protections
// in order to insert code breakpoints on pages that
// do not have write access. This option is not on
// by default as it allows breakpoints to be set
// in potentially hazardous memory areas.
#define DEBUG_ENGOPT_ALLOW_READ_ONLY_BREAKPOINTS 0x00000400
// When using a software (bp/bu) breakpoint in code
// that will be executed by multiple threads it is
// possible for breakpoint management to cause the
// breakpoint to be missed or for spurious single-step
// exceptions to be generated. This flag suspends
// all but the active thread when doing breakpoint
// management and thereby avoids multithreading
// problems. Care must be taken when using it, though,
// as the suspension of threads can cause deadlocks
// if the suspended threads are holding resources that
// the active thread needs. Additionally, there
// are still rare situations where problems may
// occur, but setting this flag corrects nearly
// all multithreading issues with software breakpoints.
// Thread-restricted stepping and execution supersedes
// this flags effect.
// This flag is ignored in kernel sessions as there
// is no way to restrict processor execution.
#define DEBUG_ENGOPT_SYNCHRONIZE_BREAKPOINTS 0x00000800
// Disallows executing shell commands through the
// engine with .shell (!!).
#define DEBUG_ENGOPT_DISALLOW_SHELL_COMMANDS 0x00001000
// Turns on "quiet mode", a somewhat less verbose mode
// of operation supported in the debuggers that were
// superseded by dbgeng.dll. This equates to the KDQUIET
// environment variable.
#define DEBUG_ENGOPT_KD_QUIET_MODE 0x00002000
// Disables managed code debugging support in the engine.
// If managed support is already in use this flag has no effect.
#define DEBUG_ENGOPT_DISABLE_MANAGED_SUPPORT 0x00004000
// Disables symbol loading for all modules created
// after this flag is set.
#define DEBUG_ENGOPT_DISABLE_MODULE_SYMBOL_LOAD 0x00008000
// Disables execution commands.
#define DEBUG_ENGOPT_DISABLE_EXECUTION_COMMANDS 0x00010000
#define DEBUG_ENGOPT_ALL 0x0001FFFF
// General unspecified ID constant.
#define DEBUG_ANY_ID 0xffffffff
typedef struct _DEBUG_STACK_FRAME
{
ULONG64 InstructionOffset;
ULONG64 ReturnOffset;
ULONG64 FrameOffset;
ULONG64 StackOffset;
ULONG64 FuncTableEntry;
ULONG64 Params[4];
ULONG64 Reserved[6];
BOOL Virtual;
ULONG FrameNumber;
} DEBUG_STACK_FRAME, *PDEBUG_STACK_FRAME;
// OutputStackTrace flags.
// Display a small number of arguments for each call.
// These may or may not be the actual arguments depending
// on the architecture, particular function and
// point during the execution of the function.
// If the current code level is assembly arguments
// are dumped as hex values. If the code level is
// source the engine attempts to provide symbolic
// argument information.
#define DEBUG_STACK_ARGUMENTS 0x00000001
// Displays information about the functions
// frame such as __stdcall arguments, FPO
// information and whatever else is available.
#define DEBUG_STACK_FUNCTION_INFO 0x00000002
// Displays source line information for each
// frame of the stack trace.
#define DEBUG_STACK_SOURCE_LINE 0x00000004
// Show return, previous frame and other relevant address
// values for each frame.
#define DEBUG_STACK_FRAME_ADDRESSES 0x00000008
// Show column names.
#define DEBUG_STACK_COLUMN_NAMES 0x00000010
// Show non-volatile register context for each
// frame. This is only meaningful for some platforms.
#define DEBUG_STACK_NONVOLATILE_REGISTERS 0x00000020
// Show frame numbers
#define DEBUG_STACK_FRAME_NUMBERS 0x00000040
// Show typed source parameters.
#define DEBUG_STACK_PARAMETERS 0x00000080
// Show just return address in stack frame addresses.
#define DEBUG_STACK_FRAME_ADDRESSES_RA_ONLY 0x00000100
// Show frame-to-frame memory usage.
#define DEBUG_STACK_FRAME_MEMORY_USAGE 0x00000200
// Show typed source parameters one to a line.
#define DEBUG_STACK_PARAMETERS_NEWLINE 0x00000400
// Classes of debuggee. Each class
// has different qualifiers for specific
// kinds of debuggees.
#define DEBUG_CLASS_UNINITIALIZED 0
#define DEBUG_CLASS_KERNEL 1
#define DEBUG_CLASS_USER_WINDOWS 2
#define DEBUG_CLASS_IMAGE_FILE 3
// Generic dump types. These can be used
// with either user or kernel sessions.
// Session-type-specific aliases are also
// provided.
#define DEBUG_DUMP_SMALL 1024
#define DEBUG_DUMP_DEFAULT 1025
#define DEBUG_DUMP_FULL 1026
#define DEBUG_DUMP_IMAGE_FILE 1027
#define DEBUG_DUMP_TRACE_LOG 1028
#define DEBUG_DUMP_WINDOWS_CE 1029
// Specific types of kernel debuggees.
#define DEBUG_KERNEL_CONNECTION 0
#define DEBUG_KERNEL_LOCAL 1
#define DEBUG_KERNEL_EXDI_DRIVER 2
#define DEBUG_KERNEL_SMALL_DUMP DEBUG_DUMP_SMALL
#define DEBUG_KERNEL_DUMP DEBUG_DUMP_DEFAULT
#define DEBUG_KERNEL_FULL_DUMP DEBUG_DUMP_FULL
#define DEBUG_KERNEL_TRACE_LOG DEBUG_DUMP_TRACE_LOG
// Specific types of Windows user debuggees.
#define DEBUG_USER_WINDOWS_PROCESS 0
#define DEBUG_USER_WINDOWS_PROCESS_SERVER 1
#define DEBUG_USER_WINDOWS_SMALL_DUMP DEBUG_DUMP_SMALL
#define DEBUG_USER_WINDOWS_DUMP DEBUG_DUMP_DEFAULT
#define DEBUG_USER_WINDOWS_DUMP_WINDOWS_CE DEBUG_DUMP_WINDOWS_CE
// Extension flags.
#define DEBUG_EXTENSION_AT_ENGINE 0x00000000
// Execute and ExecuteCommandFile flags.
// These flags only apply to the command
// text itself; output from the executed
// command is controlled by the output
// control parameter.
// Default execution. Command is logged
// but not output.
#define DEBUG_EXECUTE_DEFAULT 0x00000000
// Echo commands during execution. In
// ExecuteCommandFile also echoes the prompt
// for each line of the file.
#define DEBUG_EXECUTE_ECHO 0x00000001
// Do not log or output commands during execution.
// Overridden by DEBUG_EXECUTE_ECHO.
#define DEBUG_EXECUTE_NOT_LOGGED 0x00000002
// If this flag is not set an empty string
// to Execute will repeat the last Execute
// string.
#define DEBUG_EXECUTE_NO_REPEAT 0x00000004
// Specific event filter types. Some event
// filters have optional arguments to further
// qualify their operation.
#define DEBUG_FILTER_CREATE_THREAD 0x00000000
#define DEBUG_FILTER_EXIT_THREAD 0x00000001
#define DEBUG_FILTER_CREATE_PROCESS 0x00000002
#define DEBUG_FILTER_EXIT_PROCESS 0x00000003
// Argument is the name of a module to break on.
#define DEBUG_FILTER_LOAD_MODULE 0x00000004
// Argument is the base address of a specific module to break on.
#define DEBUG_FILTER_UNLOAD_MODULE 0x00000005
#define DEBUG_FILTER_SYSTEM_ERROR 0x00000006
// Initial breakpoint and initial module load are one-shot
// events that are triggered at the appropriate points in
// the beginning of a session. Their commands are executed
// and then further processing is controlled by the normal
// exception and load module filters.
#define DEBUG_FILTER_INITIAL_BREAKPOINT 0x00000007
#define DEBUG_FILTER_INITIAL_MODULE_LOAD 0x00000008
// The debug output filter allows the debugger to stop
// when output is produced so that the code causing
// output can be tracked down or synchronized with.
// This filter is not supported for live dual-machine
// kernel debugging.
#define DEBUG_FILTER_DEBUGGEE_OUTPUT 0x00000009
// Event filter execution options.
// Break in always.
#define DEBUG_FILTER_BREAK 0x00000000
// Break in on second-chance exceptions. For events
// that are not exceptions this is the same as BREAK.
#define DEBUG_FILTER_SECOND_CHANCE_BREAK 0x00000001
// Output a message about the event but continue.
#define DEBUG_FILTER_OUTPUT 0x00000002
// Continue the event.
#define DEBUG_FILTER_IGNORE 0x00000003
// Used to remove general exception filters.
#define DEBUG_FILTER_REMOVE 0x00000004
// Event filter continuation options. These options are
// only used when DEBUG_STATUS_GO is used to continue
// execution. If a specific go status such as
// DEBUG_STATUS_GO_NOT_HANDLED is used it controls
// the continuation.
#define DEBUG_FILTER_GO_HANDLED 0x00000000
#define DEBUG_FILTER_GO_NOT_HANDLED 0x00000001
// Specific event filter settings.
typedef struct _DEBUG_SPECIFIC_FILTER_PARAMETERS
{
ULONG ExecutionOption;
ULONG ContinueOption;
ULONG TextSize;
ULONG CommandSize;
// If ArgumentSize is zero this filter does
// not have an argument. An empty argument for
// a filter which does have an argument will take
// one byte for the terminator.
ULONG ArgumentSize;
} DEBUG_SPECIFIC_FILTER_PARAMETERS, *PDEBUG_SPECIFIC_FILTER_PARAMETERS;
// Exception event filter settings.
typedef struct _DEBUG_EXCEPTION_FILTER_PARAMETERS
{
ULONG ExecutionOption;
ULONG ContinueOption;
ULONG TextSize;
ULONG CommandSize;
ULONG SecondCommandSize;
ULONG ExceptionCode;
} DEBUG_EXCEPTION_FILTER_PARAMETERS, *PDEBUG_EXCEPTION_FILTER_PARAMETERS;
// Wait flags.
#define DEBUG_WAIT_DEFAULT 0x00000000
// Last event information structures.
typedef struct _DEBUG_LAST_EVENT_INFO_BREAKPOINT
{
ULONG Id;
} DEBUG_LAST_EVENT_INFO_BREAKPOINT, *PDEBUG_LAST_EVENT_INFO_BREAKPOINT;
typedef struct _DEBUG_LAST_EVENT_INFO_EXCEPTION
{
EXCEPTION_RECORD64 ExceptionRecord;
ULONG FirstChance;
} DEBUG_LAST_EVENT_INFO_EXCEPTION, *PDEBUG_LAST_EVENT_INFO_EXCEPTION;
typedef struct _DEBUG_LAST_EVENT_INFO_EXIT_THREAD
{
ULONG ExitCode;
} DEBUG_LAST_EVENT_INFO_EXIT_THREAD, *PDEBUG_LAST_EVENT_INFO_EXIT_THREAD;
typedef struct _DEBUG_LAST_EVENT_INFO_EXIT_PROCESS
{
ULONG ExitCode;
} DEBUG_LAST_EVENT_INFO_EXIT_PROCESS, *PDEBUG_LAST_EVENT_INFO_EXIT_PROCESS;
typedef struct _DEBUG_LAST_EVENT_INFO_LOAD_MODULE
{
ULONG64 Base;
} DEBUG_LAST_EVENT_INFO_LOAD_MODULE, *PDEBUG_LAST_EVENT_INFO_LOAD_MODULE;
typedef struct _DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE
{
ULONG64 Base;
} DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE, *PDEBUG_LAST_EVENT_INFO_UNLOAD_MODULE;
typedef struct _DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR
{
ULONG Error;
ULONG Level;
} DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR, *PDEBUG_LAST_EVENT_INFO_SYSTEM_ERROR;
// DEBUG_VALUE types.
#define DEBUG_VALUE_INVALID 0
#define DEBUG_VALUE_INT8 1
#define DEBUG_VALUE_INT16 2
#define DEBUG_VALUE_INT32 3
#define DEBUG_VALUE_INT64 4
#define DEBUG_VALUE_FLOAT32 5
#define DEBUG_VALUE_FLOAT64 6
#define DEBUG_VALUE_FLOAT80 7
#define DEBUG_VALUE_FLOAT82 8
#define DEBUG_VALUE_FLOAT128 9
#define DEBUG_VALUE_VECTOR64 10
#define DEBUG_VALUE_VECTOR128 11
// Count of type indices.
#define DEBUG_VALUE_TYPES 12
#if defined(_MSC_VER)
#if _MSC_VER >= 800
#if _MSC_VER >= 1200
#pragma warning(push)
#endif
#pragma warning(disable:4201) /* Nameless struct/union */
#endif
#endif
// We want the DEBUG_VALUE structure to have 8-byte alignment
// and be 32 bytes total. This is tricky because the compiler
// wants to pad the union of values out to a even 8-byte multiple,
// pushing the type out too far. We can't use 4-packing because
// then the 8-byte alignment requirement is lost, so instead
// we shrink the union to 24 bytes and have a reserved field
// before the type field. The same amount of space is available
// and everybody's happy, but the structure is somewhat unusual.
typedef struct _DEBUG_VALUE
{
union
{
UCHAR I8;
USHORT I16;
ULONG I32;
struct
{
// Extra NAT indicator for IA64
// integer registers. NAT will
// always be false for other CPUs.
ULONG64 I64;
BOOL Nat;
};
float F32;
double F64;
UCHAR F80Bytes[10];
UCHAR F82Bytes[11];
UCHAR F128Bytes[16];
// Vector interpretations. The actual number
// of valid elements depends on the vector length.
UCHAR VI8[16];
USHORT VI16[8];
ULONG VI32[4];
ULONG64 VI64[2];
float VF32[4];
double VF64[2];
struct
{
ULONG LowPart;
ULONG HighPart;
} I64Parts32;
struct
{
ULONG64 LowPart;
LONG64 HighPart;
} F128Parts64;
// Allows raw byte access to content. Array
// can be indexed for as much data as Type
// describes. This array also serves to pad
// the structure out to 32 bytes and reserves
// space for future members.
UCHAR RawBytes[24];
};
ULONG TailOfRawBytes;
ULONG Type;
} DEBUG_VALUE, *PDEBUG_VALUE;
#if defined(_MSC_VER)
#if _MSC_VER >= 800
#if _MSC_VER >= 1200
#pragma warning(pop)
#else
#pragma warning(default:4201) /* Nameless struct/union */
#endif
#endif
#endif
#undef INTERFACE
#define INTERFACE IDebugControl
DECLARE_INTERFACE_(IDebugControl, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugControl.
// Checks for a user interrupt, such a Ctrl-C
// or stop button.
// This method is reentrant.
STDMETHOD(GetInterrupt)(
THIS
) PURE;
// Registers a user interrupt.
// This method is reentrant.
STDMETHOD(SetInterrupt)(
THIS_
__in ULONG Flags
) PURE;
// Interrupting a user-mode process requires
// access to some system resources that the
// process may hold itself, preventing the
// interrupt from occurring. The engine
// will time-out pending interrupt requests
// and simulate an interrupt if necessary.
// These methods control the interrupt timeout.
STDMETHOD(GetInterruptTimeout)(
THIS_
__out PULONG Seconds
) PURE;
STDMETHOD(SetInterruptTimeout)(
THIS_
__in ULONG Seconds
) PURE;
STDMETHOD(GetLogFile)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PBOOL Append
) PURE;
// Opens a log file which collects all
// output. Output from every client except
// those that explicitly disable logging
// goes into the log.
// Opening a log file closes any log file
// already open.
STDMETHOD(OpenLogFile)(
THIS_
__in PCSTR File,
__in BOOL Append
) PURE;
STDMETHOD(CloseLogFile)(
THIS
) PURE;
// Controls what output is logged.
STDMETHOD(GetLogMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetLogMask)(
THIS_
__in ULONG Mask
) PURE;
// Input requests input from all clients.
// The first input that is returned is used
// to satisfy the call. Other returned
// input is discarded.
STDMETHOD(Input)(
THIS_
__out_ecount(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG InputSize
) PURE;
// This method is used by clients to return
// input when it is available. It will
// return S_OK if the input is used to
// satisfy an Input call and S_FALSE if
// the input is ignored.
// This method is reentrant.
STDMETHOD(ReturnInput)(
THIS_
__in PCSTR Buffer
) PURE;
// Sends output through clients
// output callbacks if the mask is allowed
// by the current output control mask and
// according to the output distribution
// settings.
STDMETHODV(Output)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(OutputVaList)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// The following methods allow direct control
// over the distribution of the given output
// for situations where something other than
// the default is desired. These methods require
// extra work in the engine so they should
// only be used when necessary.
STDMETHODV(ControlledOutput)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(ControlledOutputVaList)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// Displays the standard command-line prompt
// followed by the given output. If Format
// is NULL no additional output is produced.
// Output is produced under the
// DEBUG_OUTPUT_PROMPT mask.
// This method only outputs the prompt; it
// does not get input.
STDMETHODV(OutputPrompt)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
...
) PURE;
STDMETHOD(OutputPromptVaList)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
__in va_list Args
) PURE;
// Gets the text that would be displayed by OutputPrompt.
STDMETHOD(GetPromptText)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// Outputs information about the current
// debuggee state such as a register
// summary, disassembly at the current PC,
// closest symbol and others.
// Uses the line prefix.
STDMETHOD(OutputCurrentState)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// Outputs the debugger and extension version
// information. This method is reentrant.
// Uses the line prefix.
STDMETHOD(OutputVersionInformation)(
THIS_
__in ULONG OutputControl
) PURE;
// In user-mode debugging sessions the
// engine will set an event when
// exceptions are continued. This can
// be used to synchronize other processes
// with the debuggers handling of events.
// For example, this is used to support
// the e argument to ntsd.
STDMETHOD(GetNotifyEventHandle)(
THIS_
__out PULONG64 Handle
) PURE;
STDMETHOD(SetNotifyEventHandle)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Assemble)(
THIS_
__in ULONG64 Offset,
__in PCSTR Instr,
__out PULONG64 EndOffset
) PURE;
STDMETHOD(Disassemble)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DisassemblySize,
__out PULONG64 EndOffset
) PURE;
// Returns the value of the effective address
// computed for the last Disassemble, if there
// was one.
STDMETHOD(GetDisassembleEffectiveOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Uses the line prefix if necessary.
STDMETHOD(OutputDisassembly)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG Flags,
__out PULONG64 EndOffset
) PURE;
// Produces multiple lines of disassembly output.
// There will be PreviousLines of disassembly before
// the given offset if a valid disassembly exists.
// In all, there will be TotalLines of output produced.
// The first and last line offsets are returned
// specially and all lines offsets can be retrieved
// through LineOffsets. LineOffsets will contain
// offsets for each line where disassembly started.
// When disassembly of a single instruction takes
// multiple lines the initial offset will be followed
// by DEBUG_INVALID_OFFSET.
// Uses the line prefix.
STDMETHOD(OutputDisassemblyLines)(
THIS_
__in ULONG OutputControl,
__in ULONG PreviousLines,
__in ULONG TotalLines,
__in ULONG64 Offset,
__in ULONG Flags,
__out_opt PULONG OffsetLine,
__out_opt PULONG64 StartOffset,
__out_opt PULONG64 EndOffset,
__out_ecount_opt(TotalLines) PULONG64 LineOffsets
) PURE;
// Returns the offset of the start of
// the instruction thats the given
// delta away from the instruction
// at the initial offset.
// This routine does not check for
// validity of the instruction or
// the memory containing it.
STDMETHOD(GetNearInstruction)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out PULONG64 NearOffset
) PURE;
// Offsets can be passed in as zero to use the current
// thread state.
STDMETHOD(GetStackTrace)(
THIS_
__in ULONG64 FrameOffset,
__in ULONG64 StackOffset,
__in ULONG64 InstructionOffset,
__out_ecount(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__out_opt PULONG FramesFilled
) PURE;
// Does a simple stack trace to determine
// what the current return address is.
STDMETHOD(GetReturnOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// If Frames is NULL OutputStackTrace will
// use GetStackTrace to get FramesSize frames
// and then output them. The current register
// values for frame, stack and instruction offsets
// are used.
// Uses the line prefix.
STDMETHOD(OutputStackTrace)(
THIS_
__in ULONG OutputControl,
__in_ecount_opt(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__in ULONG Flags
) PURE;
// Returns information about the debuggee such
// as user vs. kernel, dump vs. live, etc.
STDMETHOD(GetDebuggeeType)(
THIS_
__out PULONG Class,
__out PULONG Qualifier
) PURE;
// Returns the type of physical processors in
// the machine.
// Returns one of the IMAGE_FILE_MACHINE values.
STDMETHOD(GetActualProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Returns the type of processor used in the
// current processor context.
STDMETHOD(GetExecutingProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Query all the possible processor types that
// may be encountered during this debug session.
STDMETHOD(GetNumberPossibleExecutingProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetPossibleExecutingProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Get the number of actual processors in
// the machine.
STDMETHOD(GetNumberProcessors)(
THIS_
__out PULONG Number
) PURE;
// PlatformId is one of the VER_PLATFORM values.
// Major and minor are as given in the NT
// kernel debugger protocol.
// ServicePackString and ServicePackNumber indicate the
// system service pack level. ServicePackNumber is not
// available in some sessions where the service pack level
// is only expressed as a string. The service pack information
// will be empty if the system does not have a service pack
// applied.
// The build string is string information identifying the
// particular build of the system. The build string is
// empty if the system has no particular identifying
// information.
STDMETHOD(GetSystemVersion)(
THIS_
__out PULONG PlatformId,
__out PULONG Major,
__out PULONG Minor,
__out_ecount_opt(ServicePackStringSize) PSTR ServicePackString,
__in ULONG ServicePackStringSize,
__out_opt PULONG ServicePackStringUsed,
__out PULONG ServicePackNumber,
__out_ecount_opt(BuildStringSize) PSTR BuildString,
__in ULONG BuildStringSize,
__out_opt PULONG BuildStringUsed
) PURE;
// Returns the page size for the currently executing
// processor context. The page size may vary between
// processor types.
STDMETHOD(GetPageSize)(
THIS_
__out PULONG Size
) PURE;
// Returns S_OK if the current processor context uses
// 64-bit addresses, otherwise S_FALSE.
STDMETHOD(IsPointer64Bit)(
THIS
) PURE;
// Reads the bugcheck data area and returns the
// current contents. This method only works
// in kernel debugging sessions.
STDMETHOD(ReadBugCheckData)(
THIS_
__out PULONG Code,
__out PULONG64 Arg1,
__out PULONG64 Arg2,
__out PULONG64 Arg3,
__out PULONG64 Arg4
) PURE;
// Query all the processor types supported by
// the engine. This is a complete list and is
// not related to the machine running the engine
// or the debuggee.
STDMETHOD(GetNumberSupportedProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetSupportedProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Returns a full, descriptive name and an
// abbreviated name for a processor type.
STDMETHOD(GetProcessorTypeNames)(
THIS_
__in ULONG Type,
__out_ecount_opt(FullNameBufferSize) PSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
// Gets and sets the type of processor to
// use when doing things like setting
// breakpoints, accessing registers,
// getting stack traces and so on.
STDMETHOD(GetEffectiveProcessorType)(
THIS_
__out PULONG Type
) PURE;
STDMETHOD(SetEffectiveProcessorType)(
THIS_
__in ULONG Type
) PURE;
// Returns information about whether and how
// the debuggee is running. Status will
// be GO if the debuggee is running and
// BREAK if it isnt.
// If no debuggee exists the status is
// NO_DEBUGGEE.
// This method is reentrant.
STDMETHOD(GetExecutionStatus)(
THIS_
__out PULONG Status
) PURE;
// Changes the execution status of the
// engine from stopped to running.
// Status must be one of the go or step
// status values.
STDMETHOD(SetExecutionStatus)(
THIS_
__in ULONG Status
) PURE;
// Controls what code interpretation level the debugger
// runs at. The debugger checks the code level when
// deciding whether to step by a source line or
// assembly instruction along with other related operations.
STDMETHOD(GetCodeLevel)(
THIS_
__out PULONG Level
) PURE;
STDMETHOD(SetCodeLevel)(
THIS_
__in ULONG Level
) PURE;
// Gets and sets engine control flags.
// These methods are reentrant.
STDMETHOD(GetEngineOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetEngineOptions)(
THIS_
__in ULONG Options
) PURE;
// Gets and sets control values for
// handling system error events.
// If the system error level is less
// than or equal to the given levels
// the error may be displayed and
// the default break for the event
// may be set.
STDMETHOD(GetSystemErrorControl)(
THIS_
__out PULONG OutputLevel,
__out PULONG BreakLevel
) PURE;
STDMETHOD(SetSystemErrorControl)(
THIS_
__in ULONG OutputLevel,
__in ULONG BreakLevel
) PURE;
// The command processor supports simple
// string replacement macros in Evaluate and
// Execute. There are currently ten macro
// slots available. Slots 0-9 map to
// the command invocations $u0-$u9.
STDMETHOD(GetTextMacro)(
THIS_
__in ULONG Slot,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MacroSize
) PURE;
STDMETHOD(SetTextMacro)(
THIS_
__in ULONG Slot,
__in PCSTR Macro
) PURE;
// Controls the default number radix used
// in expressions and commands.
STDMETHOD(GetRadix)(
THIS_
__out PULONG Radix
) PURE;
STDMETHOD(SetRadix)(
THIS_
__in ULONG Radix
) PURE;
// Evaluates the given expression string and
// returns the resulting value.
// If DesiredType is DEBUG_VALUE_INVALID then
// the natural type is used.
// RemainderIndex, if provided, is set to the index
// of the first character in the input string that was
// not used when evaluating the expression.
STDMETHOD(Evaluate)(
THIS_
__in PCSTR Expression,
__in ULONG DesiredType,
__out PDEBUG_VALUE Value,
__out_opt PULONG RemainderIndex
) PURE;
// Attempts to convert the input value to a value
// of the requested type in the output value.
// Conversions can fail if no conversion exists.
// Successful conversions may be lossy.
STDMETHOD(CoerceValue)(
THIS_
__in PDEBUG_VALUE In,
__in ULONG OutType,
__out PDEBUG_VALUE Out
) PURE;
STDMETHOD(CoerceValues)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_VALUE In,
__in_ecount(Count) PULONG OutTypes,
__out_ecount(Count) PDEBUG_VALUE Out
) PURE;
// Executes the given command string.
// If the string has multiple commands
// Execute will not return until all
// of them have been executed. If this
// requires waiting for the debuggee to
// execute an internal wait will be done
// so Execute can take an arbitrary amount
// of time.
STDMETHOD(Execute)(
THIS_
__in ULONG OutputControl,
__in PCSTR Command,
__in ULONG Flags
) PURE;
// Executes the given command file by
// reading a line at a time and processing
// it with Execute.
STDMETHOD(ExecuteCommandFile)(
THIS_
__in ULONG OutputControl,
__in PCSTR CommandFile,
__in ULONG Flags
) PURE;
// Breakpoint interfaces are described
// elsewhere in this section.
STDMETHOD(GetNumberBreakpoints)(
THIS_
__out PULONG Number
) PURE;
// It is possible for this retrieval function to
// fail even with an index within the number of
// existing breakpoints if the breakpoint is
// a private breakpoint.
STDMETHOD(GetBreakpointByIndex)(
THIS_
__in ULONG Index,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
STDMETHOD(GetBreakpointById)(
THIS_
__in ULONG Id,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// If Ids is non-NULL the Count breakpoints
// referred to in the Ids array are returned,
// otherwise breakpoints from index Start to
// Start + Count 1 are returned.
STDMETHOD(GetBreakpointParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Ids,
__in ULONG Start,
__out_ecount(Count) PDEBUG_BREAKPOINT_PARAMETERS Params
) PURE;
// Breakpoints are created empty and disabled.
// When their parameters have been set they
// should be enabled by setting the ENABLE flag.
// If DesiredId is DEBUG_ANY_ID then the
// engine picks an unused ID. If DesiredId
// is any other number the engine attempts
// to use the given ID for the breakpoint.
// If another breakpoint exists with that ID
// the call will fail.
STDMETHOD(AddBreakpoint)(
THIS_
__in ULONG Type,
__in ULONG DesiredId,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// Breakpoint interface is invalid after this call.
STDMETHOD(RemoveBreakpoint)(
THIS_
__in PDEBUG_BREAKPOINT Bp
) PURE;
// Control and use extension DLLs.
STDMETHOD(AddExtension)(
THIS_
__in PCSTR Path,
__in ULONG Flags,
__out PULONG64 Handle
) PURE;
STDMETHOD(RemoveExtension)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(GetExtensionByPath)(
THIS_
__in PCSTR Path,
__out PULONG64 Handle
) PURE;
// If Handle is zero the extension
// chain is walked searching for the
// function.
STDMETHOD(CallExtension)(
THIS_
__in ULONG64 Handle,
__in PCSTR Function,
__in_opt PCSTR Arguments
) PURE;
// GetExtensionFunction works like
// GetProcAddress on extension DLLs
// to allow raw function-call-level
// interaction with extension DLLs.
// Such functions do not need to
// follow the standard extension prototype
// if they are not going to be called
// through the text extension interface.
// _EFN_ is automatically prepended to
// the name string given.
// This function cannot be called remotely.
STDMETHOD(GetExtensionFunction)(
THIS_
__in ULONG64 Handle,
__in PCSTR FuncName,
__out FARPROC* Function
) PURE;
// These methods return alternate
// extension interfaces in order to allow
// interface-style extension DLLs to mix in
// older extension calls.
// Structure sizes must be initialized before
// the call.
// These methods cannot be called remotely.
STDMETHOD(GetWindbgExtensionApis32)(
THIS_
__inout PWINDBG_EXTENSION_APIS32 Api
) PURE;
STDMETHOD(GetWindbgExtensionApis64)(
THIS_
__inout PWINDBG_EXTENSION_APIS64 Api
) PURE;
// The engine provides a simple mechanism
// to filter common events. Arbitrarily complicated
// filtering can be done by registering event callbacks
// but simple event filtering only requires
// setting the options of one of the predefined
// event filters.
// Simple event filters are either for specific
// events and therefore have an enumerant or
// they are for an exception and are based on
// the exceptions code. Exception filters
// are further divided into exceptions specially
// handled by the engine, which is a fixed set,
// and arbitrary exceptions.
// All three groups of filters are indexed together
// with the specific filters first, then the specific
// exception filters and finally the arbitrary
// exception filters.
// The first specific exception is the default
// exception. If an exception event occurs for
// an exception without settings the default
// exception settings are used.
STDMETHOD(GetNumberEventFilters)(
THIS_
__out PULONG SpecificEvents,
__out PULONG SpecificExceptions,
__out PULONG ArbitraryExceptions
) PURE;
// Some filters have descriptive text associated with them.
STDMETHOD(GetEventFilterText)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// All filters support executing a command when the
// event occurs.
STDMETHOD(GetEventFilterCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetEventFilterCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
STDMETHOD(GetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
STDMETHOD(SetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__in_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
// Some specific filters have arguments to further
// qualify their operation.
STDMETHOD(GetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ArgumentSize
) PURE;
STDMETHOD(SetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__in PCSTR Argument
) PURE;
// If Codes is non-NULL Start is ignored.
STDMETHOD(GetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Codes,
__in ULONG Start,
__out_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// The codes in the parameter data control the application
// of the parameter data. If a code is not already in
// the set of filters it is added. If the ExecutionOption
// for a code is REMOVE then the filter is removed.
// Specific exception filters cannot be removed.
STDMETHOD(SetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// Exception filters support an additional command for
// second-chance events.
STDMETHOD(GetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
// Yields processing to the engine until
// an event occurs. This method may
// only be called by the thread that started
// the debug session.
// When an event occurs the engine carries
// out all event processing such as calling
// callbacks.
// If the callbacks indicate that execution should
// break the wait will return, otherwise it
// goes back to waiting for a new event.
// If the timeout expires, S_FALSE is returned.
// The timeout is not currently supported for
// kernel debugging.
STDMETHOD(WaitForEvent)(
THIS_
__in ULONG Flags,
__in ULONG Timeout
) PURE;
// Retrieves information about the last event that occurred.
// EventType is one of the event callback mask bits.
// ExtraInformation contains additional event-specific
// information. Not all events have additional information.
STDMETHOD(GetLastEventInformation)(
THIS_
__out PULONG Type,
__out PULONG ProcessId,
__out PULONG ThreadId,
__out_bcount_opt(ExtraInformationSize) PVOID ExtraInformation,
__in ULONG ExtraInformationSize,
__out_opt PULONG ExtraInformationUsed,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG DescriptionUsed
) PURE;
};
// OutputTextReplacements flags.
#define DEBUG_OUT_TEXT_REPL_DEFAULT 0x00000000
#undef INTERFACE
#define INTERFACE IDebugControl2
DECLARE_INTERFACE_(IDebugControl2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugControl.
// Checks for a user interrupt, such a Ctrl-C
// or stop button.
// This method is reentrant.
STDMETHOD(GetInterrupt)(
THIS
) PURE;
// Registers a user interrupt.
// This method is reentrant.
STDMETHOD(SetInterrupt)(
THIS_
__in ULONG Flags
) PURE;
// Interrupting a user-mode process requires
// access to some system resources that the
// process may hold itself, preventing the
// interrupt from occurring. The engine
// will time-out pending interrupt requests
// and simulate an interrupt if necessary.
// These methods control the interrupt timeout.
STDMETHOD(GetInterruptTimeout)(
THIS_
__out PULONG Seconds
) PURE;
STDMETHOD(SetInterruptTimeout)(
THIS_
__in ULONG Seconds
) PURE;
STDMETHOD(GetLogFile)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PBOOL Append
) PURE;
// Opens a log file which collects all
// output. Output from every client except
// those that explicitly disable logging
// goes into the log.
// Opening a log file closes any log file
// already open.
STDMETHOD(OpenLogFile)(
THIS_
__in PCSTR File,
__in BOOL Append
) PURE;
STDMETHOD(CloseLogFile)(
THIS
) PURE;
// Controls what output is logged.
STDMETHOD(GetLogMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetLogMask)(
THIS_
__in ULONG Mask
) PURE;
// Input requests input from all clients.
// The first input that is returned is used
// to satisfy the call. Other returned
// input is discarded.
STDMETHOD(Input)(
THIS_
__out_ecount(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG InputSize
) PURE;
// This method is used by clients to return
// input when it is available. It will
// return S_OK if the input is used to
// satisfy an Input call and S_FALSE if
// the input is ignored.
// This method is reentrant.
STDMETHOD(ReturnInput)(
THIS_
__in PCSTR Buffer
) PURE;
// Sends output through clients
// output callbacks if the mask is allowed
// by the current output control mask and
// according to the output distribution
// settings.
STDMETHODV(Output)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(OutputVaList)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// The following methods allow direct control
// over the distribution of the given output
// for situations where something other than
// the default is desired. These methods require
// extra work in the engine so they should
// only be used when necessary.
STDMETHODV(ControlledOutput)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(ControlledOutputVaList)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// Displays the standard command-line prompt
// followed by the given output. If Format
// is NULL no additional output is produced.
// Output is produced under the
// DEBUG_OUTPUT_PROMPT mask.
// This method only outputs the prompt; it
// does not get input.
STDMETHODV(OutputPrompt)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
...
) PURE;
STDMETHOD(OutputPromptVaList)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
__in va_list Args
) PURE;
// Gets the text that would be displayed by OutputPrompt.
STDMETHOD(GetPromptText)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// Outputs information about the current
// debuggee state such as a register
// summary, disassembly at the current PC,
// closest symbol and others.
// Uses the line prefix.
STDMETHOD(OutputCurrentState)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// Outputs the debugger and extension version
// information. This method is reentrant.
// Uses the line prefix.
STDMETHOD(OutputVersionInformation)(
THIS_
__in ULONG OutputControl
) PURE;
// In user-mode debugging sessions the
// engine will set an event when
// exceptions are continued. This can
// be used to synchronize other processes
// with the debuggers handling of events.
// For example, this is used to support
// the e argument to ntsd.
STDMETHOD(GetNotifyEventHandle)(
THIS_
__out PULONG64 Handle
) PURE;
STDMETHOD(SetNotifyEventHandle)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Assemble)(
THIS_
__in ULONG64 Offset,
__in PCSTR Instr,
__out PULONG64 EndOffset
) PURE;
STDMETHOD(Disassemble)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DisassemblySize,
__out PULONG64 EndOffset
) PURE;
// Returns the value of the effective address
// computed for the last Disassemble, if there
// was one.
STDMETHOD(GetDisassembleEffectiveOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Uses the line prefix if necessary.
STDMETHOD(OutputDisassembly)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG Flags,
__out PULONG64 EndOffset
) PURE;
// Produces multiple lines of disassembly output.
// There will be PreviousLines of disassembly before
// the given offset if a valid disassembly exists.
// In all, there will be TotalLines of output produced.
// The first and last line offsets are returned
// specially and all lines offsets can be retrieved
// through LineOffsets. LineOffsets will contain
// offsets for each line where disassembly started.
// When disassembly of a single instruction takes
// multiple lines the initial offset will be followed
// by DEBUG_INVALID_OFFSET.
// Uses the line prefix.
STDMETHOD(OutputDisassemblyLines)(
THIS_
__in ULONG OutputControl,
__in ULONG PreviousLines,
__in ULONG TotalLines,
__in ULONG64 Offset,
__in ULONG Flags,
__out_opt PULONG OffsetLine,
__out_opt PULONG64 StartOffset,
__out_opt PULONG64 EndOffset,
__out_ecount_opt(TotalLines) PULONG64 LineOffsets
) PURE;
// Returns the offset of the start of
// the instruction thats the given
// delta away from the instruction
// at the initial offset.
// This routine does not check for
// validity of the instruction or
// the memory containing it.
STDMETHOD(GetNearInstruction)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out PULONG64 NearOffset
) PURE;
// Offsets can be passed in as zero to use the current
// thread state.
STDMETHOD(GetStackTrace)(
THIS_
__in ULONG64 FrameOffset,
__in ULONG64 StackOffset,
__in ULONG64 InstructionOffset,
__out_ecount(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__out_opt PULONG FramesFilled
) PURE;
// Does a simple stack trace to determine
// what the current return address is.
STDMETHOD(GetReturnOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// If Frames is NULL OutputStackTrace will
// use GetStackTrace to get FramesSize frames
// and then output them. The current register
// values for frame, stack and instruction offsets
// are used.
// Uses the line prefix.
STDMETHOD(OutputStackTrace)(
THIS_
__in ULONG OutputControl,
__in_ecount_opt(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__in ULONG Flags
) PURE;
// Returns information about the debuggee such
// as user vs. kernel, dump vs. live, etc.
STDMETHOD(GetDebuggeeType)(
THIS_
__out PULONG Class,
__out PULONG Qualifier
) PURE;
// Returns the type of physical processors in
// the machine.
// Returns one of the IMAGE_FILE_MACHINE values.
STDMETHOD(GetActualProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Returns the type of processor used in the
// current processor context.
STDMETHOD(GetExecutingProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Query all the possible processor types that
// may be encountered during this debug session.
STDMETHOD(GetNumberPossibleExecutingProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetPossibleExecutingProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Get the number of actual processors in
// the machine.
STDMETHOD(GetNumberProcessors)(
THIS_
__out PULONG Number
) PURE;
// PlatformId is one of the VER_PLATFORM values.
// Major and minor are as given in the NT
// kernel debugger protocol.
// ServicePackString and ServicePackNumber indicate the
// system service pack level. ServicePackNumber is not
// available in some sessions where the service pack level
// is only expressed as a string. The service pack information
// will be empty if the system does not have a service pack
// applied.
// The build string is string information identifying the
// particular build of the system. The build string is
// empty if the system has no particular identifying
// information.
STDMETHOD(GetSystemVersion)(
THIS_
__out PULONG PlatformId,
__out PULONG Major,
__out PULONG Minor,
__out_ecount_opt(ServicePackStringSize) PSTR ServicePackString,
__in ULONG ServicePackStringSize,
__out_opt PULONG ServicePackStringUsed,
__out PULONG ServicePackNumber,
__out_ecount_opt(BuildStringSize) PSTR BuildString,
__in ULONG BuildStringSize,
__out_opt PULONG BuildStringUsed
) PURE;
// Returns the page size for the currently executing
// processor context. The page size may vary between
// processor types.
STDMETHOD(GetPageSize)(
THIS_
__out PULONG Size
) PURE;
// Returns S_OK if the current processor context uses
// 64-bit addresses, otherwise S_FALSE.
STDMETHOD(IsPointer64Bit)(
THIS
) PURE;
// Reads the bugcheck data area and returns the
// current contents. This method only works
// in kernel debugging sessions.
STDMETHOD(ReadBugCheckData)(
THIS_
__out PULONG Code,
__out PULONG64 Arg1,
__out PULONG64 Arg2,
__out PULONG64 Arg3,
__out PULONG64 Arg4
) PURE;
// Query all the processor types supported by
// the engine. This is a complete list and is
// not related to the machine running the engine
// or the debuggee.
STDMETHOD(GetNumberSupportedProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetSupportedProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Returns a full, descriptive name and an
// abbreviated name for a processor type.
STDMETHOD(GetProcessorTypeNames)(
THIS_
__in ULONG Type,
__out_ecount_opt(FullNameBufferSize) PSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
// Gets and sets the type of processor to
// use when doing things like setting
// breakpoints, accessing registers,
// getting stack traces and so on.
STDMETHOD(GetEffectiveProcessorType)(
THIS_
__out PULONG Type
) PURE;
STDMETHOD(SetEffectiveProcessorType)(
THIS_
__in ULONG Type
) PURE;
// Returns information about whether and how
// the debuggee is running. Status will
// be GO if the debuggee is running and
// BREAK if it isnt.
// If no debuggee exists the status is
// NO_DEBUGGEE.
// This method is reentrant.
STDMETHOD(GetExecutionStatus)(
THIS_
__out PULONG Status
) PURE;
// Changes the execution status of the
// engine from stopped to running.
// Status must be one of the go or step
// status values.
STDMETHOD(SetExecutionStatus)(
THIS_
__in ULONG Status
) PURE;
// Controls what code interpretation level the debugger
// runs at. The debugger checks the code level when
// deciding whether to step by a source line or
// assembly instruction along with other related operations.
STDMETHOD(GetCodeLevel)(
THIS_
__out PULONG Level
) PURE;
STDMETHOD(SetCodeLevel)(
THIS_
__in ULONG Level
) PURE;
// Gets and sets engine control flags.
// These methods are reentrant.
STDMETHOD(GetEngineOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetEngineOptions)(
THIS_
__in ULONG Options
) PURE;
// Gets and sets control values for
// handling system error events.
// If the system error level is less
// than or equal to the given levels
// the error may be displayed and
// the default break for the event
// may be set.
STDMETHOD(GetSystemErrorControl)(
THIS_
__out PULONG OutputLevel,
__out PULONG BreakLevel
) PURE;
STDMETHOD(SetSystemErrorControl)(
THIS_
__in ULONG OutputLevel,
__in ULONG BreakLevel
) PURE;
// The command processor supports simple
// string replacement macros in Evaluate and
// Execute. There are currently ten macro
// slots available. Slots 0-9 map to
// the command invocations $u0-$u9.
STDMETHOD(GetTextMacro)(
THIS_
__in ULONG Slot,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MacroSize
) PURE;
STDMETHOD(SetTextMacro)(
THIS_
__in ULONG Slot,
__in PCSTR Macro
) PURE;
// Controls the default number radix used
// in expressions and commands.
STDMETHOD(GetRadix)(
THIS_
__out PULONG Radix
) PURE;
STDMETHOD(SetRadix)(
THIS_
__in ULONG Radix
) PURE;
// Evaluates the given expression string and
// returns the resulting value.
// If DesiredType is DEBUG_VALUE_INVALID then
// the natural type is used.
// RemainderIndex, if provided, is set to the index
// of the first character in the input string that was
// not used when evaluating the expression.
STDMETHOD(Evaluate)(
THIS_
__in PCSTR Expression,
__in ULONG DesiredType,
__out PDEBUG_VALUE Value,
__out_opt PULONG RemainderIndex
) PURE;
// Attempts to convert the input value to a value
// of the requested type in the output value.
// Conversions can fail if no conversion exists.
// Successful conversions may be lossy.
STDMETHOD(CoerceValue)(
THIS_
__in PDEBUG_VALUE In,
__in ULONG OutType,
__out PDEBUG_VALUE Out
) PURE;
STDMETHOD(CoerceValues)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_VALUE In,
__in_ecount(Count) PULONG OutTypes,
__out_ecount(Count) PDEBUG_VALUE Out
) PURE;
// Executes the given command string.
// If the string has multiple commands
// Execute will not return until all
// of them have been executed. If this
// requires waiting for the debuggee to
// execute an internal wait will be done
// so Execute can take an arbitrary amount
// of time.
STDMETHOD(Execute)(
THIS_
__in ULONG OutputControl,
__in PCSTR Command,
__in ULONG Flags
) PURE;
// Executes the given command file by
// reading a line at a time and processing
// it with Execute.
STDMETHOD(ExecuteCommandFile)(
THIS_
__in ULONG OutputControl,
__in PCSTR CommandFile,
__in ULONG Flags
) PURE;
// Breakpoint interfaces are described
// elsewhere in this section.
STDMETHOD(GetNumberBreakpoints)(
THIS_
__out PULONG Number
) PURE;
// It is possible for this retrieval function to
// fail even with an index within the number of
// existing breakpoints if the breakpoint is
// a private breakpoint.
STDMETHOD(GetBreakpointByIndex)(
THIS_
__in ULONG Index,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
STDMETHOD(GetBreakpointById)(
THIS_
__in ULONG Id,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// If Ids is non-NULL the Count breakpoints
// referred to in the Ids array are returned,
// otherwise breakpoints from index Start to
// Start + Count 1 are returned.
STDMETHOD(GetBreakpointParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Ids,
__in ULONG Start,
__out_ecount(Count) PDEBUG_BREAKPOINT_PARAMETERS Params
) PURE;
// Breakpoints are created empty and disabled.
// When their parameters have been set they
// should be enabled by setting the ENABLE flag.
// If DesiredId is DEBUG_ANY_ID then the
// engine picks an unused ID. If DesiredId
// is any other number the engine attempts
// to use the given ID for the breakpoint.
// If another breakpoint exists with that ID
// the call will fail.
STDMETHOD(AddBreakpoint)(
THIS_
__in ULONG Type,
__in ULONG DesiredId,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// Breakpoint interface is invalid after this call.
STDMETHOD(RemoveBreakpoint)(
THIS_
__in PDEBUG_BREAKPOINT Bp
) PURE;
// Control and use extension DLLs.
STDMETHOD(AddExtension)(
THIS_
__in PCSTR Path,
__in ULONG Flags,
__out PULONG64 Handle
) PURE;
STDMETHOD(RemoveExtension)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(GetExtensionByPath)(
THIS_
__in PCSTR Path,
__out PULONG64 Handle
) PURE;
// If Handle is zero the extension
// chain is walked searching for the
// function.
STDMETHOD(CallExtension)(
THIS_
__in ULONG64 Handle,
__in PCSTR Function,
__in_opt PCSTR Arguments
) PURE;
// GetExtensionFunction works like
// GetProcAddress on extension DLLs
// to allow raw function-call-level
// interaction with extension DLLs.
// Such functions do not need to
// follow the standard extension prototype
// if they are not going to be called
// through the text extension interface.
// This function cannot be called remotely.
STDMETHOD(GetExtensionFunction)(
THIS_
__in ULONG64 Handle,
__in PCSTR FuncName,
__out FARPROC* Function
) PURE;
// These methods return alternate
// extension interfaces in order to allow
// interface-style extension DLLs to mix in
// older extension calls.
// Structure sizes must be initialized before
// the call.
// These methods cannot be called remotely.
STDMETHOD(GetWindbgExtensionApis32)(
THIS_
__inout PWINDBG_EXTENSION_APIS32 Api
) PURE;
STDMETHOD(GetWindbgExtensionApis64)(
THIS_
__inout PWINDBG_EXTENSION_APIS64 Api
) PURE;
// The engine provides a simple mechanism
// to filter common events. Arbitrarily complicated
// filtering can be done by registering event callbacks
// but simple event filtering only requires
// setting the options of one of the predefined
// event filters.
// Simple event filters are either for specific
// events and therefore have an enumerant or
// they are for an exception and are based on
// the exceptions code. Exception filters
// are further divided into exceptions specially
// handled by the engine, which is a fixed set,
// and arbitrary exceptions.
// All three groups of filters are indexed together
// with the specific filters first, then the specific
// exception filters and finally the arbitrary
// exception filters.
// The first specific exception is the default
// exception. If an exception event occurs for
// an exception without settings the default
// exception settings are used.
STDMETHOD(GetNumberEventFilters)(
THIS_
__out PULONG SpecificEvents,
__out PULONG SpecificExceptions,
__out PULONG ArbitraryExceptions
) PURE;
// Some filters have descriptive text associated with them.
STDMETHOD(GetEventFilterText)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// All filters support executing a command when the
// event occurs.
STDMETHOD(GetEventFilterCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetEventFilterCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
STDMETHOD(GetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
STDMETHOD(SetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__in_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
// Some specific filters have arguments to further
// qualify their operation.
STDMETHOD(GetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ArgumentSize
) PURE;
STDMETHOD(SetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__in PCSTR Argument
) PURE;
// If Codes is non-NULL Start is ignored.
STDMETHOD(GetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Codes,
__in ULONG Start,
__out_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// The codes in the parameter data control the application
// of the parameter data. If a code is not already in
// the set of filters it is added. If the ExecutionOption
// for a code is REMOVE then the filter is removed.
// Specific exception filters cannot be removed.
STDMETHOD(SetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// Exception filters support an additional command for
// second-chance events.
STDMETHOD(GetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
// Yields processing to the engine until
// an event occurs. This method may
// only be called by the thread that started
// the debug session.
// When an event occurs the engine carries
// out all event processing such as calling
// callbacks.
// If the callbacks indicate that execution should
// break the wait will return, otherwise it
// goes back to waiting for a new event.
// If the timeout expires, S_FALSE is returned.
// The timeout is not currently supported for
// kernel debugging.
STDMETHOD(WaitForEvent)(
THIS_
__in ULONG Flags,
__in ULONG Timeout
) PURE;
// Retrieves information about the last event that occurred.
// EventType is one of the event callback mask bits.
// ExtraInformation contains additional event-specific
// information. Not all events have additional information.
STDMETHOD(GetLastEventInformation)(
THIS_
__out PULONG Type,
__out PULONG ProcessId,
__out PULONG ThreadId,
__out_bcount_opt(ExtraInformationSize) PVOID ExtraInformation,
__in ULONG ExtraInformationSize,
__out_opt PULONG ExtraInformationUsed,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG DescriptionUsed
) PURE;
// IDebugControl2.
STDMETHOD(GetCurrentTimeDate)(
THIS_
__out PULONG TimeDate
) PURE;
// Retrieves the number of seconds since the
// machine started running.
STDMETHOD(GetCurrentSystemUpTime)(
THIS_
__out PULONG UpTime
) PURE;
// If the current session is a dump session,
// retrieves any extended format information.
STDMETHOD(GetDumpFormatFlags)(
THIS_
__out PULONG FormatFlags
) PURE;
// The debugger has been enhanced to allow
// arbitrary text replacements in addition
// to the simple $u0-$u9 text macros.
// Text replacement takes a given source
// text in commands and converts it to the
// given destination text. Replacements
// are named by their source text so that
// only one replacement for a source text
// string can exist.
STDMETHOD(GetNumberTextReplacements)(
THIS_
__out PULONG NumRepl
) PURE;
// If SrcText is non-NULL the replacement
// is looked up by source text, otherwise
// Index is used to get the Nth replacement.
STDMETHOD(GetTextReplacement)(
THIS_
__in_opt PCSTR SrcText,
__in ULONG Index,
__out_ecount_opt(SrcBufferSize) PSTR SrcBuffer,
__in ULONG SrcBufferSize,
__out_opt PULONG SrcSize,
__out_ecount_opt(DstBufferSize) PSTR DstBuffer,
__in ULONG DstBufferSize,
__out_opt PULONG DstSize
) PURE;
// Setting the destination text to
// NULL removes the alias.
STDMETHOD(SetTextReplacement)(
THIS_
__in PCSTR SrcText,
__in_opt PCSTR DstText
) PURE;
STDMETHOD(RemoveTextReplacements)(
THIS
) PURE;
// Outputs the complete list of current
// replacements.
STDMETHOD(OutputTextReplacements)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
};
//
// Assembly/disassembly options.
//
// The specific effects of these flags varies depending
// on the particular instruction set.
//
#define DEBUG_ASMOPT_DEFAULT 0x00000000
// Display additional information in disassembly.
#define DEBUG_ASMOPT_VERBOSE 0x00000001
// Do not display raw code bytes in disassembly.
#define DEBUG_ASMOPT_NO_CODE_BYTES 0x00000002
// Do not take the output width into account when
// formatting disassembly.
#define DEBUG_ASMOPT_IGNORE_OUTPUT_WIDTH 0x00000004
// Display source file line number before each line if available.
#define DEBUG_ASMOPT_SOURCE_LINE_NUMBER 0x00000008
//
// Expression syntax options.
//
// MASM-style expression evaluation.
#define DEBUG_EXPR_MASM 0x00000000
// C++-style expression evaluation.
#define DEBUG_EXPR_CPLUSPLUS 0x00000001
//
// Event index description information.
//
#define DEBUG_EINDEX_NAME 0x00000000
//
// SetNextEventIndex relation options.
//
// Value increases forward from the first index.
#define DEBUG_EINDEX_FROM_START 0x00000000
// Value increases backwards from the last index.
#define DEBUG_EINDEX_FROM_END 0x00000001
// Value is a signed delta from the current index.
#define DEBUG_EINDEX_FROM_CURRENT 0x00000002
#undef INTERFACE
#define INTERFACE IDebugControl3
DECLARE_INTERFACE_(IDebugControl3, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugControl.
// Checks for a user interrupt, such a Ctrl-C
// or stop button.
// This method is reentrant.
STDMETHOD(GetInterrupt)(
THIS
) PURE;
// Registers a user interrupt.
// This method is reentrant.
STDMETHOD(SetInterrupt)(
THIS_
__in ULONG Flags
) PURE;
// Interrupting a user-mode process requires
// access to some system resources that the
// process may hold itself, preventing the
// interrupt from occurring. The engine
// will time-out pending interrupt requests
// and simulate an interrupt if necessary.
// These methods control the interrupt timeout.
STDMETHOD(GetInterruptTimeout)(
THIS_
__out PULONG Seconds
) PURE;
STDMETHOD(SetInterruptTimeout)(
THIS_
__in ULONG Seconds
) PURE;
STDMETHOD(GetLogFile)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PBOOL Append
) PURE;
// Opens a log file which collects all
// output. Output from every client except
// those that explicitly disable logging
// goes into the log.
// Opening a log file closes any log file
// already open.
STDMETHOD(OpenLogFile)(
THIS_
__in PCSTR File,
__in BOOL Append
) PURE;
STDMETHOD(CloseLogFile)(
THIS
) PURE;
// Controls what output is logged.
STDMETHOD(GetLogMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetLogMask)(
THIS_
__in ULONG Mask
) PURE;
// Input requests input from all clients.
// The first input that is returned is used
// to satisfy the call. Other returned
// input is discarded.
STDMETHOD(Input)(
THIS_
__out_ecount(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG InputSize
) PURE;
// This method is used by clients to return
// input when it is available. It will
// return S_OK if the input is used to
// satisfy an Input call and S_FALSE if
// the input is ignored.
// This method is reentrant.
STDMETHOD(ReturnInput)(
THIS_
__in PCSTR Buffer
) PURE;
// Sends output through clients
// output callbacks if the mask is allowed
// by the current output control mask and
// according to the output distribution
// settings.
STDMETHODV(Output)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(OutputVaList)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// The following methods allow direct control
// over the distribution of the given output
// for situations where something other than
// the default is desired. These methods require
// extra work in the engine so they should
// only be used when necessary.
STDMETHODV(ControlledOutput)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(ControlledOutputVaList)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// Displays the standard command-line prompt
// followed by the given output. If Format
// is NULL no additional output is produced.
// Output is produced under the
// DEBUG_OUTPUT_PROMPT mask.
// This method only outputs the prompt; it
// does not get input.
STDMETHODV(OutputPrompt)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
...
) PURE;
STDMETHOD(OutputPromptVaList)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
__in va_list Args
) PURE;
// Gets the text that would be displayed by OutputPrompt.
STDMETHOD(GetPromptText)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// Outputs information about the current
// debuggee state such as a register
// summary, disassembly at the current PC,
// closest symbol and others.
// Uses the line prefix.
STDMETHOD(OutputCurrentState)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// Outputs the debugger and extension version
// information. This method is reentrant.
// Uses the line prefix.
STDMETHOD(OutputVersionInformation)(
THIS_
__in ULONG OutputControl
) PURE;
// In user-mode debugging sessions the
// engine will set an event when
// exceptions are continued. This can
// be used to synchronize other processes
// with the debuggers handling of events.
// For example, this is used to support
// the e argument to ntsd.
STDMETHOD(GetNotifyEventHandle)(
THIS_
__out PULONG64 Handle
) PURE;
STDMETHOD(SetNotifyEventHandle)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Assemble)(
THIS_
__in ULONG64 Offset,
__in PCSTR Instr,
__out PULONG64 EndOffset
) PURE;
STDMETHOD(Disassemble)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DisassemblySize,
__out PULONG64 EndOffset
) PURE;
// Returns the value of the effective address
// computed for the last Disassemble, if there
// was one.
STDMETHOD(GetDisassembleEffectiveOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Uses the line prefix if necessary.
STDMETHOD(OutputDisassembly)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG Flags,
__out PULONG64 EndOffset
) PURE;
// Produces multiple lines of disassembly output.
// There will be PreviousLines of disassembly before
// the given offset if a valid disassembly exists.
// In all, there will be TotalLines of output produced.
// The first and last line offsets are returned
// specially and all lines offsets can be retrieved
// through LineOffsets. LineOffsets will contain
// offsets for each line where disassembly started.
// When disassembly of a single instruction takes
// multiple lines the initial offset will be followed
// by DEBUG_INVALID_OFFSET.
// Uses the line prefix.
STDMETHOD(OutputDisassemblyLines)(
THIS_
__in ULONG OutputControl,
__in ULONG PreviousLines,
__in ULONG TotalLines,
__in ULONG64 Offset,
__in ULONG Flags,
__out_opt PULONG OffsetLine,
__out_opt PULONG64 StartOffset,
__out_opt PULONG64 EndOffset,
__out_ecount_opt(TotalLines) PULONG64 LineOffsets
) PURE;
// Returns the offset of the start of
// the instruction thats the given
// delta away from the instruction
// at the initial offset.
// This routine does not check for
// validity of the instruction or
// the memory containing it.
STDMETHOD(GetNearInstruction)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out PULONG64 NearOffset
) PURE;
// Offsets can be passed in as zero to use the current
// thread state.
STDMETHOD(GetStackTrace)(
THIS_
__in ULONG64 FrameOffset,
__in ULONG64 StackOffset,
__in ULONG64 InstructionOffset,
__out_ecount(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__out_opt PULONG FramesFilled
) PURE;
// Does a simple stack trace to determine
// what the current return address is.
STDMETHOD(GetReturnOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// If Frames is NULL OutputStackTrace will
// use GetStackTrace to get FramesSize frames
// and then output them. The current register
// values for frame, stack and instruction offsets
// are used.
// Uses the line prefix.
STDMETHOD(OutputStackTrace)(
THIS_
__in ULONG OutputControl,
__in_ecount_opt(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__in ULONG Flags
) PURE;
// Returns information about the debuggee such
// as user vs. kernel, dump vs. live, etc.
STDMETHOD(GetDebuggeeType)(
THIS_
__out PULONG Class,
__out PULONG Qualifier
) PURE;
// Returns the type of physical processors in
// the machine.
// Returns one of the IMAGE_FILE_MACHINE values.
STDMETHOD(GetActualProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Returns the type of processor used in the
// current processor context.
STDMETHOD(GetExecutingProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Query all the possible processor types that
// may be encountered during this debug session.
STDMETHOD(GetNumberPossibleExecutingProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetPossibleExecutingProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Get the number of actual processors in
// the machine.
STDMETHOD(GetNumberProcessors)(
THIS_
__out PULONG Number
) PURE;
// PlatformId is one of the VER_PLATFORM values.
// Major and minor are as given in the NT
// kernel debugger protocol.
// ServicePackString and ServicePackNumber indicate the
// system service pack level. ServicePackNumber is not
// available in some sessions where the service pack level
// is only expressed as a string. The service pack information
// will be empty if the system does not have a service pack
// applied.
// The build string is string information identifying the
// particular build of the system. The build string is
// empty if the system has no particular identifying
// information.
STDMETHOD(GetSystemVersion)(
THIS_
__out PULONG PlatformId,
__out PULONG Major,
__out PULONG Minor,
__out_ecount_opt(ServicePackStringSize) PSTR ServicePackString,
__in ULONG ServicePackStringSize,
__out_opt PULONG ServicePackStringUsed,
__out PULONG ServicePackNumber,
__out_ecount_opt(BuildStringSize) PSTR BuildString,
__in ULONG BuildStringSize,
__out_opt PULONG BuildStringUsed
) PURE;
// Returns the page size for the currently executing
// processor context. The page size may vary between
// processor types.
STDMETHOD(GetPageSize)(
THIS_
__out PULONG Size
) PURE;
// Returns S_OK if the current processor context uses
// 64-bit addresses, otherwise S_FALSE.
STDMETHOD(IsPointer64Bit)(
THIS
) PURE;
// Reads the bugcheck data area and returns the
// current contents. This method only works
// in kernel debugging sessions.
STDMETHOD(ReadBugCheckData)(
THIS_
__out PULONG Code,
__out PULONG64 Arg1,
__out PULONG64 Arg2,
__out PULONG64 Arg3,
__out PULONG64 Arg4
) PURE;
// Query all the processor types supported by
// the engine. This is a complete list and is
// not related to the machine running the engine
// or the debuggee.
STDMETHOD(GetNumberSupportedProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetSupportedProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Returns a full, descriptive name and an
// abbreviated name for a processor type.
STDMETHOD(GetProcessorTypeNames)(
THIS_
__in ULONG Type,
__out_ecount_opt(FullNameBufferSize) PSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
// Gets and sets the type of processor to
// use when doing things like setting
// breakpoints, accessing registers,
// getting stack traces and so on.
STDMETHOD(GetEffectiveProcessorType)(
THIS_
__out PULONG Type
) PURE;
STDMETHOD(SetEffectiveProcessorType)(
THIS_
__in ULONG Type
) PURE;
// Returns information about whether and how
// the debuggee is running. Status will
// be GO if the debuggee is running and
// BREAK if it isnt.
// If no debuggee exists the status is
// NO_DEBUGGEE.
// This method is reentrant.
STDMETHOD(GetExecutionStatus)(
THIS_
__out PULONG Status
) PURE;
// Changes the execution status of the
// engine from stopped to running.
// Status must be one of the go or step
// status values.
STDMETHOD(SetExecutionStatus)(
THIS_
__in ULONG Status
) PURE;
// Controls what code interpretation level the debugger
// runs at. The debugger checks the code level when
// deciding whether to step by a source line or
// assembly instruction along with other related operations.
STDMETHOD(GetCodeLevel)(
THIS_
__out PULONG Level
) PURE;
STDMETHOD(SetCodeLevel)(
THIS_
__in ULONG Level
) PURE;
// Gets and sets engine control flags.
// These methods are reentrant.
STDMETHOD(GetEngineOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetEngineOptions)(
THIS_
__in ULONG Options
) PURE;
// Gets and sets control values for
// handling system error events.
// If the system error level is less
// than or equal to the given levels
// the error may be displayed and
// the default break for the event
// may be set.
STDMETHOD(GetSystemErrorControl)(
THIS_
__out PULONG OutputLevel,
__out PULONG BreakLevel
) PURE;
STDMETHOD(SetSystemErrorControl)(
THIS_
__in ULONG OutputLevel,
__in ULONG BreakLevel
) PURE;
// The command processor supports simple
// string replacement macros in Evaluate and
// Execute. There are currently ten macro
// slots available. Slots 0-9 map to
// the command invocations $u0-$u9.
STDMETHOD(GetTextMacro)(
THIS_
__in ULONG Slot,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MacroSize
) PURE;
STDMETHOD(SetTextMacro)(
THIS_
__in ULONG Slot,
__in PCSTR Macro
) PURE;
// Controls the default number radix used
// in expressions and commands.
STDMETHOD(GetRadix)(
THIS_
__out PULONG Radix
) PURE;
STDMETHOD(SetRadix)(
THIS_
__in ULONG Radix
) PURE;
// Evaluates the given expression string and
// returns the resulting value.
// If DesiredType is DEBUG_VALUE_INVALID then
// the natural type is used.
// RemainderIndex, if provided, is set to the index
// of the first character in the input string that was
// not used when evaluating the expression.
STDMETHOD(Evaluate)(
THIS_
__in PCSTR Expression,
__in ULONG DesiredType,
__out PDEBUG_VALUE Value,
__out_opt PULONG RemainderIndex
) PURE;
// Attempts to convert the input value to a value
// of the requested type in the output value.
// Conversions can fail if no conversion exists.
// Successful conversions may be lossy.
STDMETHOD(CoerceValue)(
THIS_
__in PDEBUG_VALUE In,
__in ULONG OutType,
__out PDEBUG_VALUE Out
) PURE;
STDMETHOD(CoerceValues)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_VALUE In,
__in_ecount(Count) PULONG OutTypes,
__out_ecount(Count) PDEBUG_VALUE Out
) PURE;
// Executes the given command string.
// If the string has multiple commands
// Execute will not return until all
// of them have been executed. If this
// requires waiting for the debuggee to
// execute an internal wait will be done
// so Execute can take an arbitrary amount
// of time.
STDMETHOD(Execute)(
THIS_
__in ULONG OutputControl,
__in PCSTR Command,
__in ULONG Flags
) PURE;
// Executes the given command file by
// reading a line at a time and processing
// it with Execute.
STDMETHOD(ExecuteCommandFile)(
THIS_
__in ULONG OutputControl,
__in PCSTR CommandFile,
__in ULONG Flags
) PURE;
// Breakpoint interfaces are described
// elsewhere in this section.
STDMETHOD(GetNumberBreakpoints)(
THIS_
__out PULONG Number
) PURE;
// It is possible for this retrieval function to
// fail even with an index within the number of
// existing breakpoints if the breakpoint is
// a private breakpoint.
STDMETHOD(GetBreakpointByIndex)(
THIS_
__in ULONG Index,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
STDMETHOD(GetBreakpointById)(
THIS_
__in ULONG Id,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// If Ids is non-NULL the Count breakpoints
// referred to in the Ids array are returned,
// otherwise breakpoints from index Start to
// Start + Count 1 are returned.
STDMETHOD(GetBreakpointParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Ids,
__in ULONG Start,
__out_ecount(Count) PDEBUG_BREAKPOINT_PARAMETERS Params
) PURE;
// Breakpoints are created empty and disabled.
// When their parameters have been set they
// should be enabled by setting the ENABLE flag.
// If DesiredId is DEBUG_ANY_ID then the
// engine picks an unused ID. If DesiredId
// is any other number the engine attempts
// to use the given ID for the breakpoint.
// If another breakpoint exists with that ID
// the call will fail.
STDMETHOD(AddBreakpoint)(
THIS_
__in ULONG Type,
__in ULONG DesiredId,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// Breakpoint interface is invalid after this call.
STDMETHOD(RemoveBreakpoint)(
THIS_
__in PDEBUG_BREAKPOINT Bp
) PURE;
// Control and use extension DLLs.
STDMETHOD(AddExtension)(
THIS_
__in PCSTR Path,
__in ULONG Flags,
__out PULONG64 Handle
) PURE;
STDMETHOD(RemoveExtension)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(GetExtensionByPath)(
THIS_
__in PCSTR Path,
__out PULONG64 Handle
) PURE;
// If Handle is zero the extension
// chain is walked searching for the
// function.
STDMETHOD(CallExtension)(
THIS_
__in ULONG64 Handle,
__in PCSTR Function,
__in_opt PCSTR Arguments
) PURE;
// GetExtensionFunction works like
// GetProcAddress on extension DLLs
// to allow raw function-call-level
// interaction with extension DLLs.
// Such functions do not need to
// follow the standard extension prototype
// if they are not going to be called
// through the text extension interface.
// This function cannot be called remotely.
STDMETHOD(GetExtensionFunction)(
THIS_
__in ULONG64 Handle,
__in PCSTR FuncName,
__out FARPROC* Function
) PURE;
// These methods return alternate
// extension interfaces in order to allow
// interface-style extension DLLs to mix in
// older extension calls.
// Structure sizes must be initialized before
// the call.
// These methods cannot be called remotely.
STDMETHOD(GetWindbgExtensionApis32)(
THIS_
__inout PWINDBG_EXTENSION_APIS32 Api
) PURE;
STDMETHOD(GetWindbgExtensionApis64)(
THIS_
__inout PWINDBG_EXTENSION_APIS64 Api
) PURE;
// The engine provides a simple mechanism
// to filter common events. Arbitrarily complicated
// filtering can be done by registering event callbacks
// but simple event filtering only requires
// setting the options of one of the predefined
// event filters.
// Simple event filters are either for specific
// events and therefore have an enumerant or
// they are for an exception and are based on
// the exceptions code. Exception filters
// are further divided into exceptions specially
// handled by the engine, which is a fixed set,
// and arbitrary exceptions.
// All three groups of filters are indexed together
// with the specific filters first, then the specific
// exception filters and finally the arbitrary
// exception filters.
// The first specific exception is the default
// exception. If an exception event occurs for
// an exception without settings the default
// exception settings are used.
STDMETHOD(GetNumberEventFilters)(
THIS_
__out PULONG SpecificEvents,
__out PULONG SpecificExceptions,
__out PULONG ArbitraryExceptions
) PURE;
// Some filters have descriptive text associated with them.
STDMETHOD(GetEventFilterText)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// All filters support executing a command when the
// event occurs.
STDMETHOD(GetEventFilterCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetEventFilterCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
STDMETHOD(GetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
STDMETHOD(SetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__in_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
// Some specific filters have arguments to further
// qualify their operation.
STDMETHOD(GetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ArgumentSize
) PURE;
STDMETHOD(SetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__in PCSTR Argument
) PURE;
// If Codes is non-NULL Start is ignored.
STDMETHOD(GetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Codes,
__in ULONG Start,
__out_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// The codes in the parameter data control the application
// of the parameter data. If a code is not already in
// the set of filters it is added. If the ExecutionOption
// for a code is REMOVE then the filter is removed.
// Specific exception filters cannot be removed.
STDMETHOD(SetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// Exception filters support an additional command for
// second-chance events.
STDMETHOD(GetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
// Yields processing to the engine until
// an event occurs. This method may
// only be called by the thread that started
// the debug session.
// When an event occurs the engine carries
// out all event processing such as calling
// callbacks.
// If the callbacks indicate that execution should
// break the wait will return, otherwise it
// goes back to waiting for a new event.
// If the timeout expires, S_FALSE is returned.
// The timeout is not currently supported for
// kernel debugging.
STDMETHOD(WaitForEvent)(
THIS_
__in ULONG Flags,
__in ULONG Timeout
) PURE;
// Retrieves information about the last event that occurred.
// EventType is one of the event callback mask bits.
// ExtraInformation contains additional event-specific
// information. Not all events have additional information.
STDMETHOD(GetLastEventInformation)(
THIS_
__out PULONG Type,
__out PULONG ProcessId,
__out PULONG ThreadId,
__out_bcount_opt(ExtraInformationSize) PVOID ExtraInformation,
__in ULONG ExtraInformationSize,
__out_opt PULONG ExtraInformationUsed,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG DescriptionUsed
) PURE;
// IDebugControl2.
STDMETHOD(GetCurrentTimeDate)(
THIS_
__out PULONG TimeDate
) PURE;
// Retrieves the number of seconds since the
// machine started running.
STDMETHOD(GetCurrentSystemUpTime)(
THIS_
__out PULONG UpTime
) PURE;
// If the current session is a dump session,
// retrieves any extended format information.
STDMETHOD(GetDumpFormatFlags)(
THIS_
__out PULONG FormatFlags
) PURE;
// The debugger has been enhanced to allow
// arbitrary text replacements in addition
// to the simple $u0-$u9 text macros.
// Text replacement takes a given source
// text in commands and converts it to the
// given destination text. Replacements
// are named by their source text so that
// only one replacement for a source text
// string can exist.
STDMETHOD(GetNumberTextReplacements)(
THIS_
__out PULONG NumRepl
) PURE;
// If SrcText is non-NULL the replacement
// is looked up by source text, otherwise
// Index is used to get the Nth replacement.
STDMETHOD(GetTextReplacement)(
THIS_
__in_opt PCSTR SrcText,
__in ULONG Index,
__out_ecount_opt(SrcBufferSize) PSTR SrcBuffer,
__in ULONG SrcBufferSize,
__out_opt PULONG SrcSize,
__out_ecount_opt(DstBufferSize) PSTR DstBuffer,
__in ULONG DstBufferSize,
__out_opt PULONG DstSize
) PURE;
// Setting the destination text to
// NULL removes the alias.
STDMETHOD(SetTextReplacement)(
THIS_
__in PCSTR SrcText,
__in_opt PCSTR DstText
) PURE;
STDMETHOD(RemoveTextReplacements)(
THIS
) PURE;
// Outputs the complete list of current
// replacements.
STDMETHOD(OutputTextReplacements)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// IDebugControl3.
// Control options for assembly and disassembly.
STDMETHOD(GetAssemblyOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddAssemblyOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveAssemblyOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetAssemblyOptions)(
THIS_
__in ULONG Options
) PURE;
// Control the expression syntax.
STDMETHOD(GetExpressionSyntax)(
THIS_
__out PULONG Flags
) PURE;
STDMETHOD(SetExpressionSyntax)(
THIS_
__in ULONG Flags
) PURE;
// Look up a syntax by its abbreviated
// name and set it.
STDMETHOD(SetExpressionSyntaxByName)(
THIS_
__in PCSTR AbbrevName
) PURE;
STDMETHOD(GetNumberExpressionSyntaxes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetExpressionSyntaxNames)(
THIS_
__in ULONG Index,
__out_ecount_opt(FullNameBufferSize) PSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
//
// Some debug sessions have only a single
// possible event, such as a snapshot dump
// file; some have dynamic events, such as
// a live debug session; and others may have
// multiple events, such as a dump file that
// contains snapshots from different points
// in time. The following methods allow
// discovery and selection of the available
// events for a session.
// Sessions with one or more static events
// will be able to report all of the events
// when queried. Sessions with dynamic events
// will only report a single event representing
// the current event.
// Switching events constitutes execution and
// changing the current event will alter the
// execution status to a running state, after
// which WaitForEvent must be used to process
// the selected event.
//
// GetNumberEvents returns S_OK if this is the
// complete set of events possible, such as for
// a static session; or S_FALSE if other events
// may be possible, such as for a dynamic session.
STDMETHOD(GetNumberEvents)(
THIS_
__out PULONG Events
) PURE;
// Sessions may have descriptive information for
// the various events available. The amount of
// information varies according to the specific
// session and data.
STDMETHOD(GetEventIndexDescription)(
THIS_
__in ULONG Index,
__in ULONG Which,
__in_opt PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DescSize
) PURE;
STDMETHOD(GetCurrentEventIndex)(
THIS_
__out PULONG Index
) PURE;
// SetNextEventIndex works like seek in that
// it can set an absolute or relative index.
// SetNextEventIndex works similarly to SetExecutionStatus
// by putting the session into a running state, after
// which the caller must call WaitForEvent. The
// current event index only changes when WaitForEvent
// is called.
STDMETHOD(SetNextEventIndex)(
THIS_
__in ULONG Relation,
__in ULONG Value,
__out PULONG NextIndex
) PURE;
};
//
// Log file flags.
//
#define DEBUG_LOG_DEFAULT 0x00000000
#define DEBUG_LOG_APPEND 0x00000001
#define DEBUG_LOG_UNICODE 0x00000002
//
// System version strings.
//
#define DEBUG_SYSVERSTR_SERVICE_PACK 0x00000000
#define DEBUG_SYSVERSTR_BUILD 0x00000001
//
// GetManagedStatus flags and strings.
//
#define DEBUG_MANAGED_DISABLED 0x00000000
#define DEBUG_MANAGED_ALLOWED 0x00000001
#define DEBUG_MANAGED_DLL_LOADED 0x00000002
#define DEBUG_MANSTR_NONE 0x00000000
#define DEBUG_MANSTR_LOADED_SUPPORT_DLL 0x00000001
#define DEBUG_MANSTR_LOAD_STATUS 0x00000002
//
// ResetManagedStatus flags.
//
// Reset state to default engine startup state with
// no support loaded.
#define DEBUG_MANRESET_DEFAULT 0x00000000
// Force managed support DLL load attempt.
#define DEBUG_MANRESET_LOAD_DLL 0x00000001
#undef INTERFACE
#define INTERFACE IDebugControl4
DECLARE_INTERFACE_(IDebugControl4, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugControl.
// Checks for a user interrupt, such a Ctrl-C
// or stop button.
// This method is reentrant.
STDMETHOD(GetInterrupt)(
THIS
) PURE;
// Registers a user interrupt.
// This method is reentrant.
STDMETHOD(SetInterrupt)(
THIS_
__in ULONG Flags
) PURE;
// Interrupting a user-mode process requires
// access to some system resources that the
// process may hold itself, preventing the
// interrupt from occurring. The engine
// will time-out pending interrupt requests
// and simulate an interrupt if necessary.
// These methods control the interrupt timeout.
STDMETHOD(GetInterruptTimeout)(
THIS_
__out PULONG Seconds
) PURE;
STDMETHOD(SetInterruptTimeout)(
THIS_
__in ULONG Seconds
) PURE;
STDMETHOD(GetLogFile)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PBOOL Append
) PURE;
// Opens a log file which collects all
// output. Output from every client except
// those that explicitly disable logging
// goes into the log.
// Opening a log file closes any log file
// already open.
STDMETHOD(OpenLogFile)(
THIS_
__in PCSTR File,
__in BOOL Append
) PURE;
STDMETHOD(CloseLogFile)(
THIS
) PURE;
// Controls what output is logged.
STDMETHOD(GetLogMask)(
THIS_
__out PULONG Mask
) PURE;
STDMETHOD(SetLogMask)(
THIS_
__in ULONG Mask
) PURE;
// Input requests input from all clients.
// The first input that is returned is used
// to satisfy the call. Other returned
// input is discarded.
STDMETHOD(Input)(
THIS_
__out_ecount(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG InputSize
) PURE;
// This method is used by clients to return
// input when it is available. It will
// return S_OK if the input is used to
// satisfy an Input call and S_FALSE if
// the input is ignored.
// This method is reentrant.
STDMETHOD(ReturnInput)(
THIS_
__in PCSTR Buffer
) PURE;
// Sends output through clients
// output callbacks if the mask is allowed
// by the current output control mask and
// according to the output distribution
// settings.
STDMETHODV(Output)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(OutputVaList)(
THIS_
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// The following methods allow direct control
// over the distribution of the given output
// for situations where something other than
// the default is desired. These methods require
// extra work in the engine so they should
// only be used when necessary.
STDMETHODV(ControlledOutput)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
...
) PURE;
STDMETHOD(ControlledOutputVaList)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCSTR Format,
__in va_list Args
) PURE;
// Displays the standard command-line prompt
// followed by the given output. If Format
// is NULL no additional output is produced.
// Output is produced under the
// DEBUG_OUTPUT_PROMPT mask.
// This method only outputs the prompt; it
// does not get input.
STDMETHODV(OutputPrompt)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
...
) PURE;
STDMETHOD(OutputPromptVaList)(
THIS_
__in ULONG OutputControl,
__in_opt PCSTR Format,
__in va_list Args
) PURE;
// Gets the text that would be displayed by OutputPrompt.
STDMETHOD(GetPromptText)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// Outputs information about the current
// debuggee state such as a register
// summary, disassembly at the current PC,
// closest symbol and others.
// Uses the line prefix.
STDMETHOD(OutputCurrentState)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// Outputs the debugger and extension version
// information. This method is reentrant.
// Uses the line prefix.
STDMETHOD(OutputVersionInformation)(
THIS_
__in ULONG OutputControl
) PURE;
// In user-mode debugging sessions the
// engine will set an event when
// exceptions are continued. This can
// be used to synchronize other processes
// with the debuggers handling of events.
// For example, this is used to support
// the e argument to ntsd.
STDMETHOD(GetNotifyEventHandle)(
THIS_
__out PULONG64 Handle
) PURE;
STDMETHOD(SetNotifyEventHandle)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Assemble)(
THIS_
__in ULONG64 Offset,
__in PCSTR Instr,
__out PULONG64 EndOffset
) PURE;
STDMETHOD(Disassemble)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DisassemblySize,
__out PULONG64 EndOffset
) PURE;
// Returns the value of the effective address
// computed for the last Disassemble, if there
// was one.
STDMETHOD(GetDisassembleEffectiveOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Uses the line prefix if necessary.
STDMETHOD(OutputDisassembly)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG Flags,
__out PULONG64 EndOffset
) PURE;
// Produces multiple lines of disassembly output.
// There will be PreviousLines of disassembly before
// the given offset if a valid disassembly exists.
// In all, there will be TotalLines of output produced.
// The first and last line offsets are returned
// specially and all lines offsets can be retrieved
// through LineOffsets. LineOffsets will contain
// offsets for each line where disassembly started.
// When disassembly of a single instruction takes
// multiple lines the initial offset will be followed
// by DEBUG_INVALID_OFFSET.
// Uses the line prefix.
STDMETHOD(OutputDisassemblyLines)(
THIS_
__in ULONG OutputControl,
__in ULONG PreviousLines,
__in ULONG TotalLines,
__in ULONG64 Offset,
__in ULONG Flags,
__out_opt PULONG OffsetLine,
__out_opt PULONG64 StartOffset,
__out_opt PULONG64 EndOffset,
__out_ecount_opt(TotalLines) PULONG64 LineOffsets
) PURE;
// Returns the offset of the start of
// the instruction thats the given
// delta away from the instruction
// at the initial offset.
// This routine does not check for
// validity of the instruction or
// the memory containing it.
STDMETHOD(GetNearInstruction)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out PULONG64 NearOffset
) PURE;
// Offsets can be passed in as zero to use the current
// thread state.
STDMETHOD(GetStackTrace)(
THIS_
__in ULONG64 FrameOffset,
__in ULONG64 StackOffset,
__in ULONG64 InstructionOffset,
__out_ecount(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__out_opt PULONG FramesFilled
) PURE;
// Does a simple stack trace to determine
// what the current return address is.
STDMETHOD(GetReturnOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// If Frames is NULL OutputStackTrace will
// use GetStackTrace to get FramesSize frames
// and then output them. The current register
// values for frame, stack and instruction offsets
// are used.
// Uses the line prefix.
STDMETHOD(OutputStackTrace)(
THIS_
__in ULONG OutputControl,
__in_ecount_opt(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__in ULONG Flags
) PURE;
// Returns information about the debuggee such
// as user vs. kernel, dump vs. live, etc.
STDMETHOD(GetDebuggeeType)(
THIS_
__out PULONG Class,
__out PULONG Qualifier
) PURE;
// Returns the type of physical processors in
// the machine.
// Returns one of the IMAGE_FILE_MACHINE values.
STDMETHOD(GetActualProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Returns the type of processor used in the
// current processor context.
STDMETHOD(GetExecutingProcessorType)(
THIS_
__out PULONG Type
) PURE;
// Query all the possible processor types that
// may be encountered during this debug session.
STDMETHOD(GetNumberPossibleExecutingProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetPossibleExecutingProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Get the number of actual processors in
// the machine.
STDMETHOD(GetNumberProcessors)(
THIS_
__out PULONG Number
) PURE;
// PlatformId is one of the VER_PLATFORM values.
// Major and minor are as given in the NT
// kernel debugger protocol.
// ServicePackString and ServicePackNumber indicate the
// system service pack level. ServicePackNumber is not
// available in some sessions where the service pack level
// is only expressed as a string. The service pack information
// will be empty if the system does not have a service pack
// applied.
// The build string is string information identifying the
// particular build of the system. The build string is
// empty if the system has no particular identifying
// information.
STDMETHOD(GetSystemVersion)(
THIS_
__out PULONG PlatformId,
__out PULONG Major,
__out PULONG Minor,
__out_ecount_opt(ServicePackStringSize) PSTR ServicePackString,
__in ULONG ServicePackStringSize,
__out_opt PULONG ServicePackStringUsed,
__out PULONG ServicePackNumber,
__out_ecount_opt(BuildStringSize) PSTR BuildString,
__in ULONG BuildStringSize,
__out_opt PULONG BuildStringUsed
) PURE;
// Returns the page size for the currently executing
// processor context. The page size may vary between
// processor types.
STDMETHOD(GetPageSize)(
THIS_
__out PULONG Size
) PURE;
// Returns S_OK if the current processor context uses
// 64-bit addresses, otherwise S_FALSE.
STDMETHOD(IsPointer64Bit)(
THIS
) PURE;
// Reads the bugcheck data area and returns the
// current contents. This method only works
// in kernel debugging sessions.
STDMETHOD(ReadBugCheckData)(
THIS_
__out PULONG Code,
__out PULONG64 Arg1,
__out PULONG64 Arg2,
__out PULONG64 Arg3,
__out PULONG64 Arg4
) PURE;
// Query all the processor types supported by
// the engine. This is a complete list and is
// not related to the machine running the engine
// or the debuggee.
STDMETHOD(GetNumberSupportedProcessorTypes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetSupportedProcessorTypes)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Types
) PURE;
// Returns a full, descriptive name and an
// abbreviated name for a processor type.
STDMETHOD(GetProcessorTypeNames)(
THIS_
__in ULONG Type,
__out_ecount_opt(FullNameBufferSize) PSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
// Gets and sets the type of processor to
// use when doing things like setting
// breakpoints, accessing registers,
// getting stack traces and so on.
STDMETHOD(GetEffectiveProcessorType)(
THIS_
__out PULONG Type
) PURE;
STDMETHOD(SetEffectiveProcessorType)(
THIS_
__in ULONG Type
) PURE;
// Returns information about whether and how
// the debuggee is running. Status will
// be GO if the debuggee is running and
// BREAK if it isnt.
// If no debuggee exists the status is
// NO_DEBUGGEE.
// This method is reentrant.
STDMETHOD(GetExecutionStatus)(
THIS_
__out PULONG Status
) PURE;
// Changes the execution status of the
// engine from stopped to running.
// Status must be one of the go or step
// status values.
STDMETHOD(SetExecutionStatus)(
THIS_
__in ULONG Status
) PURE;
// Controls what code interpretation level the debugger
// runs at. The debugger checks the code level when
// deciding whether to step by a source line or
// assembly instruction along with other related operations.
STDMETHOD(GetCodeLevel)(
THIS_
__out PULONG Level
) PURE;
STDMETHOD(SetCodeLevel)(
THIS_
__in ULONG Level
) PURE;
// Gets and sets engine control flags.
// These methods are reentrant.
STDMETHOD(GetEngineOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveEngineOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetEngineOptions)(
THIS_
__in ULONG Options
) PURE;
// Gets and sets control values for
// handling system error events.
// If the system error level is less
// than or equal to the given levels
// the error may be displayed and
// the default break for the event
// may be set.
STDMETHOD(GetSystemErrorControl)(
THIS_
__out PULONG OutputLevel,
__out PULONG BreakLevel
) PURE;
STDMETHOD(SetSystemErrorControl)(
THIS_
__in ULONG OutputLevel,
__in ULONG BreakLevel
) PURE;
// The command processor supports simple
// string replacement macros in Evaluate and
// Execute. There are currently ten macro
// slots available. Slots 0-9 map to
// the command invocations $u0-$u9.
STDMETHOD(GetTextMacro)(
THIS_
__in ULONG Slot,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MacroSize
) PURE;
STDMETHOD(SetTextMacro)(
THIS_
__in ULONG Slot,
__in PCSTR Macro
) PURE;
// Controls the default number radix used
// in expressions and commands.
STDMETHOD(GetRadix)(
THIS_
__out PULONG Radix
) PURE;
STDMETHOD(SetRadix)(
THIS_
__in ULONG Radix
) PURE;
// Evaluates the given expression string and
// returns the resulting value.
// If DesiredType is DEBUG_VALUE_INVALID then
// the natural type is used.
// RemainderIndex, if provided, is set to the index
// of the first character in the input string that was
// not used when evaluating the expression.
STDMETHOD(Evaluate)(
THIS_
__in PCSTR Expression,
__in ULONG DesiredType,
__out PDEBUG_VALUE Value,
__out_opt PULONG RemainderIndex
) PURE;
// Attempts to convert the input value to a value
// of the requested type in the output value.
// Conversions can fail if no conversion exists.
// Successful conversions may be lossy.
STDMETHOD(CoerceValue)(
THIS_
__in PDEBUG_VALUE In,
__in ULONG OutType,
__out PDEBUG_VALUE Out
) PURE;
STDMETHOD(CoerceValues)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_VALUE In,
__in_ecount(Count) PULONG OutTypes,
__out_ecount(Count) PDEBUG_VALUE Out
) PURE;
// Executes the given command string.
// If the string has multiple commands
// Execute will not return until all
// of them have been executed. If this
// requires waiting for the debuggee to
// execute an internal wait will be done
// so Execute can take an arbitrary amount
// of time.
STDMETHOD(Execute)(
THIS_
__in ULONG OutputControl,
__in PCSTR Command,
__in ULONG Flags
) PURE;
// Executes the given command file by
// reading a line at a time and processing
// it with Execute.
STDMETHOD(ExecuteCommandFile)(
THIS_
__in ULONG OutputControl,
__in PCSTR CommandFile,
__in ULONG Flags
) PURE;
// Breakpoint interfaces are described
// elsewhere in this section.
STDMETHOD(GetNumberBreakpoints)(
THIS_
__out PULONG Number
) PURE;
// It is possible for this retrieval function to
// fail even with an index within the number of
// existing breakpoints if the breakpoint is
// a private breakpoint.
STDMETHOD(GetBreakpointByIndex)(
THIS_
__in ULONG Index,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
STDMETHOD(GetBreakpointById)(
THIS_
__in ULONG Id,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// If Ids is non-NULL the Count breakpoints
// referred to in the Ids array are returned,
// otherwise breakpoints from index Start to
// Start + Count 1 are returned.
STDMETHOD(GetBreakpointParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Ids,
__in ULONG Start,
__out_ecount(Count) PDEBUG_BREAKPOINT_PARAMETERS Params
) PURE;
// Breakpoints are created empty and disabled.
// When their parameters have been set they
// should be enabled by setting the ENABLE flag.
// If DesiredId is DEBUG_ANY_ID then the
// engine picks an unused ID. If DesiredId
// is any other number the engine attempts
// to use the given ID for the breakpoint.
// If another breakpoint exists with that ID
// the call will fail.
STDMETHOD(AddBreakpoint)(
THIS_
__in ULONG Type,
__in ULONG DesiredId,
__out PDEBUG_BREAKPOINT* Bp
) PURE;
// Breakpoint interface is invalid after this call.
STDMETHOD(RemoveBreakpoint)(
THIS_
__in PDEBUG_BREAKPOINT Bp
) PURE;
// Control and use extension DLLs.
STDMETHOD(AddExtension)(
THIS_
__in PCSTR Path,
__in ULONG Flags,
__out PULONG64 Handle
) PURE;
STDMETHOD(RemoveExtension)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(GetExtensionByPath)(
THIS_
__in PCSTR Path,
__out PULONG64 Handle
) PURE;
// If Handle is zero the extension
// chain is walked searching for the
// function.
STDMETHOD(CallExtension)(
THIS_
__in ULONG64 Handle,
__in PCSTR Function,
__in_opt PCSTR Arguments
) PURE;
// GetExtensionFunction works like
// GetProcAddress on extension DLLs
// to allow raw function-call-level
// interaction with extension DLLs.
// Such functions do not need to
// follow the standard extension prototype
// if they are not going to be called
// through the text extension interface.
// This function cannot be called remotely.
STDMETHOD(GetExtensionFunction)(
THIS_
__in ULONG64 Handle,
__in PCSTR FuncName,
__out FARPROC* Function
) PURE;
// These methods return alternate
// extension interfaces in order to allow
// interface-style extension DLLs to mix in
// older extension calls.
// Structure sizes must be initialized before
// the call.
// These methods cannot be called remotely.
STDMETHOD(GetWindbgExtensionApis32)(
THIS_
__inout PWINDBG_EXTENSION_APIS32 Api
) PURE;
STDMETHOD(GetWindbgExtensionApis64)(
THIS_
__inout PWINDBG_EXTENSION_APIS64 Api
) PURE;
// The engine provides a simple mechanism
// to filter common events. Arbitrarily complicated
// filtering can be done by registering event callbacks
// but simple event filtering only requires
// setting the options of one of the predefined
// event filters.
// Simple event filters are either for specific
// events and therefore have an enumerant or
// they are for an exception and are based on
// the exceptions code. Exception filters
// are further divided into exceptions specially
// handled by the engine, which is a fixed set,
// and arbitrary exceptions.
// All three groups of filters are indexed together
// with the specific filters first, then the specific
// exception filters and finally the arbitrary
// exception filters.
// The first specific exception is the default
// exception. If an exception event occurs for
// an exception without settings the default
// exception settings are used.
STDMETHOD(GetNumberEventFilters)(
THIS_
__out PULONG SpecificEvents,
__out PULONG SpecificExceptions,
__out PULONG ArbitraryExceptions
) PURE;
// Some filters have descriptive text associated with them.
STDMETHOD(GetEventFilterText)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
// All filters support executing a command when the
// event occurs.
STDMETHOD(GetEventFilterCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetEventFilterCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
STDMETHOD(GetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
STDMETHOD(SetSpecificFilterParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__in_ecount(Count) PDEBUG_SPECIFIC_FILTER_PARAMETERS Params
) PURE;
// Some specific filters have arguments to further
// qualify their operation.
STDMETHOD(GetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ArgumentSize
) PURE;
STDMETHOD(SetSpecificFilterArgument)(
THIS_
__in ULONG Index,
__in PCSTR Argument
) PURE;
// If Codes is non-NULL Start is ignored.
STDMETHOD(GetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Codes,
__in ULONG Start,
__out_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// The codes in the parameter data control the application
// of the parameter data. If a code is not already in
// the set of filters it is added. If the ExecutionOption
// for a code is REMOVE then the filter is removed.
// Specific exception filters cannot be removed.
STDMETHOD(SetExceptionFilterParameters)(
THIS_
__in ULONG Count,
__in_ecount(Count) PDEBUG_EXCEPTION_FILTER_PARAMETERS Params
) PURE;
// Exception filters support an additional command for
// second-chance events.
STDMETHOD(GetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetExceptionFilterSecondCommand)(
THIS_
__in ULONG Index,
__in PCSTR Command
) PURE;
// Yields processing to the engine until
// an event occurs. This method may
// only be called by the thread that started
// the debug session.
// When an event occurs the engine carries
// out all event processing such as calling
// callbacks.
// If the callbacks indicate that execution should
// break the wait will return, otherwise it
// goes back to waiting for a new event.
// If the timeout expires, S_FALSE is returned.
// The timeout is not currently supported for
// kernel debugging.
STDMETHOD(WaitForEvent)(
THIS_
__in ULONG Flags,
__in ULONG Timeout
) PURE;
// Retrieves information about the last event that occurred.
// EventType is one of the event callback mask bits.
// ExtraInformation contains additional event-specific
// information. Not all events have additional information.
STDMETHOD(GetLastEventInformation)(
THIS_
__out PULONG Type,
__out PULONG ProcessId,
__out PULONG ThreadId,
__out_bcount_opt(ExtraInformationSize) PVOID ExtraInformation,
__in ULONG ExtraInformationSize,
__out_opt PULONG ExtraInformationUsed,
__out_ecount_opt(DescriptionSize) PSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG DescriptionUsed
) PURE;
// IDebugControl2.
STDMETHOD(GetCurrentTimeDate)(
THIS_
__out PULONG TimeDate
) PURE;
// Retrieves the number of seconds since the
// machine started running.
STDMETHOD(GetCurrentSystemUpTime)(
THIS_
__out PULONG UpTime
) PURE;
// If the current session is a dump session,
// retrieves any extended format information.
STDMETHOD(GetDumpFormatFlags)(
THIS_
__out PULONG FormatFlags
) PURE;
// The debugger has been enhanced to allow
// arbitrary text replacements in addition
// to the simple $u0-$u9 text macros.
// Text replacement takes a given source
// text in commands and converts it to the
// given destination text. Replacements
// are named by their source text so that
// only one replacement for a source text
// string can exist.
STDMETHOD(GetNumberTextReplacements)(
THIS_
__out PULONG NumRepl
) PURE;
// If SrcText is non-NULL the replacement
// is looked up by source text, otherwise
// Index is used to get the Nth replacement.
STDMETHOD(GetTextReplacement)(
THIS_
__in_opt PCSTR SrcText,
__in ULONG Index,
__out_ecount_opt(SrcBufferSize) PSTR SrcBuffer,
__in ULONG SrcBufferSize,
__out_opt PULONG SrcSize,
__out_ecount_opt(DstBufferSize) PSTR DstBuffer,
__in ULONG DstBufferSize,
__out_opt PULONG DstSize
) PURE;
// Setting the destination text to
// NULL removes the alias.
STDMETHOD(SetTextReplacement)(
THIS_
__in PCSTR SrcText,
__in_opt PCSTR DstText
) PURE;
STDMETHOD(RemoveTextReplacements)(
THIS
) PURE;
// Outputs the complete list of current
// replacements.
STDMETHOD(OutputTextReplacements)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// IDebugControl3.
// Control options for assembly and disassembly.
STDMETHOD(GetAssemblyOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddAssemblyOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveAssemblyOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetAssemblyOptions)(
THIS_
__in ULONG Options
) PURE;
// Control the expression syntax.
STDMETHOD(GetExpressionSyntax)(
THIS_
__out PULONG Flags
) PURE;
STDMETHOD(SetExpressionSyntax)(
THIS_
__in ULONG Flags
) PURE;
// Look up a syntax by its abbreviated
// name and set it.
STDMETHOD(SetExpressionSyntaxByName)(
THIS_
__in PCSTR AbbrevName
) PURE;
STDMETHOD(GetNumberExpressionSyntaxes)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetExpressionSyntaxNames)(
THIS_
__in ULONG Index,
__out_ecount_opt(FullNameBufferSize) PSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
//
// Some debug sessions have only a single
// possible event, such as a snapshot dump
// file; some have dynamic events, such as
// a live debug session; and others may have
// multiple events, such as a dump file that
// contains snapshots from different points
// in time. The following methods allow
// discovery and selection of the available
// events for a session.
// Sessions with one or more static events
// will be able to report all of the events
// when queried. Sessions with dynamic events
// will only report a single event representing
// the current event.
// Switching events constitutes execution and
// changing the current event will alter the
// execution status to a running state, after
// which WaitForEvent must be used to process
// the selected event.
//
// GetNumberEvents returns S_OK if this is the
// complete set of events possible, such as for
// a static session; or S_FALSE if other events
// may be possible, such as for a dynamic session.
STDMETHOD(GetNumberEvents)(
THIS_
__out PULONG Events
) PURE;
// Sessions may have descriptive information for
// the various events available. The amount of
// information varies according to the specific
// session and data.
STDMETHOD(GetEventIndexDescription)(
THIS_
__in ULONG Index,
__in ULONG Which,
__in_opt PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DescSize
) PURE;
STDMETHOD(GetCurrentEventIndex)(
THIS_
__out PULONG Index
) PURE;
// SetNextEventIndex works like seek in that
// it can set an absolute or relative index.
// SetNextEventIndex works similarly to SetExecutionStatus
// by putting the session into a running state, after
// which the caller must call WaitForEvent. The
// current event index only changes when WaitForEvent
// is called.
STDMETHOD(SetNextEventIndex)(
THIS_
__in ULONG Relation,
__in ULONG Value,
__out PULONG NextIndex
) PURE;
// IDebugControl4.
STDMETHOD(GetLogFileWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PBOOL Append
) PURE;
STDMETHOD(OpenLogFileWide)(
THIS_
__in PCWSTR File,
__in BOOL Append
) PURE;
STDMETHOD(InputWide)(
THIS_
__out PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG InputSize
) PURE;
STDMETHOD(ReturnInputWide)(
THIS_
__in PCWSTR Buffer
) PURE;
STDMETHODV(OutputWide)(
THIS_
__in ULONG Mask,
__in PCWSTR Format,
...
) PURE;
STDMETHOD(OutputVaListWide)(
THIS_
__in ULONG Mask,
__in PCWSTR Format,
__in va_list Args
) PURE;
STDMETHODV(ControlledOutputWide)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCWSTR Format,
...
) PURE;
STDMETHOD(ControlledOutputVaListWide)(
THIS_
__in ULONG OutputControl,
__in ULONG Mask,
__in PCWSTR Format,
__in va_list Args
) PURE;
STDMETHODV(OutputPromptWide)(
THIS_
__in ULONG OutputControl,
__in_opt PCWSTR Format,
...
) PURE;
STDMETHOD(OutputPromptVaListWide)(
THIS_
__in ULONG OutputControl,
__in_opt PCWSTR Format,
__in va_list Args
) PURE;
STDMETHOD(GetPromptTextWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
STDMETHOD(AssembleWide)(
THIS_
__in ULONG64 Offset,
__in PCWSTR Instr,
__out PULONG64 EndOffset
) PURE;
STDMETHOD(DisassembleWide)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DisassemblySize,
__out PULONG64 EndOffset
) PURE;
STDMETHOD(GetProcessorTypeNamesWide)(
THIS_
__in ULONG Type,
__out_ecount_opt(FullNameBufferSize) PWSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PWSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
STDMETHOD(GetTextMacroWide)(
THIS_
__in ULONG Slot,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MacroSize
) PURE;
STDMETHOD(SetTextMacroWide)(
THIS_
__in ULONG Slot,
__in PCWSTR Macro
) PURE;
STDMETHOD(EvaluateWide)(
THIS_
__in PCWSTR Expression,
__in ULONG DesiredType,
__out PDEBUG_VALUE Value,
__out_opt PULONG RemainderIndex
) PURE;
STDMETHOD(ExecuteWide)(
THIS_
__in ULONG OutputControl,
__in PCWSTR Command,
__in ULONG Flags
) PURE;
STDMETHOD(ExecuteCommandFileWide)(
THIS_
__in ULONG OutputControl,
__in PCWSTR CommandFile,
__in ULONG Flags
) PURE;
STDMETHOD(GetBreakpointByIndex2)(
THIS_
__in ULONG Index,
__out PDEBUG_BREAKPOINT2* Bp
) PURE;
STDMETHOD(GetBreakpointById2)(
THIS_
__in ULONG Id,
__out PDEBUG_BREAKPOINT2* Bp
) PURE;
STDMETHOD(AddBreakpoint2)(
THIS_
__in ULONG Type,
__in ULONG DesiredId,
__out PDEBUG_BREAKPOINT2* Bp
) PURE;
STDMETHOD(RemoveBreakpoint2)(
THIS_
__in PDEBUG_BREAKPOINT2 Bp
) PURE;
STDMETHOD(AddExtensionWide)(
THIS_
__in PCWSTR Path,
__in ULONG Flags,
__out PULONG64 Handle
) PURE;
STDMETHOD(GetExtensionByPathWide)(
THIS_
__in PCWSTR Path,
__out PULONG64 Handle
) PURE;
STDMETHOD(CallExtensionWide)(
THIS_
__in ULONG64 Handle,
__in PCWSTR Function,
__in_opt PCWSTR Arguments
) PURE;
STDMETHOD(GetExtensionFunctionWide)(
THIS_
__in ULONG64 Handle,
__in PCWSTR FuncName,
__out FARPROC* Function
) PURE;
STDMETHOD(GetEventFilterTextWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG TextSize
) PURE;
STDMETHOD(GetEventFilterCommandWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetEventFilterCommandWide)(
THIS_
__in ULONG Index,
__in PCWSTR Command
) PURE;
STDMETHOD(GetSpecificFilterArgumentWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ArgumentSize
) PURE;
STDMETHOD(SetSpecificFilterArgumentWide)(
THIS_
__in ULONG Index,
__in PCWSTR Argument
) PURE;
STDMETHOD(GetExceptionFilterSecondCommandWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG CommandSize
) PURE;
STDMETHOD(SetExceptionFilterSecondCommandWide)(
THIS_
__in ULONG Index,
__in PCWSTR Command
) PURE;
STDMETHOD(GetLastEventInformationWide)(
THIS_
__out PULONG Type,
__out PULONG ProcessId,
__out PULONG ThreadId,
__out_bcount_opt(ExtraInformationSize) PVOID ExtraInformation,
__in ULONG ExtraInformationSize,
__out_opt PULONG ExtraInformationUsed,
__out_ecount_opt(DescriptionSize) PWSTR Description,
__in ULONG DescriptionSize,
__out_opt PULONG DescriptionUsed
) PURE;
STDMETHOD(GetTextReplacementWide)(
THIS_
__in_opt PCWSTR SrcText,
__in ULONG Index,
__out_ecount_opt(SrcBufferSize) PWSTR SrcBuffer,
__in ULONG SrcBufferSize,
__out_opt PULONG SrcSize,
__out_ecount_opt(DstBufferSize) PWSTR DstBuffer,
__in ULONG DstBufferSize,
__out_opt PULONG DstSize
) PURE;
STDMETHOD(SetTextReplacementWide)(
THIS_
__in PCWSTR SrcText,
__in_opt PCWSTR DstText
) PURE;
STDMETHOD(SetExpressionSyntaxByNameWide)(
THIS_
__in PCWSTR AbbrevName
) PURE;
STDMETHOD(GetExpressionSyntaxNamesWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(FullNameBufferSize) PWSTR FullNameBuffer,
__in ULONG FullNameBufferSize,
__out_opt PULONG FullNameSize,
__out_ecount_opt(AbbrevNameBufferSize) PWSTR AbbrevNameBuffer,
__in ULONG AbbrevNameBufferSize,
__out_opt PULONG AbbrevNameSize
) PURE;
STDMETHOD(GetEventIndexDescriptionWide)(
THIS_
__in ULONG Index,
__in ULONG Which,
__in_opt PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG DescSize
) PURE;
STDMETHOD(GetLogFile2)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PULONG Flags
) PURE;
STDMETHOD(OpenLogFile2)(
THIS_
__in PCSTR File,
__in ULONG Flags
) PURE;
STDMETHOD(GetLogFile2Wide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FileSize,
__out PULONG Flags
) PURE;
STDMETHOD(OpenLogFile2Wide)(
THIS_
__in PCWSTR File,
__in ULONG Flags
) PURE;
// GetSystemVersion always returns the kd
// major/minor version numbers, which are
// different than the Win32 version numbers.
// GetSystemVersionValues can be used
// to determine the Win32 version values.
STDMETHOD(GetSystemVersionValues)(
THIS_
__out PULONG PlatformId,
__out PULONG Win32Major,
__out PULONG Win32Minor,
__out_opt PULONG KdMajor,
__out_opt PULONG KdMinor
) PURE;
// Strings are selected with DEBUG_SYSVERSTR_*.
STDMETHOD(GetSystemVersionString)(
THIS_
__in ULONG Which,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(GetSystemVersionStringWide)(
THIS_
__in ULONG Which,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
// Stack tracing with a full initial context
// and full context return for each frame.
// The FrameContextsSize parameter is the total
// byte size of FrameContexts. FrameContextsEntrySize
// gives the byte size of each entry in
// FrameContexts.
STDMETHOD(GetContextStackTrace)(
THIS_
__in_bcount_opt(StartContextSize) PVOID StartContext,
__in ULONG StartContextSize,
__out_ecount_opt(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__out_bcount_opt(FrameContextsSize) PVOID FrameContexts,
__in ULONG FrameContextsSize,
__in ULONG FrameContextsEntrySize,
__out_opt PULONG FramesFilled
) PURE;
STDMETHOD(OutputContextStackTrace)(
THIS_
__in ULONG OutputControl,
__in_ecount(FramesSize) PDEBUG_STACK_FRAME Frames,
__in ULONG FramesSize,
__in_bcount(FrameContextsSize) PVOID FrameContexts,
__in ULONG FrameContextsSize,
__in ULONG FrameContextsEntrySize,
__in ULONG Flags
) PURE;
// Some targets, such as user-mode minidump files,
// have separate "event of interest" information
// stored within them. This method allows
// access to that information.
STDMETHOD(GetStoredEventInformation)(
THIS_
__out PULONG Type,
__out PULONG ProcessId,
__out PULONG ThreadId,
__out_bcount_opt(ContextSize) PVOID Context,
__in ULONG ContextSize,
__out_opt PULONG ContextUsed,
__out_bcount_opt(ExtraInformationSize) PVOID ExtraInformation,
__in ULONG ExtraInformationSize,
__out_opt PULONG ExtraInformationUsed
) PURE;
// Managed debugging support relies on debugging
// functionality provided by the Common Language Runtime.
// This method provides feedback on the engine's
// use of the runtime debugging APIs.
STDMETHOD(GetManagedStatus)(
THIS_
__out_opt PULONG Flags,
__in ULONG WhichString,
__out_ecount_opt(StringSize) PSTR String,
__in ULONG StringSize,
__out_opt PULONG StringNeeded
) PURE;
STDMETHOD(GetManagedStatusWide)(
THIS_
__out_opt PULONG Flags,
__in ULONG WhichString,
__out_ecount_opt(StringSize) PWSTR String,
__in ULONG StringSize,
__out_opt PULONG StringNeeded
) PURE;
// Clears and reinitializes the engine's
// managed code debugging support.
STDMETHOD(ResetManagedStatus)(
THIS_
__in ULONG Flags
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugDataSpaces.
//
//----------------------------------------------------------------------------
// Data space indices for callbacks and other methods.
#define DEBUG_DATA_SPACE_VIRTUAL 0
#define DEBUG_DATA_SPACE_PHYSICAL 1
#define DEBUG_DATA_SPACE_CONTROL 2
#define DEBUG_DATA_SPACE_IO 3
#define DEBUG_DATA_SPACE_MSR 4
#define DEBUG_DATA_SPACE_BUS_DATA 5
#define DEBUG_DATA_SPACE_DEBUGGER_DATA 6
// Count of data spaces.
#define DEBUG_DATA_SPACE_COUNT 7
// Indices for ReadDebuggerData interface
#define DEBUG_DATA_KernBase 24
#define DEBUG_DATA_BreakpointWithStatusAddr 32
#define DEBUG_DATA_SavedContextAddr 40
#define DEBUG_DATA_KiCallUserModeAddr 56
#define DEBUG_DATA_KeUserCallbackDispatcherAddr 64
#define DEBUG_DATA_PsLoadedModuleListAddr 72
#define DEBUG_DATA_PsActiveProcessHeadAddr 80
#define DEBUG_DATA_PspCidTableAddr 88
#define DEBUG_DATA_ExpSystemResourcesListAddr 96
#define DEBUG_DATA_ExpPagedPoolDescriptorAddr 104
#define DEBUG_DATA_ExpNumberOfPagedPoolsAddr 112
#define DEBUG_DATA_KeTimeIncrementAddr 120
#define DEBUG_DATA_KeBugCheckCallbackListHeadAddr 128
#define DEBUG_DATA_KiBugcheckDataAddr 136
#define DEBUG_DATA_IopErrorLogListHeadAddr 144
#define DEBUG_DATA_ObpRootDirectoryObjectAddr 152
#define DEBUG_DATA_ObpTypeObjectTypeAddr 160
#define DEBUG_DATA_MmSystemCacheStartAddr 168
#define DEBUG_DATA_MmSystemCacheEndAddr 176
#define DEBUG_DATA_MmSystemCacheWsAddr 184
#define DEBUG_DATA_MmPfnDatabaseAddr 192
#define DEBUG_DATA_MmSystemPtesStartAddr 200
#define DEBUG_DATA_MmSystemPtesEndAddr 208
#define DEBUG_DATA_MmSubsectionBaseAddr 216
#define DEBUG_DATA_MmNumberOfPagingFilesAddr 224
#define DEBUG_DATA_MmLowestPhysicalPageAddr 232
#define DEBUG_DATA_MmHighestPhysicalPageAddr 240
#define DEBUG_DATA_MmNumberOfPhysicalPagesAddr 248
#define DEBUG_DATA_MmMaximumNonPagedPoolInBytesAddr 256
#define DEBUG_DATA_MmNonPagedSystemStartAddr 264
#define DEBUG_DATA_MmNonPagedPoolStartAddr 272
#define DEBUG_DATA_MmNonPagedPoolEndAddr 280
#define DEBUG_DATA_MmPagedPoolStartAddr 288
#define DEBUG_DATA_MmPagedPoolEndAddr 296
#define DEBUG_DATA_MmPagedPoolInformationAddr 304
#define DEBUG_DATA_MmPageSize 312
#define DEBUG_DATA_MmSizeOfPagedPoolInBytesAddr 320
#define DEBUG_DATA_MmTotalCommitLimitAddr 328
#define DEBUG_DATA_MmTotalCommittedPagesAddr 336
#define DEBUG_DATA_MmSharedCommitAddr 344
#define DEBUG_DATA_MmDriverCommitAddr 352
#define DEBUG_DATA_MmProcessCommitAddr 360
#define DEBUG_DATA_MmPagedPoolCommitAddr 368
#define DEBUG_DATA_MmExtendedCommitAddr 376
#define DEBUG_DATA_MmZeroedPageListHeadAddr 384
#define DEBUG_DATA_MmFreePageListHeadAddr 392
#define DEBUG_DATA_MmStandbyPageListHeadAddr 400
#define DEBUG_DATA_MmModifiedPageListHeadAddr 408
#define DEBUG_DATA_MmModifiedNoWritePageListHeadAddr 416
#define DEBUG_DATA_MmAvailablePagesAddr 424
#define DEBUG_DATA_MmResidentAvailablePagesAddr 432
#define DEBUG_DATA_PoolTrackTableAddr 440
#define DEBUG_DATA_NonPagedPoolDescriptorAddr 448
#define DEBUG_DATA_MmHighestUserAddressAddr 456
#define DEBUG_DATA_MmSystemRangeStartAddr 464
#define DEBUG_DATA_MmUserProbeAddressAddr 472
#define DEBUG_DATA_KdPrintCircularBufferAddr 480
#define DEBUG_DATA_KdPrintCircularBufferEndAddr 488
#define DEBUG_DATA_KdPrintWritePointerAddr 496
#define DEBUG_DATA_KdPrintRolloverCountAddr 504
#define DEBUG_DATA_MmLoadedUserImageListAddr 512
#define DEBUG_DATA_NtBuildLabAddr 520
#define DEBUG_DATA_KiNormalSystemCall 528
#define DEBUG_DATA_KiProcessorBlockAddr 536
#define DEBUG_DATA_MmUnloadedDriversAddr 544
#define DEBUG_DATA_MmLastUnloadedDriverAddr 552
#define DEBUG_DATA_MmTriageActionTakenAddr 560
#define DEBUG_DATA_MmSpecialPoolTagAddr 568
#define DEBUG_DATA_KernelVerifierAddr 576
#define DEBUG_DATA_MmVerifierDataAddr 584
#define DEBUG_DATA_MmAllocatedNonPagedPoolAddr 592
#define DEBUG_DATA_MmPeakCommitmentAddr 600
#define DEBUG_DATA_MmTotalCommitLimitMaximumAddr 608
#define DEBUG_DATA_CmNtCSDVersionAddr 616
#define DEBUG_DATA_MmPhysicalMemoryBlockAddr 624
#define DEBUG_DATA_MmSessionBase 632
#define DEBUG_DATA_MmSessionSize 640
#define DEBUG_DATA_MmSystemParentTablePage 648
#define DEBUG_DATA_MmVirtualTranslationBase 656
#define DEBUG_DATA_OffsetKThreadNextProcessor 664
#define DEBUG_DATA_OffsetKThreadTeb 666
#define DEBUG_DATA_OffsetKThreadKernelStack 668
#define DEBUG_DATA_OffsetKThreadInitialStack 670
#define DEBUG_DATA_OffsetKThreadApcProcess 672
#define DEBUG_DATA_OffsetKThreadState 674
#define DEBUG_DATA_OffsetKThreadBStore 676
#define DEBUG_DATA_OffsetKThreadBStoreLimit 678
#define DEBUG_DATA_SizeEProcess 680
#define DEBUG_DATA_OffsetEprocessPeb 682
#define DEBUG_DATA_OffsetEprocessParentCID 684
#define DEBUG_DATA_OffsetEprocessDirectoryTableBase 686
#define DEBUG_DATA_SizePrcb 688
#define DEBUG_DATA_OffsetPrcbDpcRoutine 690
#define DEBUG_DATA_OffsetPrcbCurrentThread 692
#define DEBUG_DATA_OffsetPrcbMhz 694
#define DEBUG_DATA_OffsetPrcbCpuType 696
#define DEBUG_DATA_OffsetPrcbVendorString 698
#define DEBUG_DATA_OffsetPrcbProcessorState 700
#define DEBUG_DATA_OffsetPrcbNumber 702
#define DEBUG_DATA_SizeEThread 704
#define DEBUG_DATA_KdPrintCircularBufferPtrAddr 712
#define DEBUG_DATA_KdPrintBufferSizeAddr 720
#define DEBUG_DATA_PaeEnabled 100000
#define DEBUG_DATA_SharedUserData 100008
#define DEBUG_DATA_ProductType 100016
#define DEBUG_DATA_SuiteMask 100024
#define DEBUG_DATA_DumpWriterStatus 100032
#define DEBUG_DATA_DumpFormatVersion 100040
#define DEBUG_DATA_DumpWriterVersion 100048
#define DEBUG_DATA_DumpPowerState 100056
#define DEBUG_DATA_DumpMmStorage 100064
//
// Processor information structures.
//
typedef struct _DEBUG_PROCESSOR_IDENTIFICATION_ALPHA
{
ULONG Type;
ULONG Revision;
} DEBUG_PROCESSOR_IDENTIFICATION_ALPHA, *PDEBUG_PROCESSOR_IDENTIFICATION_ALPHA;
typedef struct _DEBUG_PROCESSOR_IDENTIFICATION_AMD64
{
ULONG Family;
ULONG Model;
ULONG Stepping;
CHAR VendorString[16];
} DEBUG_PROCESSOR_IDENTIFICATION_AMD64, *PDEBUG_PROCESSOR_IDENTIFICATION_AMD64;
typedef struct _DEBUG_PROCESSOR_IDENTIFICATION_IA64
{
ULONG Model;
ULONG Revision;
ULONG Family;
ULONG ArchRev;
CHAR VendorString[16];
} DEBUG_PROCESSOR_IDENTIFICATION_IA64, *PDEBUG_PROCESSOR_IDENTIFICATION_IA64;
typedef struct _DEBUG_PROCESSOR_IDENTIFICATION_X86
{
ULONG Family;
ULONG Model;
ULONG Stepping;
CHAR VendorString[16];
} DEBUG_PROCESSOR_IDENTIFICATION_X86, *PDEBUG_PROCESSOR_IDENTIFICATION_X86;
typedef struct _DEBUG_PROCESSOR_IDENTIFICATION_ARM
{
ULONG Type;
ULONG Revision;
} DEBUG_PROCESSOR_IDENTIFICATION_ARM, *PDEBUG_PROCESSOR_IDENTIFICATION_ARM;
typedef union _DEBUG_PROCESSOR_IDENTIFICATION_ALL
{
DEBUG_PROCESSOR_IDENTIFICATION_ALPHA Alpha;
DEBUG_PROCESSOR_IDENTIFICATION_AMD64 Amd64;
DEBUG_PROCESSOR_IDENTIFICATION_IA64 Ia64;
DEBUG_PROCESSOR_IDENTIFICATION_X86 X86;
DEBUG_PROCESSOR_IDENTIFICATION_ARM Arm;
} DEBUG_PROCESSOR_IDENTIFICATION_ALL, *PDEBUG_PROCESSOR_IDENTIFICATION_ALL;
// Indices for ReadProcessorSystemData.
#define DEBUG_DATA_KPCR_OFFSET 0
#define DEBUG_DATA_KPRCB_OFFSET 1
#define DEBUG_DATA_KTHREAD_OFFSET 2
#define DEBUG_DATA_BASE_TRANSLATION_VIRTUAL_OFFSET 3
#define DEBUG_DATA_PROCESSOR_IDENTIFICATION 4
#define DEBUG_DATA_PROCESSOR_SPEED 5
#undef INTERFACE
#define INTERFACE IDebugDataSpaces
DECLARE_INTERFACE_(IDebugDataSpaces, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugDataSpaces.
STDMETHOD(ReadVirtual)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtual)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// SearchVirtual searches the given virtual
// address range for the given pattern. PatternSize
// gives the byte length of the pattern and PatternGranularity
// controls the granularity of comparisons during
// the search.
// For example, a DWORD-granular search would
// use a pattern granularity of four to search by DWORD
// increments.
STDMETHOD(SearchVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Length,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__in ULONG PatternGranularity,
__out PULONG64 MatchOffset
) PURE;
// These methods are identical to Read/WriteVirtual
// except that they avoid the kernel virtual memory
// cache entirely and are therefore useful for reading
// virtual memory which is inherently volatile, such
// as memory-mapped device areas, without contaminating
// or invalidating the cache.
// In user-mode they are the same as Read/WriteVirtual.
STDMETHOD(ReadVirtualUncached)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtualUncached)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// The following two methods are convenience
// methods for accessing pointer values.
// They automatically convert between native pointers
// and canonical 64-bit values as necessary.
// These routines stop at the first failure.
STDMETHOD(ReadPointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__out_ecount(Count) PULONG64 Ptrs
) PURE;
STDMETHOD(WritePointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__in_ecount(Count) PULONG64 Ptrs
) PURE;
// All non-virtual data spaces are only
// available when kernel debugging.
STDMETHOD(ReadPhysical)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WritePhysical)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadMsr)(
THIS_
__in ULONG Msr,
__out PULONG64 Value
) PURE;
STDMETHOD(WriteMsr)(
THIS_
__in ULONG Msr,
__in ULONG64 Value
) PURE;
STDMETHOD(ReadBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(CheckLowMemory)(
THIS
) PURE;
STDMETHOD(ReadDebuggerData)(
THIS_
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
STDMETHOD(ReadProcessorSystemData)(
THIS_
__in ULONG Processor,
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
};
//
// Handle data types and structures.
//
#define DEBUG_HANDLE_DATA_TYPE_BASIC 0
#define DEBUG_HANDLE_DATA_TYPE_TYPE_NAME 1
#define DEBUG_HANDLE_DATA_TYPE_OBJECT_NAME 2
#define DEBUG_HANDLE_DATA_TYPE_HANDLE_COUNT 3
#define DEBUG_HANDLE_DATA_TYPE_TYPE_NAME_WIDE 4
#define DEBUG_HANDLE_DATA_TYPE_OBJECT_NAME_WIDE 5
typedef struct _DEBUG_HANDLE_DATA_BASIC
{
ULONG TypeNameSize;
ULONG ObjectNameSize;
ULONG Attributes;
ULONG GrantedAccess;
ULONG HandleCount;
ULONG PointerCount;
} DEBUG_HANDLE_DATA_BASIC, *PDEBUG_HANDLE_DATA_BASIC;
#undef INTERFACE
#define INTERFACE IDebugDataSpaces2
DECLARE_INTERFACE_(IDebugDataSpaces2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugDataSpaces.
STDMETHOD(ReadVirtual)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtual)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// SearchVirtual searches the given virtual
// address range for the given pattern. PatternSize
// gives the byte length of the pattern and PatternGranularity
// controls the granularity of comparisons during
// the search.
// For example, a DWORD-granular search would
// use a pattern granularity of four to search by DWORD
// increments.
STDMETHOD(SearchVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Length,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__in ULONG PatternGranularity,
__out PULONG64 MatchOffset
) PURE;
// These methods are identical to Read/WriteVirtual
// except that they avoid the kernel virtual memory
// cache entirely and are therefore useful for reading
// virtual memory which is inherently volatile, such
// as memory-mapped device areas, without contaminating
// or invalidating the cache.
// In user-mode they are the same as Read/WriteVirtual.
STDMETHOD(ReadVirtualUncached)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtualUncached)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// The following two methods are convenience
// methods for accessing pointer values.
// They automatically convert between native pointers
// and canonical 64-bit values as necessary.
// These routines stop at the first failure.
STDMETHOD(ReadPointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__out_ecount(Count) PULONG64 Ptrs
) PURE;
STDMETHOD(WritePointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__in_ecount(Count) PULONG64 Ptrs
) PURE;
// All non-virtual data spaces are only
// available when kernel debugging.
STDMETHOD(ReadPhysical)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WritePhysical)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadMsr)(
THIS_
__in ULONG Msr,
__out PULONG64 Value
) PURE;
STDMETHOD(WriteMsr)(
THIS_
__in ULONG Msr,
__in ULONG64 Value
) PURE;
STDMETHOD(ReadBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(CheckLowMemory)(
THIS
) PURE;
STDMETHOD(ReadDebuggerData)(
THIS_
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
STDMETHOD(ReadProcessorSystemData)(
THIS_
__in ULONG Processor,
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
// IDebugDataSpaces2.
STDMETHOD(VirtualToPhysical)(
THIS_
__in ULONG64 Virtual,
__out PULONG64 Physical
) PURE;
// Returns the physical addresses for the
// N levels of the systems paging structures.
// Level zero is the starting base physical
// address for virtual translations.
// Levels one-(N-1) will point to the appropriate
// paging descriptor for the virtual address at
// the given level of the paging hierarchy. The
// exact number of levels depends on many factors.
// The last level will be the fully translated
// physical address, matching what VirtualToPhysical
// returns. If the address can only be partially
// translated S_FALSE is returned.
STDMETHOD(GetVirtualTranslationPhysicalOffsets)(
THIS_
__in ULONG64 Virtual,
__out_ecount_opt(OffsetsSize) PULONG64 Offsets,
__in ULONG OffsetsSize,
__out_opt PULONG Levels
) PURE;
// System handle data is accessible in certain
// debug sessions. The particular data available
// varies from session to session and platform
// to platform.
STDMETHOD(ReadHandleData)(
THIS_
__in ULONG64 Handle,
__in ULONG DataType,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
// Fills memory with the given pattern.
// The fill stops at the first non-writable byte.
STDMETHOD(FillVirtual)(
THIS_
__in ULONG64 Start,
__in ULONG Size,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__out_opt PULONG Filled
) PURE;
STDMETHOD(FillPhysical)(
THIS_
__in ULONG64 Start,
__in ULONG Size,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__out_opt PULONG Filled
) PURE;
// Queries virtual memory mapping information given
// an address similarly to the Win32 API VirtualQuery.
// MEMORY_BASIC_INFORMATION64 is defined in crash.h.
// This method currently only works for user-mode sessions.
STDMETHOD(QueryVirtual)(
THIS_
__in ULONG64 Offset,
__out PMEMORY_BASIC_INFORMATION64 Info
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugDataSpaces3
DECLARE_INTERFACE_(IDebugDataSpaces3, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugDataSpaces.
STDMETHOD(ReadVirtual)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtual)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// SearchVirtual searches the given virtual
// address range for the given pattern. PatternSize
// gives the byte length of the pattern and PatternGranularity
// controls the granularity of comparisons during
// the search.
// For example, a DWORD-granular search would
// use a pattern granularity of four to search by DWORD
// increments.
STDMETHOD(SearchVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Length,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__in ULONG PatternGranularity,
__out PULONG64 MatchOffset
) PURE;
// These methods are identical to Read/WriteVirtual
// except that they avoid the kernel virtual memory
// cache entirely and are therefore useful for reading
// virtual memory which is inherently volatile, such
// as memory-mapped device areas, without contaminating
// or invalidating the cache.
// In user-mode they are the same as Read/WriteVirtual.
STDMETHOD(ReadVirtualUncached)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtualUncached)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// The following two methods are convenience
// methods for accessing pointer values.
// They automatically convert between native pointers
// and canonical 64-bit values as necessary.
// These routines stop at the first failure.
STDMETHOD(ReadPointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__out_ecount(Count) PULONG64 Ptrs
) PURE;
STDMETHOD(WritePointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__in_ecount(Count) PULONG64 Ptrs
) PURE;
// All non-virtual data spaces are only
// available when kernel debugging.
STDMETHOD(ReadPhysical)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WritePhysical)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadMsr)(
THIS_
__in ULONG Msr,
__out PULONG64 Value
) PURE;
STDMETHOD(WriteMsr)(
THIS_
__in ULONG Msr,
__in ULONG64 Value
) PURE;
STDMETHOD(ReadBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(CheckLowMemory)(
THIS
) PURE;
STDMETHOD(ReadDebuggerData)(
THIS_
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
STDMETHOD(ReadProcessorSystemData)(
THIS_
__in ULONG Processor,
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
// IDebugDataSpaces2.
STDMETHOD(VirtualToPhysical)(
THIS_
__in ULONG64 Virtual,
__out PULONG64 Physical
) PURE;
// Returns the physical addresses for the
// N levels of the systems paging structures.
// Level zero is the starting base physical
// address for virtual translations.
// Levels one-(N-1) will point to the appropriate
// paging descriptor for the virtual address at
// the given level of the paging hierarchy. The
// exact number of levels depends on many factors.
// The last level will be the fully translated
// physical address, matching what VirtualToPhysical
// returns. If the address can only be partially
// translated S_FALSE is returned.
STDMETHOD(GetVirtualTranslationPhysicalOffsets)(
THIS_
__in ULONG64 Virtual,
__out_ecount_opt(OffsetsSize) PULONG64 Offsets,
__in ULONG OffsetsSize,
__out_opt PULONG Levels
) PURE;
// System handle data is accessible in certain
// debug sessions. The particular data available
// varies from session to session and platform
// to platform.
STDMETHOD(ReadHandleData)(
THIS_
__in ULONG64 Handle,
__in ULONG DataType,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
// Fills memory with the given pattern.
// The fill stops at the first non-writable byte.
STDMETHOD(FillVirtual)(
THIS_
__in ULONG64 Start,
__in ULONG Size,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__out_opt PULONG Filled
) PURE;
STDMETHOD(FillPhysical)(
THIS_
__in ULONG64 Start,
__in ULONG Size,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__out_opt PULONG Filled
) PURE;
// Queries virtual memory mapping information given
// an address similarly to the Win32 API VirtualQuery.
// MEMORY_BASIC_INFORMATION64 is defined in crash.h.
// This method currently only works for user-mode sessions.
STDMETHOD(QueryVirtual)(
THIS_
__in ULONG64 Offset,
__out PMEMORY_BASIC_INFORMATION64 Info
) PURE;
// IDebugDataSpaces3.
// Convenience method for reading an image
// header from virtual memory. Given the
// image base, this method determines where
// the NT headers are, validates the necessary
// markers and converts the headers into
// 64-bit form for consistency.
// A caller can check whether the headers were
// originally 32-bit by checking the optional
// header magic value.
// This method will not read ROM headers.
STDMETHOD(ReadImageNtHeaders)(
THIS_
__in ULONG64 ImageBase,
__out PIMAGE_NT_HEADERS64 Headers
) PURE;
// Some debug sessions have arbitrary additional
// data available. For example, additional dump
// information files may contain extra information
// gathered at the same time as the primary dump.
// Such information is tagged with a unique identifier
// and can only be retrieved via the tag.
// Tagged data cannot be partially available; the
// tagged block is either fully present or completely
// absent.
STDMETHOD(ReadTagged)(
THIS_
__in LPGUID Tag,
__in ULONG Offset,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG TotalSize
) PURE;
STDMETHOD(StartEnumTagged)(
THIS_
__out PULONG64 Handle
) PURE;
STDMETHOD(GetNextTagged)(
THIS_
__in ULONG64 Handle,
__out LPGUID Tag,
__out PULONG Size
) PURE;
STDMETHOD(EndEnumTagged)(
THIS_
__in ULONG64 Handle
) PURE;
};
#define DEBUG_OFFSINFO_VIRTUAL_SOURCE 0x00000001
#define DEBUG_VSOURCE_INVALID 0x00000000
#define DEBUG_VSOURCE_DEBUGGEE 0x00000001
#define DEBUG_VSOURCE_MAPPED_IMAGE 0x00000002
#define DEBUG_VSEARCH_DEFAULT 0x00000000
#define DEBUG_VSEARCH_WRITABLE_ONLY 0x00000001
#define DEBUG_PHYSICAL_DEFAULT 0x00000000
#define DEBUG_PHYSICAL_CACHED 0x00000001
#define DEBUG_PHYSICAL_UNCACHED 0x00000002
#define DEBUG_PHYSICAL_WRITE_COMBINED 0x00000003
#undef INTERFACE
#define INTERFACE IDebugDataSpaces4
DECLARE_INTERFACE_(IDebugDataSpaces4, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugDataSpaces.
STDMETHOD(ReadVirtual)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtual)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// SearchVirtual searches the given virtual
// address range for the given pattern. PatternSize
// gives the byte length of the pattern and PatternGranularity
// controls the granularity of comparisons during
// the search.
// For example, a DWORD-granular search would
// use a pattern granularity of four to search by DWORD
// increments.
STDMETHOD(SearchVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Length,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__in ULONG PatternGranularity,
__out PULONG64 MatchOffset
) PURE;
// These methods are identical to Read/WriteVirtual
// except that they avoid the kernel virtual memory
// cache entirely and are therefore useful for reading
// virtual memory which is inherently volatile, such
// as memory-mapped device areas, without contaminating
// or invalidating the cache.
// In user-mode they are the same as Read/WriteVirtual.
STDMETHOD(ReadVirtualUncached)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteVirtualUncached)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
// The following two methods are convenience
// methods for accessing pointer values.
// They automatically convert between native pointers
// and canonical 64-bit values as necessary.
// These routines stop at the first failure.
STDMETHOD(ReadPointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__out_ecount(Count) PULONG64 Ptrs
) PURE;
STDMETHOD(WritePointersVirtual)(
THIS_
__in ULONG Count,
__in ULONG64 Offset,
__in_ecount(Count) PULONG64 Ptrs
) PURE;
// All non-virtual data spaces are only
// available when kernel debugging.
STDMETHOD(ReadPhysical)(
THIS_
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WritePhysical)(
THIS_
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteControl)(
THIS_
__in ULONG Processor,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteIo)(
THIS_
__in ULONG InterfaceType,
__in ULONG BusNumber,
__in ULONG AddressSpace,
__in ULONG64 Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(ReadMsr)(
THIS_
__in ULONG Msr,
__out PULONG64 Value
) PURE;
STDMETHOD(WriteMsr)(
THIS_
__in ULONG Msr,
__in ULONG64 Value
) PURE;
STDMETHOD(ReadBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteBusData)(
THIS_
__in ULONG BusDataType,
__in ULONG BusNumber,
__in ULONG SlotNumber,
__in ULONG Offset,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(CheckLowMemory)(
THIS
) PURE;
STDMETHOD(ReadDebuggerData)(
THIS_
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
STDMETHOD(ReadProcessorSystemData)(
THIS_
__in ULONG Processor,
__in ULONG Index,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
// IDebugDataSpaces2.
STDMETHOD(VirtualToPhysical)(
THIS_
__in ULONG64 Virtual,
__out PULONG64 Physical
) PURE;
// Returns the physical addresses for the
// N levels of the systems paging structures.
// Level zero is the starting base physical
// address for virtual translations.
// Levels one-(N-1) will point to the appropriate
// paging descriptor for the virtual address at
// the given level of the paging hierarchy. The
// exact number of levels depends on many factors.
// The last level will be the fully translated
// physical address, matching what VirtualToPhysical
// returns. If the address can only be partially
// translated S_FALSE is returned.
STDMETHOD(GetVirtualTranslationPhysicalOffsets)(
THIS_
__in ULONG64 Virtual,
__out_ecount_opt(OffsetsSize) PULONG64 Offsets,
__in ULONG OffsetsSize,
__out_opt PULONG Levels
) PURE;
// System handle data is accessible in certain
// debug sessions. The particular data available
// varies from session to session and platform
// to platform.
STDMETHOD(ReadHandleData)(
THIS_
__in ULONG64 Handle,
__in ULONG DataType,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG DataSize
) PURE;
// Fills memory with the given pattern.
// The fill stops at the first non-writable byte.
STDMETHOD(FillVirtual)(
THIS_
__in ULONG64 Start,
__in ULONG Size,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__out_opt PULONG Filled
) PURE;
STDMETHOD(FillPhysical)(
THIS_
__in ULONG64 Start,
__in ULONG Size,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__out_opt PULONG Filled
) PURE;
// Queries virtual memory mapping information given
// an address similarly to the Win32 API VirtualQuery.
// MEMORY_BASIC_INFORMATION64 is defined in crash.h.
// This method currently only works for user-mode sessions.
STDMETHOD(QueryVirtual)(
THIS_
__in ULONG64 Offset,
__out PMEMORY_BASIC_INFORMATION64 Info
) PURE;
// IDebugDataSpaces3.
// Convenience method for reading an image
// header from virtual memory. Given the
// image base, this method determines where
// the NT headers are, validates the necessary
// markers and converts the headers into
// 64-bit form for consistency.
// A caller can check whether the headers were
// originally 32-bit by checking the optional
// header magic value.
// This method will not read ROM headers.
STDMETHOD(ReadImageNtHeaders)(
THIS_
__in ULONG64 ImageBase,
__out PIMAGE_NT_HEADERS64 Headers
) PURE;
// Some debug sessions have arbitrary additional
// data available. For example, additional dump
// information files may contain extra information
// gathered at the same time as the primary dump.
// Such information is tagged with a unique identifier
// and can only be retrieved via the tag.
// Tagged data cannot be partially available; the
// tagged block is either fully present or completely
// absent.
STDMETHOD(ReadTagged)(
THIS_
__in LPGUID Tag,
__in ULONG Offset,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG TotalSize
) PURE;
STDMETHOD(StartEnumTagged)(
THIS_
__out PULONG64 Handle
) PURE;
STDMETHOD(GetNextTagged)(
THIS_
__in ULONG64 Handle,
__out LPGUID Tag,
__out PULONG Size
) PURE;
STDMETHOD(EndEnumTagged)(
THIS_
__in ULONG64 Handle
) PURE;
// IDebugDataSpaces4.
// General information about an address in the given data space.
// Queries are from DEBUG_OFFSINFO_*.
STDMETHOD(GetOffsetInformation)(
THIS_
__in ULONG Space,
__in ULONG Which,
__in ULONG64 Offset,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG InfoSize
) PURE;
// Given a particular address, return the
// next address which has a different validity.
// For example, in debug sessions such as a live
// user-mode session where virtual address validity
// changes from page to page this will return the
// page after the given page. In sessions such as
// a user-mode dump file where validity can change
// from byte to byte this will return the start of
// the next region that has different validity.
STDMETHOD(GetNextDifferentlyValidOffsetVirtual)(
THIS_
__in ULONG64 Offset,
__out PULONG64 NextOffset
) PURE;
// Given a particular range of virtual addresses,
// find the first region which is valid memory.
STDMETHOD(GetValidRegionVirtual)(
THIS_
__in ULONG64 Base,
__in ULONG Size,
__out PULONG64 ValidBase,
__out PULONG ValidSize
) PURE;
STDMETHOD(SearchVirtual2)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Length,
__in ULONG Flags,
__in_bcount(PatternSize) PVOID Pattern,
__in ULONG PatternSize,
__in ULONG PatternGranularity,
__out PULONG64 MatchOffset
) PURE;
// Attempts to read a multi-byte string
// starting at the given virtual address.
// The possible string length, including terminator,
// is capped at the given max size.
// If a return buffer is given it will always
// be terminated.
STDMETHOD(ReadMultiByteStringVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG MaxBytes,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringBytes
) PURE;
// Reads a multi-byte string and converts
// it to Unicode using the given code page.
STDMETHOD(ReadMultiByteStringVirtualWide)(
THIS_
__in ULONG64 Offset,
__in ULONG MaxBytes,
__in ULONG CodePage,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringBytes
) PURE;
STDMETHOD(ReadUnicodeStringVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG MaxBytes,
__in ULONG CodePage,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringBytes
) PURE;
STDMETHOD(ReadUnicodeStringVirtualWide)(
THIS_
__in ULONG64 Offset,
__in ULONG MaxBytes,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringBytes
) PURE;
STDMETHOD(ReadPhysical2)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WritePhysical2)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugEventCallbacks.
//
//----------------------------------------------------------------------------
// Interest mask bits.
#define DEBUG_EVENT_BREAKPOINT 0x00000001
#define DEBUG_EVENT_EXCEPTION 0x00000002
#define DEBUG_EVENT_CREATE_THREAD 0x00000004
#define DEBUG_EVENT_EXIT_THREAD 0x00000008
#define DEBUG_EVENT_CREATE_PROCESS 0x00000010
#define DEBUG_EVENT_EXIT_PROCESS 0x00000020
#define DEBUG_EVENT_LOAD_MODULE 0x00000040
#define DEBUG_EVENT_UNLOAD_MODULE 0x00000080
#define DEBUG_EVENT_SYSTEM_ERROR 0x00000100
#define DEBUG_EVENT_SESSION_STATUS 0x00000200
#define DEBUG_EVENT_CHANGE_DEBUGGEE_STATE 0x00000400
#define DEBUG_EVENT_CHANGE_ENGINE_STATE 0x00000800
#define DEBUG_EVENT_CHANGE_SYMBOL_STATE 0x00001000
// SessionStatus flags.
// A debuggee has been discovered for the session.
#define DEBUG_SESSION_ACTIVE 0x00000000
// The session has been ended by EndSession.
#define DEBUG_SESSION_END_SESSION_ACTIVE_TERMINATE 0x00000001
#define DEBUG_SESSION_END_SESSION_ACTIVE_DETACH 0x00000002
#define DEBUG_SESSION_END_SESSION_PASSIVE 0x00000003
// The debuggee has run to completion. User-mode only.
#define DEBUG_SESSION_END 0x00000004
// The target machine has rebooted. Kernel-mode only.
#define DEBUG_SESSION_REBOOT 0x00000005
// The target machine has hibernated. Kernel-mode only.
#define DEBUG_SESSION_HIBERNATE 0x00000006
// The engine was unable to continue the session.
#define DEBUG_SESSION_FAILURE 0x00000007
// ChangeDebuggeeState flags.
// The debuggees state has changed generally, such
// as when the debuggee has been executing.
// Argument is zero.
#define DEBUG_CDS_ALL 0xffffffff
// Registers have changed. If only a single register
// changed, argument is the index of the register.
// Otherwise it is DEBUG_ANY_ID.
#define DEBUG_CDS_REGISTERS 0x00000001
// Data spaces have changed. If only a single
// space was affected, argument is the data
// space. Otherwise it is DEBUG_ANY_ID.
#define DEBUG_CDS_DATA 0x00000002
// ChangeEngineState flags.
// The engine state has changed generally.
// Argument is zero.
#define DEBUG_CES_ALL 0xffffffff
// Current thread changed. This may imply a change
// of system and process also. Argument is the ID of the new
// current thread or DEBUG_ANY_ID if no thread is current.
#define DEBUG_CES_CURRENT_THREAD 0x00000001
// Effective processor changed. Argument is the
// new processor type.
#define DEBUG_CES_EFFECTIVE_PROCESSOR 0x00000002
// Breakpoints changed. If only a single breakpoint
// changed, argument is the ID of the breakpoint.
// Otherwise it is DEBUG_ANY_ID.
#define DEBUG_CES_BREAKPOINTS 0x00000004
// Code interpretation level changed. Argument is
// the new level.
#define DEBUG_CES_CODE_LEVEL 0x00000008
// Execution status changed. Argument is the new
// execution status.
#define DEBUG_CES_EXECUTION_STATUS 0x00000010
// Engine options have changed. Argument is the new
// options value.
#define DEBUG_CES_ENGINE_OPTIONS 0x00000020
// Log file information has changed. Argument
// is TRUE if a log file was opened and FALSE if
// a log file was closed.
#define DEBUG_CES_LOG_FILE 0x00000040
// Default number radix has changed. Argument
// is the new radix.
#define DEBUG_CES_RADIX 0x00000080
// Event filters changed. If only a single filter
// changed the argument is the filter's index,
// otherwise it is DEBUG_ANY_ID.
#define DEBUG_CES_EVENT_FILTERS 0x00000100
// Process options have changed. Argument is the new
// options value.
#define DEBUG_CES_PROCESS_OPTIONS 0x00000200
// Extensions have been added or removed.
#define DEBUG_CES_EXTENSIONS 0x00000400
// Systems have been added or removed. The argument
// is the system ID. Systems, unlike processes and
// threads, may be created at any time and not
// just during WaitForEvent.
#define DEBUG_CES_SYSTEMS 0x00000800
// Assembly/disassembly options have changed. Argument
// is the new options value.
#define DEBUG_CES_ASSEMBLY_OPTIONS 0x00001000
// Expression syntax has changed. Argument
// is the new syntax value.
#define DEBUG_CES_EXPRESSION_SYNTAX 0x00002000
// Text replacements have changed.
#define DEBUG_CES_TEXT_REPLACEMENTS 0x00004000
// ChangeSymbolState flags.
// Symbol state has changed generally, such
// as after reload operations. Argument is zero.
#define DEBUG_CSS_ALL 0xffffffff
// Modules have been loaded. If only a
// single module changed, argument is the
// base address of the module. Otherwise
// it is zero.
#define DEBUG_CSS_LOADS 0x00000001
// Modules have been unloaded. If only a
// single module changed, argument is the
// base address of the module. Otherwise
// it is zero.
#define DEBUG_CSS_UNLOADS 0x00000002
// Current symbol scope changed.
#define DEBUG_CSS_SCOPE 0x00000004
// Paths have changed.
#define DEBUG_CSS_PATHS 0x00000008
// Symbol options have changed. Argument is the new
// options value.
#define DEBUG_CSS_SYMBOL_OPTIONS 0x00000010
// Type options have changed. Argument is the new
// options value.
#define DEBUG_CSS_TYPE_OPTIONS 0x00000020
#undef INTERFACE
#define INTERFACE IDebugEventCallbacks
DECLARE_INTERFACE_(IDebugEventCallbacks, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugEventCallbacks.
// The engine calls GetInterestMask once when
// the event callbacks are set for a client.
STDMETHOD(GetInterestMask)(
THIS_
__out PULONG Mask
) PURE;
// A breakpoint event is generated when
// a breakpoint exception is received and
// it can be mapped to an existing breakpoint.
// The callback method is given a reference
// to the breakpoint and should release it when
// it is done with it.
STDMETHOD(Breakpoint)(
THIS_
__in PDEBUG_BREAKPOINT Bp
) PURE;
// Exceptions include breaks which cannot
// be mapped to an existing breakpoint
// instance.
STDMETHOD(Exception)(
THIS_
__in PEXCEPTION_RECORD64 Exception,
__in ULONG FirstChance
) PURE;
// Any of these values can be zero if they
// cannot be provided by the engine.
// Currently the kernel does not return thread
// or process change events.
STDMETHOD(CreateThread)(
THIS_
__in ULONG64 Handle,
__in ULONG64 DataOffset,
__in ULONG64 StartOffset
) PURE;
STDMETHOD(ExitThread)(
THIS_
__in ULONG ExitCode
) PURE;
// Any of these values can be zero if they
// cannot be provided by the engine.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 Handle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in_opt PCSTR ModuleName,
__in_opt PCSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp,
__in ULONG64 InitialThreadHandle,
__in ULONG64 ThreadDataOffset,
__in ULONG64 StartOffset
) PURE;
STDMETHOD(ExitProcess)(
THIS_
__in ULONG ExitCode
) PURE;
// Any of these values may be zero.
STDMETHOD(LoadModule)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in_opt PCSTR ModuleName,
__in_opt PCSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp
) PURE;
STDMETHOD(UnloadModule)(
THIS_
__in_opt PCSTR ImageBaseName,
__in ULONG64 BaseOffset
) PURE;
STDMETHOD(SystemError)(
THIS_
__in ULONG Error,
__in ULONG Level
) PURE;
// Session status is synchronous like the other
// wait callbacks but it is called as the state
// of the session is changing rather than at
// specific events so its return value does not
// influence waiting. Implementations should just
// return DEBUG_STATUS_NO_CHANGE.
// Also, because some of the status
// notifications are very early or very
// late in the session lifetime there may not be
// current processes or threads when the notification
// is generated.
STDMETHOD(SessionStatus)(
THIS_
__in ULONG Status
) PURE;
// The following callbacks are informational
// callbacks notifying the provider about
// changes in debug state. The return value
// of these callbacks is ignored. Implementations
// can not call back into the engine.
// Debuggee state, such as registers or data spaces,
// has changed.
STDMETHOD(ChangeDebuggeeState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
) PURE;
// Engine state has changed.
STDMETHOD(ChangeEngineState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
) PURE;
// Symbol state has changed.
STDMETHOD(ChangeSymbolState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugEventCallbacksWide
DECLARE_INTERFACE_(IDebugEventCallbacksWide, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugEventCallbacksWide.
// The engine calls GetInterestMask once when
// the event callbacks are set for a client.
STDMETHOD(GetInterestMask)(
THIS_
__out PULONG Mask
) PURE;
// A breakpoint event is generated when
// a breakpoint exception is received and
// it can be mapped to an existing breakpoint.
// The callback method is given a reference
// to the breakpoint and should release it when
// it is done with it.
STDMETHOD(Breakpoint)(
THIS_
__in PDEBUG_BREAKPOINT2 Bp
) PURE;
// Exceptions include breaks which cannot
// be mapped to an existing breakpoint
// instance.
STDMETHOD(Exception)(
THIS_
__in PEXCEPTION_RECORD64 Exception,
__in ULONG FirstChance
) PURE;
// Any of these values can be zero if they
// cannot be provided by the engine.
// Currently the kernel does not return thread
// or process change events.
STDMETHOD(CreateThread)(
THIS_
__in ULONG64 Handle,
__in ULONG64 DataOffset,
__in ULONG64 StartOffset
) PURE;
STDMETHOD(ExitThread)(
THIS_
__in ULONG ExitCode
) PURE;
// Any of these values can be zero if they
// cannot be provided by the engine.
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 Handle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in_opt PCWSTR ModuleName,
__in_opt PCWSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp,
__in ULONG64 InitialThreadHandle,
__in ULONG64 ThreadDataOffset,
__in ULONG64 StartOffset
) PURE;
STDMETHOD(ExitProcess)(
THIS_
__in ULONG ExitCode
) PURE;
// Any of these values may be zero.
STDMETHOD(LoadModule)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in_opt PCWSTR ModuleName,
__in_opt PCWSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp
) PURE;
STDMETHOD(UnloadModule)(
THIS_
__in_opt PCWSTR ImageBaseName,
__in ULONG64 BaseOffset
) PURE;
STDMETHOD(SystemError)(
THIS_
__in ULONG Error,
__in ULONG Level
) PURE;
// Session status is synchronous like the other
// wait callbacks but it is called as the state
// of the session is changing rather than at
// specific events so its return value does not
// influence waiting. Implementations should just
// return DEBUG_STATUS_NO_CHANGE.
// Also, because some of the status
// notifications are very early or very
// late in the session lifetime there may not be
// current processes or threads when the notification
// is generated.
STDMETHOD(SessionStatus)(
THIS_
__in ULONG Status
) PURE;
// The following callbacks are informational
// callbacks notifying the provider about
// changes in debug state. The return value
// of these callbacks is ignored. Implementations
// can not call back into the engine.
// Debuggee state, such as registers or data spaces,
// has changed.
STDMETHOD(ChangeDebuggeeState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
) PURE;
// Engine state has changed.
STDMETHOD(ChangeEngineState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
) PURE;
// Symbol state has changed.
STDMETHOD(ChangeSymbolState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugInputCallbacks.
//
//----------------------------------------------------------------------------
#undef INTERFACE
#define INTERFACE IDebugInputCallbacks
DECLARE_INTERFACE_(IDebugInputCallbacks, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugInputCallbacks.
// A call to the StartInput method is a request for
// a line of input from any client. The returned input
// should always be zero-terminated. The buffer size
// provided is only a guideline. A client can return
// more if necessary and the engine will truncate it
// before returning from IDebugControl::Input.
// The return value is ignored.
STDMETHOD(StartInput)(
THIS_
__in ULONG BufferSize
) PURE;
// The return value is ignored.
STDMETHOD(EndInput)(
THIS
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugOutputCallbacks.
//
//----------------------------------------------------------------------------
#undef INTERFACE
#define INTERFACE IDebugOutputCallbacks
DECLARE_INTERFACE_(IDebugOutputCallbacks, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugOutputCallbacks.
// This method is only called if the supplied mask
// is allowed by the clients output control.
// The return value is ignored.
STDMETHOD(Output)(
THIS_
__in ULONG Mask,
__in PCSTR Text
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugOutputCallbacksWide
DECLARE_INTERFACE_(IDebugOutputCallbacksWide, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugOutputCallbacksWide.
// This method is only called if the supplied mask
// is allowed by the clients output control.
// The return value is ignored.
STDMETHOD(Output)(
THIS_
__in ULONG Mask,
__in PCWSTR Text
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugRegisters.
//
//----------------------------------------------------------------------------
#define DEBUG_REGISTERS_DEFAULT 0x00000000
#define DEBUG_REGISTERS_INT32 0x00000001
#define DEBUG_REGISTERS_INT64 0x00000002
#define DEBUG_REGISTERS_FLOAT 0x00000004
#define DEBUG_REGISTERS_ALL 0x00000007
#define DEBUG_REGISTER_SUB_REGISTER 0x00000001
typedef struct _DEBUG_REGISTER_DESCRIPTION
{
// DEBUG_VALUE type.
ULONG Type;
ULONG Flags;
// If this is a subregister the full
// registers description index is
// given in SubregMaster. The length, mask
// and shift describe how the subregisters
// bits fit into the full register.
ULONG SubregMaster;
ULONG SubregLength;
ULONG64 SubregMask;
ULONG SubregShift;
ULONG Reserved0;
} DEBUG_REGISTER_DESCRIPTION, *PDEBUG_REGISTER_DESCRIPTION;
#undef INTERFACE
#define INTERFACE IDebugRegisters
DECLARE_INTERFACE_(IDebugRegisters, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugRegisters.
STDMETHOD(GetNumberRegisters)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetDescription)(
THIS_
__in ULONG Register,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PDEBUG_REGISTER_DESCRIPTION Desc
) PURE;
STDMETHOD(GetIndexByName)(
THIS_
__in PCSTR Name,
__out PULONG Index
) PURE;
STDMETHOD(GetValue)(
THIS_
__in ULONG Register,
__out PDEBUG_VALUE Value
) PURE;
// SetValue makes a best effort at coercing
// the given value into the given registers
// value type. If the given value is larger
// than the register can hold the least
// significant bits will be dropped. Float
// to int and int to float will be done
// if necessary. Subregister bits will be
// inserted into the master register.
STDMETHOD(SetValue)(
THIS_
__in ULONG Register,
__in PDEBUG_VALUE Value
) PURE;
// Gets Count register values. If Indices is
// non-NULL it must contain Count register
// indices which control the registers affected.
// If Indices is NULL the registers from Start
// to Start + Count 1 are retrieved.
STDMETHOD(GetValues)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__out_ecount(Count) PDEBUG_VALUE Values
) PURE;
STDMETHOD(SetValues)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__in_ecount(Count) PDEBUG_VALUE Values
) PURE;
// Outputs a group of registers in a well-formatted
// way thats specific to the platforms register set.
// Uses the line prefix.
STDMETHOD(OutputRegisters)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// Abstracted pieces of processor information.
// The mapping of these values to architectural
// registers is architecture-specific and their
// interpretation and existence may vary. They
// are intended to be directly compatible with
// calls which take this information, such as
// stack walking.
STDMETHOD(GetInstructionOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(GetStackOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(GetFrameOffset)(
THIS_
__out PULONG64 Offset
) PURE;
};
//
// The engine maintains several separate
// pieces of context information. There is
// the current debuggee context, a possible
// override context, such as from .cxr,
// a context for the current scope frame and so on.
//
// Get register information from the debuggee.
#define DEBUG_REGSRC_DEBUGGEE 0x00000000
// Get register information from an explicit
// override context, such as one set by .cxr.
// If there is no override context the request will fail.
#define DEBUG_REGSRC_EXPLICIT 0x00000001
// Get register information from the current scope
// frame. Note that stack unwinding does not guarantee
// accurate updating of the register context,
// so scope frame register context may not be accurate
// in all cases.
#define DEBUG_REGSRC_FRAME 0x00000002
#undef INTERFACE
#define INTERFACE IDebugRegisters2
DECLARE_INTERFACE_(IDebugRegisters2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugRegisters.
STDMETHOD(GetNumberRegisters)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetDescription)(
THIS_
__in ULONG Register,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PDEBUG_REGISTER_DESCRIPTION Desc
) PURE;
STDMETHOD(GetIndexByName)(
THIS_
__in PCSTR Name,
__out PULONG Index
) PURE;
STDMETHOD(GetValue)(
THIS_
__in ULONG Register,
__out PDEBUG_VALUE Value
) PURE;
// SetValue makes a best effort at coercing
// the given value into the given registers
// value type. If the given value is larger
// than the register can hold the least
// significant bits will be dropped. Float
// to int and int to float will be done
// if necessary. Subregister bits will be
// inserted into the master register.
STDMETHOD(SetValue)(
THIS_
__in ULONG Register,
__in PDEBUG_VALUE Value
) PURE;
// Gets Count register values. If Indices is
// non-NULL it must contain Count register
// indices which control the registers affected.
// If Indices is NULL the registers from Start
// to Start + Count 1 are retrieved.
STDMETHOD(GetValues)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__out_ecount(Count) PDEBUG_VALUE Values
) PURE;
STDMETHOD(SetValues)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__in_ecount(Count) PDEBUG_VALUE Values
) PURE;
// Outputs a group of registers in a well-formatted
// way thats specific to the platforms register set.
// Uses the line prefix.
STDMETHOD(OutputRegisters)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags
) PURE;
// Abstracted pieces of processor information.
// The mapping of these values to architectural
// registers is architecture-specific and their
// interpretation and existence may vary. They
// are intended to be directly compatible with
// calls which take this information, such as
// stack walking.
STDMETHOD(GetInstructionOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(GetStackOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(GetFrameOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// IDebugRegisters2.
STDMETHOD(GetDescriptionWide)(
THIS_
__in ULONG Register,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PDEBUG_REGISTER_DESCRIPTION Desc
) PURE;
STDMETHOD(GetIndexByNameWide)(
THIS_
__in PCWSTR Name,
__out PULONG Index
) PURE;
// Pseudo-registers are synthetic values derived
// by the engine that are presented in a manner
// similar to regular registers. They are simple
// value holders, similar to actual registers.
// Pseudo-registers are defined for concepts,
// such as current-instruction-pointer or
// current-thread-data. As such they have
// types appropriate for their data.
STDMETHOD(GetNumberPseudoRegisters)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetPseudoDescription)(
THIS_
__in ULONG Register,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 TypeModule,
__out_opt PULONG TypeId
) PURE;
STDMETHOD(GetPseudoDescriptionWide)(
THIS_
__in ULONG Register,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 TypeModule,
__out_opt PULONG TypeId
) PURE;
STDMETHOD(GetPseudoIndexByName)(
THIS_
__in PCSTR Name,
__out PULONG Index
) PURE;
STDMETHOD(GetPseudoIndexByNameWide)(
THIS_
__in PCWSTR Name,
__out PULONG Index
) PURE;
// Some pseudo-register values are affected
// by the register source, others are not.
STDMETHOD(GetPseudoValues)(
THIS_
__in ULONG Source,
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__out_ecount(Count) PDEBUG_VALUE Values
) PURE;
// Many pseudo-registers are read-only and cannot be set.
STDMETHOD(SetPseudoValues)(
THIS_
__in ULONG Source,
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__in_ecount(Count) PDEBUG_VALUE Values
) PURE;
// These expanded methods allow selection
// of the source of register information.
STDMETHOD(GetValues2)(
THIS_
__in ULONG Source,
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__out_ecount(Count) PDEBUG_VALUE Values
) PURE;
STDMETHOD(SetValues2)(
THIS_
__in ULONG Source,
__in ULONG Count,
__in_ecount_opt(Count) PULONG Indices,
__in ULONG Start,
__in_ecount(Count) PDEBUG_VALUE Values
) PURE;
STDMETHOD(OutputRegisters2)(
THIS_
__in ULONG OutputControl,
__in ULONG Source,
__in ULONG Flags
) PURE;
STDMETHOD(GetInstructionOffset2)(
THIS_
__in ULONG Source,
__out PULONG64 Offset
) PURE;
STDMETHOD(GetStackOffset2)(
THIS_
__in ULONG Source,
__out PULONG64 Offset
) PURE;
STDMETHOD(GetFrameOffset2)(
THIS_
__in ULONG Source,
__out PULONG64 Offset
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugSymbolGroup
//
//----------------------------------------------------------------------------
// OutputSymbols flags.
// Default output contains
// <Name>**NAME**<Offset>**OFF**<Value>**VALUE**<Type>**TYPE**
// per symbol.
#define DEBUG_OUTPUT_SYMBOLS_DEFAULT 0x00000000
#define DEBUG_OUTPUT_SYMBOLS_NO_NAMES 0x00000001
#define DEBUG_OUTPUT_SYMBOLS_NO_OFFSETS 0x00000002
#define DEBUG_OUTPUT_SYMBOLS_NO_VALUES 0x00000004
#define DEBUG_OUTPUT_SYMBOLS_NO_TYPES 0x00000010
#define DEBUG_OUTPUT_NAME_END "**NAME**"
#define DEBUG_OUTPUT_OFFSET_END "**OFF**"
#define DEBUG_OUTPUT_VALUE_END "**VALUE**"
#define DEBUG_OUTPUT_TYPE_END "**TYPE**"
#define DEBUG_OUTPUT_NAME_END_WIDE L"**NAME**"
#define DEBUG_OUTPUT_OFFSET_END_WIDE L"**OFF**"
#define DEBUG_OUTPUT_VALUE_END_WIDE L"**VALUE**"
#define DEBUG_OUTPUT_TYPE_END_WIDE L"**TYPE**"
#ifdef UNICODE
#define DEBUG_OUTPUT_NAME_END_T DEBUG_OUTPUT_NAME_END_WIDE
#define DEBUG_OUTPUT_OFFSET_END_T DEBUG_OUTPUT_OFFSET_END_WIDE
#define DEBUG_OUTPUT_VALUE_END_T DEBUG_OUTPUT_VALUE_END_WIDE
#define DEBUG_OUTPUT_TYPE_END_T DEBUG_OUTPUT_TYPE_END_WIDE
#else
#define DEBUG_OUTPUT_NAME_END_T DEBUG_OUTPUT_NAME_END
#define DEBUG_OUTPUT_OFFSET_END_T DEBUG_OUTPUT_OFFSET_END
#define DEBUG_OUTPUT_VALUE_END_T DEBUG_OUTPUT_VALUE_END
#define DEBUG_OUTPUT_TYPE_END_T DEBUG_OUTPUT_TYPE_END
#endif
// DEBUG_SYMBOL_PARAMETERS flags.
// Cumulative expansion level, takes four bits.
#define DEBUG_SYMBOL_EXPANSION_LEVEL_MASK 0x0000000f
// Symbols subelements follow.
#define DEBUG_SYMBOL_EXPANDED 0x00000010
// Symbols value is read-only.
#define DEBUG_SYMBOL_READ_ONLY 0x00000020
// Symbol subelements are array elements.
#define DEBUG_SYMBOL_IS_ARRAY 0x00000040
// Symbol is a float value.
#define DEBUG_SYMBOL_IS_FLOAT 0x00000080
// Symbol is a scope argument.
#define DEBUG_SYMBOL_IS_ARGUMENT 0x00000100
// Symbol is a scope argument.
#define DEBUG_SYMBOL_IS_LOCAL 0x00000200
typedef struct _DEBUG_SYMBOL_PARAMETERS
{
ULONG64 Module;
ULONG TypeId;
// ParentSymbol may be DEBUG_ANY_ID when unknown.
ULONG ParentSymbol;
// A subelement of a symbol can be a field, such
// as in structs, unions or classes; or an array
// element count for arrays.
ULONG SubElements;
ULONG Flags;
ULONG64 Reserved;
} DEBUG_SYMBOL_PARAMETERS, *PDEBUG_SYMBOL_PARAMETERS;
#undef INTERFACE
#define INTERFACE IDebugSymbolGroup
DECLARE_INTERFACE_(IDebugSymbolGroup, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSymbolGroup.
STDMETHOD(GetNumberSymbols)(
THIS_
__out PULONG Number
) PURE;
// On input Index indicates the desired insertion
// index. On output Index contains the actual index.
// Use DEBUG_ANY_ID to append a symbol to the end.
STDMETHOD(AddSymbol)(
THIS_
__in PCSTR Name,
__inout PULONG Index
) PURE;
STDMETHOD(RemoveSymbolByName)(
THIS_
__in PCSTR Name
) PURE;
STDMETHOD(RemoveSymbolByIndex)(
THIS_
__in ULONG Index
) PURE;
STDMETHOD(GetSymbolName)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetSymbolParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PDEBUG_SYMBOL_PARAMETERS Params
) PURE;
STDMETHOD(ExpandSymbol)(
THIS_
__in ULONG Index,
__in BOOL Expand
) PURE;
// Uses the line prefix.
STDMETHOD(OutputSymbols)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in ULONG Start,
__in ULONG Count
) PURE;
STDMETHOD(WriteSymbol)(
THIS_
__in ULONG Index,
__in PCSTR Value
) PURE;
STDMETHOD(OutputAsType)(
THIS_
__in ULONG Index,
__in PCSTR Type
) PURE;
};
#define DEBUG_SYMENT_IS_CODE 0x00000001
#define DEBUG_SYMENT_IS_DATA 0x00000002
#define DEBUG_SYMENT_IS_PARAMETER 0x00000004
#define DEBUG_SYMENT_IS_LOCAL 0x00000008
#define DEBUG_SYMENT_IS_MANAGED 0x00000010
#define DEBUG_SYMENT_IS_SYNTHETIC 0x00000020
typedef struct _DEBUG_SYMBOL_ENTRY
{
ULONG64 ModuleBase;
ULONG64 Offset;
ULONG64 Id;
ULONG64 Arg64;
ULONG Size;
ULONG Flags;
ULONG TypeId;
ULONG NameSize;
ULONG Token;
ULONG Tag;
ULONG Arg32;
ULONG Reserved;
} DEBUG_SYMBOL_ENTRY, *PDEBUG_SYMBOL_ENTRY;
#undef INTERFACE
#define INTERFACE IDebugSymbolGroup2
DECLARE_INTERFACE_(IDebugSymbolGroup2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSymbolGroup.
STDMETHOD(GetNumberSymbols)(
THIS_
__out PULONG Number
) PURE;
// On input Index indicates the desired insertion
// index. On output Index contains the actual index.
// Use DEBUG_ANY_ID to append a symbol to the end.
STDMETHOD(AddSymbol)(
THIS_
__in PCSTR Name,
__inout PULONG Index
) PURE;
STDMETHOD(RemoveSymbolByName)(
THIS_
__in PCSTR Name
) PURE;
STDMETHOD(RemoveSymbolByIndex)(
THIS_
__in ULONG Index
) PURE;
STDMETHOD(GetSymbolName)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetSymbolParameters)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PDEBUG_SYMBOL_PARAMETERS Params
) PURE;
STDMETHOD(ExpandSymbol)(
THIS_
__in ULONG Index,
__in BOOL Expand
) PURE;
// Uses the line prefix.
STDMETHOD(OutputSymbols)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in ULONG Start,
__in ULONG Count
) PURE;
STDMETHOD(WriteSymbol)(
THIS_
__in ULONG Index,
__in PCSTR Value
) PURE;
STDMETHOD(OutputAsType)(
THIS_
__in ULONG Index,
__in PCSTR Type
) PURE;
// IDebugSymbolGroup2.
STDMETHOD(AddSymbolWide)(
THIS_
__in PCWSTR Name,
__inout PULONG Index
) PURE;
STDMETHOD(RemoveSymbolByNameWide)(
THIS_
__in PCWSTR Name
) PURE;
STDMETHOD(GetSymbolNameWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(WriteSymbolWide)(
THIS_
__in ULONG Index,
__in PCWSTR Value
) PURE;
STDMETHOD(OutputAsTypeWide)(
THIS_
__in ULONG Index,
__in PCWSTR Type
) PURE;
STDMETHOD(GetSymbolTypeName)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetSymbolTypeNameWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetSymbolSize)(
THIS_
__in ULONG Index,
__out PULONG Size
) PURE;
// If the symbol has an absolute address
// this method will retrieve it.
STDMETHOD(GetSymbolOffset)(
THIS_
__in ULONG Index,
__out PULONG64 Offset
) PURE;
// If the symbol is enregistered this
// method will return the register index.
STDMETHOD(GetSymbolRegister)(
THIS_
__in ULONG Index,
__out PULONG Register
) PURE;
STDMETHOD(GetSymbolValueText)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetSymbolValueTextWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetSymbolEntryInformation)(
THIS_
__in ULONG Index,
__out PDEBUG_SYMBOL_ENTRY Entry
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugSymbols.
//
//----------------------------------------------------------------------------
//
// Information about a module.
//
// Flags.
#define DEBUG_MODULE_LOADED 0x00000000
#define DEBUG_MODULE_UNLOADED 0x00000001
#define DEBUG_MODULE_USER_MODE 0x00000002
#define DEBUG_MODULE_EXPLICIT 0x00000008
#define DEBUG_MODULE_SECONDARY 0x00000010
#define DEBUG_MODULE_SYNTHETIC 0x00000020
#define DEBUG_MODULE_SYM_BAD_CHECKSUM 0x00010000
// Symbol types.
#define DEBUG_SYMTYPE_NONE 0
#define DEBUG_SYMTYPE_COFF 1
#define DEBUG_SYMTYPE_CODEVIEW 2
#define DEBUG_SYMTYPE_PDB 3
#define DEBUG_SYMTYPE_EXPORT 4
#define DEBUG_SYMTYPE_DEFERRED 5
#define DEBUG_SYMTYPE_SYM 6
#define DEBUG_SYMTYPE_DIA 7
typedef struct _DEBUG_MODULE_PARAMETERS
{
ULONG64 Base;
ULONG Size;
ULONG TimeDateStamp;
ULONG Checksum;
ULONG Flags;
ULONG SymbolType;
ULONG ImageNameSize;
ULONG ModuleNameSize;
ULONG LoadedImageNameSize;
ULONG SymbolFileNameSize;
ULONG MappedImageNameSize;
ULONG64 Reserved[2];
} DEBUG_MODULE_PARAMETERS, *PDEBUG_MODULE_PARAMETERS;
// Scope arguments are function arguments
// and thus only change when the scope
// crosses functions.
#define DEBUG_SCOPE_GROUP_ARGUMENTS 0x00000001
// Scope locals are locals declared in a particular
// scope and are only defined within that scope.
#define DEBUG_SCOPE_GROUP_LOCALS 0x00000002
// All symbols in the scope.
#define DEBUG_SCOPE_GROUP_ALL 0x00000003
// Typed data output control flags.
#define DEBUG_OUTTYPE_DEFAULT 0x00000000
#define DEBUG_OUTTYPE_NO_INDENT 0x00000001
#define DEBUG_OUTTYPE_NO_OFFSET 0x00000002
#define DEBUG_OUTTYPE_VERBOSE 0x00000004
#define DEBUG_OUTTYPE_COMPACT_OUTPUT 0x00000008
#define DEBUG_OUTTYPE_RECURSION_LEVEL(Max) (((Max) & 0xf) << 4)
#define DEBUG_OUTTYPE_ADDRESS_OF_FIELD 0x00010000
#define DEBUG_OUTTYPE_ADDRESS_AT_END 0x00020000
#define DEBUG_OUTTYPE_BLOCK_RECURSE 0x00200000
// FindSourceFile flags.
#define DEBUG_FIND_SOURCE_DEFAULT 0x00000000
// Returns fully-qualified paths only. If this
// is not set the path returned may be relative.
#define DEBUG_FIND_SOURCE_FULL_PATH 0x00000001
// Scans all the path elements for a match and
// returns the one that has the most similarity
// between the given file and the matching element.
#define DEBUG_FIND_SOURCE_BEST_MATCH 0x00000002
// Do not search source server paths.
#define DEBUG_FIND_SOURCE_NO_SRCSRV 0x00000004
// Restrict FindSourceFileAndToken to token lookup only.
#define DEBUG_FIND_SOURCE_TOKEN_LOOKUP 0x00000008
// A special value marking an offset that should not
// be treated as a valid offset. This is only used
// in special situations where it is unlikely that
// this value would be a valid offset.
#define DEBUG_INVALID_OFFSET ((ULONG64)-1)
#undef INTERFACE
#define INTERFACE IDebugSymbols
DECLARE_INTERFACE_(IDebugSymbols, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSymbols.
// Controls the symbol options used during
// symbol operations.
// Uses the same flags as dbghelps SymSetOptions.
STDMETHOD(GetSymbolOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(GetNameByOffset)(
THIS_
__in ULONG64 Offset,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
// A symbol name may not be unique, particularly
// when overloaded functions exist which all
// have the same name. If GetOffsetByName
// finds multiple matches for the name it
// can return any one of them. In that
// case it will return S_FALSE to indicate
// that ambiguity was arbitrarily resolved.
// A caller can then use SearchSymbols to
// find all of the matches if it wishes to
// perform different disambiguation.
STDMETHOD(GetOffsetByName)(
THIS_
__in PCSTR Symbol,
__out PULONG64 Offset
) PURE;
// GetNearNameByOffset returns symbols
// located near the symbol closest to
// to the offset, such as the previous
// or next symbol. If Delta is zero it
// operates identically to GetNameByOffset.
// If Delta is nonzero and such a symbol
// does not exist an error is returned.
// The next symbol, if one exists, will
// always have a higher offset than the
// input offset so the displacement is
// always negative. The situation is
// reversed for the previous symbol.
STDMETHOD(GetNearNameByOffset)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetLineByOffset)(
THIS_
__in ULONG64 Offset,
__out_opt PULONG Line,
__out_ecount_opt(FileBufferSize) PSTR FileBuffer,
__in ULONG FileBufferSize,
__out_opt PULONG FileSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetOffsetByLine)(
THIS_
__in ULONG Line,
__in PCSTR File,
__out PULONG64 Offset
) PURE;
// Enumerates the engines list of modules
// loaded for the current process. This may
// or may not match the system module list
// for the process. Reload can be used to
// synchronize the engines list with the system
// if necessary.
// Some sessions also track recently unloaded
// code modules for help in analyzing failures
// where an attempt is made to call unloaded code.
// These modules are indexed after the loaded
// modules.
STDMETHOD(GetNumberModules)(
THIS_
__out PULONG Loaded,
__out PULONG Unloaded
) PURE;
STDMETHOD(GetModuleByIndex)(
THIS_
__in ULONG Index,
__out PULONG64 Base
) PURE;
// The module name may not be unique.
// This method returns the first match.
STDMETHOD(GetModuleByModuleName)(
THIS_
__in PCSTR Name,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// Offset can be any offset within
// the module extent. Extents may
// not be unique when including unloaded
// drivers. This method returns the
// first match.
STDMETHOD(GetModuleByOffset)(
THIS_
__in ULONG64 Offset,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
STDMETHOD(GetModuleNames)(
THIS_
__in ULONG Index,
__in ULONG64 Base,
__out_ecount_opt(ImageNameBufferSize) PSTR ImageNameBuffer,
__in ULONG ImageNameBufferSize,
__out_opt PULONG ImageNameSize,
__out_ecount_opt(ModuleNameBufferSize) PSTR ModuleNameBuffer,
__in ULONG ModuleNameBufferSize,
__out_opt PULONG ModuleNameSize,
__out_ecount_opt(LoadedImageNameBufferSize) PSTR LoadedImageNameBuffer,
__in ULONG LoadedImageNameBufferSize,
__out_opt PULONG LoadedImageNameSize
) PURE;
STDMETHOD(GetModuleParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG64 Bases,
__in ULONG Start,
__out_ecount(Count) PDEBUG_MODULE_PARAMETERS Params
) PURE;
// Looks up the module from a <Module>!<Symbol>
// string.
STDMETHOD(GetSymbolModule)(
THIS_
__in PCSTR Symbol,
__out PULONG64 Base
) PURE;
// Returns the string name of a type.
STDMETHOD(GetTypeName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns the ID for a type name.
STDMETHOD(GetTypeId)(
THIS_
__in ULONG64 Module,
__in PCSTR Name,
__out PULONG TypeId
) PURE;
STDMETHOD(GetTypeSize)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out PULONG Size
) PURE;
// Given a type which can contain members
// this method returns the offset of a
// particular member within the type.
// TypeId should give the container type ID
// and Field gives the dot-separated path
// to the field of interest.
STDMETHOD(GetFieldOffset)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in PCSTR Field,
__out PULONG Offset
) PURE;
STDMETHOD(GetSymbolTypeId)(
THIS_
__in PCSTR Symbol,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
// As with GetOffsetByName a symbol's
// name may be ambiguous. GetOffsetTypeId
// returns the type for the symbol closest
// to the given offset and can be used
// to avoid ambiguity.
STDMETHOD(GetOffsetTypeId)(
THIS_
__in ULONG64 Offset,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
// Helpers for virtual and physical data
// which combine creation of a location with
// the actual operation.
STDMETHOD(ReadTypedDataVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteTypedDataVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(OutputTypedDataVirtual)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG Flags
) PURE;
STDMETHOD(ReadTypedDataPhysical)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteTypedDataPhysical)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(OutputTypedDataPhysical)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG Flags
) PURE;
// Function arguments and scope block symbols
// can be retrieved relative to currently
// executing code. A caller can provide just
// a code offset for scoping purposes and look
// up names or the caller can provide a full frame
// and look up actual values. The values for
// scoped symbols are best-guess and may or may not
// be accurate depending on program optimizations,
// the machine architecture, the current point
// in the programs execution and so on.
// A caller can also provide a complete register
// context for setting a scope to a previous
// machine state such as a context saved for
// an exception. Usually this isnt necessary
// and the current register context is used.
STDMETHOD(GetScope)(
THIS_
__out_opt PULONG64 InstructionOffset,
__out_opt PDEBUG_STACK_FRAME ScopeFrame,
__out_bcount_opt(ScopeContextSize) PVOID ScopeContext,
__in ULONG ScopeContextSize
) PURE;
// If ScopeFrame or ScopeContext is non-NULL then
// InstructionOffset is ignored.
// If ScopeContext is NULL the current
// register context is used.
// If the scope identified by the given
// information is the same as before
// SetScope returns S_OK. If the scope
// information changes, such as when the
// scope moves between functions or scope
// blocks, SetScope returns S_FALSE.
STDMETHOD(SetScope)(
THIS_
__in ULONG64 InstructionOffset,
__in_opt PDEBUG_STACK_FRAME ScopeFrame,
__in_bcount_opt(ScopeContextSize) PVOID ScopeContext,
__in ULONG ScopeContextSize
) PURE;
// ResetScope clears the scope information
// for situations where scoped symbols
// mask global symbols or when resetting
// from explicit information to the current
// information.
STDMETHOD(ResetScope)(
THIS
) PURE;
// A scope symbol is tied to its particular
// scope and only is meaningful within the scope.
// The returned group can be updated by passing it back
// into the method for lower-cost
// incremental updates when stepping.
STDMETHOD(GetScopeSymbolGroup)(
THIS_
__in ULONG Flags,
__in_opt PDEBUG_SYMBOL_GROUP Update,
__out PDEBUG_SYMBOL_GROUP* Symbols
) PURE;
// Create a new symbol group.
STDMETHOD(CreateSymbolGroup)(
THIS_
__out PDEBUG_SYMBOL_GROUP* Group
) PURE;
// StartSymbolMatch matches symbol names
// against the given pattern using simple
// regular expressions. The search results
// are iterated through using GetNextSymbolMatch.
// When the caller is done examining results
// the match should be freed via EndSymbolMatch.
// If the match pattern contains a module name
// the search is restricted to a single module.
// Pattern matching is only done on symbol names,
// not module names.
// All active symbol match handles are invalidated
// when the set of loaded symbols changes.
STDMETHOD(StartSymbolMatch)(
THIS_
__in PCSTR Pattern,
__out PULONG64 Handle
) PURE;
// If Buffer is NULL the match does not
// advance.
STDMETHOD(GetNextSymbolMatch)(
THIS_
__in ULONG64 Handle,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MatchSize,
__out_opt PULONG64 Offset
) PURE;
STDMETHOD(EndSymbolMatch)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Reload)(
THIS_
__in PCSTR Module
) PURE;
STDMETHOD(GetSymbolPath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetSymbolPath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendSymbolPath)(
THIS_
__in PCSTR Addition
) PURE;
// Manipulate the path for executable images.
// Some dump files need to load executable images
// in order to resolve dump information. This
// path controls where the engine looks for
// images.
STDMETHOD(GetImagePath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetImagePath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendImagePath)(
THIS_
__in PCSTR Addition
) PURE;
// Path routines for source file location
// methods.
STDMETHOD(GetSourcePath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
// Gets the nth part of the source path.
STDMETHOD(GetSourcePathElement)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ElementSize
) PURE;
STDMETHOD(SetSourcePath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendSourcePath)(
THIS_
__in PCSTR Addition
) PURE;
// Uses the given file path and the source path
// information to try and locate an existing file.
// The given file path is merged with elements
// of the source path and checked for existence.
// If a match is found the element used is returned.
// A starting element can be specified to restrict
// the search to a subset of the path elements;
// this can be useful when checking for multiple
// matches along the source path.
// The returned element can be 1, indicating
// the file was found directly and not on the path.
STDMETHOD(FindSourceFile)(
THIS_
__in ULONG StartElement,
__in PCSTR File,
__in ULONG Flags,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
// Retrieves all the line offset information
// for a particular source file. Buffer is
// first intialized to DEBUG_INVALID_OFFSET for
// every entry. Then for each piece of line
// symbol information Buffer[Line] set to
// Lines offset. This produces a per-line
// map of the offsets for the lines of the
// given file. Line numbers are decremented
// for the map so Buffer[0] contains the offset
// for line number 1.
// If there is no line information at all for
// the given file the method fails rather
// than returning a map of invalid offsets.
STDMETHOD(GetSourceFileLineOffsets)(
THIS_
__in PCSTR File,
__out_ecount_opt(BufferLines) PULONG64 Buffer,
__in ULONG BufferLines,
__out_opt PULONG FileLines
) PURE;
};
//
// GetModuleNameString strings.
//
#define DEBUG_MODNAME_IMAGE 0x00000000
#define DEBUG_MODNAME_MODULE 0x00000001
#define DEBUG_MODNAME_LOADED_IMAGE 0x00000002
#define DEBUG_MODNAME_SYMBOL_FILE 0x00000003
#define DEBUG_MODNAME_MAPPED_IMAGE 0x00000004
//
// Type options, used with Get/SetTypeOptions.
//
// Display PUSHORT and USHORT arrays in Unicode.
#define DEBUG_TYPEOPTS_UNICODE_DISPLAY 0x00000001
// Display LONG types in default base instead of decimal.
#define DEBUG_TYPEOPTS_LONGSTATUS_DISPLAY 0x00000002
// Display integer types in default base instead of decimal.
#define DEBUG_TYPEOPTS_FORCERADIX_OUTPUT 0x00000004
#undef INTERFACE
#define INTERFACE IDebugSymbols2
DECLARE_INTERFACE_(IDebugSymbols2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSymbols.
// Controls the symbol options used during
// symbol operations.
// Uses the same flags as dbghelps SymSetOptions.
STDMETHOD(GetSymbolOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(GetNameByOffset)(
THIS_
__in ULONG64 Offset,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
// A symbol name may not be unique, particularly
// when overloaded functions exist which all
// have the same name. If GetOffsetByName
// finds multiple matches for the name it
// can return any one of them. In that
// case it will return S_FALSE to indicate
// that ambiguity was arbitrarily resolved.
// A caller can then use SearchSymbols to
// find all of the matches if it wishes to
// perform different disambiguation.
STDMETHOD(GetOffsetByName)(
THIS_
__in PCSTR Symbol,
__out PULONG64 Offset
) PURE;
// GetNearNameByOffset returns symbols
// located near the symbol closest to
// to the offset, such as the previous
// or next symbol. If Delta is zero it
// operates identically to GetNameByOffset.
// If Delta is nonzero and such a symbol
// does not exist an error is returned.
// The next symbol, if one exists, will
// always have a higher offset than the
// input offset so the displacement is
// always negative. The situation is
// reversed for the previous symbol.
STDMETHOD(GetNearNameByOffset)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetLineByOffset)(
THIS_
__in ULONG64 Offset,
__out_opt PULONG Line,
__out_ecount_opt(FileBufferSize) PSTR FileBuffer,
__in ULONG FileBufferSize,
__out_opt PULONG FileSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetOffsetByLine)(
THIS_
__in ULONG Line,
__in PCSTR File,
__out PULONG64 Offset
) PURE;
// Enumerates the engines list of modules
// loaded for the current process. This may
// or may not match the system module list
// for the process. Reload can be used to
// synchronize the engines list with the system
// if necessary.
// Some sessions also track recently unloaded
// code modules for help in analyzing failures
// where an attempt is made to call unloaded code.
// These modules are indexed after the loaded
// modules.
STDMETHOD(GetNumberModules)(
THIS_
__out PULONG Loaded,
__out PULONG Unloaded
) PURE;
STDMETHOD(GetModuleByIndex)(
THIS_
__in ULONG Index,
__out PULONG64 Base
) PURE;
// The module name may not be unique.
// This method returns the first match.
STDMETHOD(GetModuleByModuleName)(
THIS_
__in PCSTR Name,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// Offset can be any offset within
// the module extent. Extents may
// not be unique when including unloaded
// drivers. This method returns the
// first match.
STDMETHOD(GetModuleByOffset)(
THIS_
__in ULONG64 Offset,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
STDMETHOD(GetModuleNames)(
THIS_
__in ULONG Index,
__in ULONG64 Base,
__out_ecount_opt(ImageNameBufferSize) PSTR ImageNameBuffer,
__in ULONG ImageNameBufferSize,
__out_opt PULONG ImageNameSize,
__out_ecount_opt(ModuleNameBufferSize) PSTR ModuleNameBuffer,
__in ULONG ModuleNameBufferSize,
__out_opt PULONG ModuleNameSize,
__out_ecount_opt(LoadedImageNameBufferSize) PSTR LoadedImageNameBuffer,
__in ULONG LoadedImageNameBufferSize,
__out_opt PULONG LoadedImageNameSize
) PURE;
STDMETHOD(GetModuleParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG64 Bases,
__in ULONG Start,
__out_ecount(Count) PDEBUG_MODULE_PARAMETERS Params
) PURE;
// Looks up the module from a <Module>!<Symbol>
// string.
STDMETHOD(GetSymbolModule)(
THIS_
__in PCSTR Symbol,
__out PULONG64 Base
) PURE;
// Returns the string name of a type.
STDMETHOD(GetTypeName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns the ID for a type name.
STDMETHOD(GetTypeId)(
THIS_
__in ULONG64 Module,
__in PCSTR Name,
__out PULONG TypeId
) PURE;
STDMETHOD(GetTypeSize)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out PULONG Size
) PURE;
// Given a type which can contain members
// this method returns the offset of a
// particular member within the type.
// TypeId should give the container type ID
// and Field gives the dot-separated path
// to the field of interest.
STDMETHOD(GetFieldOffset)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in PCSTR Field,
__out PULONG Offset
) PURE;
STDMETHOD(GetSymbolTypeId)(
THIS_
__in PCSTR Symbol,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
// As with GetOffsetByName a symbol's
// name may be ambiguous. GetOffsetTypeId
// returns the type for the symbol closest
// to the given offset and can be used
// to avoid ambiguity.
STDMETHOD(GetOffsetTypeId)(
THIS_
__in ULONG64 Offset,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
// Helpers for virtual and physical data
// which combine creation of a location with
// the actual operation.
STDMETHOD(ReadTypedDataVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteTypedDataVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(OutputTypedDataVirtual)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG Flags
) PURE;
STDMETHOD(ReadTypedDataPhysical)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteTypedDataPhysical)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(OutputTypedDataPhysical)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG Flags
) PURE;
// Function arguments and scope block symbols
// can be retrieved relative to currently
// executing code. A caller can provide just
// a code offset for scoping purposes and look
// up names or the caller can provide a full frame
// and look up actual values. The values for
// scoped symbols are best-guess and may or may not
// be accurate depending on program optimizations,
// the machine architecture, the current point
// in the programs execution and so on.
// A caller can also provide a complete register
// context for setting a scope to a previous
// machine state such as a context saved for
// an exception. Usually this isnt necessary
// and the current register context is used.
STDMETHOD(GetScope)(
THIS_
__out_opt PULONG64 InstructionOffset,
__out_opt PDEBUG_STACK_FRAME ScopeFrame,
__out_bcount_opt(ScopeContextSize) PVOID ScopeContext,
__in ULONG ScopeContextSize
) PURE;
// If ScopeFrame or ScopeContext is non-NULL then
// InstructionOffset is ignored.
// If ScopeContext is NULL the current
// register context is used.
// If the scope identified by the given
// information is the same as before
// SetScope returns S_OK. If the scope
// information changes, such as when the
// scope moves between functions or scope
// blocks, SetScope returns S_FALSE.
STDMETHOD(SetScope)(
THIS_
__in ULONG64 InstructionOffset,
__in_opt PDEBUG_STACK_FRAME ScopeFrame,
__in_bcount_opt(ScopeContextSize) PVOID ScopeContext,
__in ULONG ScopeContextSize
) PURE;
// ResetScope clears the scope information
// for situations where scoped symbols
// mask global symbols or when resetting
// from explicit information to the current
// information.
STDMETHOD(ResetScope)(
THIS
) PURE;
// A scope symbol is tied to its particular
// scope and only is meaningful within the scope.
// The returned group can be updated by passing it back
// into the method for lower-cost
// incremental updates when stepping.
STDMETHOD(GetScopeSymbolGroup)(
THIS_
__in ULONG Flags,
__in_opt PDEBUG_SYMBOL_GROUP Update,
__out PDEBUG_SYMBOL_GROUP* Symbols
) PURE;
// Create a new symbol group.
STDMETHOD(CreateSymbolGroup)(
THIS_
__out PDEBUG_SYMBOL_GROUP* Group
) PURE;
// StartSymbolMatch matches symbol names
// against the given pattern using simple
// regular expressions. The search results
// are iterated through using GetNextSymbolMatch.
// When the caller is done examining results
// the match should be freed via EndSymbolMatch.
// If the match pattern contains a module name
// the search is restricted to a single module.
// Pattern matching is only done on symbol names,
// not module names.
// All active symbol match handles are invalidated
// when the set of loaded symbols changes.
STDMETHOD(StartSymbolMatch)(
THIS_
__in PCSTR Pattern,
__out PULONG64 Handle
) PURE;
// If Buffer is NULL the match does not
// advance.
STDMETHOD(GetNextSymbolMatch)(
THIS_
__in ULONG64 Handle,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MatchSize,
__out_opt PULONG64 Offset
) PURE;
STDMETHOD(EndSymbolMatch)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Reload)(
THIS_
__in PCSTR Module
) PURE;
STDMETHOD(GetSymbolPath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetSymbolPath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendSymbolPath)(
THIS_
__in PCSTR Addition
) PURE;
// Manipulate the path for executable images.
// Some dump files need to load executable images
// in order to resolve dump information. This
// path controls where the engine looks for
// images.
STDMETHOD(GetImagePath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetImagePath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendImagePath)(
THIS_
__in PCSTR Addition
) PURE;
// Path routines for source file location
// methods.
STDMETHOD(GetSourcePath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
// Gets the nth part of the source path.
STDMETHOD(GetSourcePathElement)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ElementSize
) PURE;
STDMETHOD(SetSourcePath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendSourcePath)(
THIS_
__in PCSTR Addition
) PURE;
// Uses the given file path and the source path
// information to try and locate an existing file.
// The given file path is merged with elements
// of the source path and checked for existence.
// If a match is found the element used is returned.
// A starting element can be specified to restrict
// the search to a subset of the path elements;
// this can be useful when checking for multiple
// matches along the source path.
// The returned element can be 1, indicating
// the file was found directly and not on the path.
STDMETHOD(FindSourceFile)(
THIS_
__in ULONG StartElement,
__in PCSTR File,
__in ULONG Flags,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
// Retrieves all the line offset information
// for a particular source file. Buffer is
// first intialized to DEBUG_INVALID_OFFSET for
// every entry. Then for each piece of line
// symbol information Buffer[Line] set to
// Lines offset. This produces a per-line
// map of the offsets for the lines of the
// given file. Line numbers are decremented
// for the map so Buffer[0] contains the offset
// for line number 1.
// If there is no line information at all for
// the given file the method fails rather
// than returning a map of invalid offsets.
STDMETHOD(GetSourceFileLineOffsets)(
THIS_
__in PCSTR File,
__out_ecount_opt(BufferLines) PULONG64 Buffer,
__in ULONG BufferLines,
__out_opt PULONG FileLines
) PURE;
// IDebugSymbols2.
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
// Item is specified as in VerQueryValue.
// Module version information is only
// available for loaded modules and may
// not be available in all debug sessions.
STDMETHOD(GetModuleVersionInformation)(
THIS_
__in ULONG Index,
__in ULONG64 Base,
__in PCSTR Item,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG VerInfoSize
) PURE;
// Retrieves any available module name string
// such as module name or symbol file name.
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
// If symbols are deferred an error will
// be returned.
// E_NOINTERFACE may be returned, indicating
// no information exists.
STDMETHOD(GetModuleNameString)(
THIS_
__in ULONG Which,
__in ULONG Index,
__in ULONG64 Base,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns the string name of a constant type.
STDMETHOD(GetConstantName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG64 Value,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Gets name of a field in a struct
// FieldNumber is 0 based index of field in a struct
STDMETHOD(GetFieldName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG FieldIndex,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Control options for typed values.
STDMETHOD(GetTypeOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddTypeOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveTypeOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetTypeOptions)(
THIS_
__in ULONG Options
) PURE;
};
//
// GetModuleBy* flags.
//
// Scan all modules, loaded and unloaded.
#define DEBUG_GETMOD_DEFAULT 0x00000000
// Do not scan loaded modules.
#define DEBUG_GETMOD_NO_LOADED_MODULES 0x00000001
// Do not scan unloaded modules.
#define DEBUG_GETMOD_NO_UNLOADED_MODULES 0x00000002
//
// AddSyntheticModule flags.
//
#define DEBUG_ADDSYNTHMOD_DEFAULT 0x00000000
//
// AddSyntheticSymbol flags.
//
#define DEBUG_ADDSYNTHSYM_DEFAULT 0x00000000
//
// OutputSymbolByOffset flags.
//
// Use the current debugger settings for symbol output.
#define DEBUG_OUTSYM_DEFAULT 0x00000000
// Always display the offset in addition to any symbol hit.
#define DEBUG_OUTSYM_FORCE_OFFSET 0x00000001
// Display source line information if found.
#define DEBUG_OUTSYM_SOURCE_LINE 0x00000002
// Output symbol hits that don't exactly match.
#define DEBUG_OUTSYM_ALLOW_DISPLACEMENT 0x00000004
//
// GetFunctionEntryByOffset flags.
//
#define DEBUG_GETFNENT_DEFAULT 0x00000000
// The engine provides artificial entries for well-known
// cases. This flag limits the entry search to only
// the raw entries and disables artificial entry lookup.
#define DEBUG_GETFNENT_RAW_ENTRY_ONLY 0x00000001
typedef struct _DEBUG_MODULE_AND_ID
{
ULONG64 ModuleBase;
ULONG64 Id;
} DEBUG_MODULE_AND_ID, *PDEBUG_MODULE_AND_ID;
#define DEBUG_SOURCE_IS_STATEMENT 0x00000001
typedef struct _DEBUG_SYMBOL_SOURCE_ENTRY
{
ULONG64 ModuleBase;
ULONG64 Offset;
ULONG64 FileNameId;
ULONG64 EngineInternal;
ULONG Size;
ULONG Flags;
ULONG FileNameSize;
// Line numbers are one-based.
// May be DEBUG_ANY_ID if unknown.
ULONG StartLine;
ULONG EndLine;
// Column numbers are one-based byte indices.
// May be DEBUG_ANY_ID if unknown.
ULONG StartColumn;
ULONG EndColumn;
ULONG Reserved;
} DEBUG_SYMBOL_SOURCE_ENTRY, *PDEBUG_SYMBOL_SOURCE_ENTRY;
#undef INTERFACE
#define INTERFACE IDebugSymbols3
DECLARE_INTERFACE_(IDebugSymbols3, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSymbols.
// Controls the symbol options used during
// symbol operations.
// Uses the same flags as dbghelps SymSetOptions.
STDMETHOD(GetSymbolOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetSymbolOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(GetNameByOffset)(
THIS_
__in ULONG64 Offset,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
// A symbol name may not be unique, particularly
// when overloaded functions exist which all
// have the same name. If GetOffsetByName
// finds multiple matches for the name it
// can return any one of them. In that
// case it will return S_FALSE to indicate
// that ambiguity was arbitrarily resolved.
// A caller can then use SearchSymbols to
// find all of the matches if it wishes to
// perform different disambiguation.
STDMETHOD(GetOffsetByName)(
THIS_
__in PCSTR Symbol,
__out PULONG64 Offset
) PURE;
// GetNearNameByOffset returns symbols
// located near the symbol closest to
// to the offset, such as the previous
// or next symbol. If Delta is zero it
// operates identically to GetNameByOffset.
// If Delta is nonzero and such a symbol
// does not exist an error is returned.
// The next symbol, if one exists, will
// always have a higher offset than the
// input offset so the displacement is
// always negative. The situation is
// reversed for the previous symbol.
STDMETHOD(GetNearNameByOffset)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetLineByOffset)(
THIS_
__in ULONG64 Offset,
__out_opt PULONG Line,
__out_ecount_opt(FileBufferSize) PSTR FileBuffer,
__in ULONG FileBufferSize,
__out_opt PULONG FileSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetOffsetByLine)(
THIS_
__in ULONG Line,
__in PCSTR File,
__out PULONG64 Offset
) PURE;
// Enumerates the engines list of modules
// loaded for the current process. This may
// or may not match the system module list
// for the process. Reload can be used to
// synchronize the engines list with the system
// if necessary.
// Some sessions also track recently unloaded
// code modules for help in analyzing failures
// where an attempt is made to call unloaded code.
// These modules are indexed after the loaded
// modules.
STDMETHOD(GetNumberModules)(
THIS_
__out PULONG Loaded,
__out PULONG Unloaded
) PURE;
STDMETHOD(GetModuleByIndex)(
THIS_
__in ULONG Index,
__out PULONG64 Base
) PURE;
// The module name may not be unique.
// This method returns the first match.
STDMETHOD(GetModuleByModuleName)(
THIS_
__in PCSTR Name,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// Offset can be any offset within
// the module extent. Extents may
// not be unique when including unloaded
// drivers. This method returns the
// first match.
STDMETHOD(GetModuleByOffset)(
THIS_
__in ULONG64 Offset,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
STDMETHOD(GetModuleNames)(
THIS_
__in ULONG Index,
__in ULONG64 Base,
__out_ecount_opt(ImageNameBufferSize) PSTR ImageNameBuffer,
__in ULONG ImageNameBufferSize,
__out_opt PULONG ImageNameSize,
__out_ecount_opt(ModuleNameBufferSize) PSTR ModuleNameBuffer,
__in ULONG ModuleNameBufferSize,
__out_opt PULONG ModuleNameSize,
__out_ecount_opt(LoadedImageNameBufferSize) PSTR LoadedImageNameBuffer,
__in ULONG LoadedImageNameBufferSize,
__out_opt PULONG LoadedImageNameSize
) PURE;
STDMETHOD(GetModuleParameters)(
THIS_
__in ULONG Count,
__in_ecount_opt(Count) PULONG64 Bases,
__in ULONG Start,
__out_ecount(Count) PDEBUG_MODULE_PARAMETERS Params
) PURE;
// Looks up the module from a <Module>!<Symbol>
// string.
STDMETHOD(GetSymbolModule)(
THIS_
__in PCSTR Symbol,
__out PULONG64 Base
) PURE;
// Returns the string name of a type.
STDMETHOD(GetTypeName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns the ID for a type name.
STDMETHOD(GetTypeId)(
THIS_
__in ULONG64 Module,
__in PCSTR Name,
__out PULONG TypeId
) PURE;
STDMETHOD(GetTypeSize)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out PULONG Size
) PURE;
// Given a type which can contain members
// this method returns the offset of a
// particular member within the type.
// TypeId should give the container type ID
// and Field gives the dot-separated path
// to the field of interest.
STDMETHOD(GetFieldOffset)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in PCSTR Field,
__out PULONG Offset
) PURE;
STDMETHOD(GetSymbolTypeId)(
THIS_
__in PCSTR Symbol,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
// As with GetOffsetByName a symbol's
// name may be ambiguous. GetOffsetTypeId
// returns the type for the symbol closest
// to the given offset and can be used
// to avoid ambiguity.
STDMETHOD(GetOffsetTypeId)(
THIS_
__in ULONG64 Offset,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
// Helpers for virtual and physical data
// which combine creation of a location with
// the actual operation.
STDMETHOD(ReadTypedDataVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteTypedDataVirtual)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(OutputTypedDataVirtual)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG Flags
) PURE;
STDMETHOD(ReadTypedDataPhysical)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__out_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesRead
) PURE;
STDMETHOD(WriteTypedDataPhysical)(
THIS_
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in_bcount(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BytesWritten
) PURE;
STDMETHOD(OutputTypedDataPhysical)(
THIS_
__in ULONG OutputControl,
__in ULONG64 Offset,
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG Flags
) PURE;
// Function arguments and scope block symbols
// can be retrieved relative to currently
// executing code. A caller can provide just
// a code offset for scoping purposes and look
// up names or the caller can provide a full frame
// and look up actual values. The values for
// scoped symbols are best-guess and may or may not
// be accurate depending on program optimizations,
// the machine architecture, the current point
// in the programs execution and so on.
// A caller can also provide a complete register
// context for setting a scope to a previous
// machine state such as a context saved for
// an exception. Usually this isnt necessary
// and the current register context is used.
STDMETHOD(GetScope)(
THIS_
__out_opt PULONG64 InstructionOffset,
__out_opt PDEBUG_STACK_FRAME ScopeFrame,
__out_bcount_opt(ScopeContextSize) PVOID ScopeContext,
__in ULONG ScopeContextSize
) PURE;
// If ScopeFrame or ScopeContext is non-NULL then
// InstructionOffset is ignored.
// If ScopeContext is NULL the current
// register context is used.
// If the scope identified by the given
// information is the same as before
// SetScope returns S_OK. If the scope
// information changes, such as when the
// scope moves between functions or scope
// blocks, SetScope returns S_FALSE.
STDMETHOD(SetScope)(
THIS_
__in ULONG64 InstructionOffset,
__in_opt PDEBUG_STACK_FRAME ScopeFrame,
__in_bcount_opt(ScopeContextSize) PVOID ScopeContext,
__in ULONG ScopeContextSize
) PURE;
// ResetScope clears the scope information
// for situations where scoped symbols
// mask global symbols or when resetting
// from explicit information to the current
// information.
STDMETHOD(ResetScope)(
THIS
) PURE;
// A scope symbol is tied to its particular
// scope and only is meaningful within the scope.
// The returned group can be updated by passing it back
// into the method for lower-cost
// incremental updates when stepping.
STDMETHOD(GetScopeSymbolGroup)(
THIS_
__in ULONG Flags,
__in_opt PDEBUG_SYMBOL_GROUP Update,
__out PDEBUG_SYMBOL_GROUP* Symbols
) PURE;
// Create a new symbol group.
STDMETHOD(CreateSymbolGroup)(
THIS_
__out PDEBUG_SYMBOL_GROUP* Group
) PURE;
// StartSymbolMatch matches symbol names
// against the given pattern using simple
// regular expressions. The search results
// are iterated through using GetNextSymbolMatch.
// When the caller is done examining results
// the match should be freed via EndSymbolMatch.
// If the match pattern contains a module name
// the search is restricted to a single module.
// Pattern matching is only done on symbol names,
// not module names.
// All active symbol match handles are invalidated
// when the set of loaded symbols changes.
STDMETHOD(StartSymbolMatch)(
THIS_
__in PCSTR Pattern,
__out PULONG64 Handle
) PURE;
// If Buffer is NULL the match does not
// advance.
STDMETHOD(GetNextSymbolMatch)(
THIS_
__in ULONG64 Handle,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MatchSize,
__out_opt PULONG64 Offset
) PURE;
STDMETHOD(EndSymbolMatch)(
THIS_
__in ULONG64 Handle
) PURE;
STDMETHOD(Reload)(
THIS_
__in PCSTR Module
) PURE;
STDMETHOD(GetSymbolPath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetSymbolPath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendSymbolPath)(
THIS_
__in PCSTR Addition
) PURE;
// Manipulate the path for executable images.
// Some dump files need to load executable images
// in order to resolve dump information. This
// path controls where the engine looks for
// images.
STDMETHOD(GetImagePath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetImagePath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendImagePath)(
THIS_
__in PCSTR Addition
) PURE;
// Path routines for source file location
// methods.
STDMETHOD(GetSourcePath)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
// Gets the nth part of the source path.
STDMETHOD(GetSourcePathElement)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ElementSize
) PURE;
STDMETHOD(SetSourcePath)(
THIS_
__in PCSTR Path
) PURE;
STDMETHOD(AppendSourcePath)(
THIS_
__in PCSTR Addition
) PURE;
// Uses the given file path and the source path
// information to try and locate an existing file.
// The given file path is merged with elements
// of the source path and checked for existence.
// If a match is found the element used is returned.
// A starting element can be specified to restrict
// the search to a subset of the path elements;
// this can be useful when checking for multiple
// matches along the source path.
// The returned element can be 1, indicating
// the file was found directly and not on the path.
STDMETHOD(FindSourceFile)(
THIS_
__in ULONG StartElement,
__in PCSTR File,
__in ULONG Flags,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
// Retrieves all the line offset information
// for a particular source file. Buffer is
// first intialized to DEBUG_INVALID_OFFSET for
// every entry. Then for each piece of line
// symbol information Buffer[Line] set to
// Lines offset. This produces a per-line
// map of the offsets for the lines of the
// given file. Line numbers are decremented
// for the map so Buffer[0] contains the offset
// for line number 1.
// If there is no line information at all for
// the given file the method fails rather
// than returning a map of invalid offsets.
STDMETHOD(GetSourceFileLineOffsets)(
THIS_
__in PCSTR File,
__out_ecount_opt(BufferLines) PULONG64 Buffer,
__in ULONG BufferLines,
__out_opt PULONG FileLines
) PURE;
// IDebugSymbols2.
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
// Item is specified as in VerQueryValue.
// Module version information is only
// available for loaded modules and may
// not be available in all debug sessions.
STDMETHOD(GetModuleVersionInformation)(
THIS_
__in ULONG Index,
__in ULONG64 Base,
__in PCSTR Item,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG VerInfoSize
) PURE;
// Retrieves any available module name string
// such as module name or symbol file name.
// If Index is DEBUG_ANY_ID the base address
// is used to look up the module instead.
// If symbols are deferred an error will
// be returned.
// E_NOINTERFACE may be returned, indicating
// no information exists.
STDMETHOD(GetModuleNameString)(
THIS_
__in ULONG Which,
__in ULONG Index,
__in ULONG64 Base,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns the string name of a constant type.
STDMETHOD(GetConstantName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG64 Value,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Gets name of a field in a struct
// FieldNumber is 0 based index of field in a struct
STDMETHOD(GetFieldName)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG FieldIndex,
__out_ecount_opt(NameBufferSize) PSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Control options for typed values.
STDMETHOD(GetTypeOptions)(
THIS_
__out PULONG Options
) PURE;
STDMETHOD(AddTypeOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(RemoveTypeOptions)(
THIS_
__in ULONG Options
) PURE;
STDMETHOD(SetTypeOptions)(
THIS_
__in ULONG Options
) PURE;
// IDebugSymbols3.
STDMETHOD(GetNameByOffsetWide)(
THIS_
__in ULONG64 Offset,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetOffsetByNameWide)(
THIS_
__in PCWSTR Symbol,
__out PULONG64 Offset
) PURE;
STDMETHOD(GetNearNameByOffsetWide)(
THIS_
__in ULONG64 Offset,
__in LONG Delta,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetLineByOffsetWide)(
THIS_
__in ULONG64 Offset,
__out_opt PULONG Line,
__out_ecount_opt(FileBufferSize) PWSTR FileBuffer,
__in ULONG FileBufferSize,
__out_opt PULONG FileSize,
__out_opt PULONG64 Displacement
) PURE;
STDMETHOD(GetOffsetByLineWide)(
THIS_
__in ULONG Line,
__in PCWSTR File,
__out PULONG64 Offset
) PURE;
STDMETHOD(GetModuleByModuleNameWide)(
THIS_
__in PCWSTR Name,
__in ULONG StartIndex,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
STDMETHOD(GetSymbolModuleWide)(
THIS_
__in PCWSTR Symbol,
__out PULONG64 Base
) PURE;
STDMETHOD(GetTypeNameWide)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns the ID for a type name.
STDMETHOD(GetTypeIdWide)(
THIS_
__in ULONG64 Module,
__in PCWSTR Name,
__out PULONG TypeId
) PURE;
STDMETHOD(GetFieldOffsetWide)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in PCWSTR Field,
__out PULONG Offset
) PURE;
STDMETHOD(GetSymbolTypeIdWide)(
THIS_
__in PCWSTR Symbol,
__out PULONG TypeId,
__out_opt PULONG64 Module
) PURE;
STDMETHOD(GetScopeSymbolGroup2)(
THIS_
__in ULONG Flags,
__in_opt PDEBUG_SYMBOL_GROUP2 Update,
__out PDEBUG_SYMBOL_GROUP2* Symbols
) PURE;
STDMETHOD(CreateSymbolGroup2)(
THIS_
__out PDEBUG_SYMBOL_GROUP2* Group
) PURE;
STDMETHOD(StartSymbolMatchWide)(
THIS_
__in PCWSTR Pattern,
__out PULONG64 Handle
) PURE;
STDMETHOD(GetNextSymbolMatchWide)(
THIS_
__in ULONG64 Handle,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG MatchSize,
__out_opt PULONG64 Offset
) PURE;
STDMETHOD(ReloadWide)(
THIS_
__in PCWSTR Module
) PURE;
STDMETHOD(GetSymbolPathWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetSymbolPathWide)(
THIS_
__in PCWSTR Path
) PURE;
STDMETHOD(AppendSymbolPathWide)(
THIS_
__in PCWSTR Addition
) PURE;
STDMETHOD(GetImagePathWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(SetImagePathWide)(
THIS_
__in PCWSTR Path
) PURE;
STDMETHOD(AppendImagePathWide)(
THIS_
__in PCWSTR Addition
) PURE;
STDMETHOD(GetSourcePathWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG PathSize
) PURE;
STDMETHOD(GetSourcePathElementWide)(
THIS_
__in ULONG Index,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ElementSize
) PURE;
STDMETHOD(SetSourcePathWide)(
THIS_
__in PCWSTR Path
) PURE;
STDMETHOD(AppendSourcePathWide)(
THIS_
__in PCWSTR Addition
) PURE;
STDMETHOD(FindSourceFileWide)(
THIS_
__in ULONG StartElement,
__in PCWSTR File,
__in ULONG Flags,
__out_opt PULONG FoundElement,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG FoundSize
) PURE;
STDMETHOD(GetSourceFileLineOffsetsWide)(
THIS_
__in PCWSTR File,
__out_ecount_opt(BufferLines) PULONG64 Buffer,
__in ULONG BufferLines,
__out_opt PULONG FileLines
) PURE;
STDMETHOD(GetModuleVersionInformationWide)(
THIS_
__in ULONG Index,
__in ULONG64 Base,
__in PCWSTR Item,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG VerInfoSize
) PURE;
STDMETHOD(GetModuleNameStringWide)(
THIS_
__in ULONG Which,
__in ULONG Index,
__in ULONG64 Base,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetConstantNameWide)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG64 Value,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
STDMETHOD(GetFieldNameWide)(
THIS_
__in ULONG64 Module,
__in ULONG TypeId,
__in ULONG FieldIndex,
__out_ecount_opt(NameBufferSize) PWSTR NameBuffer,
__in ULONG NameBufferSize,
__out_opt PULONG NameSize
) PURE;
// Returns S_OK if the engine is using managed
// debugging support when retriving information
// for the given module. This can be expensive
// to check.
STDMETHOD(IsManagedModule)(
THIS_
__in ULONG Index,
__in ULONG64 Base
) PURE;
// The module name may not be unique.
// This method returns the first match.
STDMETHOD(GetModuleByModuleName2)(
THIS_
__in PCSTR Name,
__in ULONG StartIndex,
__in ULONG Flags,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
STDMETHOD(GetModuleByModuleName2Wide)(
THIS_
__in PCWSTR Name,
__in ULONG StartIndex,
__in ULONG Flags,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// Offset can be any offset within
// the module extent. Extents may
// not be unique when including unloaded
// drivers. This method returns the
// first match.
STDMETHOD(GetModuleByOffset2)(
THIS_
__in ULONG64 Offset,
__in ULONG StartIndex,
__in ULONG Flags,
__out_opt PULONG Index,
__out_opt PULONG64 Base
) PURE;
// A caller can create artificial loaded modules in
// the engine's module list if desired.
// These modules only serve as names for
// a region of addresses. They cannot have
// real symbols loaded for them; if that
// is desired Reload can be used with explicit
// parameters to create a true module entry.
// The region must not be in use by any other
// module.
// A general reload will discard any synthetic modules.
STDMETHOD(AddSyntheticModule)(
THIS_
__in ULONG64 Base,
__in ULONG Size,
__in PCSTR ImagePath,
__in PCSTR ModuleName,
__in ULONG Flags
) PURE;
STDMETHOD(AddSyntheticModuleWide)(
THIS_
__in ULONG64 Base,
__in ULONG Size,
__in PCWSTR ImagePath,
__in PCWSTR ModuleName,
__in ULONG Flags
) PURE;
STDMETHOD(RemoveSyntheticModule)(
THIS_
__in ULONG64 Base
) PURE;
// Modify the current frame used for scoping.
// This is equivalent to the '.frame' command.
STDMETHOD(GetCurrentScopeFrameIndex)(
THIS_
__out PULONG Index
) PURE;
STDMETHOD(SetScopeFrameByIndex)(
THIS_
__in ULONG Index
) PURE;
// Recovers JIT_DEBUG_INFO information at the given
// address from the debuggee and sets current
// debugger scope context from it.
// Equivalent to '.jdinfo' command.
STDMETHOD(SetScopeFromJitDebugInfo)(
THIS_
__in ULONG OutputControl,
__in ULONG64 InfoOffset
) PURE;
// Switches the current debugger scope to
// the stored event information.
// Equivalent to the '.ecxr' command.
STDMETHOD(SetScopeFromStoredEvent)(
THIS
) PURE;
// Takes the first symbol hit and outputs it.
// Controlled with DEBUG_OUTSYM_* flags.
STDMETHOD(OutputSymbolByOffset)(
THIS_
__in ULONG OutputControl,
__in ULONG Flags,
__in ULONG64 Offset
) PURE;
// Function entry information for a particular
// piece of code can be retrieved by this method.
// The actual data returned is system-dependent.
STDMETHOD(GetFunctionEntryByOffset)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_bcount_opt(BufferSize) PVOID Buffer,
__in ULONG BufferSize,
__out_opt PULONG BufferNeeded
) PURE;
// Given a type which can contain members
// this method returns the type ID and offset of a
// particular member within the type.
// Field gives the dot-separated path
// to the field of interest.
STDMETHOD(GetFieldTypeAndOffset)(
THIS_
__in ULONG64 Module,
__in ULONG ContainerTypeId,
__in PCSTR Field,
__out_opt PULONG FieldTypeId,
__out_opt PULONG Offset
) PURE;
STDMETHOD(GetFieldTypeAndOffsetWide)(
THIS_
__in ULONG64 Module,
__in ULONG ContainerTypeId,
__in PCWSTR Field,
__out_opt PULONG FieldTypeId,
__out_opt PULONG Offset
) PURE;
// Artificial symbols can be created in any
// existing module as a way to name an address.
// The address must not already have symbol
// information.
// A reload will discard synthetic symbols
// for all address regions reloaded.
STDMETHOD(AddSyntheticSymbol)(
THIS_
__in ULONG64 Offset,
__in ULONG Size,
__in PCSTR Name,
__in ULONG Flags,
__out_opt PDEBUG_MODULE_AND_ID Id
) PURE;
STDMETHOD(AddSyntheticSymbolWide)(
THIS_
__in ULONG64 Offset,
__in ULONG Size,
__in PCWSTR Name,
__in ULONG Flags,
__out_opt PDEBUG_MODULE_AND_ID Id
) PURE;
STDMETHOD(RemoveSyntheticSymbol)(
THIS_
__in PDEBUG_MODULE_AND_ID Id
) PURE;
// The following methods can return multiple
// hits for symbol lookups to allow for all
// possible hits to be returned.
STDMETHOD(GetSymbolEntriesByOffset)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(IdsCount) PDEBUG_MODULE_AND_ID Ids,
__out_ecount_opt(IdsCount) PULONG64 Displacements,
__in ULONG IdsCount,
__out_opt PULONG Entries
) PURE;
STDMETHOD(GetSymbolEntriesByName)(
THIS_
__in PCSTR Symbol,
__in ULONG Flags,
__out_ecount_opt(IdsCount) PDEBUG_MODULE_AND_ID Ids,
__in ULONG IdsCount,
__out_opt PULONG Entries
) PURE;
STDMETHOD(GetSymbolEntriesByNameWide)(
THIS_
__in PCWSTR Symbol,
__in ULONG Flags,
__out_ecount_opt(IdsCount) PDEBUG_MODULE_AND_ID Ids,
__in ULONG IdsCount,
__out_opt PULONG Entries
) PURE;
// Symbol lookup by managed metadata token.
STDMETHOD(GetSymbolEntryByToken)(
THIS_
__in ULONG64 ModuleBase,
__in ULONG Token,
__out PDEBUG_MODULE_AND_ID Id
) PURE;
// Retrieves full symbol entry information from an ID.
STDMETHOD(GetSymbolEntryInformation)(
THIS_
__in PDEBUG_MODULE_AND_ID Id,
__out PDEBUG_SYMBOL_ENTRY Info
) PURE;
STDMETHOD(GetSymbolEntryString)(
THIS_
__in PDEBUG_MODULE_AND_ID Id,
__in ULONG Which,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(GetSymbolEntryStringWide)(
THIS_
__in PDEBUG_MODULE_AND_ID Id,
__in ULONG Which,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
// Returns all known memory regions associated
// with the given symbol. Simple symbols will
// have a single region starting from their base.
// More complicated regions, such as functions
// with multiple code areas, can have an arbitrarily
// large number of regions.
// The quality of information returned is highly
// dependent on the symbolic information availble.
STDMETHOD(GetSymbolEntryOffsetRegions)(
THIS_
__in PDEBUG_MODULE_AND_ID Id,
__in ULONG Flags,
__out_ecount_opt(RegionsCount) PDEBUG_OFFSET_REGION Regions,
__in ULONG RegionsCount,
__out_opt PULONG RegionsAvail
) PURE;
// This method allows navigating within the
// symbol entry hierarchy.
STDMETHOD(GetSymbolEntryBySymbolEntry)(
THIS_
__in PDEBUG_MODULE_AND_ID FromId,
__in ULONG Flags,
__out PDEBUG_MODULE_AND_ID ToId
) PURE;
// The following methods can return multiple
// hits for source lookups to allow for all
// possible hits to be returned.
STDMETHOD(GetSourceEntriesByOffset)(
THIS_
__in ULONG64 Offset,
__in ULONG Flags,
__out_ecount_opt(EntriesCount) PDEBUG_SYMBOL_SOURCE_ENTRY Entries,
__in ULONG EntriesCount,
__out_opt PULONG EntriesAvail
) PURE;
STDMETHOD(GetSourceEntriesByLine)(
THIS_
__in ULONG Line,
__in PCSTR File,
__in ULONG Flags,
__out_ecount_opt(EntriesCount) PDEBUG_SYMBOL_SOURCE_ENTRY Entries,
__in ULONG EntriesCount,
__out_opt PULONG EntriesAvail
) PURE;
STDMETHOD(GetSourceEntriesByLineWide)(
THIS_
__in ULONG Line,
__in PCWSTR File,
__in ULONG Flags,
__out_ecount_opt(EntriesCount) PDEBUG_SYMBOL_SOURCE_ENTRY Entries,
__in ULONG EntriesCount,
__out_opt PULONG EntriesAvail
) PURE;
STDMETHOD(GetSourceEntryString)(
THIS_
__in PDEBUG_SYMBOL_SOURCE_ENTRY Entry,
__in ULONG Which,
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
STDMETHOD(GetSourceEntryStringWide)(
THIS_
__in PDEBUG_SYMBOL_SOURCE_ENTRY Entry,
__in ULONG Which,
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG StringSize
) PURE;
// Returns all known memory regions associated
// with the given source entry. As with
// GetSymbolEntryOffsetRegions the regions available
// are variable.
STDMETHOD(GetSourceEntryOffsetRegions)(
THIS_
__in PDEBUG_SYMBOL_SOURCE_ENTRY Entry,
__in ULONG Flags,
__out_ecount_opt(RegionsCount) PDEBUG_OFFSET_REGION Regions,
__in ULONG RegionsCount,
__out_opt PULONG RegionsAvail
) PURE;
// This method allows navigating within the
// source entries.
STDMETHOD(GetSourceEntryBySourceEntry)(
THIS_
__in PDEBUG_SYMBOL_SOURCE_ENTRY FromEntry,
__in ULONG Flags,
__out PDEBUG_SYMBOL_SOURCE_ENTRY ToEntry
) PURE;
};
//----------------------------------------------------------------------------
//
// IDebugSystemObjects
//
//----------------------------------------------------------------------------
#undef INTERFACE
#define INTERFACE IDebugSystemObjects
DECLARE_INTERFACE_(IDebugSystemObjects, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSystemObjects.
// In user mode debugging the debugger
// tracks all threads and processes and
// enumerates them through the following
// methods. When enumerating threads
// the threads are enumerated for the current
// process.
// Kernel mode debugging currently is
// limited to enumerating only the threads
// assigned to processors, not all of
// the threads in the system. Process
// enumeration is limited to a single
// virtual process representing kernel space.
// Returns the ID of the thread on which
// the last event occurred.
STDMETHOD(GetEventThread)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(GetEventProcess)(
THIS_
__out PULONG Id
) PURE;
// Controls implicit thread used by the
// debug engine. The debuggers current
// thread is just a piece of data held
// by the debugger for calls which use
// thread-specific information. In those
// calls the debuggers current thread is used.
// The debuggers current thread is not related
// to any system thread attribute.
// IDs for threads are small integer IDs
// maintained by the engine. They are not
// related to system thread IDs.
STDMETHOD(GetCurrentThreadId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetCurrentThreadId)(
THIS_
__in ULONG Id
) PURE;
// The current process is the process
// that owns the current thread.
STDMETHOD(GetCurrentProcessId)(
THIS_
__out PULONG Id
) PURE;
// Setting the current process automatically
// sets the current thread to the thread that
// was last current in that process.
STDMETHOD(SetCurrentProcessId)(
THIS_
__in ULONG Id
) PURE;
// Gets the number of threads in the current process.
STDMETHOD(GetNumberThreads)(
THIS_
__out PULONG Number
) PURE;
// Gets thread count information for all processes
// and the largest number of threads in a single process.
STDMETHOD(GetTotalNumberThreads)(
THIS_
__out PULONG Total,
__out PULONG LargestProcess
) PURE;
STDMETHOD(GetThreadIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Gets the debugger ID for the thread
// currently running on the given
// processor. Only works in kernel
// debugging.
STDMETHOD(GetThreadIdByProcessor)(
THIS_
__in ULONG Processor,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// system data structure. When kernel debugging
// this is the offset of the KTHREAD.
// When user debugging it is the offset
// of the current TEB.
STDMETHOD(GetCurrentThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given
// system thread data structure.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// TEB. In user mode this is equivalent to
// the threads data offset.
STDMETHOD(GetCurrentThreadTeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given TEB.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByTeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current thread.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentThreadSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger thread ID for the given
// system thread ID.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current thread.
// In kernel mode the value returned is the
// index of the processor the thread is
// executing on plus one.
STDMETHOD(GetCurrentThreadHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger thread ID for the given handle.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Currently kernel mode sessions will only have
// a single process representing kernel space.
STDMETHOD(GetNumberProcesses)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetProcessIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Returns the offset of the current processs
// system data structure. When kernel debugging
// this is the offset of the KPROCESS of
// the process that owns the current thread.
// When user debugging it is the offset
// of the current PEB.
STDMETHOD(GetCurrentProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given
// system process data structure.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current processs
// PEB. In user mode this is equivalent to
// the processs data offset.
STDMETHOD(GetCurrentProcessPeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given PEB.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByPeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current process.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentProcessSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger process ID for the given
// system process ID.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current process.
// In kernel mode this is the kernel processs
// artificial handle used for symbol operations
// and so can only be used with dbghelp APIs.
STDMETHOD(GetCurrentProcessHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger process ID for the given handle.
STDMETHOD(GetProcessIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Retrieve the name of the executable loaded
// in the process. This may fail if no executable
// was identified.
STDMETHOD(GetCurrentProcessExecutableName)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExeSize
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugSystemObjects2
DECLARE_INTERFACE_(IDebugSystemObjects2, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSystemObjects.
// In user mode debugging the debugger
// tracks all threads and processes and
// enumerates them through the following
// methods. When enumerating threads
// the threads are enumerated for the current
// process.
// Kernel mode debugging currently is
// limited to enumerating only the threads
// assigned to processors, not all of
// the threads in the system. Process
// enumeration is limited to a single
// virtual process representing kernel space.
// Returns the ID of the thread on which
// the last event occurred.
STDMETHOD(GetEventThread)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(GetEventProcess)(
THIS_
__out PULONG Id
) PURE;
// Controls implicit thread used by the
// debug engine. The debuggers current
// thread is just a piece of data held
// by the debugger for calls which use
// thread-specific information. In those
// calls the debuggers current thread is used.
// The debuggers current thread is not related
// to any system thread attribute.
// IDs for threads are small integer IDs
// maintained by the engine. They are not
// related to system thread IDs.
STDMETHOD(GetCurrentThreadId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetCurrentThreadId)(
THIS_
__in ULONG Id
) PURE;
// The current process is the process
// that owns the current thread.
STDMETHOD(GetCurrentProcessId)(
THIS_
__out PULONG Id
) PURE;
// Setting the current process automatically
// sets the current thread to the thread that
// was last current in that process.
STDMETHOD(SetCurrentProcessId)(
THIS_
__in ULONG Id
) PURE;
// Gets the number of threads in the current process.
STDMETHOD(GetNumberThreads)(
THIS_
__out PULONG Number
) PURE;
// Gets thread count information for all processes
// and the largest number of threads in a single process.
STDMETHOD(GetTotalNumberThreads)(
THIS_
__out PULONG Total,
__out PULONG LargestProcess
) PURE;
STDMETHOD(GetThreadIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Gets the debugger ID for the thread
// currently running on the given
// processor. Only works in kernel
// debugging.
STDMETHOD(GetThreadIdByProcessor)(
THIS_
__in ULONG Processor,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// system data structure. When kernel debugging
// this is the offset of the KTHREAD.
// When user debugging it is the offset
// of the current TEB.
STDMETHOD(GetCurrentThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given
// system thread data structure.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// TEB. In user mode this is equivalent to
// the threads data offset.
STDMETHOD(GetCurrentThreadTeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given TEB.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByTeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current thread.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentThreadSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger thread ID for the given
// system thread ID.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current thread.
// In kernel mode the value returned is the
// index of the processor the thread is
// executing on plus one.
STDMETHOD(GetCurrentThreadHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger thread ID for the given handle.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Currently kernel mode sessions will only have
// a single process representing kernel space.
STDMETHOD(GetNumberProcesses)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetProcessIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Returns the offset of the current processs
// system data structure. When kernel debugging
// this is the offset of the KPROCESS of
// the process that owns the current thread.
// When user debugging it is the offset
// of the current PEB.
STDMETHOD(GetCurrentProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given
// system process data structure.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current processs
// PEB. In user mode this is equivalent to
// the processs data offset.
STDMETHOD(GetCurrentProcessPeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given PEB.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByPeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current process.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentProcessSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger process ID for the given
// system process ID.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current process.
// In kernel mode this is the kernel processs
// artificial handle used for symbol operations
// and so can only be used with dbghelp APIs.
STDMETHOD(GetCurrentProcessHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger process ID for the given handle.
STDMETHOD(GetProcessIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Retrieve the name of the executable loaded
// in the process. This may fail if no executable
// was identified.
STDMETHOD(GetCurrentProcessExecutableName)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExeSize
) PURE;
// IDebugSystemObjects2.
// Return the number of seconds that the current
// process has been running.
STDMETHOD(GetCurrentProcessUpTime)(
THIS_
__out PULONG UpTime
) PURE;
// During kernel sessions the debugger retrieves
// some information from the system thread and process
// running on the current processor. For example,
// the debugger will retrieve virtual memory translation
// information for when the debugger needs to
// carry out its own virtual to physical translations.
// Occasionally it can be interesting to perform
// similar operations but on a process which isnt
// currently running. The follow methods allow a caller
// to override the data offsets used by the debugger
// so that other system threads and processes can
// be used instead. These values are defaulted to
// the thread and process running on the current
// processor each time the debuggee executes or
// the current processor changes.
// The thread and process settings are independent so
// it is possible to refer to a thread in a process
// other than the current process and vice versa.
// Setting an offset of zero will reload the
// default value.
STDMETHOD(GetImplicitThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetImplicitThreadDataOffset)(
THIS_
__in ULONG64 Offset
) PURE;
STDMETHOD(GetImplicitProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetImplicitProcessDataOffset)(
THIS_
__in ULONG64 Offset
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugSystemObjects3
DECLARE_INTERFACE_(IDebugSystemObjects3, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSystemObjects.
// In user mode debugging the debugger
// tracks all threads and processes and
// enumerates them through the following
// methods. When enumerating threads
// the threads are enumerated for the current
// process.
// Kernel mode debugging currently is
// limited to enumerating only the threads
// assigned to processors, not all of
// the threads in the system. Process
// enumeration is limited to a single
// virtual process representing kernel space.
// Returns the ID of the thread on which
// the last event occurred.
STDMETHOD(GetEventThread)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(GetEventProcess)(
THIS_
__out PULONG Id
) PURE;
// Controls implicit thread used by the
// debug engine. The debuggers current
// thread is just a piece of data held
// by the debugger for calls which use
// thread-specific information. In those
// calls the debuggers current thread is used.
// The debuggers current thread is not related
// to any system thread attribute.
// IDs for threads are small integer IDs
// maintained by the engine. They are not
// related to system thread IDs.
STDMETHOD(GetCurrentThreadId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetCurrentThreadId)(
THIS_
__in ULONG Id
) PURE;
// The current process is the process
// that owns the current thread.
STDMETHOD(GetCurrentProcessId)(
THIS_
__out PULONG Id
) PURE;
// Setting the current process automatically
// sets the current thread to the thread that
// was last current in that process.
STDMETHOD(SetCurrentProcessId)(
THIS_
__in ULONG Id
) PURE;
// Gets the number of threads in the current process.
STDMETHOD(GetNumberThreads)(
THIS_
__out PULONG Number
) PURE;
// Gets thread count information for all processes
// and the largest number of threads in a single process.
STDMETHOD(GetTotalNumberThreads)(
THIS_
__out PULONG Total,
__out PULONG LargestProcess
) PURE;
STDMETHOD(GetThreadIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Gets the debugger ID for the thread
// currently running on the given
// processor. Only works in kernel
// debugging.
STDMETHOD(GetThreadIdByProcessor)(
THIS_
__in ULONG Processor,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// system data structure. When kernel debugging
// this is the offset of the KTHREAD.
// When user debugging it is the offset
// of the current TEB.
STDMETHOD(GetCurrentThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given
// system thread data structure.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// TEB. In user mode this is equivalent to
// the threads data offset.
STDMETHOD(GetCurrentThreadTeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given TEB.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByTeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current thread.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentThreadSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger thread ID for the given
// system thread ID.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current thread.
// In kernel mode the value returned is the
// index of the processor the thread is
// executing on plus one.
STDMETHOD(GetCurrentThreadHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger thread ID for the given handle.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Currently kernel mode sessions will only have
// a single process representing kernel space.
STDMETHOD(GetNumberProcesses)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetProcessIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Returns the offset of the current processs
// system data structure. When kernel debugging
// this is the offset of the KPROCESS of
// the process that owns the current thread.
// When user debugging it is the offset
// of the current PEB.
STDMETHOD(GetCurrentProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given
// system process data structure.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current processs
// PEB. In user mode this is equivalent to
// the processs data offset.
STDMETHOD(GetCurrentProcessPeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given PEB.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByPeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current process.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentProcessSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger process ID for the given
// system process ID.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current process.
// In kernel mode this is the kernel processs
// artificial handle used for symbol operations
// and so can only be used with dbghelp APIs.
STDMETHOD(GetCurrentProcessHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger process ID for the given handle.
STDMETHOD(GetProcessIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Retrieve the name of the executable loaded
// in the process. This may fail if no executable
// was identified.
STDMETHOD(GetCurrentProcessExecutableName)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExeSize
) PURE;
// IDebugSystemObjects2.
// Return the number of seconds that the current
// process has been running.
STDMETHOD(GetCurrentProcessUpTime)(
THIS_
__out PULONG UpTime
) PURE;
// During kernel sessions the debugger retrieves
// some information from the system thread and process
// running on the current processor. For example,
// the debugger will retrieve virtual memory translation
// information for when the debugger needs to
// carry out its own virtual to physical translations.
// Occasionally it can be interesting to perform
// similar operations but on a process which isnt
// currently running. The follow methods allow a caller
// to override the data offsets used by the debugger
// so that other system threads and processes can
// be used instead. These values are defaulted to
// the thread and process running on the current
// processor each time the debuggee executes or
// the current processor changes.
// The thread and process settings are independent so
// it is possible to refer to a thread in a process
// other than the current process and vice versa.
// Setting an offset of zero will reload the
// default value.
STDMETHOD(GetImplicitThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetImplicitThreadDataOffset)(
THIS_
__in ULONG64 Offset
) PURE;
STDMETHOD(GetImplicitProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetImplicitProcessDataOffset)(
THIS_
__in ULONG64 Offset
) PURE;
// IDebugSystemObjects3.
STDMETHOD(GetEventSystem)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(GetCurrentSystemId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetCurrentSystemId)(
THIS_
__in ULONG Id
) PURE;
STDMETHOD(GetNumberSystems)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetSystemIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Ids
) PURE;
STDMETHOD(GetTotalNumberThreadsAndProcesses)(
THIS_
__out PULONG TotalThreads,
__out PULONG TotalProcesses,
__out PULONG LargestProcessThreads,
__out PULONG LargestSystemThreads,
__out PULONG LargestSystemProcesses
) PURE;
STDMETHOD(GetCurrentSystemServer)(
THIS_
__out PULONG64 Server
) PURE;
STDMETHOD(GetSystemByServer)(
THIS_
__in ULONG64 Server,
__out PULONG Id
) PURE;
STDMETHOD(GetCurrentSystemServerName)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
};
#undef INTERFACE
#define INTERFACE IDebugSystemObjects4
DECLARE_INTERFACE_(IDebugSystemObjects4, IUnknown)
{
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
) PURE;
STDMETHOD_(ULONG, AddRef)(
THIS
) PURE;
STDMETHOD_(ULONG, Release)(
THIS
) PURE;
// IDebugSystemObjects.
// In user mode debugging the debugger
// tracks all threads and processes and
// enumerates them through the following
// methods. When enumerating threads
// the threads are enumerated for the current
// process.
// Kernel mode debugging currently is
// limited to enumerating only the threads
// assigned to processors, not all of
// the threads in the system. Process
// enumeration is limited to a single
// virtual process representing kernel space.
// Returns the ID of the thread on which
// the last event occurred.
STDMETHOD(GetEventThread)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(GetEventProcess)(
THIS_
__out PULONG Id
) PURE;
// Controls implicit thread used by the
// debug engine. The debuggers current
// thread is just a piece of data held
// by the debugger for calls which use
// thread-specific information. In those
// calls the debuggers current thread is used.
// The debuggers current thread is not related
// to any system thread attribute.
// IDs for threads are small integer IDs
// maintained by the engine. They are not
// related to system thread IDs.
STDMETHOD(GetCurrentThreadId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetCurrentThreadId)(
THIS_
__in ULONG Id
) PURE;
// The current process is the process
// that owns the current thread.
STDMETHOD(GetCurrentProcessId)(
THIS_
__out PULONG Id
) PURE;
// Setting the current process automatically
// sets the current thread to the thread that
// was last current in that process.
STDMETHOD(SetCurrentProcessId)(
THIS_
__in ULONG Id
) PURE;
// Gets the number of threads in the current process.
STDMETHOD(GetNumberThreads)(
THIS_
__out PULONG Number
) PURE;
// Gets thread count information for all processes
// and the largest number of threads in a single process.
STDMETHOD(GetTotalNumberThreads)(
THIS_
__out PULONG Total,
__out PULONG LargestProcess
) PURE;
STDMETHOD(GetThreadIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Gets the debugger ID for the thread
// currently running on the given
// processor. Only works in kernel
// debugging.
STDMETHOD(GetThreadIdByProcessor)(
THIS_
__in ULONG Processor,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// system data structure. When kernel debugging
// this is the offset of the KTHREAD.
// When user debugging it is the offset
// of the current TEB.
STDMETHOD(GetCurrentThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given
// system thread data structure.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current threads
// TEB. In user mode this is equivalent to
// the threads data offset.
STDMETHOD(GetCurrentThreadTeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger thread ID for the given TEB.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByTeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current thread.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentThreadSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger thread ID for the given
// system thread ID.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current thread.
// In kernel mode the value returned is the
// index of the processor the thread is
// executing on plus one.
STDMETHOD(GetCurrentThreadHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger thread ID for the given handle.
// Currently when kernel debugging this will fail
// if the thread is not executing on a processor.
STDMETHOD(GetThreadIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Currently kernel mode sessions will only have
// a single process representing kernel space.
STDMETHOD(GetNumberProcesses)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetProcessIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount_opt(Count) PULONG Ids,
__out_ecount_opt(Count) PULONG SysIds
) PURE;
// Returns the offset of the current processs
// system data structure. When kernel debugging
// this is the offset of the KPROCESS of
// the process that owns the current thread.
// When user debugging it is the offset
// of the current PEB.
STDMETHOD(GetCurrentProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given
// system process data structure.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByDataOffset)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the offset of the current processs
// PEB. In user mode this is equivalent to
// the processs data offset.
STDMETHOD(GetCurrentProcessPeb)(
THIS_
__out PULONG64 Offset
) PURE;
// Looks up a debugger process ID for the given PEB.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdByPeb)(
THIS_
__in ULONG64 Offset,
__out PULONG Id
) PURE;
// Returns the system unique ID for the current process.
// Not currently supported when kernel debugging.
STDMETHOD(GetCurrentProcessSystemId)(
THIS_
__out PULONG SysId
) PURE;
// Looks up a debugger process ID for the given
// system process ID.
// Not currently supported when kernel debugging.
STDMETHOD(GetProcessIdBySystemId)(
THIS_
__in ULONG SysId,
__out PULONG Id
) PURE;
// Returns the handle of the current process.
// In kernel mode this is the kernel processs
// artificial handle used for symbol operations
// and so can only be used with dbghelp APIs.
STDMETHOD(GetCurrentProcessHandle)(
THIS_
__out PULONG64 Handle
) PURE;
// Looks up a debugger process ID for the given handle.
STDMETHOD(GetProcessIdByHandle)(
THIS_
__in ULONG64 Handle,
__out PULONG Id
) PURE;
// Retrieve the name of the executable loaded
// in the process. This may fail if no executable
// was identified.
STDMETHOD(GetCurrentProcessExecutableName)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExeSize
) PURE;
// IDebugSystemObjects2.
// Return the number of seconds that the current
// process has been running.
STDMETHOD(GetCurrentProcessUpTime)(
THIS_
__out PULONG UpTime
) PURE;
// During kernel sessions the debugger retrieves
// some information from the system thread and process
// running on the current processor. For example,
// the debugger will retrieve virtual memory translation
// information for when the debugger needs to
// carry out its own virtual to physical translations.
// Occasionally it can be interesting to perform
// similar operations but on a process which isnt
// currently running. The follow methods allow a caller
// to override the data offsets used by the debugger
// so that other system threads and processes can
// be used instead. These values are defaulted to
// the thread and process running on the current
// processor each time the debuggee executes or
// the current processor changes.
// The thread and process settings are independent so
// it is possible to refer to a thread in a process
// other than the current process and vice versa.
// Setting an offset of zero will reload the
// default value.
STDMETHOD(GetImplicitThreadDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetImplicitThreadDataOffset)(
THIS_
__in ULONG64 Offset
) PURE;
STDMETHOD(GetImplicitProcessDataOffset)(
THIS_
__out PULONG64 Offset
) PURE;
STDMETHOD(SetImplicitProcessDataOffset)(
THIS_
__in ULONG64 Offset
) PURE;
// IDebugSystemObjects3.
STDMETHOD(GetEventSystem)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(GetCurrentSystemId)(
THIS_
__out PULONG Id
) PURE;
STDMETHOD(SetCurrentSystemId)(
THIS_
__in ULONG Id
) PURE;
STDMETHOD(GetNumberSystems)(
THIS_
__out PULONG Number
) PURE;
STDMETHOD(GetSystemIdsByIndex)(
THIS_
__in ULONG Start,
__in ULONG Count,
__out_ecount(Count) PULONG Ids
) PURE;
STDMETHOD(GetTotalNumberThreadsAndProcesses)(
THIS_
__out PULONG TotalThreads,
__out PULONG TotalProcesses,
__out PULONG LargestProcessThreads,
__out PULONG LargestSystemThreads,
__out PULONG LargestSystemProcesses
) PURE;
STDMETHOD(GetCurrentSystemServer)(
THIS_
__out PULONG64 Server
) PURE;
STDMETHOD(GetSystemByServer)(
THIS_
__in ULONG64 Server,
__out PULONG Id
) PURE;
STDMETHOD(GetCurrentSystemServerName)(
THIS_
__out_ecount_opt(BufferSize) PSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
// IDebugSystemObjects4.
STDMETHOD(GetCurrentProcessExecutableNameWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG ExeSize
) PURE;
STDMETHOD(GetCurrentSystemServerNameWide)(
THIS_
__out_ecount_opt(BufferSize) PWSTR Buffer,
__in ULONG BufferSize,
__out_opt PULONG NameSize
) PURE;
};
//----------------------------------------------------------------------------
//
// Debugger/debuggee communication.
//
// A distinguished exception, DBG_COMMAND_EXCEPTION (0x40010009),
// can be used by a debuggee to communicate with the debugger.
// The arguments of the exception must be:
// 1. Exception ID.
// 2. Command code.
// 3. Size of argument.
// 4. Pointer to argument.
//
// The arguments depend on the command code.
//
//----------------------------------------------------------------------------
#define DEBUG_COMMAND_EXCEPTION_ID 0xdbe00dbe
// Invalid command code.
#define DEBUG_CMDEX_INVALID 0x00000000
//
// The debugger can collect strings for display at the
// next event. A debuggee can use this to register information
// about a program situation before places where an event
// may occur, such as a risky operation or assertion.
// The strings are automatically flushed on the next
// event continuation. Strings are kept on a per-thread basis.
//
// When adding, the argument is the string to add.
// Reset has no arguments and clears all strings.
//
#define DEBUG_CMDEX_ADD_EVENT_STRING 0x00000001
#define DEBUG_CMDEX_RESET_EVENT_STRINGS 0x00000002
#ifndef DEBUG_NO_IMPLEMENTATION
FORCEINLINE void
DebugCommandException(ULONG Command, ULONG ArgSize, PVOID Arg)
{
ULONG_PTR ExArgs[4];
ExArgs[0] = DEBUG_COMMAND_EXCEPTION_ID;
ExArgs[1] = Command;
ExArgs[2] = ArgSize;
ExArgs[3] = (ULONG_PTR)Arg;
RaiseException(DBG_COMMAND_EXCEPTION, 0, 4, ExArgs);
}
#endif // #ifndef DEBUG_NO_IMPLEMENTATION
//----------------------------------------------------------------------------
//
// Extension callbacks.
//
//----------------------------------------------------------------------------
// Returns a version with the major version in
// the high word and the minor version in the low word.
#define DEBUG_EXTENSION_VERSION(Major, Minor) \
((((Major) & 0xffff) << 16) | ((Minor) & 0xffff))
// Initialization routine. Called once when the extension DLL
// is loaded. Returns a version and returns flags detailing
// overall qualities of the extension DLL.
// A session may or may not be active at the time the DLL
// is loaded so initialization routines should not expect
// to be able to query session information.
typedef HRESULT (CALLBACK* PDEBUG_EXTENSION_INITIALIZE)
(__out PULONG Version, __out PULONG Flags);
// Exit routine. Called once just before the extension DLL is
// unloaded. As with initialization, a session may or
// may not be active at the time of the call.
typedef void (CALLBACK* PDEBUG_EXTENSION_UNINITIALIZE)
(void);
// A debuggee has been discovered for the session. It
// is not necessarily halted.
#define DEBUG_NOTIFY_SESSION_ACTIVE 0x00000000
// The session no longer has a debuggee.
#define DEBUG_NOTIFY_SESSION_INACTIVE 0x00000001
// The debuggee is halted and accessible.
#define DEBUG_NOTIFY_SESSION_ACCESSIBLE 0x00000002
// The debuggee is running or inaccessible.
#define DEBUG_NOTIFY_SESSION_INACCESSIBLE 0x00000003
typedef void (CALLBACK* PDEBUG_EXTENSION_NOTIFY)
(__in ULONG Notify, __in ULONG64 Argument);
// A PDEBUG_EXTENSION_CALL function can return this code
// to indicate that it was unable to handle the request
// and that the search for an extension function should
// continue down the extension DLL chain.
// Taken from STATUS_VALIDATE_CONTINUE
#define DEBUG_EXTENSION_CONTINUE_SEARCH \
HRESULT_FROM_NT(0xC0000271L)
// Every routine in an extension DLL has the following prototype.
// The extension may be called from multiple clients so it
// should not cache the client value between calls.
typedef HRESULT (CALLBACK* PDEBUG_EXTENSION_CALL)
(__in PDEBUG_CLIENT Client, __in_opt PCSTR Args);
// Extensions may export this API in order to dump the struct that
// are well known to them. Engine would call this to inject extension
// output into dt's struct dump
typedef HRESULT (CALLBACK * PDEBUG_ENTENSION_KNOWNSTRUCT)(
__in ULONG Flag, __in ULONG64 Address, __in PSTR StructName,
__out_ecount_opt(BufferSize) PSTR Buffer, __inout PULONG BufferSize);
//
// KnownStructOutput flags
//
#define DEBUG_KNOWN_STRUCT_GET_NAMES 1 // Return names of supported structs
#define DEBUG_KNOWN_STRUCT_GET_SINGLE_LINE_OUTPUT 2 // Return value output for type
#define DEBUG_KNOWN_STRUCT_SUPPRESS_TYPE_NAME 3 // Return S_OK for suppressing type name
//----------------------------------------------------------------------------
//
// Extension functions.
//
// Extension functions differ from extension callbacks in that
// they are arbitrary functions exported from an extension DLL
// for other code callers instead of for human invocation from
// debugger commands. Extension function pointers are retrieved
// for an extension DLL with IDebugControl::GetExtensionFunction.
//
// Extension function names must begin with _EFN_. Other than that
// they can have any name and prototype. Extension functions
// must be public exports of their extension DLL. They should
// have a typedef for their function pointer prototype in an
// extension header so that callers have a header file to include
// with a type that allows a correctly-formed invocation of the
// extension function.
//
// The engine does not perform any validation of calls to
// extension functions. Once the extension function pointer
// is retrieved with GetExtensionFunction all calls go
// directly between the caller and the extension function and
// are not mediated by the engine.
//
//----------------------------------------------------------------------------
#ifdef __cplusplus
};
//----------------------------------------------------------------------------
//
// C++ implementation helper classes.
//
//----------------------------------------------------------------------------
#if !defined(DEBUG_NO_IMPLEMENTATION) && !defined(_M_CEE_PURE)
//
// DebugBaseEventCallbacks provides a do-nothing base implementation
// of IDebugEventCallbacks. A program can derive their own
// event callbacks class from DebugBaseEventCallbacks and implement
// only the methods they are interested in. Programs must be
// careful to implement GetInterestMask appropriately.
//
class DebugBaseEventCallbacks : public IDebugEventCallbacks
{
public:
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
)
{
*Interface = NULL;
#if _MSC_VER >= 1100
if (IsEqualIID(InterfaceId, __uuidof(IUnknown)) ||
IsEqualIID(InterfaceId, __uuidof(IDebugEventCallbacks)))
#else
if (IsEqualIID(InterfaceId, IID_IUnknown) ||
IsEqualIID(InterfaceId, IID_IDebugEventCallbacks))
#endif
{
*Interface = (IDebugEventCallbacks *)this;
AddRef();
return S_OK;
}
else
{
return E_NOINTERFACE;
}
}
// IDebugEventCallbacks.
STDMETHOD(Breakpoint)(
THIS_
__in PDEBUG_BREAKPOINT Bp
)
{
UNREFERENCED_PARAMETER(Bp);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(Exception)(
THIS_
__in PEXCEPTION_RECORD64 Exception,
__in ULONG FirstChance
)
{
UNREFERENCED_PARAMETER(Exception);
UNREFERENCED_PARAMETER(FirstChance);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(CreateThread)(
THIS_
__in ULONG64 Handle,
__in ULONG64 DataOffset,
__in ULONG64 StartOffset
)
{
UNREFERENCED_PARAMETER(Handle);
UNREFERENCED_PARAMETER(DataOffset);
UNREFERENCED_PARAMETER(StartOffset);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(ExitThread)(
THIS_
__in ULONG ExitCode
)
{
UNREFERENCED_PARAMETER(ExitCode);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 Handle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in PCSTR ModuleName,
__in PCSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp,
__in ULONG64 InitialThreadHandle,
__in ULONG64 ThreadDataOffset,
__in ULONG64 StartOffset
)
{
UNREFERENCED_PARAMETER(ImageFileHandle);
UNREFERENCED_PARAMETER(Handle);
UNREFERENCED_PARAMETER(BaseOffset);
UNREFERENCED_PARAMETER(ModuleSize);
UNREFERENCED_PARAMETER(ModuleName);
UNREFERENCED_PARAMETER(ImageName);
UNREFERENCED_PARAMETER(CheckSum);
UNREFERENCED_PARAMETER(TimeDateStamp);
UNREFERENCED_PARAMETER(InitialThreadHandle);
UNREFERENCED_PARAMETER(ThreadDataOffset);
UNREFERENCED_PARAMETER(StartOffset);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(ExitProcess)(
THIS_
__in ULONG ExitCode
)
{
UNREFERENCED_PARAMETER(ExitCode);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(LoadModule)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in PCSTR ModuleName,
__in PCSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp
)
{
UNREFERENCED_PARAMETER(ImageFileHandle);
UNREFERENCED_PARAMETER(BaseOffset);
UNREFERENCED_PARAMETER(ModuleSize);
UNREFERENCED_PARAMETER(ModuleName);
UNREFERENCED_PARAMETER(ImageName);
UNREFERENCED_PARAMETER(CheckSum);
UNREFERENCED_PARAMETER(TimeDateStamp);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(UnloadModule)(
THIS_
__in PCSTR ImageBaseName,
__in ULONG64 BaseOffset
)
{
UNREFERENCED_PARAMETER(ImageBaseName);
UNREFERENCED_PARAMETER(BaseOffset);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(SystemError)(
THIS_
__in ULONG Error,
__in ULONG Level
)
{
UNREFERENCED_PARAMETER(Error);
UNREFERENCED_PARAMETER(Level);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(SessionStatus)(
THIS_
__in ULONG Status
)
{
UNREFERENCED_PARAMETER(Status);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(ChangeDebuggeeState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
)
{
UNREFERENCED_PARAMETER(Flags);
UNREFERENCED_PARAMETER(Argument);
return S_OK;
}
STDMETHOD(ChangeEngineState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
)
{
UNREFERENCED_PARAMETER(Flags);
UNREFERENCED_PARAMETER(Argument);
return S_OK;
}
STDMETHOD(ChangeSymbolState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
)
{
UNREFERENCED_PARAMETER(Flags);
UNREFERENCED_PARAMETER(Argument);
return S_OK;
}
};
class DebugBaseEventCallbacksWide : public IDebugEventCallbacksWide
{
public:
// IUnknown.
STDMETHOD(QueryInterface)(
THIS_
__in REFIID InterfaceId,
__out PVOID* Interface
)
{
*Interface = NULL;
#if _MSC_VER >= 1100
if (IsEqualIID(InterfaceId, __uuidof(IUnknown)) ||
IsEqualIID(InterfaceId, __uuidof(IDebugEventCallbacksWide)))
#else
if (IsEqualIID(InterfaceId, IID_IUnknown) ||
IsEqualIID(InterfaceId, IID_IDebugEventCallbacksWide))
#endif
{
*Interface = (IDebugEventCallbacksWide *)this;
AddRef();
return S_OK;
}
else
{
return E_NOINTERFACE;
}
}
// IDebugEventCallbacksWide.
STDMETHOD(Breakpoint)(
THIS_
__in PDEBUG_BREAKPOINT2 Bp
)
{
UNREFERENCED_PARAMETER(Bp);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(Exception)(
THIS_
__in PEXCEPTION_RECORD64 Exception,
__in ULONG FirstChance
)
{
UNREFERENCED_PARAMETER(Exception);
UNREFERENCED_PARAMETER(FirstChance);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(CreateThread)(
THIS_
__in ULONG64 Handle,
__in ULONG64 DataOffset,
__in ULONG64 StartOffset
)
{
UNREFERENCED_PARAMETER(Handle);
UNREFERENCED_PARAMETER(DataOffset);
UNREFERENCED_PARAMETER(StartOffset);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(ExitThread)(
THIS_
__in ULONG ExitCode
)
{
UNREFERENCED_PARAMETER(ExitCode);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(CreateProcess)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 Handle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in PCWSTR ModuleName,
__in PCWSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp,
__in ULONG64 InitialThreadHandle,
__in ULONG64 ThreadDataOffset,
__in ULONG64 StartOffset
)
{
UNREFERENCED_PARAMETER(ImageFileHandle);
UNREFERENCED_PARAMETER(Handle);
UNREFERENCED_PARAMETER(BaseOffset);
UNREFERENCED_PARAMETER(ModuleSize);
UNREFERENCED_PARAMETER(ModuleName);
UNREFERENCED_PARAMETER(ImageName);
UNREFERENCED_PARAMETER(CheckSum);
UNREFERENCED_PARAMETER(TimeDateStamp);
UNREFERENCED_PARAMETER(InitialThreadHandle);
UNREFERENCED_PARAMETER(ThreadDataOffset);
UNREFERENCED_PARAMETER(StartOffset);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(ExitProcess)(
THIS_
__in ULONG ExitCode
)
{
UNREFERENCED_PARAMETER(ExitCode);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(LoadModule)(
THIS_
__in ULONG64 ImageFileHandle,
__in ULONG64 BaseOffset,
__in ULONG ModuleSize,
__in PCWSTR ModuleName,
__in PCWSTR ImageName,
__in ULONG CheckSum,
__in ULONG TimeDateStamp
)
{
UNREFERENCED_PARAMETER(ImageFileHandle);
UNREFERENCED_PARAMETER(BaseOffset);
UNREFERENCED_PARAMETER(ModuleSize);
UNREFERENCED_PARAMETER(ModuleName);
UNREFERENCED_PARAMETER(ImageName);
UNREFERENCED_PARAMETER(CheckSum);
UNREFERENCED_PARAMETER(TimeDateStamp);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(UnloadModule)(
THIS_
__in PCWSTR ImageBaseName,
__in ULONG64 BaseOffset
)
{
UNREFERENCED_PARAMETER(ImageBaseName);
UNREFERENCED_PARAMETER(BaseOffset);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(SystemError)(
THIS_
__in ULONG Error,
__in ULONG Level
)
{
UNREFERENCED_PARAMETER(Error);
UNREFERENCED_PARAMETER(Level);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(SessionStatus)(
THIS_
__in ULONG Status
)
{
UNREFERENCED_PARAMETER(Status);
return DEBUG_STATUS_NO_CHANGE;
}
STDMETHOD(ChangeDebuggeeState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
)
{
UNREFERENCED_PARAMETER(Flags);
UNREFERENCED_PARAMETER(Argument);
return S_OK;
}
STDMETHOD(ChangeEngineState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
)
{
UNREFERENCED_PARAMETER(Flags);
UNREFERENCED_PARAMETER(Argument);
return S_OK;
}
STDMETHOD(ChangeSymbolState)(
THIS_
__in ULONG Flags,
__in ULONG64 Argument
)
{
UNREFERENCED_PARAMETER(Flags);
UNREFERENCED_PARAMETER(Argument);
return S_OK;
}
};
#endif // #ifndef DEBUG_NO_IMPLEMENTATION
#ifdef DEBUG_UNICODE_MACROS
#ifdef UNICODE
#define IDebugEventCallbacksT IDebugEventCallbacksWide
#define IID_IDebugEventCallbacksT IID_IDebugEventCallbacksWide
#define IDebugOutputCallbacksT IDebugOutputCallbacksWide
#define IID_IDebugOutputCallbacksT IID_IDebugOutputCallbacksWide
#define DebugBaseEventCallbacksT DebugBaseEventCallbacksWide
#define DebugConnectT DebugConnectWide
#define GetSourceFileInformationT GetSourceFileInformationWide
#define FindSourceFileAndTokenT FindSourceFileAndTokenWide
#define GetSymbolInformationT GetSymbolInformationWide
#define GetCommandT GetCommandWide
#define SetCommandT SetCommandWide
#define GetOffsetExpressionT GetOffsetExpressionWide
#define SetOffsetExpressionT SetOffsetExpressionWide
#define GetRunningProcessSystemIdByExecutableNameT GetRunningProcessSystemIdByExecutableNameWide
#define GetRunningProcessDescriptionT GetRunningProcessDescriptionWide
#define CreateProcessT CreateProcessWide
#define CreateProcessAndAttachT CreateProcessAndAttachWide
#define AddDumpInformationFileT AddDumpInformationFileWide
#define GetDumpFileT GetDumpFileWide
#define AttachKernelT AttachKernelWide
#define GetKernelConnectionOptionsT GetKernelConnectionOptionsWide
#define SetKernelConnectionOptionsT SetKernelConnectionOptionsWide
#define StartProcessServerT StartProcessServerWide
#define ConnectProcessServerT ConnectProcessServerWide
#define StartServerT StartServerWide
#define OutputServersT OutputServersWide
#define GetOutputCallbacksT GetOutputCallbacksWide
#define SetOutputCallbacksT SetOutputCallbacksWide
#define GetOutputLinePrefixT GetOutputLinePrefixWide
#define SetOutputLinePrefixT SetOutputLinePrefixWide
#define GetIdentityT GetIdentityWide
#define OutputIdentityT OutputIdentityWide
#define GetEventCallbacksT GetEventCallbacksWide
#define SetEventCallbacksT SetEventCallbacksWide
#define CreateProcess2T CreateProcess2Wide
#define CreateProcessAndAttach2T CreateProcessAndAttach2Wide
#define PushOutputLinePrefixT PushOutputLinePrefixWide
#define GetQuitLockStringT GetQuitLockStringWide
#define SetQuitLockStringT SetQuitLockStringWide
#define GetLogFileT GetLogFileWide
#define OpenLogFileT OpenLogFileWide
#define InputT InputWide
#define ReturnInputT ReturnInputWide
#define OutputT OutputWide
#define OutputVaListT OutputVaListWide
#define ControlledOutputT ControlledOutputWide
#define ControlledOutputVaListT ControlledOutputVaListWide
#define OutputPromptT OutputPromptWide
#define OutputPromptVaListT OutputPromptVaListWide
#define GetPromptTextT GetPromptTextWide
#define AssembleT AssembleWide
#define DisassembleT DisassembleWide
#define GetProcessorTypeNamesT GetProcessorTypeNamesWide
#define GetTextMacroT GetTextMacroWide
#define SetTextMacroT SetTextMacroWide
#define EvaluateT EvaluateWide
#define ExecuteT ExecuteWide
#define ExecuteCommandFileT ExecuteCommandFileWide
#define AddExtensionT AddExtensionWide
#define GetExtensionByPathT GetExtensionByPathWide
#define CallExtensionT CallExtensionWide
#define GetExtensionFunctionT GetExtensionFunctionWide
#define GetEventFilterTextT GetEventFilterTextWide
#define GetEventFilterCommandT GetEventFilterCommandWide
#define SetEventFilterCommandT SetEventFilterCommandWide
#define GetSpecificFilterArgumentT GetSpecificFilterArgumentWide
#define SetSpecificFilterArgumentT SetSpecificFilterArgumentWide
#define GetExceptionFilterSecondCommandT GetExceptionFilterSecondCommandWide
#define SetExceptionFilterSecondCommandT SetExceptionFilterSecondCommandWide
#define GetLastEventInformationT GetLastEventInformationWide
#define GetTextReplacementT GetTextReplacementWide
#define SetTextReplacementT SetTextReplacementWide
#define SetExpressionSyntaxByNameT SetExpressionSyntaxByNameWide
#define GetExpressionSyntaxNamesT GetExpressionSyntaxNamesWide
#define GetEventIndexDescriptionT GetEventIndexDescriptionWide
#define GetLogFile2T GetLogFileWide
#define OpenLogFile2T OpenLogFileWide
#define GetSystemVersionStringT GetSystemVersionStringWide
#define ReadMultiByteStringVirtualT ReadMultiByteStringVirtualWide
#define ReadUnicodeStringVirtualT ReadUnicodeStringVirtualWide
#define GetDescriptionT GetDescriptionWide
#define GetIndexByNameT GetIndexByNameWide
#define GetPseudoDescriptionT GetPseudoDescriptionWide
#define GetPseudoIndexByNameT GetPseudoIndexByNameWide
#define AddSymbolT AddSymbolWide
#define RemoveSymbolByNameT RemoveSymbolByNameWide
#define GetSymbolNameT GetSymbolNameWide
#define WriteSymbolT WriteSymbolWide
#define OutputAsTypeT OutputAsTypeWide
#define GetSymbolTypeNameT GetSymbolTypeNameWide
#define GetSymbolValueTextT GetSymbolValueTextWide
#define GetNameByOffsetT GetNameByOffsetWide
#define GetOffsetByNameT GetOffsetByNameWide
#define GetNearNameByOffsetT GetNearNameByOffsetWide
#define GetLineByOffsetT GetLineByOffsetWide
#define GetOffsetByLineT GetOffsetByLineWide
#define GetModuleByModuleNameT GetModuleByModuleNameWide
#define GetSymbolModuleT GetSymbolModuleWide
#define GetTypeNameT GetTypeNameWide
#define GetTypeIdT GetTypeIdWide
#define GetFieldOffsetT GetFieldOffsetWide
#define GetSymbolTypeIdT GetSymbolTypeIdWide
#define StartSymbolMatchT StartSymbolMatchWide
#define GetNextSymbolMatchT GetNextSymbolMatchWide
#define ReloadT ReloadWide
#define GetSymbolPathT GetSymbolPathWide
#define SetSymbolPathT SetSymbolPathWide
#define AppendSymbolPathT AppendSymbolPathWide
#define GetImagePathT GetImagePathWide
#define SetImagePathT SetImagePathWide
#define AppendImagePathT AppendImagePathWide
#define GetSourcePathT GetSourcePathWide
#define GetSourcePathElementT GetSourcePathElementWide
#define SetSourcePathT SetSourcePathWide
#define AppendSourcePathT AppendSourcePathWide
#define FindSourceFileT FindSourceFileWide
#define GetSourceFileLineOffsetsT GetSourceFileLineOffsetsWide
#define GetModuleVersionInformationT GetModuleVersionInformationWide
#define GetModuleNameStringT GetModuleNameStringWide
#define GetConstantNameT GetConstantNameWide
#define GetFieldNameT GetFieldNameWide
#define GetFieldTypeAndOffsetT GetFieldTypeAndOffsetWide
#define GetSymbolEntriesByNameT GetSymbolEntriesByNameWide
#define GetSymbolEntryStringT GetSymbolEntryStringWide
#define GetSourceEntriesByLineT GetSourceEntriesByLineWide
#define GetSourceEntryStringT GetSourceEntryStringWide
#define GetCurrentProcessExecutableNameT GetCurrentProcessExecutableNameWide
#define GetCurrentSystemServerNameT GetCurrentSystemServerNameWide
#else // #ifdef UNICODE
#define IDebugEventCallbacksT IDebugEventCallbacks
#define IID_IDebugEventCallbacksT IID_IDebugEventCallbacks
#define IDebugOutputCallbacksT IDebugOutputCallbacks
#define IID_IDebugOutputCallbacksT IID_IDebugOutputCallbacks
#define DebugBaseEventCallbacksT DebugBaseEventCallbacks
#define DebugConnectT DebugConnect
#define GetSourceFileInformationT GetSourceFileInformation
#define FindSourceFileAndTokenT FindSourceFileAndToken
#define GetSymbolInformationT GetSymbolInformation
#define GetCommandT GetCommand
#define SetCommandT SetCommand
#define GetOffsetExpressionT GetOffsetExpression
#define SetOffsetExpressionT SetOffsetExpression
#define GetRunningProcessSystemIdByExecutableNameT GetRunningProcessSystemIdByExecutableName
#define GetRunningProcessDescriptionT GetRunningProcessDescription
#define CreateProcessT CreateProcess
#define CreateProcessAndAttachT CreateProcessAndAttach
#define AddDumpInformationFileT AddDumpInformationFile
#define GetDumpFileT GetDumpFile
#define AttachKernelT AttachKernel
#define GetKernelConnectionOptionsT GetKernelConnectionOptions
#define SetKernelConnectionOptionsT SetKernelConnectionOptions
#define StartProcessServerT StartProcessServer
#define ConnectProcessServerT ConnectProcessServer
#define StartServerT StartServer
#define OutputServersT OutputServers
#define GetOutputCallbacksT GetOutputCallbacks
#define SetOutputCallbacksT SetOutputCallbacks
#define GetOutputLinePrefixT GetOutputLinePrefix
#define SetOutputLinePrefixT SetOutputLinePrefix
#define GetIdentityT GetIdentity
#define OutputIdentityT OutputIdentity
#define GetEventCallbacksT GetEventCallbacks
#define SetEventCallbacksT SetEventCallbacks
#define CreateProcess2T CreateProcess2
#define CreateProcessAndAttach2T CreateProcessAndAttach2
#define PushOutputLinePrefixT PushOutputLinePrefix
#define GetQuitLockStringT GetQuitLockString
#define SetQuitLockStringT SetQuitLockString
#define GetLogFileT GetLogFile
#define OpenLogFileT OpenLogFile
#define InputT Input
#define ReturnInputT ReturnInput
#define OutputT Output
#define OutputVaListT OutputVaList
#define ControlledOutputT ControlledOutput
#define ControlledOutputVaListT ControlledOutputVaList
#define OutputPromptT OutputPrompt
#define OutputPromptVaListT OutputPromptVaList
#define GetPromptTextT GetPromptText
#define AssembleT Assemble
#define DisassembleT Disassemble
#define GetProcessorTypeNamesT GetProcessorTypeNames
#define GetTextMacroT GetTextMacro
#define SetTextMacroT SetTextMacro
#define EvaluateT Evaluate
#define ExecuteT Execute
#define ExecuteCommandFileT ExecuteCommandFile
#define AddExtensionT AddExtension
#define GetExtensionByPathT GetExtensionByPath
#define CallExtensionT CallExtension
#define GetExtensionFunctionT GetExtensionFunction
#define GetEventFilterTextT GetEventFilterText
#define GetEventFilterCommandT GetEventFilterCommand
#define SetEventFilterCommandT SetEventFilterCommand
#define GetSpecificFilterArgumentT GetSpecificFilterArgument
#define SetSpecificFilterArgumentT SetSpecificFilterArgument
#define GetExceptionFilterSecondCommandT GetExceptionFilterSecondCommand
#define SetExceptionFilterSecondCommandT SetExceptionFilterSecondCommand
#define GetLastEventInformationT GetLastEventInformation
#define GetTextReplacementT GetTextReplacement
#define SetTextReplacementT SetTextReplacement
#define SetExpressionSyntaxByNameT SetExpressionSyntaxByName
#define GetExpressionSyntaxNamesT GetExpressionSyntaxNames
#define GetEventIndexDescriptionT GetEventIndexDescription
#define GetLogFile2T GetLogFile
#define OpenLogFile2T OpenLogFile
#define GetSystemVersionStringT GetSystemVersionString
#define ReadMultiByteStringVirtualT ReadMultiByteStringVirtual
#define ReadUnicodeStringVirtualT ReadUnicodeStringVirtual
#define GetDescriptionT GetDescription
#define GetIndexByNameT GetIndexByName
#define GetPseudoDescriptionT GetPseudoDescription
#define GetPseudoIndexByNameT GetPseudoIndexByName
#define AddSymbolT AddSymbol
#define RemoveSymbolByNameT RemoveSymbolByName
#define GetSymbolNameT GetSymbolName
#define WriteSymbolT WriteSymbol
#define OutputAsTypeT OutputAsType
#define GetSymbolTypeNameT GetSymbolTypeName
#define GetSymbolValueTextT GetSymbolValueText
#define GetNameByOffsetT GetNameByOffset
#define GetOffsetByNameT GetOffsetByName
#define GetNearNameByOffsetT GetNearNameByOffset
#define GetLineByOffsetT GetLineByOffset
#define GetOffsetByLineT GetOffsetByLine
#define GetModuleByModuleNameT GetModuleByModuleName
#define GetSymbolModuleT GetSymbolModule
#define GetTypeNameT GetTypeName
#define GetTypeIdT GetTypeId
#define GetFieldOffsetT GetFieldOffset
#define GetSymbolTypeIdT GetSymbolTypeId
#define StartSymbolMatchT StartSymbolMatch
#define GetNextSymbolMatchT GetNextSymbolMatch
#define ReloadT Reload
#define GetSymbolPathT GetSymbolPath
#define SetSymbolPathT SetSymbolPath
#define AppendSymbolPathT AppendSymbolPath
#define GetImagePathT GetImagePath
#define SetImagePathT SetImagePath
#define AppendImagePathT AppendImagePath
#define GetSourcePathT GetSourcePath
#define GetSourcePathElementT GetSourcePathElement
#define SetSourcePathT SetSourcePath
#define AppendSourcePathT AppendSourcePath
#define FindSourceFileT FindSourceFile
#define GetSourceFileLineOffsetsT GetSourceFileLineOffsets
#define GetModuleVersionInformationT GetModuleVersionInformation
#define GetModuleNameStringT GetModuleNameString
#define GetConstantNameT GetConstantName
#define GetFieldNameT GetFieldName
#define GetFieldTypeAndOffsetT GetFieldTypeAndOffset
#define GetSymbolEntriesByNameT GetSymbolEntriesByName
#define GetSymbolEntryStringT GetSymbolEntryString
#define GetSourceEntriesByLineT GetSourceEntriesByLine
#define GetSourceEntryStringT GetSourceEntryString
#define GetCurrentProcessExecutableNameT GetCurrentProcessExecutableName
#define GetCurrentSystemServerNameT GetCurrentSystemServerName
#endif // #ifdef UNICODE
#endif // #ifdef DEBUG_UNICODE_MACROS
#endif // #ifdef __cplusplus
#endif // #ifndef __DBGENG_H__