diff options
Diffstat (limited to 'public/sdk/inc/windbgkd.h')
-rw-r--r-- | public/sdk/inc/windbgkd.h | 881 |
1 files changed, 881 insertions, 0 deletions
diff --git a/public/sdk/inc/windbgkd.h b/public/sdk/inc/windbgkd.h new file mode 100644 index 000000000..7e94d5eac --- /dev/null +++ b/public/sdk/inc/windbgkd.h @@ -0,0 +1,881 @@ +/*++ BUILD Version: 0063 // Increment this if a change has global effects + +Copyright (c) 1990-1994 Microsoft Corporation + +Module Name: + + windbgkd.h + +Abstract: + + This module defines the 32-Bit Windows Kernel Debugger interface. + +Revision History: + +--*/ + +#ifndef _WINDBGKD_ +#define _WINDBGKD_ + +typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS; + +#ifdef _X86_ + +// +// DBGKD_CONTROL_REPORT +// +// This structure contains machine specific data passed to the debugger +// when a Wait_State_Change message is sent. Idea is to allow debugger +// to do what it needes without reading any more packets. +// Structure is filled in by KdpSetControlReport +// + +#define DBGKD_MAXSTREAM 16 + +typedef struct _DBGKD_CONTROL_REPORT { + DWORD Dr6; + DWORD Dr7; + WORD InstructionCount; + WORD ReportFlags; + BYTE InstructionStream[DBGKD_MAXSTREAM]; + WORD SegCs; + WORD SegDs; + WORD SegEs; + WORD SegFs; + DWORD EFlags; +} DBGKD_CONTROL_REPORT, *PDBGKD_CONTROL_REPORT; + +#define REPORT_INCLUDES_SEGS 0x0001 // this is for backward compatibility + +// +// DBGKD_CONTROL_SET +// +// This structure control value the debugger wants to set on every +// continue, and thus sets here to avoid packet traffic. +// + +typedef struct _DBGKD_CONTROL_SET { + DWORD TraceFlag; // WARNING: This must NOT be a BOOLEAN, + // or host and target will end + // up with different alignments! + DWORD Dr7; + DWORD CurrentSymbolStart; // Range in which to trace locally + DWORD CurrentSymbolEnd; +} DBGKD_CONTROL_SET, *PDBGKD_CONTROL_SET; + +#endif //_X86_ + + +typedef struct _DESCRIPTOR_TABLE_ENTRY { + DWORD Selector; + LDT_ENTRY Descriptor; +} DESCRIPTOR_TABLE_ENTRY, *PDESCRIPTOR_TABLE_ENTRY; + + +#if defined(_MIPS_) + +// end_ntddk end_nthal + +// +// Define MIPS specific kernel debugger information. +// +// The following structure contains machine specific data passed to +// the host system kernel debugger in a wait state change message. +// + +#define DBGKD_MAXSTREAM 16 + +typedef struct _DBGKD_CONTROL_REPORT { + DWORD InstructionCount; + BYTE InstructionStream[DBGKD_MAXSTREAM]; +} DBGKD_CONTROL_REPORT, *PDBGKD_CONTROL_REPORT; + +// +// The following structure contains information that the host system +// kernel debugger wants to set on every continue operation and avoids +// the need to send extra packets of information. +// + +typedef DWORD DBGKD_CONTROL_SET, *PDBGKD_CONTROL_SET; + +#endif // ntddk nthal + +#ifdef _ALPHA_ + +// +// Define Alpha specific kernel debugger information. +// +// The following structure contains machine specific data passed to +// the host system kernel debugger in a wait state change message. +// + +#define DBGKD_MAXSTREAM 16 + +typedef struct _DBGKD_CONTROL_REPORT { + DWORD InstructionCount; + BYTE InstructionStream[DBGKD_MAXSTREAM]; +} DBGKD_CONTROL_REPORT, *PDBGKD_CONTROL_REPORT; + +// +// The following structure contains information that the host system +// kernel debugger wants to set on every continue operation and avoids +// the need to send extra packets of information. +// + +typedef DWORD DBGKD_CONTROL_SET, *PDBGKD_CONTROL_SET; + +#endif // _ALPHA_ + +#if defined(_PPC_) + + +// +// Define PowerPC specific kernel debugger information. +// +// The following structure contains machine specific data passed to +// the host system kernel debugger in a wait state change message. +// +// **FINISH** Copied without change from MIPS; may need modification + +#define DBGKD_MAXSTREAM 16 + +typedef struct _DBGKD_CONTROL_REPORT { + DWORD InstructionCount; + BYTE InstructionStream[DBGKD_MAXSTREAM]; +} DBGKD_CONTROL_REPORT, *PDBGKD_CONTROL_REPORT; + +// +// The following structure contains information that the host system +// kernel debugger wants to set on every continue operation and avoids +// the need to send extra packets of information. +// + +typedef DWORD DBGKD_CONTROL_SET, *PDBGKD_CONTROL_SET; + +#endif // defined(_PPC_) + +#ifdef _PPC_ +// +// Special Registers for PowerPC +// + +typedef struct _KSPECIAL_REGISTERS { + DWORD KernelDr0; + DWORD KernelDr1; + DWORD KernelDr2; + DWORD KernelDr3; + DWORD KernelDr4; + DWORD KernelDr5; + DWORD KernelDr6; + DWORD KernelDr7; + DWORD Sprg0; + DWORD Sprg1; + DWORD Sr0; + DWORD Sr1; + DWORD Sr2; + DWORD Sr3; + DWORD Sr4; + DWORD Sr5; + DWORD Sr6; + DWORD Sr7; + DWORD Sr8; + DWORD Sr9; + DWORD Sr10; + DWORD Sr11; + DWORD Sr12; + DWORD Sr13; + DWORD Sr14; + DWORD Sr15; + DWORD DBAT0L; + DWORD DBAT0U; + DWORD DBAT1L; + DWORD DBAT1U; + DWORD DBAT2L; + DWORD DBAT2U; + DWORD DBAT3L; + DWORD DBAT3U; + DWORD IBAT0L; + DWORD IBAT0U; + DWORD IBAT1L; + DWORD IBAT1U; + DWORD IBAT2L; + DWORD IBAT2U; + DWORD IBAT3L; + DWORD IBAT3U; + DWORD Sdr1; + DWORD Reserved[9]; +} KSPECIAL_REGISTERS, *PKSPECIAL_REGISTERS; + +// +// Processor State structure. +// + +typedef struct _KPROCESSOR_STATE { + struct _CONTEXT ContextFrame; + struct _KSPECIAL_REGISTERS SpecialRegisters; +} KPROCESSOR_STATE, *PKPROCESSOR_STATE; + +#endif // _PPC_ + +#ifdef _X86_ +// +// Special Registers for i386 +// + +typedef struct _DESCRIPTOR { + WORD Pad; + WORD Limit; + DWORD Base; +} KDESCRIPTOR, *PKDESCRIPTOR; + +typedef struct _KSPECIAL_REGISTERS { + DWORD Cr0; + DWORD Cr2; + DWORD Cr3; + DWORD Cr4; + DWORD KernelDr0; + DWORD KernelDr1; + DWORD KernelDr2; + DWORD KernelDr3; + DWORD KernelDr6; + DWORD KernelDr7; + KDESCRIPTOR Gdtr; + KDESCRIPTOR Idtr; + WORD Tr; + WORD Ldtr; + DWORD Reserved[6]; +} KSPECIAL_REGISTERS, *PKSPECIAL_REGISTERS; + +// +// Processor State frame: Before a processor freezes itself, it +// dumps the processor state to the processor state frame for +// debugger to examine. +// + +typedef struct _KPROCESSOR_STATE { + struct _CONTEXT ContextFrame; + struct _KSPECIAL_REGISTERS SpecialRegisters; +} KPROCESSOR_STATE, *PKPROCESSOR_STATE; +#endif // _X86_ + +typedef struct _DBGKM_EXCEPTION { + EXCEPTION_RECORD ExceptionRecord; + DWORD FirstChance; +} DBGKM_EXCEPTION, *PDBGKM_EXCEPTION; + + +// +// DbgKd APIs are for the portable kernel debugger +// + +// +// KD_PACKETS are the low level data format used in KD. All packets +// begin with a packet leader, byte count, packet type. The sequence +// for accepting a packet is: +// +// - read 4 bytes to get packet leader. If read times out (10 seconds) +// with a short read, or if packet leader is incorrect, then retry +// the read. +// +// - next read 2 byte packet type. If read times out (10 seconds) with +// a short read, or if packet type is bad, then start again looking +// for a packet leader. +// +// - next read 4 byte packet Id. If read times out (10 seconds) +// with a short read, or if packet Id is not what we expect, then +// ask for resend and restart again looking for a packet leader. +// +// - next read 2 byte byte count. If read times out (10 seconds) with +// a short read, or if byte count is greater than PACKET_MAX_SIZE, +// then start again looking for a packet leader. +// +// - next read 4 byte packet data checksum. +// +// - The packet data immediately follows the packet. There should be +// ByteCount bytes following the packet header. Read the packet +// data, if read times out (10 seconds) then start again looking for +// a packet leader. +// + + +typedef struct _KD_PACKET { + DWORD PacketLeader; + WORD PacketType; + WORD ByteCount; + DWORD PacketId; + DWORD Checksum; +} KD_PACKET, *PKD_PACKET; + + +#define PACKET_MAX_SIZE 4000 +#define INITIAL_PACKET_ID 0x80800000 // DON't use 0 +#define SYNC_PACKET_ID 0x00000800 // Or in with INITIAL_PACKET_ID + // to force a packet ID reset. + +// +// BreakIn packet +// + +#define BREAKIN_PACKET 0x62626262 +#define BREAKIN_PACKET_BYTE 0x62 + +// +// Packet lead in sequence +// + +#define PACKET_LEADER 0x30303030 //0x77000077 +#define PACKET_LEADER_BYTE 0x30 + +#define CONTROL_PACKET_LEADER 0x69696969 +#define CONTROL_PACKET_LEADER_BYTE 0x69 + +// +// Packet Trailing Byte +// + +#define PACKET_TRAILING_BYTE 0xAA + +// +// Packet Types +// + +#define PACKET_TYPE_UNUSED 0 +#define PACKET_TYPE_KD_STATE_CHANGE 1 +#define PACKET_TYPE_KD_STATE_MANIPULATE 2 +#define PACKET_TYPE_KD_DEBUG_IO 3 +#define PACKET_TYPE_KD_ACKNOWLEDGE 4 // Packet-control type +#define PACKET_TYPE_KD_RESEND 5 // Packet-control type +#define PACKET_TYPE_KD_RESET 6 // Packet-control type +#define PACKET_TYPE_MAX 7 + +// +// If the packet type is PACKET_TYPE_KD_STATE_CHANGE, then +// the format of the packet data is as follows: +// + +#define DbgKdExceptionStateChange 0x00003030L +#define DbgKdLoadSymbolsStateChange 0x00003031L + +// +// Pathname Data follows directly +// + +typedef struct _DBGKD_LOAD_SYMBOLS { + DWORD PathNameLength; + PVOID BaseOfDll; + DWORD ProcessId; + DWORD CheckSum; + DWORD SizeOfImage; + BOOLEAN UnloadSymbols; +} DBGKD_LOAD_SYMBOLS, *PDBGKD_LOAD_SYMBOLS; + +typedef struct _DBGKD_WAIT_STATE_CHANGE { + DWORD NewState; + WORD ProcessorLevel; + WORD Processor; + DWORD NumberProcessors; + PVOID Thread; + PVOID ProgramCounter; + union { + DBGKM_EXCEPTION Exception; + DBGKD_LOAD_SYMBOLS LoadSymbols; + } u; + DBGKD_CONTROL_REPORT ControlReport; + CONTEXT Context; +} DBGKD_WAIT_STATE_CHANGE, *PDBGKD_WAIT_STATE_CHANGE; + +// +// If the packet type is PACKET_TYPE_KD_STATE_MANIPULATE, then +// the format of the packet data is as follows: +// +// Api Numbers for state manipulation +// + +#define DbgKdReadVirtualMemoryApi 0x00003130L +#define DbgKdWriteVirtualMemoryApi 0x00003131L +#define DbgKdGetContextApi 0x00003132L +#define DbgKdSetContextApi 0x00003133L +#define DbgKdWriteBreakPointApi 0x00003134L +#define DbgKdRestoreBreakPointApi 0x00003135L +#define DbgKdContinueApi 0x00003136L +#define DbgKdReadControlSpaceApi 0x00003137L +#define DbgKdWriteControlSpaceApi 0x00003138L +#define DbgKdReadIoSpaceApi 0x00003139L +#define DbgKdWriteIoSpaceApi 0x0000313AL +#define DbgKdRebootApi 0x0000313BL +#define DbgKdContinueApi2 0x0000313CL +#define DbgKdReadPhysicalMemoryApi 0x0000313DL +#define DbgKdWritePhysicalMemoryApi 0x0000313EL +#define DbgKdQuerySpecialCallsApi 0x0000313FL +#define DbgKdSetSpecialCallApi 0x00003140L +#define DbgKdClearSpecialCallsApi 0x00003141L +#define DbgKdSetInternalBreakPointApi 0x00003142L +#define DbgKdGetInternalBreakPointApi 0x00003143L +#define DbgKdReadIoSpaceExtendedApi 0x00003144L +#define DbgKdWriteIoSpaceExtendedApi 0x00003145L +#define DbgKdGetVersionApi 0x00003146L +#define DbgKdWriteBreakPointExApi 0x00003147L +#define DbgKdRestoreBreakPointExApi 0x00003148L +#define DbgKdCauseBugCheckApi 0x00003149L +#define DbgKdSwitchProcessor 0x00003150L +#define DbgKdPageInApi 0x00003151L +#define DbgKdReadMachineSpecificRegister 0x00003152L +#define DbgKdWriteMachineSpecificRegister 0x00003153L + +// +// Response is a read memory message with data following +// + +typedef struct _DBGKD_READ_MEMORY { + PVOID TargetBaseAddress; + DWORD TransferCount; + DWORD ActualBytesRead; +} DBGKD_READ_MEMORY, *PDBGKD_READ_MEMORY; + +// +// Data follows directly +// + +typedef struct _DBGKD_WRITE_MEMORY { + PVOID TargetBaseAddress; + DWORD TransferCount; + DWORD ActualBytesWritten; +} DBGKD_WRITE_MEMORY, *PDBGKD_WRITE_MEMORY; + +// +// Response is a get context message with a full context record following +// + +typedef struct _DBGKD_GET_CONTEXT { + DWORD ContextFlags; +} DBGKD_GET_CONTEXT, *PDBGKD_GET_CONTEXT; + +// +// Full Context record follows +// + +typedef struct _DBGKD_SET_CONTEXT { + DWORD ContextFlags; +} DBGKD_SET_CONTEXT, *PDBGKD_SET_CONTEXT; + +#define BREAKPOINT_TABLE_SIZE 32 // max number supported by kernel + +typedef struct _DBGKD_WRITE_BREAKPOINT { + PVOID BreakPointAddress; + DWORD BreakPointHandle; +} DBGKD_WRITE_BREAKPOINT, *PDBGKD_WRITE_BREAKPOINT; + +typedef struct _DBGKD_RESTORE_BREAKPOINT { + DWORD BreakPointHandle; +} DBGKD_RESTORE_BREAKPOINT, *PDBGKD_RESTORE_BREAKPOINT; + +typedef struct _DBGKD_BREAKPOINTEX { + DWORD BreakPointCount; + DWORD ContinueStatus; +} DBGKD_BREAKPOINTEX, *PDBGKD_BREAKPOINTEX; + +typedef struct _DBGKD_CONTINUE { + DWORD ContinueStatus; +} DBGKD_CONTINUE, *PDBGKD_CONTINUE; + +typedef struct _DBGKD_CONTINUE2 { + DWORD ContinueStatus; + DBGKD_CONTROL_SET ControlSet; +} DBGKD_CONTINUE2, *PDBGKD_CONTINUE2; + +typedef struct _DBGKD_READ_WRITE_IO { + DWORD DataSize; // 1, 2, 4 + PVOID IoAddress; + DWORD DataValue; +} DBGKD_READ_WRITE_IO, *PDBGKD_READ_WRITE_IO; + +typedef struct _DBGKD_READ_WRITE_IO_EXTENDED { + DWORD DataSize; // 1, 2, 4 + DWORD InterfaceType; + DWORD BusNumber; + DWORD AddressSpace; + PVOID IoAddress; + DWORD DataValue; +} DBGKD_READ_WRITE_IO_EXTENDED, *PDBGKD_READ_WRITE_IO_EXTENDED; + +typedef struct _DBGKD_READ_WRITE_MSR { + DWORD Msr; + DWORD DataValueLow; + DWORD DataValueHigh; +} DBGKD_READ_WRITE_MSR, *PDBGKD_READ_WRITE_MSR; + + +typedef struct _DBGKD_QUERY_SPECIAL_CALLS { + DWORD NumberOfSpecialCalls; + // DWORD SpecialCalls[]; +} DBGKD_QUERY_SPECIAL_CALLS, *PDBGKD_QUERY_SPECIAL_CALLS; + +typedef struct _DBGKD_SET_SPECIAL_CALL { + DWORD SpecialCall; +} DBGKD_SET_SPECIAL_CALL, *PDBGKD_SET_SPECIAL_CALL; + +typedef struct _DBGKD_SET_INTERNAL_BREAKPOINT { + DWORD BreakpointAddress; + DWORD Flags; +} DBGKD_SET_INTERNAL_BREAKPOINT, *PDBGKD_SET_INTERNAL_BREAKPOINT; + +typedef struct _DBGKD_GET_INTERNAL_BREAKPOINT { + DWORD BreakpointAddress; + DWORD Flags; + DWORD Calls; + DWORD MaxCallsPerPeriod; + DWORD MinInstructions; + DWORD MaxInstructions; + DWORD TotalInstructions; +} DBGKD_GET_INTERNAL_BREAKPOINT, *PDBGKD_GET_INTERNAL_BREAKPOINT; + +#define DBGKD_INTERNAL_BP_FLAG_COUNTONLY 0x00000001 // don't count instructions +#define DBGKD_INTERNAL_BP_FLAG_INVALID 0x00000002 // disabled BP +#define DBGKD_INTERNAL_BP_FLAG_SUSPENDED 0x00000004 // temporarily suspended +#define DBGKD_INTERNAL_BP_FLAG_DYING 0x00000008 // kill on exit + +typedef struct _DBGKD_GET_VERSION { + WORD MajorVersion; + WORD MinorVersion; + WORD ProtocolVersion; + WORD Flags; + DWORD KernBase; + DWORD PsLoadedModuleList; + WORD MachineType; + + // + // help for walking stacks with user callbacks: + // + + // + // The address of the thread structure is provided in the + // WAIT_STATE_CHANGE packet. This is the offset from the base of + // the thread structure to the pointer to the kernel stack frame + // for the currently active usermode callback. + // + + WORD ThCallbackStack; // offset in thread data + + // + // these values are offsets into that frame: + // + + WORD NextCallback; // saved pointer to next callback frame + WORD FramePointer; // saved frame pointer + + // + // Address of the kernel callout routine. + // + + DWORD KiCallUserMode; // kernel routine + + // + // Address of the usermode entry point for callbacks. + // + + DWORD KeUserCallbackDispatcher; // address in ntdll + + // + // DbgBreakPointWithStatus is a function which takes an argument + // and hits a breakpoint. This field contains the address of the + // breakpoint instruction. When the debugger sees a breakpoint + // at this address, it may retrieve the argument from the first + // argument register, or on x86 the eax register. + // + + DWORD BreakpointWithStatus; // address of breakpoint + + DWORD Reserved4; +} DBGKD_GET_VERSION, *PDBGKD_GET_VERSION; + +#define DBGKD_VERS_FLAG_MP 0x0001 // kernel is MP built + +typedef struct _DBGKD_PAGEIN { + DWORD Address; + DWORD ContinueStatus; +} DBGKD_PAGEIN, *PDBGKD_PAGEIN; + +typedef struct _DBGKD_MANIPULATE_STATE { + DWORD ApiNumber; + WORD ProcessorLevel; + WORD Processor; + DWORD ReturnStatus; + union { + DBGKD_READ_MEMORY ReadMemory; + DBGKD_WRITE_MEMORY WriteMemory; + DBGKD_GET_CONTEXT GetContext; + DBGKD_SET_CONTEXT SetContext; + DBGKD_WRITE_BREAKPOINT WriteBreakPoint; + DBGKD_RESTORE_BREAKPOINT RestoreBreakPoint; + DBGKD_CONTINUE Continue; + DBGKD_CONTINUE2 Continue2; + DBGKD_READ_WRITE_IO ReadWriteIo; + DBGKD_READ_WRITE_IO_EXTENDED ReadWriteIoExtended; + DBGKD_QUERY_SPECIAL_CALLS QuerySpecialCalls; + DBGKD_SET_SPECIAL_CALL SetSpecialCall; + DBGKD_SET_INTERNAL_BREAKPOINT SetInternalBreakpoint; + DBGKD_GET_INTERNAL_BREAKPOINT GetInternalBreakpoint; + DBGKD_GET_VERSION GetVersion; + DBGKD_BREAKPOINTEX BreakPointEx; + DBGKD_PAGEIN PageIn; + DBGKD_READ_WRITE_MSR ReadWriteMsr; + } u; +} DBGKD_MANIPULATE_STATE, *PDBGKD_MANIPULATE_STATE; + +// +// This is the format for the trace data passed back from the kernel to +// the debugger to describe multiple calls that have returned since the +// last trip back. The basic format is that there are a bunch of these +// (4 byte) unions stuck together. Each union is of one of two types: a +// 4 byte unsigned long interger, or a three field struct, describing a +// call (where "call" is delimited by returning or exiting the symbol +// scope). If the number of instructions executed is too big to fit +// into a WORD -1, then the Instructions field has +// TRACE_DATA_INSTRUCTIONS_BIG and the next union is a LongNumber +// containing the real number of instructions executed. +// +// The very first union returned in each callback is a LongNumber +// containing the number of unions returned (including the "size" +// record, os it's always at least 1 even if there's no data to return). +// +// This is all returned to the debugger when one of two things +// happens: +// +// 1) The pc moves out of all defined symbol ranges +// 2) The buffer of trace data entries is filled. +// +// The "trace done" case is hacked around on the debugger side. It +// guarantees that the pc address that indicates a trace exit never +// winds up in a defined symbol range. +// +// The only other complexity in this system is handling the SymbolNumber +// table. This table is kept in parallel by the kernel and the +// debugger. When the PC exits a known symbol range, the Begin and End +// symbol ranges are set by the debugger and are allocated to the next +// symbol slot upon return. "The next symbol slot" means the numerical +// next slot number, unless we've filled all slots, in which case it is +// #0. (ie., allocation is cyclic and not LRU or something). The +// SymbolNumber table is flushed when a SpecialCalls call is made (ie., +// at the beginning of the WatchTrace). +// + +typedef union _DBGKD_TRACE_DATA { + struct { + BYTE SymbolNumber; + CHAR LevelChange; + WORD Instructions; + } s; + DWORD LongNumber; +} DBGKD_TRACE_DATA, *PDBGKD_TRACE_DATA; + +#define TRACE_DATA_INSTRUCTIONS_BIG 0xffff + +#define TRACE_DATA_BUFFER_MAX_SIZE 40 + +// +// If the packet type is PACKET_TYPE_KD_DEBUG_IO, then +// the format of the packet data is as follows: +// + +#define DbgKdPrintStringApi 0x00003230L +#define DbgKdGetStringApi 0x00003231L + +// +// For print string, the Null terminated string to print +// immediately follows the message +// +typedef struct _DBGKD_PRINT_STRING { + DWORD LengthOfString; +} DBGKD_PRINT_STRING, *PDBGKD_PRINT_STRING; + +// +// For get string, the Null terminated promt string +// immediately follows the message. The LengthOfStringRead +// field initially contains the maximum number of characters +// to read. Upon reply, this contains the number of bytes actually +// read. The data read immediately follows the message. +// +// +typedef struct _DBGKD_GET_STRING { + DWORD LengthOfPromptString; + DWORD LengthOfStringRead; +} DBGKD_GET_STRING, *PDBGKD_GET_STRING; + +typedef struct _DBGKD_DEBUG_IO { + DWORD ApiNumber; + WORD ProcessorLevel; + WORD Processor; + union { + DBGKD_PRINT_STRING PrintString; + DBGKD_GET_STRING GetString; + } u; +} DBGKD_DEBUG_IO, *PDBGKD_DEBUG_IO; + + +VOID +NTAPI +DbgKdSendBreakIn( + VOID + ); + +PBYTE +NTAPI +DbgKdGets( + PBYTE Buffer, + WORD Length + ); + +DWORD +NTAPI +DbgKdWaitStateChange( + OUT PDBGKD_WAIT_STATE_CHANGE StateChange, + OUT PVOID Buffer, + IN DWORD BufferLength + ); + +DWORD +NTAPI +DbgKdContinue ( + IN DWORD ContinueStatus + ); + +DWORD +NTAPI +DbgKdContinue2 ( + IN DWORD ContinueStatus, + IN DBGKD_CONTROL_SET ControlSet + ); + +DWORD +NTAPI +DbgKdReadVirtualMemory( + IN PVOID TargetBaseAddress, + OUT PVOID UserInterfaceBuffer, + IN DWORD TransferCount, + OUT PDWORD ActualBytesRead OPTIONAL + ); + +DWORD +NTAPI +DbgKdWriteVirtualMemory( + IN PVOID TargetBaseAddress, + OUT PVOID UserInterfaceBuffer, + IN DWORD TransferCount, + OUT PDWORD ActualBytesWritten OPTIONAL + ); + +DWORD +NTAPI +DbgKdReadPhysicalMemory( + IN PHYSICAL_ADDRESS TargetBaseAddress, + OUT PVOID UserInterfaceBuffer, + IN DWORD TransferCount, + OUT PDWORD ActualBytesRead OPTIONAL + ); + +DWORD +NTAPI +DbgKdWritePhysicalMemory( + IN PHYSICAL_ADDRESS TargetBaseAddress, + OUT PVOID UserInterfaceBuffer, + IN DWORD TransferCount, + OUT PDWORD ActualBytesWritten OPTIONAL + ); + +DWORD +NTAPI +DbgKdReadControlSpace( + IN WORD Processor, + IN PVOID TargetBaseAddress, + OUT PVOID UserInterfaceBuffer, + IN DWORD TransferCount, + OUT PDWORD ActualBytesRead OPTIONAL + ); + +DWORD +NTAPI +DbgKdWriteControlSpace( + IN WORD Processor, + IN PVOID TargetBaseAddress, + OUT PVOID UserInterfaceBuffer, + IN DWORD TransferCount, + OUT PDWORD ActualBytesWritten OPTIONAL + ); + +DWORD +NTAPI +DbgKdReadIoSpace( + IN PVOID IoAddress, + OUT PVOID ReturnedData, + IN DWORD DataSize + ); + +DWORD +NTAPI +DbgKdWriteIoSpace( + IN PVOID IoAddress, + IN DWORD DataValue, + IN DWORD DataSize + ); + +DWORD +NTAPI +DbgKdReadMsr( + IN DWORD MsrReg, + OUT PDWORDLONG MsrValue + ); + +DWORD +NTAPI +DbgKdWriteMsr( + IN DWORD MsrReg, + IN DWORDLONG MsrValue + ); + + +DWORD +NTAPI +DbgKdGetContext( + IN WORD Processor, + IN OUT PCONTEXT Context + ); + +DWORD +NTAPI +DbgKdSetContext( + IN WORD Processor, + IN PCONTEXT Context + ); + +DWORD +NTAPI +DbgKdWriteBreakPoint( + IN PVOID BreakPointAddress, + OUT PDWORD BreakPointHandle + ); + +DWORD +NTAPI +DbgKdRestoreBreakPoint( + IN DWORD BreakPointHandle + ); + +DWORD +NTAPI +DbgKdReboot( + VOID + ); + +#ifdef _X86_ +DWORD +NTAPI +DbgKdLookupSelector( + IN WORD Processor, + IN OUT PDESCRIPTOR_TABLE_ENTRY pDescriptorTableEntry + ); +#endif + +#define DBG_EXCEPTION_HANDLED ((DWORD )0x00010001L) + +#endif // _WINDBGKD_ + |