开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
WDbgExts.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：62k
源码类别：

模拟服务器

开发平台：

C/C++

WDbgExts.h：源码内容
  1. /*++
  3. Copyright (c) Microsoft Corporation. All rights reserved.
  5. Module Name:
  7.     wdbgexts.h
  9. Abstract:
  11.     This file contains the necessary prototypes and data types for a user
  12.     to write a debugger extension DLL.  This header file is also included
  13.     by the NT debuggers (WINDBG & KD).
  15.     This header file must be included after "windows.h" and "dbghelp.h".
  17.     Please see the NT DDK documentation for specific information about
  18.     how to write your own debugger extension DLL.
  20. Environment:
  22.     Win32 only.
  24. Revision History:
  26. --*/
  28. #ifndef _WDBGEXTS_
  29. #define _WDBGEXTS_
  31. #if _MSC_VER > 1000
  32. #pragma once
  33. #endif
  35. #ifdef __cplusplus
  36. extern "C" {
  37. #endif
  39. #if !defined(WDBGAPI)
  40. #define WDBGAPI __stdcall
  41. #endif
  43. #if !defined(WDBGAPIV)
  44. #define WDBGAPIV __cdecl
  45. #endif
  47. #ifndef _WINDEF_
  48. typedef CONST void *LPCVOID;
  49. #endif
  51. #ifndef _ULONGLONG_
  52. typedef unsigned __int64 ULONGLONG;
  53. typedef ULONGLONG *PULONGLONG;
  54. #endif
  57. typedef
  58. VOID
  59. (WDBGAPIV*PWINDBG_OUTPUT_ROUTINE)(
  60.     PCSTR lpFormat,
  61.     ...
  62.     );
  64. typedef
  65. ULONG_PTR
  66. (WDBGAPI*PWINDBG_GET_EXPRESSION)(
  67.     PCSTR lpExpression
  68.     );
  70. typedef
  71. ULONG
  72. (WDBGAPI*PWINDBG_GET_EXPRESSION32)(
  73.     PCSTR lpExpression
  74.     );
  76. typedef
  77. ULONG64
  78. (WDBGAPI*PWINDBG_GET_EXPRESSION64)(
  79.     PCSTR lpExpression
  80.     );
  82. typedef
  83. VOID
  84. (WDBGAPI*PWINDBG_GET_SYMBOL)(
  85.     PVOID      offset,
  86.     PCHAR      pchBuffer,
  87.     ULONG_PTR *pDisplacement
  88.     );
  90. typedef
  91. VOID
  92. (WDBGAPI*PWINDBG_GET_SYMBOL32)(
  93.     ULONG      offset,
  94.     PCHAR      pchBuffer,
  95.     PULONG     pDisplacement
  96.     );
  98. typedef
  99. VOID
  100. (WDBGAPI*PWINDBG_GET_SYMBOL64)(
  101.     ULONG64    offset,
  102.     PCHAR      pchBuffer,
  103.     PULONG64   pDisplacement
  104.     );
  106. typedef
  107. ULONG
  108. (WDBGAPI*PWINDBG_DISASM)(
  109.     ULONG_PTR *lpOffset,
  110.     PCSTR      lpBuffer,
  111.     ULONG      fShowEffectiveAddress
  112.     );
  114. typedef
  115. ULONG
  116. (WDBGAPI*PWINDBG_DISASM32)(
  117.     ULONG     *lpOffset,
  118.     PCSTR      lpBuffer,
  119.     ULONG      fShowEffectiveAddress
  120.     );
  122. typedef
  123. ULONG
  124. (WDBGAPI*PWINDBG_DISASM64)(
  125.     ULONG64   *lpOffset,
  126.     PCSTR      lpBuffer,
  127.     ULONG      fShowEffectiveAddress
  128.     );
  130. typedef
  131. ULONG
  132. (WDBGAPI*PWINDBG_CHECK_CONTROL_C)(
  133.     VOID
  134.     );
  136. typedef
  137. ULONG
  138. (WDBGAPI*PWINDBG_READ_PROCESS_MEMORY_ROUTINE)(
  139.     ULONG_PTR  offset,
  140.     PVOID      lpBuffer,
  141.     ULONG      cb,
  142.     PULONG     lpcbBytesRead
  143.     );
  145. typedef
  146. ULONG
  147. (WDBGAPI*PWINDBG_READ_PROCESS_MEMORY_ROUTINE32)(
  148.     ULONG      offset,
  149.     PVOID      lpBuffer,
  150.     ULONG      cb,
  151.     PULONG     lpcbBytesRead
  152.     );
  154. typedef
  155. ULONG
  156. (WDBGAPI*PWINDBG_READ_PROCESS_MEMORY_ROUTINE64)(
  157.     ULONG64    offset,
  158.     PVOID      lpBuffer,
  159.     ULONG      cb,
  160.     PULONG     lpcbBytesRead
  161.     );
  163. typedef
  164. ULONG
  165. (WDBGAPI*PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE)(
  166.     ULONG_PTR  offset,
  167.     LPCVOID    lpBuffer,
  168.     ULONG      cb,
  169.     PULONG     lpcbBytesWritten
  170.     );
  172. typedef
  173. ULONG
  174. (WDBGAPI*PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE32)(
  175.     ULONG      offset,
  176.     LPCVOID    lpBuffer,
  177.     ULONG      cb,
  178.     PULONG     lpcbBytesWritten
  179.     );
  181. typedef
  182. ULONG
  183. (WDBGAPI*PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE64)(
  184.     ULONG64    offset,
  185.     LPCVOID    lpBuffer,
  186.     ULONG      cb,
  187.     PULONG     lpcbBytesWritten
  188.     );
  190. typedef
  191. ULONG
  192. (WDBGAPI*PWINDBG_GET_THREAD_CONTEXT_ROUTINE)(
  193.     ULONG       Processor,
  194.     PCONTEXT    lpContext,
  195.     ULONG       cbSizeOfContext
  196.     );
  198. typedef
  199. ULONG
  200. (WDBGAPI*PWINDBG_SET_THREAD_CONTEXT_ROUTINE)(
  201.     ULONG       Processor,
  202.     PCONTEXT    lpContext,
  203.     ULONG       cbSizeOfContext
  204.     );
  206. typedef
  207. ULONG
  208. (WDBGAPI*PWINDBG_IOCTL_ROUTINE)(
  209.     USHORT   IoctlType,
  210.     PVOID    lpvData,
  211.     ULONG    cbSize
  212.     );
  214. typedef
  215. ULONG
  216. (WDBGAPI*PWINDBG_OLDKD_READ_PHYSICAL_MEMORY)(
  217.     ULONGLONG        address,
  218.     PVOID            buffer,
  219.     ULONG            count,
  220.     PULONG           bytesread
  221.     );
  223. typedef
  224. ULONG
  225. (WDBGAPI*PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY)(
  226.     ULONGLONG        address,
  227.     PVOID            buffer,
  228.     ULONG            length,
  229.     PULONG           byteswritten
  230.     );
  233. typedef struct _EXTSTACKTRACE {
  234.     ULONG       FramePointer;
  235.     ULONG       ProgramCounter;
  236.     ULONG       ReturnAddress;
  237.     ULONG       Args[4];
  238. } EXTSTACKTRACE, *PEXTSTACKTRACE;
  240. typedef struct _EXTSTACKTRACE32 {
  241.     ULONG       FramePointer;
  242.     ULONG       ProgramCounter;
  243.     ULONG       ReturnAddress;
  244.     ULONG       Args[4];
  245. } EXTSTACKTRACE32, *PEXTSTACKTRACE32;
  247. typedef struct _EXTSTACKTRACE64 {
  248.     ULONG64     FramePointer;
  249.     ULONG64     ProgramCounter;
  250.     ULONG64     ReturnAddress;
  251.     ULONG64     Args[4];
  252. } EXTSTACKTRACE64, *PEXTSTACKTRACE64;
  255. typedef
  256. ULONG
  257. (*PWINDBG_STACKTRACE_ROUTINE)(
  258.     ULONG             FramePointer,
  259.     ULONG             StackPointer,
  260.     ULONG             ProgramCounter,
  261.     PEXTSTACKTRACE    StackFrames,
  262.     ULONG             Frames
  263.     );
  265. typedef
  266. ULONG
  267. (*PWINDBG_STACKTRACE_ROUTINE32)(
  268.     ULONG             FramePointer,
  269.     ULONG             StackPointer,
  270.     ULONG             ProgramCounter,
  271.     PEXTSTACKTRACE32  StackFrames,
  272.     ULONG             Frames
  273.     );
  275. typedef
  276. ULONG
  277. (*PWINDBG_STACKTRACE_ROUTINE64)(
  278.     ULONG64           FramePointer,
  279.     ULONG64           StackPointer,
  280.     ULONG64           ProgramCounter,
  281.     PEXTSTACKTRACE64  StackFrames,
  282.     ULONG             Frames
  283.     );
  285. typedef struct _WINDBG_EXTENSION_APIS {
  286.     ULONG                                  nSize;
  287.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  288.     PWINDBG_GET_EXPRESSION                 lpGetExpressionRoutine;
  289.     PWINDBG_GET_SYMBOL                     lpGetSymbolRoutine;
  290.     PWINDBG_DISASM                         lpDisasmRoutine;
  291.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  292.     PWINDBG_READ_PROCESS_MEMORY_ROUTINE    lpReadProcessMemoryRoutine;
  293.     PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE   lpWriteProcessMemoryRoutine;
  294.     PWINDBG_GET_THREAD_CONTEXT_ROUTINE     lpGetThreadContextRoutine;
  295.     PWINDBG_SET_THREAD_CONTEXT_ROUTINE     lpSetThreadContextRoutine;
  296.     PWINDBG_IOCTL_ROUTINE                  lpIoctlRoutine;
  297.     PWINDBG_STACKTRACE_ROUTINE             lpStackTraceRoutine;
  298. } WINDBG_EXTENSION_APIS, *PWINDBG_EXTENSION_APIS;
  300. typedef struct _WINDBG_EXTENSION_APIS32 {
  301.     ULONG                                  nSize;
  302.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  303.     PWINDBG_GET_EXPRESSION32               lpGetExpressionRoutine;
  304.     PWINDBG_GET_SYMBOL32                   lpGetSymbolRoutine;
  305.     PWINDBG_DISASM32                       lpDisasmRoutine;
  306.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  307.     PWINDBG_READ_PROCESS_MEMORY_ROUTINE32  lpReadProcessMemoryRoutine;
  308.     PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE32 lpWriteProcessMemoryRoutine;
  309.     PWINDBG_GET_THREAD_CONTEXT_ROUTINE     lpGetThreadContextRoutine;
  310.     PWINDBG_SET_THREAD_CONTEXT_ROUTINE     lpSetThreadContextRoutine;
  311.     PWINDBG_IOCTL_ROUTINE                  lpIoctlRoutine;
  312.     PWINDBG_STACKTRACE_ROUTINE32           lpStackTraceRoutine;
  313. } WINDBG_EXTENSION_APIS32, *PWINDBG_EXTENSION_APIS32;
  315. typedef struct _WINDBG_EXTENSION_APIS64 {
  316.     ULONG                                  nSize;
  317.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  318.     PWINDBG_GET_EXPRESSION64               lpGetExpressionRoutine;
  319.     PWINDBG_GET_SYMBOL64                   lpGetSymbolRoutine;
  320.     PWINDBG_DISASM64                       lpDisasmRoutine;
  321.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  322.     PWINDBG_READ_PROCESS_MEMORY_ROUTINE64  lpReadProcessMemoryRoutine;
  323.     PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE64 lpWriteProcessMemoryRoutine;
  324.     PWINDBG_GET_THREAD_CONTEXT_ROUTINE     lpGetThreadContextRoutine;
  325.     PWINDBG_SET_THREAD_CONTEXT_ROUTINE     lpSetThreadContextRoutine;
  326.     PWINDBG_IOCTL_ROUTINE                  lpIoctlRoutine;
  327.     PWINDBG_STACKTRACE_ROUTINE64           lpStackTraceRoutine;
  328. } WINDBG_EXTENSION_APIS64, *PWINDBG_EXTENSION_APIS64;
  331. typedef struct _WINDBG_OLD_EXTENSION_APIS {
  332.     ULONG                                  nSize;
  333.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  334.     PWINDBG_GET_EXPRESSION                 lpGetExpressionRoutine;
  335.     PWINDBG_GET_SYMBOL                     lpGetSymbolRoutine;
  336.     PWINDBG_DISASM                         lpDisasmRoutine;
  337.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  338. } WINDBG_OLD_EXTENSION_APIS, *PWINDBG_OLD_EXTENSION_APIS;
  340. typedef struct _WINDBG_OLDKD_EXTENSION_APIS {
  341.     ULONG                                  nSize;
  342.     PWINDBG_OUTPUT_ROUTINE                 lpOutputRoutine;
  343.     PWINDBG_GET_EXPRESSION32               lpGetExpressionRoutine;
  344.     PWINDBG_GET_SYMBOL32                   lpGetSymbolRoutine;
  345.     PWINDBG_DISASM32                       lpDisasmRoutine;
  346.     PWINDBG_CHECK_CONTROL_C                lpCheckControlCRoutine;
  347.     PWINDBG_READ_PROCESS_MEMORY_ROUTINE32  lpReadVirtualMemRoutine;
  348.     PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE32 lpWriteVirtualMemRoutine;
  349.     PWINDBG_OLDKD_READ_PHYSICAL_MEMORY     lpReadPhysicalMemRoutine;
  350.     PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY    lpWritePhysicalMemRoutine;
  351. } WINDBG_OLDKD_EXTENSION_APIS, *PWINDBG_OLDKD_EXTENSION_APIS;
  353. typedef
  354. VOID
  355. (WDBGAPI*PWINDBG_OLD_EXTENSION_ROUTINE)(
  356.     ULONG                   dwCurrentPc,
  357.     PWINDBG_EXTENSION_APIS  lpExtensionApis,
  358.     PCSTR                   lpArgumentString
  359.     );
  361. typedef
  362. VOID
  363. (WDBGAPI*PWINDBG_EXTENSION_ROUTINE)(
  364.     HANDLE                  hCurrentProcess,
  365.     HANDLE                  hCurrentThread,
  366.     ULONG                   dwCurrentPc,
  367.     ULONG                   dwProcessor,
  368.     PCSTR                   lpArgumentString
  369.     );
  371. typedef
  372. VOID
  373. (WDBGAPI*PWINDBG_EXTENSION_ROUTINE32)(
  374.     HANDLE                  hCurrentProcess,
  375.     HANDLE                  hCurrentThread,
  376.     ULONG                   dwCurrentPc,
  377.     ULONG                   dwProcessor,
  378.     PCSTR                   lpArgumentString
  379.     );
  381. typedef
  382. VOID
  383. (WDBGAPI*PWINDBG_EXTENSION_ROUTINE64)(
  384.     HANDLE                  hCurrentProcess,
  385.     HANDLE                  hCurrentThread,
  386.     ULONG64                 dwCurrentPc,
  387.     ULONG                   dwProcessor,
  388.     PCSTR                   lpArgumentString
  389.     );
  391. typedef
  392. VOID
  393. (WDBGAPI*PWINDBG_OLDKD_EXTENSION_ROUTINE)(
  394.     ULONG                        dwCurrentPc,
  395.     PWINDBG_OLDKD_EXTENSION_APIS lpExtensionApis,
  396.     PCSTR                        lpArgumentString
  397.     );
  399. typedef
  400. VOID
  401. (WDBGAPI*PWINDBG_EXTENSION_DLL_INIT)(
  402.     PWINDBG_EXTENSION_APIS lpExtensionApis,
  403.     USHORT                 MajorVersion,
  404.     USHORT                 MinorVersion
  405.     );
  407. typedef
  408. VOID
  409. (WDBGAPI*PWINDBG_EXTENSION_DLL_INIT32)(
  410.     PWINDBG_EXTENSION_APIS32 lpExtensionApis,
  411.     USHORT                   MajorVersion,
  412.     USHORT                   MinorVersion
  413.     );
  415. typedef
  416. VOID
  417. (WDBGAPI*PWINDBG_EXTENSION_DLL_INIT64)(
  418.     PWINDBG_EXTENSION_APIS64 lpExtensionApis,
  419.     USHORT                   MajorVersion,
  420.     USHORT                   MinorVersion
  421.     );
  423. typedef
  424. ULONG
  425. (WDBGAPI*PWINDBG_CHECK_VERSION)(
  426.     VOID
  427.     );
  429. #define EXT_API_VERSION_NUMBER   5
  430. #define EXT_API_VERSION_NUMBER32 5
  431. #define EXT_API_VERSION_NUMBER64 6
  433. typedef struct EXT_API_VERSION {
  434.     USHORT  MajorVersion;
  435.     USHORT  MinorVersion;
  436.     USHORT  Revision;
  437.     USHORT  Reserved;
  438. } EXT_API_VERSION, *LPEXT_API_VERSION;
  440. typedef
  441. LPEXT_API_VERSION
  442. (WDBGAPI*PWINDBG_EXTENSION_API_VERSION)(
  443.     VOID
  444.     );
  446. #define IG_KD_CONTEXT                  1
  447. #define IG_READ_CONTROL_SPACE          2
  448. #define IG_WRITE_CONTROL_SPACE         3
  449. #define IG_READ_IO_SPACE               4
  450. #define IG_WRITE_IO_SPACE              5
  451. #define IG_READ_PHYSICAL               6
  452. #define IG_WRITE_PHYSICAL              7
  453. #define IG_READ_IO_SPACE_EX            8
  454. #define IG_WRITE_IO_SPACE_EX           9
  455. #define IG_KSTACK_HELP                10   // obsolete
  456. #define IG_SET_THREAD                 11
  457. #define IG_READ_MSR                   12
  458. #define IG_WRITE_MSR                  13
  459. #define IG_GET_DEBUGGER_DATA          14
  460. #define IG_GET_KERNEL_VERSION         15
  461. #define IG_RELOAD_SYMBOLS             16
  462. #define IG_GET_SET_SYMPATH            17
  463. #define IG_GET_EXCEPTION_RECORD       18
  464. #define IG_IS_PTR64                   19
  465. #define IG_GET_BUS_DATA               20
  466. #define IG_SET_BUS_DATA               21
  467. #define IG_DUMP_SYMBOL_INFO           22
  468. #define IG_LOWMEM_CHECK               23
  469. #define IG_SEARCH_MEMORY              24
  470. #define IG_GET_CURRENT_THREAD         25
  471. #define IG_GET_CURRENT_PROCESS        26
  472. #define IG_GET_TYPE_SIZE              27
  473. #define IG_GET_CURRENT_PROCESS_HANDLE 28
  474. #define IG_GET_INPUT_LINE             29
  475. #define IG_GET_EXPRESSION_EX          30
  476. #define IG_TRANSLATE_VIRTUAL_TO_PHYSICAL 31
  477. #define IG_GET_CACHE_SIZE             32
  478. #define IG_READ_PHYSICAL_WITH_FLAGS   33
  479. #define IG_WRITE_PHYSICAL_WITH_FLAGS  34
  481. #define IG_GET_TEB_ADDRESS           128
  482. #define IG_GET_PEB_ADDRESS           129
  484. typedef struct _PROCESSORINFO {
  485.     USHORT      Processor;                // current processor
  486.     USHORT      NumberProcessors;         // total number of processors
  487. } PROCESSORINFO, *PPROCESSORINFO;
  489. typedef struct _READCONTROLSPACE {
  490.     USHORT      Processor;
  491.     ULONG       Address;
  492.     ULONG       BufLen;
  493.     UCHAR       Buf[1];
  494. } READCONTROLSPACE, *PREADCONTROLSPACE;
  496. typedef struct _READCONTROLSPACE32 {
  497.     USHORT      Processor;
  498.     ULONG       Address;
  499.     ULONG       BufLen;
  500.     UCHAR       Buf[1];
  501. } READCONTROLSPACE32, *PREADCONTROLSPACE32;
  503. typedef struct _READCONTROLSPACE64 {
  504.     USHORT      Processor;
  505.     ULONG64     Address;
  506.     ULONG       BufLen;
  507.     UCHAR       Buf[1];
  508. } READCONTROLSPACE64, *PREADCONTROLSPACE64;
  510. typedef struct _IOSPACE {
  511.     ULONG       Address;
  512.     ULONG       Length;                   // 1, 2, or 4 bytes
  513.     ULONG       Data;
  514. } IOSPACE, *PIOSPACE;
  516. typedef struct _IOSPACE32 {
  517.     ULONG       Address;
  518.     ULONG       Length;                   // 1, 2, or 4 bytes
  519.     ULONG       Data;
  520. } IOSPACE32, *PIOSPACE32;
  522. typedef struct _IOSPACE64 {
  523.     ULONG64     Address;
  524.     ULONG       Length;                   // 1, 2, or 4 bytes
  525.     ULONG       Data;
  526. } IOSPACE64, *PIOSPACE64;
  528. typedef struct _IOSPACE_EX {
  529.     ULONG       Address;
  530.     ULONG       Length;                   // 1, 2, or 4 bytes
  531.     ULONG       Data;
  532.     ULONG       InterfaceType;
  533.     ULONG       BusNumber;
  534.     ULONG       AddressSpace;
  535. } IOSPACE_EX, *PIOSPACE_EX;
  537. typedef struct _IOSPACE_EX32 {
  538.     ULONG       Address;
  539.     ULONG       Length;                   // 1, 2, or 4 bytes
  540.     ULONG       Data;
  541.     ULONG       InterfaceType;
  542.     ULONG       BusNumber;
  543.     ULONG       AddressSpace;
  544. } IOSPACE_EX32, *PIOSPACE_EX32;
  546. typedef struct _IOSPACE_EX64 {
  547.     ULONG64     Address;
  548.     ULONG       Length;                   // 1, 2, or 4 bytes
  549.     ULONG       Data;
  550.     ULONG       InterfaceType;
  551.     ULONG       BusNumber;
  552.     ULONG       AddressSpace;
  553. } IOSPACE_EX64, *PIOSPACE_EX64;
  555. typedef struct _GETSETBUSDATA {
  556.     ULONG       BusDataType;
  557.     ULONG       BusNumber;
  558.     ULONG       SlotNumber;
  559.     PVOID       Buffer;
  560.     ULONG       Offset;
  561.     ULONG       Length;
  562. } BUSDATA, *PBUSDATA;
  564. typedef struct _SEARCHMEMORY {
  565.     ULONG64 SearchAddress;
  566.     ULONG64 SearchLength;
  567.     ULONG64 FoundAddress;
  568.     ULONG   PatternLength;
  569.     PVOID   Pattern;
  570. } SEARCHMEMORY, *PSEARCHMEMORY;
  572. typedef struct _PHYSICAL {
  573.     ULONGLONG              Address;
  574.     ULONG                  BufLen;
  575.     UCHAR                  Buf[1];
  576. } PHYSICAL, *PPHYSICAL;
  578. #define PHYS_FLAG_DEFAULT        0
  579. #define PHYS_FLAG_CACHED         1
  580. #define PHYS_FLAG_UNCACHED       2
  581. #define PHYS_FLAG_WRITE_COMBINED 3
  583. typedef struct _PHYSICAL_WITH_FLAGS {
  584.     ULONGLONG              Address;
  585.     ULONG                  BufLen;
  586.     ULONG                  Flags;
  587.     UCHAR                  Buf[1];
  588. } PHYSICAL_WITH_FLAGS, *PPHYSICAL_WITH_FLAGS;
  590. typedef struct _READ_WRITE_MSR {
  591.     ULONG       Msr;
  592.     LONGLONG    Value;
  593. } READ_WRITE_MSR, *PREAD_WRITE_MSR;
  595. typedef struct _GET_SET_SYMPATH {
  596.     PCSTR       Args;       // args to !reload command
  597.     PSTR        Result;     // returns new path
  598.     int         Length;     // Length of result buffer
  599. } GET_SET_SYMPATH, *PGET_SET_SYMPATH;
  601. typedef struct _GET_TEB_ADDRESS {
  602.     ULONGLONG   Address;
  603. } GET_TEB_ADDRESS, *PGET_TEB_ADDRESS;
  605. typedef struct _GET_PEB_ADDRESS {
  606.     ULONG64     CurrentThread;
  607.     ULONGLONG   Address;
  608. } GET_PEB_ADDRESS, *PGET_PEB_ADDRESS;
  610. typedef struct _GET_CURRENT_THREAD_ADDRESS {
  611.     ULONG       Processor;
  612.     ULONG64     Address;
  613. } GET_CURRENT_THREAD_ADDRESS, *PGET_CURRENT_THREAD_ADDRESS;
  615. typedef struct _GET_CURRENT_PROCESS_ADDRESS {
  616.     ULONG       Processor;
  617.     ULONG64     CurrentThread;
  618.     ULONG64     Address;
  619. } GET_CURRENT_PROCESS_ADDRESS, *PGET_CURRENT_PROCESS_ADDRESS;
  621. typedef struct _GET_INPUT_LINE {
  622.     PCSTR       Prompt;
  623.     PSTR        Buffer;
  624.     ULONG       BufferSize;
  625.     ULONG       InputSize;
  626. } GET_INPUT_LINE, *PGET_INPUT_LINE;
  628. typedef struct _GET_EXPRESSION_EX {
  629.     PCSTR       Expression;
  630.     PCSTR       Remainder;
  631.     ULONG64     Value;
  632. } GET_EXPRESSION_EX, *PGET_EXPRESSION_EX;
  634. typedef struct _TRANSLATE_VIRTUAL_TO_PHYSICAL {
  635.     ULONG64     Virtual;
  636.     ULONG64     Physical;
  637. } TRANSLATE_VIRTUAL_TO_PHYSICAL, *PTRANSLATE_VIRTUAL_TO_PHYSICAL;
  639. //
  640. // If DBGKD_VERS_FLAG_DATA is set in Flags, info should be retrieved from
  641. // the KDDEBUGGER_DATA block rather than from the DBGKD_GET_VERSION
  642. // packet.  The data will remain in the version packet for a while to
  643. // reduce compatibility problems.
  644. //
  646. #define DBGKD_VERS_FLAG_MP      0x0001      // kernel is MP built
  647. #define DBGKD_VERS_FLAG_DATA    0x0002      // DebuggerDataList is valid
  648. #define DBGKD_VERS_FLAG_PTR64   0x0004      // native pointers are 64 bits
  649. #define DBGKD_VERS_FLAG_NOMM    0x0008      // No MM - don't decode PTEs
  650. #define DBGKD_VERS_FLAG_HSS     0x0010      // hardware stepping support
  652. #define KDBG_TAG    'GBDK'
  655. // **********************************************************************
  656. // DO NOT CHANGE THESE 32 BIT STRUCTURES!
  657. // ONLY MAKE CHAGES TO THE 64 BIT VERSION BELOW!!
  658. // **********************************************************************
  660. //
  661. // The following structure has changed in more than pointer size.
  662. //
  663. // This is the version packet for pre-NT5 Beta 2 systems.
  664. // For now, it is also still used on x86
  665. //
  666. typedef struct _DBGKD_GET_VERSION32 {
  667.     USHORT  MajorVersion;
  668.     USHORT  MinorVersion;
  669.     USHORT  ProtocolVersion;
  670.     USHORT  Flags;
  671.     ULONG   KernBase;
  672.     ULONG   PsLoadedModuleList;
  674.     USHORT  MachineType;
  676.     //
  677.     // help for walking stacks with user callbacks:
  678.     //
  680.     //
  681.     // The address of the thread structure is provided in the
  682.     // WAIT_STATE_CHANGE packet.  This is the offset from the base of
  683.     // the thread structure to the pointer to the kernel stack frame
  684.     // for the currently active usermode callback.
  685.     //
  687.     USHORT  ThCallbackStack;            // offset in thread data
  689.     //
  690.     // these values are offsets into that frame:
  691.     //
  693.     USHORT  NextCallback;               // saved pointer to next callback frame
  694.     USHORT  FramePointer;               // saved frame pointer
  696.     //
  697.     // Address of the kernel callout routine.
  698.     //
  700.     ULONG   KiCallUserMode;             // kernel routine
  702.     //
  703.     // Address of the usermode entry point for callbacks.
  704.     //
  706.     ULONG   KeUserCallbackDispatcher;   // address in ntdll
  708.     //
  709.     // DbgBreakPointWithStatus is a function which takes a ULONG argument
  710.     // and hits a breakpoint.  This field contains the address of the
  711.     // breakpoint instruction.  When the debugger sees a breakpoint
  712.     // at this address, it may retrieve the argument from the first
  713.     // argument register, or on x86 the eax register.
  714.     //
  716.     ULONG   BreakpointWithStatus;       // address of breakpoint
  718.     //
  719.     // Components may register a debug data block for use by
  720.     // debugger extensions.  This is the address of the list head.
  721.     //
  723.     ULONG   DebuggerDataList;
  725. } DBGKD_GET_VERSION32, *PDBGKD_GET_VERSION32;
  728. //
  729. // This is the debugger data packet for pre NT5 Beta 2 systems.
  730. // For now, it is still used on x86
  731. //
  733. typedef struct _DBGKD_DEBUG_DATA_HEADER32 {
  735.     LIST_ENTRY32 List;
  736.     ULONG           OwnerTag;
  737.     ULONG           Size;
  739. } DBGKD_DEBUG_DATA_HEADER32, *PDBGKD_DEBUG_DATA_HEADER32;
  741. typedef struct _KDDEBUGGER_DATA32 {
  743.     DBGKD_DEBUG_DATA_HEADER32 Header;
  744.     ULONG   KernBase;
  745.     ULONG   BreakpointWithStatus;       // address of breakpoint
  746.     ULONG   SavedContext;
  747.     USHORT  ThCallbackStack;            // offset in thread data
  748.     USHORT  NextCallback;               // saved pointer to next callback frame
  749.     USHORT  FramePointer;               // saved frame pointer
  750.     USHORT  PaeEnabled:1;
  751.     ULONG   KiCallUserMode;             // kernel routine
  752.     ULONG   KeUserCallbackDispatcher;   // address in ntdll
  754.     ULONG   PsLoadedModuleList;
  755.     ULONG   PsActiveProcessHead;
  756.     ULONG   PspCidTable;
  758.     ULONG   ExpSystemResourcesList;
  759.     ULONG   ExpPagedPoolDescriptor;
  760.     ULONG   ExpNumberOfPagedPools;
  762.     ULONG   KeTimeIncrement;
  763.     ULONG   KeBugCheckCallbackListHead;
  764.     ULONG   KiBugcheckData;
  766.     ULONG   IopErrorLogListHead;
  768.     ULONG   ObpRootDirectoryObject;
  769.     ULONG   ObpTypeObjectType;
  771.     ULONG   MmSystemCacheStart;
  772.     ULONG   MmSystemCacheEnd;
  773.     ULONG   MmSystemCacheWs;
  775.     ULONG   MmPfnDatabase;
  776.     ULONG   MmSystemPtesStart;
  777.     ULONG   MmSystemPtesEnd;
  778.     ULONG   MmSubsectionBase;
  779.     ULONG   MmNumberOfPagingFiles;
  781.     ULONG   MmLowestPhysicalPage;
  782.     ULONG   MmHighestPhysicalPage;
  783.     ULONG   MmNumberOfPhysicalPages;
  785.     ULONG   MmMaximumNonPagedPoolInBytes;
  786.     ULONG   MmNonPagedSystemStart;
  787.     ULONG   MmNonPagedPoolStart;
  788.     ULONG   MmNonPagedPoolEnd;
  790.     ULONG   MmPagedPoolStart;
  791.     ULONG   MmPagedPoolEnd;
  792.     ULONG   MmPagedPoolInformation;
  793.     ULONG   MmPageSize;
  795.     ULONG   MmSizeOfPagedPoolInBytes;
  797.     ULONG   MmTotalCommitLimit;
  798.     ULONG   MmTotalCommittedPages;
  799.     ULONG   MmSharedCommit;
  800.     ULONG   MmDriverCommit;
  801.     ULONG   MmProcessCommit;
  802.     ULONG   MmPagedPoolCommit;
  803.     ULONG   MmExtendedCommit;
  805.     ULONG   MmZeroedPageListHead;
  806.     ULONG   MmFreePageListHead;
  807.     ULONG   MmStandbyPageListHead;
  808.     ULONG   MmModifiedPageListHead;
  809.     ULONG   MmModifiedNoWritePageListHead;
  810.     ULONG   MmAvailablePages;
  811.     ULONG   MmResidentAvailablePages;
  813.     ULONG   PoolTrackTable;
  814.     ULONG   NonPagedPoolDescriptor;
  816.     ULONG   MmHighestUserAddress;
  817.     ULONG   MmSystemRangeStart;
  818.     ULONG   MmUserProbeAddress;
  820.     ULONG   KdPrintCircularBuffer;
  821.     ULONG   KdPrintCircularBufferEnd;
  822.     ULONG   KdPrintWritePointer;
  823.     ULONG   KdPrintRolloverCount;
  825.     ULONG   MmLoadedUserImageList;
  827. } KDDEBUGGER_DATA32, *PKDDEBUGGER_DATA32;
  829. // **********************************************************************
  830. //
  831. // DO NOT CHANGE KDDEBUGGER_DATA32!!
  832. // ONLY MAKE CHANGES TO KDDEBUGGER_DATA64!!!
  833. //
  834. // **********************************************************************
  837. enum
  838. {
  839.     DBGKD_SIMULATION_NONE,
  840.     DBGKD_SIMULATION_EXDI
  841. };
  843. typedef struct _DBGKD_GET_VERSION64 {
  844.     USHORT  MajorVersion;
  845.     USHORT  MinorVersion;
  846.     USHORT  ProtocolVersion;
  847.     USHORT  Flags;
  848.     USHORT  MachineType;
  850.     //
  851.     // Protocol command support descriptions.
  852.     // These allow the debugger to automatically
  853.     // adapt to different levels of command support
  854.     // in different kernels.
  855.     //
  857.     // One beyond highest packet type understood, zero based.
  858.     UCHAR   MaxPacketType;
  859.     // One beyond highest state change understood, zero based.
  860.     UCHAR   MaxStateChange;
  861.     // One beyond highest state manipulate message understood, zero based.
  862.     UCHAR   MaxManipulate;
  864.     // Kind of execution environment the kernel is running in,
  865.     // such as a real machine or a simulator.  Written back
  866.     // by the simulation if one exists.
  867.     UCHAR   Simulation;
  869.     USHORT  Unused[1];
  871.     ULONG64 KernBase;
  872.     ULONG64 PsLoadedModuleList;
  874.     //
  875.     // Components may register a debug data block for use by
  876.     // debugger extensions.  This is the address of the list head.
  877.     //
  878.     // There will always be an entry for the debugger.
  879.     //
  881.     ULONG64 DebuggerDataList;
  883. } DBGKD_GET_VERSION64, *PDBGKD_GET_VERSION64;
  886. //
  887. // This structure is used by the debugger for all targets
  888. // It is the same size as DBGKD_DATA_HEADER on all systems
  889. //
  890. typedef struct _DBGKD_DEBUG_DATA_HEADER64 {
  892.     //
  893.     // Link to other blocks
  894.     //
  896.     LIST_ENTRY64 List;
  898.     //
  899.     // This is a unique tag to identify the owner of the block.
  900.     // If your component only uses one pool tag, use it for this, too.
  901.     //
  903.     ULONG           OwnerTag;
  905.     //
  906.     // This must be initialized to the size of the data block,
  907.     // including this structure.
  908.     //
  910.     ULONG           Size;
  912. } DBGKD_DEBUG_DATA_HEADER64, *PDBGKD_DEBUG_DATA_HEADER64;
  915. //
  916. // This structure is the same size on all systems.  The only field
  917. // which must be translated by the debugger is Header.List.
  918. //
  920. //
  921. // DO NOT ADD OR REMOVE FIELDS FROM THE MIDDLE OF THIS STRUCTURE!!!
  922. //
  923. // If you remove a field, replace it with an "unused" placeholder.
  924. // Do not reuse fields until there has been enough time for old debuggers
  925. // and extensions to age out.
  926. //
  927. typedef struct _KDDEBUGGER_DATA64 {
  929.     DBGKD_DEBUG_DATA_HEADER64 Header;
  931.     //
  932.     // Base address of kernel image
  933.     //
  935.     ULONG64   KernBase;
  937.     //
  938.     // DbgBreakPointWithStatus is a function which takes an argument
  939.     // and hits a breakpoint.  This field contains the address of the
  940.     // breakpoint instruction.  When the debugger sees a breakpoint
  941.     // at this address, it may retrieve the argument from the first
  942.     // argument register, or on x86 the eax register.
  943.     //
  945.     ULONG64   BreakpointWithStatus;       // address of breakpoint
  947.     //
  948.     // Address of the saved context record during a bugcheck
  949.     //
  950.     // N.B. This is an automatic in KeBugcheckEx's frame, and
  951.     // is only valid after a bugcheck.
  952.     //
  954.     ULONG64   SavedContext;
  956.     //
  957.     // help for walking stacks with user callbacks:
  958.     //
  960.     //
  961.     // The address of the thread structure is provided in the
  962.     // WAIT_STATE_CHANGE packet.  This is the offset from the base of
  963.     // the thread structure to the pointer to the kernel stack frame
  964.     // for the currently active usermode callback.
  965.     //
  967.     USHORT  ThCallbackStack;            // offset in thread data
  969.     //
  970.     // these values are offsets into that frame:
  971.     //
  973.     USHORT  NextCallback;               // saved pointer to next callback frame
  974.     USHORT  FramePointer;               // saved frame pointer
  976.     //
  977.     // pad to a quad boundary
  978.     //
  979.     USHORT  PaeEnabled:1;
  981.     //
  982.     // Address of the kernel callout routine.
  983.     //
  985.     ULONG64   KiCallUserMode;             // kernel routine
  987.     //
  988.     // Address of the usermode entry point for callbacks.
  989.     //
  991.     ULONG64   KeUserCallbackDispatcher;   // address in ntdll
  994.     //
  995.     // Addresses of various kernel data structures and lists
  996.     // that are of interest to the kernel debugger.
  997.     //
  999.     ULONG64   PsLoadedModuleList;
  1000.     ULONG64   PsActiveProcessHead;
  1001.     ULONG64   PspCidTable;
  1003.     ULONG64   ExpSystemResourcesList;
  1004.     ULONG64   ExpPagedPoolDescriptor;
  1005.     ULONG64   ExpNumberOfPagedPools;
  1007.     ULONG64   KeTimeIncrement;
  1008.     ULONG64   KeBugCheckCallbackListHead;
  1009.     ULONG64   KiBugcheckData;
  1011.     ULONG64   IopErrorLogListHead;
  1013.     ULONG64   ObpRootDirectoryObject;
  1014.     ULONG64   ObpTypeObjectType;
  1016.     ULONG64   MmSystemCacheStart;
  1017.     ULONG64   MmSystemCacheEnd;
  1018.     ULONG64   MmSystemCacheWs;
  1020.     ULONG64   MmPfnDatabase;
  1021.     ULONG64   MmSystemPtesStart;
  1022.     ULONG64   MmSystemPtesEnd;
  1023.     ULONG64   MmSubsectionBase;
  1024.     ULONG64   MmNumberOfPagingFiles;
  1026.     ULONG64   MmLowestPhysicalPage;
  1027.     ULONG64   MmHighestPhysicalPage;
  1028.     ULONG64   MmNumberOfPhysicalPages;
  1030.     ULONG64   MmMaximumNonPagedPoolInBytes;
  1031.     ULONG64   MmNonPagedSystemStart;
  1032.     ULONG64   MmNonPagedPoolStart;
  1033.     ULONG64   MmNonPagedPoolEnd;
  1035.     ULONG64   MmPagedPoolStart;
  1036.     ULONG64   MmPagedPoolEnd;
  1037.     ULONG64   MmPagedPoolInformation;
  1038.     ULONG64   MmPageSize;
  1040.     ULONG64   MmSizeOfPagedPoolInBytes;
  1042.     ULONG64   MmTotalCommitLimit;
  1043.     ULONG64   MmTotalCommittedPages;
  1044.     ULONG64   MmSharedCommit;
  1045.     ULONG64   MmDriverCommit;
  1046.     ULONG64   MmProcessCommit;
  1047.     ULONG64   MmPagedPoolCommit;
  1048.     ULONG64   MmExtendedCommit;
  1050.     ULONG64   MmZeroedPageListHead;
  1051.     ULONG64   MmFreePageListHead;
  1052.     ULONG64   MmStandbyPageListHead;
  1053.     ULONG64   MmModifiedPageListHead;
  1054.     ULONG64   MmModifiedNoWritePageListHead;
  1055.     ULONG64   MmAvailablePages;
  1056.     ULONG64   MmResidentAvailablePages;
  1058.     ULONG64   PoolTrackTable;
  1059.     ULONG64   NonPagedPoolDescriptor;
  1061.     ULONG64   MmHighestUserAddress;
  1062.     ULONG64   MmSystemRangeStart;
  1063.     ULONG64   MmUserProbeAddress;
  1065.     ULONG64   KdPrintCircularBuffer;
  1066.     ULONG64   KdPrintCircularBufferEnd;
  1067.     ULONG64   KdPrintWritePointer;
  1068.     ULONG64   KdPrintRolloverCount;
  1070.     ULONG64   MmLoadedUserImageList;
  1072.     // NT 5.1 Addition
  1074.     ULONG64   NtBuildLab;
  1075.     ULONG64   KiNormalSystemCall;
  1077.     // NT 5.0 QFE addition
  1079.     ULONG64   KiProcessorBlock;
  1080.     ULONG64   MmUnloadedDrivers;
  1081.     ULONG64   MmLastUnloadedDriver;
  1082.     ULONG64   MmTriageActionTaken;
  1083.     ULONG64   MmSpecialPoolTag;
  1084.     ULONG64   KernelVerifier;
  1085.     ULONG64   MmVerifierData;
  1086.     ULONG64   MmAllocatedNonPagedPool;
  1087.     ULONG64   MmPeakCommitment;
  1088.     ULONG64   MmTotalCommitLimitMaximum;
  1089.     ULONG64   CmNtCSDVersion;
  1091.     // NT 5.1 Addition
  1093.     ULONG64   MmPhysicalMemoryBlock;
  1094.     ULONG64   MmSessionBase;
  1095.     ULONG64   MmSessionSize;
  1096.     ULONG64   MmSystemParentTablePage;
  1098. } KDDEBUGGER_DATA64, *PKDDEBUGGER_DATA64;
  1102. /************************************
  1104.    Type Dump Ioctl
  1106. *************************************/
  1109. //
  1110. // Fields are not indented if this is set
  1111. //
  1112. #define DBG_DUMP_NO_INDENT                0x00000001
  1113. //
  1114. // Offsets are not printed if this is set
  1115. //
  1116. #define DBG_DUMP_NO_OFFSET                0x00000002
  1117. //
  1118. // Verbose output
  1119. //
  1120. #define DBG_DUMP_VERBOSE                  0x00000004
  1121. //
  1122. // Callback is done for each of fields
  1123. //
  1124. #define DBG_DUMP_CALL_FOR_EACH            0x00000008
  1125. //
  1126. // A list of type is dumped, listLink should have info about next element pointer
  1127. //
  1128. #define DBG_DUMP_LIST                     0x00000020
  1129. //
  1130. // Nothing is printed if this is set (only callbacks and data copies done)
  1131. //
  1132. #define DBG_DUMP_NO_PRINT                 0x00000040
  1133. //
  1134. // Ioctl returns the size as usual, but will not do field prints/callbacks if this is set
  1135. //
  1136. #define DBG_DUMP_GET_SIZE_ONLY            0x00000080
  1137. //
  1138. // Specifies how much deep into structs we can go
  1139. //
  1140. #define DBG_DUMP_RECUR_LEVEL(l)           ((l & 0xf) << 8)
  1141. //
  1142. // No newlines are printed after each field
  1143. //
  1144. #define DBG_DUMP_COMPACT_OUT              0x00002000
  1145. //
  1146. // An array of type is dumped, number of elements can be specified in listLink->size
  1147. //
  1148. #define DBG_DUMP_ARRAY                    0x00008000
  1149. //
  1150. // The specified addr value is actually the address of field listLink->fName
  1151. //
  1152. #define DBG_DUMP_ADDRESS_OF_FIELD         0x00010000
  1154. //
  1155. // The specified addr value is actually the adress at the end of type
  1156. //
  1157. #define DBG_DUMP_ADDRESS_AT_END           0x00020000
  1159. //
  1160. // This could be used to copy only the primitive types like ULONG, PVOID etc.
  1161. //    - will not work with structures/unions
  1162. //
  1163. #define DBG_DUMP_COPY_TYPE_DATA           0x00040000
  1164. //
  1165. // Flag to allow read directly from physical memory
  1166. //
  1167. #define DBG_DUMP_READ_PHYSICAL            0x00080000
  1168. //
  1169. // This causes a function type to be dumped in format function(arg1, arg2, ...)
  1170. //
  1171. #define DBG_DUMP_FUNCTION_FORMAT          0x00100000
  1172. //
  1173. // This recurses on a struct but doesn't expand pointers
  1174. //
  1175. #define DBG_DUMP_BLOCK_RECURSE            0x00200000
  1177. //
  1178. // Obsolete defs
  1179. //
  1180. #define DBG_RETURN_TYPE                   0
  1181. #define DBG_RETURN_SUBTYPES               0
  1182. #define DBG_RETURN_TYPE_VALUES            0
  1184. //
  1185. // Dump and callback optons for fields - Options used in FIELD_INFO.fOptions
  1186. //
  1188. //
  1189. // Callback is done before printing the field if this is set
  1190. //
  1191. #define DBG_DUMP_FIELD_CALL_BEFORE_PRINT  0x00000001
  1192. //
  1193. // No callback is done
  1194. //
  1195. #define DBG_DUMP_FIELD_NO_CALLBACK_REQ    0x00000002
  1196. //
  1197. // Subfields of the fields are processesed
  1198. //
  1199. #define DBG_DUMP_FIELD_RECUR_ON_THIS      0x00000004
  1200. //
  1201. // fName must match completely for the field to be dumped instead just a prefix
  1202. //  match by default
  1203. //
  1204. #define DBG_DUMP_FIELD_FULL_NAME          0x00000008
  1205. //
  1206. // This causes array elements of an array field to be printed
  1207. //
  1208. #define DBG_DUMP_FIELD_ARRAY              0x00000010
  1209. //
  1210. // The data of the field is copied into fieldCallBack
  1211. //
  1212. #define DBG_DUMP_FIELD_COPY_FIELD_DATA    0x00000020
  1213. //
  1214. // In callback or when Ioctl returns, the FIELD_INFO.address has the address of field.
  1215. //  If no address is supplied for the type, it contains total offset of the field.
  1216. //
  1217. #define DBG_DUMP_FIELD_RETURN_ADDRESS     0x00001000
  1218. //
  1219. // Return the offset and size in bits instead of bytes is case of Bitfield
  1220. //
  1221. #define DBG_DUMP_FIELD_SIZE_IN_BITS       0x00002000
  1222. //
  1223. // Nothing is printed  for field if this is set (only callbacks and data copies done)
  1224. //
  1225. #define DBG_DUMP_FIELD_NO_PRINT           0x00004000
  1226. //
  1227. // If the field is a pointer, it is dumped as a string, ANSI, WCHAR, MULTI or GUID
  1228. // depending on following options
  1229. //
  1230. #define DBG_DUMP_FIELD_DEFAULT_STRING     0x00010000
  1231. #define DBG_DUMP_FIELD_WCHAR_STRING       0x00020000
  1232. #define DBG_DUMP_FIELD_MULTI_STRING       0x00040000
  1233. #define DBG_DUMP_FIELD_GUID_STRING        0x00080000
  1236. //
  1237. // Error status returned on TYPE DUMP Ioctl failure
  1238. //
  1239. #define MEMORY_READ_ERROR            0x01
  1240. #define SYMBOL_TYPE_INDEX_NOT_FOUND  0x02
  1241. #define SYMBOL_TYPE_INFO_NOT_FOUND   0x03
  1242. #define FIELDS_DID_NOT_MATCH         0x04
  1243. #define NULL_SYM_DUMP_PARAM          0x05
  1244. #define NULL_FIELD_NAME              0x06
  1245. #define INCORRECT_VERSION_INFO       0x07
  1246. #define EXIT_ON_CONTROLC             0x08
  1247. #define CANNOT_ALLOCATE_MEMORY       0x09
  1248. #define INSUFFICIENT_SPACE_TO_COPY   0x0a
  1251. //////////////////////////////////////////////////////////////////////////*/
  1253. typedef
  1254. ULONG
  1255. (WDBGAPI*PSYM_DUMP_FIELD_CALLBACK)(
  1256.     struct _FIELD_INFO *pField,
  1257.     PVOID UserContext
  1258.     );
  1260. typedef struct _FIELD_INFO {
  1261.    PUCHAR  fName;          // Name of the field
  1262.    PUCHAR  printName;      // Name to be printed at dump
  1263.    ULONG   size;           // Size of the field
  1264.    ULONG   fOptions;       // Dump Options for the field
  1265.    ULONG64 address;        // address of the field
  1266.    PVOID   fieldCallBack;  // Return info or callBack routine for the field
  1267. } FIELD_INFO, *PFIELD_INFO;
  1269. typedef struct _SYM_DUMP_PARAM {
  1270.    ULONG               size;          // size of this struct
  1271.    PUCHAR              sName;         // type name
  1272.    ULONG               Options;       // Dump options
  1273.    ULONG64             addr;          // Address to take data for type
  1274.    PFIELD_INFO         listLink;      // fName here would be used to do list dump
  1275.    PVOID               Context;       // Usercontext passed to CallbackRoutine
  1276.    PSYM_DUMP_FIELD_CALLBACK CallbackRoutine;
  1277.                                       // Routine called back
  1278.    ULONG               nFields;       // # elements in Fields
  1279.    PFIELD_INFO         Fields;        // Used to return information about field
  1280. } SYM_DUMP_PARAM, *PSYM_DUMP_PARAM;
  1282. #ifdef __cplusplus
  1283. #define CPPMOD extern "C"
  1284. #else
  1285. #define CPPMOD
  1286. #endif
  1289. #ifndef NOEXTAPI
  1291. #if   defined(KDEXT_64BIT)
  1292. #define WINDBG_EXTENSION_APIS WINDBG_EXTENSION_APIS64
  1293. #define PWINDBG_EXTENSION_APIS PWINDBG_EXTENSION_APIS64
  1294. #define DECLARE_API(s) DECLARE_API64(s)
  1295. #elif defined(KDEXT_32BIT)
  1296. #define WINDBG_EXTENSION_APIS WINDBG_EXTENSION_APIS32
  1297. #define PWINDBG_EXTENSION_APIS PWINDBG_EXTENSION_APIS32
  1298. #define DECLARE_API(s) DECLARE_API32(s)
  1299. #else
  1300. #define DECLARE_API(s)                             
  1301.     CPPMOD VOID                                    
  1302.     s(                                             
  1303.         HANDLE                 hCurrentProcess,    
  1304.         HANDLE                 hCurrentThread,     
  1305.         ULONG                  dwCurrentPc,        
  1306.         ULONG                  dwProcessor,        
  1307.         PCSTR                  args                
  1308.      )
  1309. #endif
  1311. #define DECLARE_API32(s)                           
  1312.     CPPMOD VOID                                    
  1313.     s(                                             
  1314.         HANDLE                 hCurrentProcess,    
  1315.         HANDLE                 hCurrentThread,     
  1316.         ULONG                  dwCurrentPc,        
  1317.         ULONG                  dwProcessor,        
  1318.         PCSTR                  args                
  1319.      )
  1321. #define DECLARE_API64(s)                           
  1322.     CPPMOD VOID                                    
  1323.     s(                                             
  1324.         HANDLE                 hCurrentProcess,    
  1325.         HANDLE                 hCurrentThread,     
  1326.         ULONG64                dwCurrentPc,        
  1327.         ULONG                  dwProcessor,        
  1328.         PCSTR                  args                
  1329.      )
  1332. extern WINDBG_EXTENSION_APIS   ExtensionApis;
  1335. #define dprintf          (ExtensionApis.lpOutputRoutine)
  1336. #define GetExpression    (ExtensionApis.lpGetExpressionRoutine)
  1337. #define CheckControlC    (ExtensionApis.lpCheckControlCRoutine)
  1338. #define GetContext       (ExtensionApis.lpGetThreadContextRoutine)
  1339. #define SetContext       (ExtensionApis.lpSetThreadContextRoutine)
  1340. #define Ioctl            (ExtensionApis.lpIoctlRoutine)
  1341. #define Disasm           (ExtensionApis.lpDisasmRoutine)
  1342. #define GetSymbol        (ExtensionApis.lpGetSymbolRoutine)
  1343. #define ReadMemory       (ExtensionApis.lpReadProcessMemoryRoutine)
  1344. #define WriteMemory      (ExtensionApis.lpWriteProcessMemoryRoutine)
  1345. #define StackTrace       (ExtensionApis.lpStackTraceRoutine)
  1348. #define GetKdContext(ppi) 
  1349.     Ioctl( IG_KD_CONTEXT, (PVOID)ppi, sizeof(*ppi) )
  1352. //
  1353. // BOOL
  1354. // GetDebuggerData(
  1355. //     ULONG Tag,
  1356. //     PVOID Buf,
  1357. //     ULONG Size
  1358. //     )
  1359. //
  1361. #define GetDebuggerData(TAG, BUF, SIZE)                             
  1362.       ( (((PDBGKD_DEBUG_DATA_HEADER64)(BUF))->OwnerTag = (TAG)),      
  1363.         (((PDBGKD_DEBUG_DATA_HEADER64)(BUF))->Size = (SIZE)),         
  1364.         Ioctl( IG_GET_DEBUGGER_DATA, (PVOID)(BUF), (SIZE) ) )
  1366. // Check if LocalAlloc is prototyped
  1367. //#ifdef _WINBASE_
  1369. __inline VOID
  1370. ReadPhysical(
  1371.     ULONG64             address,
  1372.     PVOID               buf,
  1373.     ULONG               size,
  1374.     PULONG              sizer
  1375.     )
  1376. {
  1377.     PPHYSICAL phy;
  1378.     *sizer = 0;
  1379.     phy = (PPHYSICAL)LocalAlloc(LPTR,  sizeof(*phy) + size );
  1380.     if (phy) {
  1381.         ZeroMemory( phy->Buf, size );
  1382.         phy->Address = address;
  1383.         phy->BufLen = size;
  1384.         Ioctl( IG_READ_PHYSICAL, (PVOID)phy, sizeof(*phy) + size );
  1385.         *sizer = phy->BufLen;
  1386.         CopyMemory( buf, phy->Buf, *sizer );
  1387.         LocalFree( phy );
  1388.     }
  1389. }
  1391. __inline VOID
  1392. WritePhysical(
  1393.     ULONG64             address,
  1394.     PVOID               buf,
  1395.     ULONG               size,
  1396.     PULONG              sizew
  1397.     )
  1398. {
  1399.     PPHYSICAL phy;
  1400.     *sizew = 0;
  1401.     phy = (PPHYSICAL)LocalAlloc(LPTR, sizeof(*phy) + size );
  1402.     if (phy) {
  1403.         ZeroMemory( phy->Buf, size );
  1404.         phy->Address = address;
  1405.         phy->BufLen = size;
  1406.         CopyMemory( phy->Buf, buf, size );
  1407.         Ioctl( IG_WRITE_PHYSICAL, (PVOID)phy, sizeof(*phy) + size );
  1408.         *sizew = phy->BufLen;
  1409.         LocalFree( phy );
  1410.     }
  1411. }
  1413. __inline VOID
  1414. ReadPhysicalWithFlags(
  1415.     ULONG64             address,
  1416.     PVOID               buf,
  1417.     ULONG               size,
  1418.     ULONG               flags,
  1419.     PULONG              sizer
  1420.     )
  1421. {
  1422.     PPHYSICAL_WITH_FLAGS phy;
  1423.     *sizer = 0;
  1424.     phy = (PPHYSICAL_WITH_FLAGS)LocalAlloc(LPTR,  sizeof(*phy) + size );
  1425.     if (phy) {
  1426.         ZeroMemory( phy->Buf, size );
  1427.         phy->Address = address;
  1428.         phy->BufLen = size;
  1429.         phy->Flags = flags;
  1430.         Ioctl( IG_READ_PHYSICAL_WITH_FLAGS, (PVOID)phy, sizeof(*phy) + size );
  1431.         *sizer = phy->BufLen;
  1432.         CopyMemory( buf, phy->Buf, *sizer );
  1433.         LocalFree( phy );
  1434.     }
  1435. }
  1437. __inline VOID
  1438. WritePhysicalWithFlags(
  1439.     ULONG64             address,
  1440.     PVOID               buf,
  1441.     ULONG               size,
  1442.     ULONG               flags,
  1443.     PULONG              sizew
  1444.     )
  1445. {
  1446.     PPHYSICAL_WITH_FLAGS phy;
  1447.     *sizew = 0;
  1448.     phy = (PPHYSICAL_WITH_FLAGS)LocalAlloc(LPTR, sizeof(*phy) + size );
  1449.     if (phy) {
  1450.         ZeroMemory( phy->Buf, size );
  1451.         phy->Address = address;
  1452.         phy->BufLen = size;
  1453.         phy->Flags = flags;
  1454.         CopyMemory( phy->Buf, buf, size );
  1455.         Ioctl( IG_WRITE_PHYSICAL_WITH_FLAGS, (PVOID)phy, sizeof(*phy) + size );
  1456.         *sizew = phy->BufLen;
  1457.         LocalFree( phy );
  1458.     }
  1459. }
  1461. __inline VOID
  1462. ReadMsr(
  1463.     ULONG       MsrReg,
  1464.     ULONGLONG   *MsrValue
  1465.     )
  1466. {
  1467.     READ_WRITE_MSR msr;
  1469.     msr.Msr = MsrReg;
  1470.     Ioctl( IG_READ_MSR, (PVOID)&msr, sizeof(msr) );
  1472.     *MsrValue = msr.Value;
  1473. }
  1475. __inline VOID
  1476. WriteMsr(
  1477.     ULONG       MsrReg,
  1478.     ULONGLONG   MsrValue
  1479.     )
  1480. {
  1481.     READ_WRITE_MSR msr;
  1483.     msr.Msr = MsrReg;
  1484.     msr.Value = MsrValue;
  1485.     Ioctl( IG_WRITE_MSR, (PVOID)&msr, sizeof(msr) );
  1486. }
  1488. __inline VOID
  1489. SetThreadForOperation(
  1490.     ULONG_PTR * Thread
  1491.     )
  1492. {
  1493.     Ioctl(IG_SET_THREAD, (PVOID)Thread, sizeof(PULONG));
  1494. }
  1496. __inline VOID
  1497. SetThreadForOperation32(
  1498.     ULONG Thread
  1499.     )
  1500. {
  1501.     Ioctl(IG_SET_THREAD, (PVOID)LongToPtr(Thread), sizeof(ULONG));
  1502. }
  1504. __inline VOID
  1505. SetThreadForOperation64(
  1506.     PULONG64 Thread
  1507.     )
  1508. {
  1509.     Ioctl(IG_SET_THREAD, (PVOID)Thread, sizeof(ULONG64));
  1510. }
  1513. __inline VOID
  1514. ReadControlSpace(
  1515.     USHORT  processor,
  1516.     ULONG   address,
  1517.     PVOID   buf,
  1518.     ULONG   size
  1519.     )
  1520. {
  1521.     PREADCONTROLSPACE prc;
  1522.     prc = (PREADCONTROLSPACE)LocalAlloc(LPTR, sizeof(*prc) + size );
  1523.     if (prc) {
  1524.         ZeroMemory( prc->Buf, size );
  1525.         prc->Processor = processor;
  1526.         prc->Address = address;
  1527.         prc->BufLen = size;
  1528.         Ioctl( IG_READ_CONTROL_SPACE, (PVOID)prc, sizeof(*prc) + size );
  1529.         CopyMemory( buf, prc->Buf, size );
  1530.         LocalFree( prc );
  1531.     }
  1532. }
  1534. __inline VOID
  1535. ReadControlSpace32(
  1536.     USHORT  processor,
  1537.     ULONG   address,
  1538.     PVOID   buf,
  1539.     ULONG   size
  1540.     )
  1541. {
  1542.     PREADCONTROLSPACE32 prc;
  1543.     prc = (PREADCONTROLSPACE32)LocalAlloc(LPTR, sizeof(*prc) + size );
  1544.     if (prc) {
  1545.         ZeroMemory( prc->Buf, size );
  1546.         prc->Processor = processor;
  1547.         prc->Address = address;
  1548.         prc->BufLen = size;
  1549.         Ioctl( IG_READ_CONTROL_SPACE, (PVOID)prc, sizeof(*prc) + size );
  1550.         CopyMemory( buf, prc->Buf, size );
  1551.         LocalFree( prc );
  1552.     }
  1553. }
  1555. #define ReadTypedControlSpace32( _Proc, _Addr, _Buf )  
  1556.      ReadControlSpace64( (USHORT)(_Proc), (ULONG)(_Addr), (PVOID)&(_Buf), (ULONG)sizeof(_Buf) )
  1558. __inline VOID
  1559. ReadControlSpace64(
  1560.     USHORT  processor,
  1561.     ULONG64 address,
  1562.     PVOID   buf,
  1563.     ULONG   size
  1564.     )
  1565. {
  1566.     PREADCONTROLSPACE64 prc;
  1567.     prc = (PREADCONTROLSPACE64)LocalAlloc(LPTR, sizeof(*prc) + size );
  1568.     if (prc) {
  1569.         ZeroMemory( prc->Buf, size );
  1570.         prc->Processor = processor;
  1571.         prc->Address = address;
  1572.         prc->BufLen = size;
  1573.         Ioctl( IG_READ_CONTROL_SPACE, (PVOID)prc, sizeof(*prc) + size );
  1574.         CopyMemory( buf, prc->Buf, size );
  1575.         LocalFree( prc );
  1576.     }
  1577. }
  1579. #define ReadTypedControlSpace64( _Proc, _Addr, _Buf )  
  1580.      ReadControlSpace64( (USHORT)(_Proc), (ULONG64)(_Addr), (PVOID)&(_Buf), (ULONG)sizeof(_Buf) )
  1582. __inline VOID
  1583. WriteControlSpace(
  1584.     USHORT  processor,
  1585.     ULONG   address,
  1586.     PVOID   buf,
  1587.     ULONG   size
  1588.     )
  1589. {
  1590.     PREADCONTROLSPACE64 prc;
  1591.     prc = (PREADCONTROLSPACE64)LocalAlloc(LPTR, sizeof(*prc) + size );
  1592.     if (prc) {
  1593.         ZeroMemory( prc->Buf, size );
  1594.         prc->Processor = processor;
  1595.         prc->Address = address;
  1596.         prc->BufLen = size;
  1597.         CopyMemory( prc->Buf, buf, size );
  1598.         Ioctl( IG_WRITE_CONTROL_SPACE, (PVOID)prc, sizeof(*prc) + size );
  1599.         LocalFree( prc );
  1600.     }
  1601. }
  1603. // #endif //  _WINBASE_
  1605. __inline VOID
  1606. ReadIoSpace(
  1607.     ULONG   address,
  1608.     PULONG  data,
  1609.     PULONG  size
  1610.     )
  1611. {
  1612.     IOSPACE is;
  1613.     is.Address = address;
  1614.     is.Length = *size;
  1615.     Ioctl( IG_READ_IO_SPACE, (PVOID)&is, sizeof(is) );
  1616.     memcpy(data, &is.Data, is.Length);
  1617.     *size = is.Length;
  1618. }
  1620. __inline VOID
  1621. ReadIoSpace32(
  1622.     ULONG   address,
  1623.     PULONG  data,
  1624.     PULONG  size
  1625.     )
  1626. {
  1627.     IOSPACE32 is;
  1628.     is.Address = address;
  1629.     is.Length = *size;
  1630.     Ioctl( IG_READ_IO_SPACE, (PVOID)&is, sizeof(is) );
  1631.     memcpy(data, &is.Data, is.Length);
  1632.     *size = is.Length;
  1633. }
  1635. __inline VOID
  1636. ReadIoSpace64(
  1637.     ULONG64 address,
  1638.     PULONG  data,
  1639.     PULONG  size
  1640.     )
  1641. {
  1642.     IOSPACE64 is;
  1643.     is.Address = address;
  1644.     is.Length = *size;
  1645.     Ioctl( IG_READ_IO_SPACE, (PVOID)&is, sizeof(is) );
  1646.     memcpy(data, &is.Data, is.Length);
  1647.     *size = is.Length;
  1648. }
  1650. __inline VOID
  1651. WriteIoSpace(
  1652.     ULONG   address,
  1653.     ULONG   data,
  1654.     PULONG  size
  1655.     )
  1656. {
  1657.     IOSPACE is;
  1658.     is.Address = (ULONG)address;
  1659.     is.Length = *size;
  1660.     is.Data = data;
  1661.     Ioctl( IG_WRITE_IO_SPACE, (PVOID)&is, sizeof(is) );
  1662.     *size = is.Length;
  1663. }
  1665. __inline VOID
  1666. WriteIoSpace32(
  1667.     ULONG   address,
  1668.     ULONG   data,
  1669.     PULONG  size
  1670.     )
  1671. {
  1672.     IOSPACE32 is;
  1673.     is.Address = address;
  1674.     is.Length = *size;
  1675.     is.Data = data;
  1676.     Ioctl( IG_WRITE_IO_SPACE, (PVOID)&is, sizeof(is) );
  1677.     *size = is.Length;
  1678. }
  1680. __inline VOID
  1681. WriteIoSpace64(
  1682.     ULONG64 address,
  1683.     ULONG   data,
  1684.     PULONG  size
  1685.     )
  1686. {
  1687.     IOSPACE64 is;
  1688.     is.Address = address;
  1689.     is.Length = *size;
  1690.     is.Data = data;
  1691.     Ioctl( IG_WRITE_IO_SPACE, (PVOID)&is, sizeof(is) );
  1692.     *size = is.Length;
  1693. }
  1695. __inline VOID
  1696. ReadIoSpaceEx(
  1697.     ULONG   address,
  1698.     PULONG  data,
  1699.     PULONG  size,
  1700.     ULONG   interfacetype,
  1701.     ULONG   busnumber,
  1702.     ULONG   addressspace
  1703.     )
  1704. {
  1705.     IOSPACE_EX is;
  1706.     is.Address = (ULONG)address;
  1707.     is.Length = *size;
  1708.     is.Data = 0;
  1709.     is.InterfaceType = interfacetype;
  1710.     is.BusNumber = busnumber;
  1711.     is.AddressSpace = addressspace;
  1712.     Ioctl( IG_READ_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  1713.     *data = is.Data;
  1714.     *size = is.Length;
  1715. }
  1717. __inline VOID
  1718. ReadIoSpaceEx32(
  1719.     ULONG   address,
  1720.     PULONG  data,
  1721.     PULONG  size,
  1722.     ULONG   interfacetype,
  1723.     ULONG   busnumber,
  1724.     ULONG   addressspace
  1725.     )
  1726. {
  1727.     IOSPACE_EX32 is;
  1728.     is.Address = address;
  1729.     is.Length = *size;
  1730.     is.Data = 0;
  1731.     is.InterfaceType = interfacetype;
  1732.     is.BusNumber = busnumber;
  1733.     is.AddressSpace = addressspace;
  1734.     Ioctl( IG_READ_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  1735.     *data = is.Data;
  1736.     *size = is.Length;
  1737. }
  1739. __inline VOID
  1740. ReadIoSpaceEx64(
  1741.     ULONG64 address,
  1742.     PULONG  data,
  1743.     PULONG  size,
  1744.     ULONG   interfacetype,
  1745.     ULONG   busnumber,
  1746.     ULONG   addressspace
  1747.     )
  1748. {
  1749.     IOSPACE_EX64 is;
  1750.     is.Address = address;
  1751.     is.Length = *size;
  1752.     is.Data = 0;
  1753.     is.InterfaceType = interfacetype;
  1754.     is.BusNumber = busnumber;
  1755.     is.AddressSpace = addressspace;
  1756.     Ioctl( IG_READ_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  1757.     *data = is.Data;
  1758.     *size = is.Length;
  1759. }
  1761. __inline VOID
  1762. WriteIoSpaceEx(
  1763.     ULONG   address,
  1764.     ULONG   data,
  1765.     PULONG  size,
  1766.     ULONG   interfacetype,
  1767.     ULONG   busnumber,
  1768.     ULONG   addressspace
  1769.     )
  1770. {
  1771.     IOSPACE_EX is;
  1772.     is.Address = (ULONG)address;
  1773.     is.Length = *size;
  1774.     is.Data = data;
  1775.     is.InterfaceType = interfacetype;
  1776.     is.BusNumber = busnumber;
  1777.     is.AddressSpace = addressspace;
  1778.     Ioctl( IG_WRITE_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  1779.     *size = is.Length;
  1780. }
  1782. __inline VOID
  1783. WriteIoSpaceEx32(
  1784.     ULONG   address,
  1785.     ULONG   data,
  1786.     PULONG  size,
  1787.     ULONG   interfacetype,
  1788.     ULONG   busnumber,
  1789.     ULONG   addressspace
  1790.     )
  1791. {
  1792.     IOSPACE_EX32 is;
  1793.     is.Address = address;
  1794.     is.Length = *size;
  1795.     is.Data = data;
  1796.     is.InterfaceType = interfacetype;
  1797.     is.BusNumber = busnumber;
  1798.     is.AddressSpace = addressspace;
  1799.     Ioctl( IG_WRITE_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  1800.     *size = is.Length;
  1801. }
  1803. __inline VOID
  1804. WriteIoSpaceEx64(
  1805.     ULONG64 address,
  1806.     ULONG   data,
  1807.     PULONG  size,
  1808.     ULONG   interfacetype,
  1809.     ULONG   busnumber,
  1810.     ULONG   addressspace
  1811.     )
  1812. {
  1813.     IOSPACE_EX64 is;
  1814.     is.Address = address;
  1815.     is.Length = *size;
  1816.     is.Data = data;
  1817.     is.InterfaceType = interfacetype;
  1818.     is.BusNumber = busnumber;
  1819.     is.AddressSpace = addressspace;
  1820.     Ioctl( IG_WRITE_IO_SPACE_EX, (PVOID)&is, sizeof(is) );
  1821.     *size = is.Length;
  1822. }
  1824. __inline VOID
  1825. ReloadSymbols(
  1826.     IN PSTR Arg OPTIONAL
  1827.     )
  1828. /*++
  1830. Routine Description:
  1832.     Calls the debugger to reload symbols.
  1834. Arguments:
  1836.     Args - Supplies the tail of a !reload command string.
  1838.         !reload [flags] [module[=address]]
  1839.         flags:   /n  do not load from usermode list
  1840.                  /u  unload symbols, no reload
  1841.                  /v  verbose
  1843.         A value of NULL is equivalent to an empty string
  1845. Return Value:
  1847.     None
  1849. --*/
  1850. {
  1851.     Ioctl(IG_RELOAD_SYMBOLS, (PVOID)Arg, Arg?((ULONG)strlen(Arg)+1):0);
  1852. }
  1854. __inline VOID
  1855. GetSetSympath(
  1856.     IN PSTR Arg,
  1857.     OUT PSTR Result OPTIONAL,
  1858.     IN int Length
  1859.     )
  1860. /*++
  1862. Routine Description:
  1864.     Calls the debugger to set or retrieve symbol search path.
  1866. Arguments:
  1868.     Arg - Supplies new search path.  If Arg is NULL or string is empty,
  1869.             the search path is not changed and the current setting is
  1870.             returned in Result.  When the symbol search path is changed,
  1871.             a call to ReloadSymbols is made implicitly.
  1873.     Result - OPTIONAL Returns the symbol search path setting.
  1875.     Length - Supplies the size of the buffer supplied by Result.
  1877. Return Value:
  1879.     None
  1881. --*/
  1882. {
  1883.     GET_SET_SYMPATH gss;
  1884.     gss.Args = Arg;
  1885.     gss.Result = Result;
  1886.     gss.Length = Length;
  1887.     Ioctl(IG_GET_SET_SYMPATH, (PVOID)&gss, sizeof(gss));
  1888. }
  1890. #if   defined(KDEXT_64BIT)
  1892. __inline
  1893. ULONG
  1894. IsPtr64(
  1895.     void
  1896.     )
  1897. {
  1898.     static ULONG flag = (ULONG)-1;
  1899.     ULONG dw;
  1900.     if (flag == (ULONG)-1) {
  1901.         if (Ioctl(IG_IS_PTR64, &dw, sizeof(dw))) {
  1902.             flag = ((dw != 0) ? 1 : 0);
  1903.         } else {
  1904.             flag = 0;
  1905.         }
  1906.     }
  1907.     return flag;
  1908. }
  1910. __inline
  1911. ULONG
  1912. ReadListEntry(
  1913.     ULONG64 Address,
  1914.     PLIST_ENTRY64 List
  1915.     )
  1916. {
  1917.     ULONG cb;
  1918.     if (IsPtr64()) {
  1919.         return (ReadMemory(Address, (PVOID)List, sizeof(*List), &cb) && cb == sizeof(*List));
  1920.     } else {
  1921.         LIST_ENTRY32 List32;
  1922.         ULONG Status;
  1923.         Status = ReadMemory(Address,
  1924.                             (PVOID)&List32,
  1925.                             sizeof(List32),
  1926.                             &cb);
  1927.         if (Status && cb == sizeof(List32)) {
  1928.             List->Flink = (ULONG64)(LONG64)(LONG)List32.Flink;
  1929.             List->Blink = (ULONG64)(LONG64)(LONG)List32.Blink;
  1930.             return 1;
  1931.         }
  1932.         return 0;
  1933.     }
  1934. }
  1936. __inline
  1937. ULONG
  1938. ReadPointer(
  1939.     ULONG64 Address,
  1940.     PULONG64 Pointer
  1941.     )
  1942. {
  1943.     ULONG cb;
  1944.     if (IsPtr64()) {
  1945.         return (ReadMemory(Address, (PVOID)Pointer, sizeof(*Pointer), &cb) && cb == sizeof(*Pointer));
  1946.     } else {
  1947.         ULONG Pointer32;
  1948.         ULONG Status;
  1949.         Status = ReadMemory(Address,
  1950.                             (PVOID)&Pointer32,
  1951.                             sizeof(Pointer32),
  1952.                             &cb);
  1953.         if (Status && cb == sizeof(Pointer32)) {
  1954.             *Pointer = (ULONG64)(LONG64)(LONG)Pointer32;
  1955.             return 1;
  1956.         }
  1957.         return 0;
  1958.     }
  1959. }
  1961. __inline
  1962. ULONG
  1963. WritePointer(
  1964.     ULONG64 Address,
  1965.     ULONG64 Pointer
  1966.     )
  1967. {
  1968.     ULONG cb;
  1969.     if (IsPtr64()) {
  1970.         return (WriteMemory(Address, &Pointer, sizeof(Pointer), &cb) && cb == sizeof(Pointer));
  1971.     } else {
  1972.         ULONG Pointer32 = (ULONG)Pointer;
  1973.         ULONG Status;
  1974.         Status = WriteMemory(Address,
  1975.                              &Pointer32,
  1976.                              sizeof(Pointer32),
  1977.                              &cb);
  1978.         return (Status && cb == sizeof(Pointer32)) ? 1 : 0;
  1979.     }
  1980. }
  1982. /**
  1983.    This does Ioctl call for type info and returns size of the type on success.
  1985.  **/
  1986. __inline
  1987. ULONG
  1988. GetTypeSize (
  1989.    IN LPCSTR    Type
  1990.    )
  1991. {
  1992.    SYM_DUMP_PARAM Sym = {
  1993.       sizeof (SYM_DUMP_PARAM), (PUCHAR)Type, DBG_DUMP_NO_PRINT | DBG_DUMP_GET_SIZE_ONLY, 0,
  1994.       NULL, NULL, NULL, 0, NULL
  1995.    };
  1997.    return Ioctl( IG_GET_TYPE_SIZE, &Sym, Sym.size );
  1998. }
  2000. /**
  2001.     GetFieldData
  2003.    Copies the value of the specified field into pOutValue assuming TypeAddress
  2004.    points to start of the type in debugee.
  2006.    If the Field is NULL and the size of Type is <= 8 Whole type value is read into
  2007.    pOutValue. This is to allow to read in primitive types suchas ULONG, PVOID etc.
  2009.    If address is zero this considers Type a global variable.
  2011.    It raises an exception if OutSize is less than size to be copied.
  2013.    Returns 0 on success, errorvalue (defined with SYM_DUMP_PARAM) otherwise.
  2015.  **/
  2016. __inline
  2017. ULONG
  2018. GetFieldData (
  2019.     IN  ULONG64 TypeAddress,
  2020.     IN  LPCSTR  Type,
  2021.     IN  LPCSTR  Field,
  2022.     IN  ULONG   OutSize,
  2023.     OUT PVOID   pOutValue
  2024.    )
  2025. {
  2026.    FIELD_INFO flds = {(PUCHAR)Field, NULL, 0, DBG_DUMP_FIELD_FULL_NAME | DBG_DUMP_FIELD_COPY_FIELD_DATA | DBG_DUMP_FIELD_RETURN_ADDRESS, 0, pOutValue};
  2027.    SYM_DUMP_PARAM Sym = {
  2028.       sizeof (SYM_DUMP_PARAM), (PUCHAR)Type, DBG_DUMP_NO_PRINT, TypeAddress,
  2029.       NULL, NULL, NULL, 1, &flds
  2030.    };
  2031.    ULONG RetVal;
  2033.    if (!Field) {
  2034.        Sym.nFields =0; Sym.Options |= DBG_DUMP_COPY_TYPE_DATA;
  2035.        Sym.Context = pOutValue;
  2036.    }
  2038.    ZeroMemory(pOutValue, OutSize);
  2039.    RetVal = Ioctl( IG_DUMP_SYMBOL_INFO, &Sym, Sym.size );
  2041.    if (OutSize < ((Field == NULL) ? 8 : flds.size)) {
  2042.        // Fail
  2043.        dprintf("Not enough space to read %s-%sn", Type, Field);
  2044.        RaiseException(EXCEPTION_ACCESS_VIOLATION, 0, 0, NULL);
  2045.        return 0;
  2046.    }
  2047.    return RetVal;
  2048. }
  2050. //
  2051. // Typecast the buffer where value is to be read
  2052. //
  2053. #define GetFieldValue(Addr, Type, Field, OutValue)         
  2054.      GetFieldData(Addr, Type, Field, sizeof(OutValue), (PVOID) &(OutValue))
  2056. //
  2057. // Used to read in value of a short (<= 8 bytes) fields
  2058. //
  2059. __inline
  2060. ULONG64
  2061. GetShortField (
  2062.     IN  ULONG64 TypeAddress,
  2063.     IN  LPCSTR  Name,
  2064.     IN  USHORT  StoreAddress
  2065.    )
  2066. {
  2067.     static ULONG64 SavedAddress;
  2068.     static PUCHAR  SavedName;
  2069.     static ULONG   ReadPhysical;
  2070.     FIELD_INFO flds = {(PUCHAR) Name, NULL, 0, DBG_DUMP_FIELD_FULL_NAME, 0, NULL};
  2071.     SYM_DUMP_PARAM Sym = {
  2072.        sizeof (SYM_DUMP_PARAM), SavedName, DBG_DUMP_NO_PRINT | ((StoreAddress & 2) ? DBG_DUMP_READ_PHYSICAL : 0),
  2073.        SavedAddress, NULL, NULL, NULL, 1, &flds
  2074.     };
  2075.       
  2077.     if (StoreAddress) {
  2078.         Sym.sName = (PUCHAR) Name;
  2079.         Sym.nFields = 0;
  2080.         SavedName = (PUCHAR) Name;
  2081.         Sym.addr = SavedAddress = TypeAddress;
  2082.         ReadPhysical = (StoreAddress & 2);
  2083.         return SavedAddress ? Ioctl( IG_DUMP_SYMBOL_INFO, &Sym, Sym.size ) : MEMORY_READ_ERROR; // zero on success
  2084.     } else {
  2085.         Sym.Options |= ReadPhysical ? DBG_DUMP_READ_PHYSICAL : 0;
  2086.     }
  2088.     if (!Ioctl( IG_DUMP_SYMBOL_INFO, &Sym, Sym.size )) {
  2089.         return flds.address;
  2090.     }
  2091.     return 0;
  2092. }
  2094. //
  2095. // Stores the address and type name for future reads
  2096. //
  2097. #define InitTypeRead(Addr, Type)  GetShortField(Addr, #Type, 1)
  2099. //
  2100. // Stores the address and type name for future reads
  2101. //
  2102. #define InitTypeReadPhysical(Addr, Type)  GetShortField(Addr, #Type, 3)
  2103. //
  2104. // Returns the field's value as ULONG64 if size of field is <= sizeof (ULONG64)
  2105. //
  2106. #define ReadField(Field)          GetShortField(0, #Field, 0)
  2108. //
  2109. // Read in a pointer value
  2110. //
  2111. __inline
  2112. ULONG
  2113. ReadPtr(
  2114.     ULONG64 Addr,
  2115.     PULONG64 pPointer
  2116.     )
  2117. {
  2118.     return GetFieldData(Addr, "PVOID", NULL, sizeof(ULONG64), (PVOID) pPointer);
  2119. }
  2121. /*
  2122.  * ListType
  2123.  *
  2124.  *  Routine ListType gives a callback on each element in the list of Type.
  2125.  *
  2126.  *   Type  :  Name of the type to be listed
  2127.  *
  2128.  *   NextPointer : Name of field which gives address of next element in list
  2129.  *
  2130.  *   Context, CallbackRoutine :
  2131.  *            Context and the callback routine. The address field in PFIELD_INFO
  2132.  *            parameter of callback contains the address of next Type element in list.
  2133.  *
  2134.  *   Address, ListByFieldAddress :
  2135.  *      if ListByFieldAddress is 0, Adress is the address of first element of Type List.
  2136.  *
  2137.  *   Lists by LIST_ENTRY are also handled implicitly (by Ioctl). If the NextPointer
  2138.  *   is a pointer to LIST_ENTRY type, the type address is properly calculated by
  2139.  *   subtracting the offsets.
  2140.  *
  2141.  *      If ListByFieldAddress is 1, the Address is considered to be the address of field
  2142.  *   "NextPointer" of the first Type element and first element address is derived
  2143.  *   from it.
  2144.  *
  2145.  */
  2147. __inline
  2148. ULONG
  2149. ListType (
  2150.     IN LPCSTR  Type,
  2151.     IN ULONG64 Address,
  2152.     IN USHORT  ListByFieldAddress,
  2153.     IN LPCSTR  NextPointer,
  2154.     IN PVOID   Context,
  2155.     IN PSYM_DUMP_FIELD_CALLBACK CallbackRoutine
  2156.     )
  2157. {
  2158.     FIELD_INFO flds = {(PUCHAR)NextPointer, NULL, 0, 0, 0, NULL};
  2159.     SYM_DUMP_PARAM Sym = {
  2160.        sizeof (SYM_DUMP_PARAM), (PUCHAR) Type, DBG_DUMP_NO_PRINT | DBG_DUMP_LIST, Address,
  2161.        &flds, Context, CallbackRoutine, 0, NULL
  2162.     };
  2164.     if (ListByFieldAddress==1) {
  2165.         //
  2166.         // Address is the address of "NextPointer"
  2167.         //
  2168.         Sym.Options |= DBG_DUMP_ADDRESS_OF_FIELD;
  2169.     }
  2171.     return Ioctl( IG_DUMP_SYMBOL_INFO, &Sym, Sym.size );
  2172. }
  2175. /**
  2177.    Routine to get offset of a "Field" of "Type" on a debugee machine. This uses
  2178.    Ioctl call for type info.
  2179.    Returns 0 on success, Ioctl error value otherwise.
  2181.  **/
  2183. __inline
  2184. ULONG
  2185. GetFieldOffset (
  2186.    IN LPCSTR     Type,
  2187.    IN LPCSTR     Field,
  2188.    OUT PULONG   pOffset
  2189.    )
  2190. {
  2191.    FIELD_INFO flds = {
  2192.        (PUCHAR)Field,
  2193.        (PUCHAR)"",
  2194.        0,
  2195.        DBG_DUMP_FIELD_FULL_NAME | DBG_DUMP_FIELD_RETURN_ADDRESS,
  2196.        0,
  2197.        NULL};
  2199.    SYM_DUMP_PARAM Sym = {
  2200.       sizeof (SYM_DUMP_PARAM),
  2201.       (PUCHAR)Type,
  2202.       DBG_DUMP_NO_PRINT,
  2203.       0,
  2204.       NULL,
  2205.       NULL,
  2206.       NULL,
  2207.       1,
  2208.       &flds
  2209.    };
  2211.    ULONG Err;
  2213.    Sym.nFields = 1;
  2214.    Err = Ioctl( IG_DUMP_SYMBOL_INFO, &Sym, Sym.size );
  2215.    *pOffset = (ULONG) (flds.address - Sym.addr);
  2216.    return Err;
  2217. }
  2220. #endif // defined(KDEXT_64BIT)
  2222. __inline VOID
  2223.  GetCurrentProcessHandle(
  2224.     PHANDLE hp
  2225.     )
  2226. {
  2227.     Ioctl(IG_GET_CURRENT_PROCESS_HANDLE, hp, sizeof(HANDLE));
  2228. }
  2230. __inline VOID
  2231.  GetTebAddress(
  2232.     PULONGLONG Address
  2233.     )
  2234. {
  2235.     GET_TEB_ADDRESS gpt;
  2236.     gpt.Address = 0;
  2237.     Ioctl(IG_GET_TEB_ADDRESS, (PVOID)&gpt, sizeof(gpt));
  2238.     *Address = gpt.Address;
  2239. }
  2241. __inline VOID
  2242.  GetPebAddress(
  2243.     ULONG64 CurrentThread,
  2244.     PULONGLONG Address
  2245.     )
  2246. {
  2247.     GET_PEB_ADDRESS gpt;
  2248.     gpt.CurrentThread = CurrentThread;
  2249.     gpt.Address = 0;
  2250.     Ioctl(IG_GET_PEB_ADDRESS, (PVOID)&gpt, sizeof(gpt));
  2251.     *Address = gpt.Address;
  2252. }
  2254. __inline VOID
  2255.  GetCurrentThreadAddr(
  2256.     DWORD    Processor,
  2257.     PULONG64  Address
  2258.     )
  2259. {
  2260.     GET_CURRENT_THREAD_ADDRESS ct;
  2261.     ct.Processor = Processor;
  2262.     Ioctl(IG_GET_CURRENT_THREAD, (PVOID)&ct, sizeof(ct));
  2263.     *Address = ct.Address;
  2264. }
  2266. __inline VOID
  2267.  GetCurrentProcessAddr(
  2268.     DWORD    Processor,
  2269.     ULONG64  CurrentThread,
  2270.     PULONG64 Address
  2271.     )
  2272. {
  2273.     GET_CURRENT_PROCESS_ADDRESS cp;
  2274.     cp.Processor = Processor;
  2275.     cp.CurrentThread = CurrentThread;
  2276.     Ioctl(IG_GET_CURRENT_PROCESS, (PVOID)&cp, sizeof(cp));
  2277.     *Address = cp.Address;
  2278. }
  2280. __inline VOID
  2281. SearchMemory(
  2282.     ULONG64  SearchAddress,
  2283.     ULONG64  SearchLength,
  2284.     ULONG    PatternLength,
  2285.     PVOID    Pattern,
  2286.     PULONG64 FoundAddress
  2287.     )
  2288. {
  2289.     SEARCHMEMORY sm;
  2290.     sm.SearchAddress = SearchAddress;
  2291.     sm.SearchLength  = SearchLength;
  2292.     sm.FoundAddress  = 0;
  2293.     sm.PatternLength = PatternLength;
  2294.     sm.Pattern       = Pattern;
  2295.     Ioctl(IG_SEARCH_MEMORY, (PVOID)&sm, sizeof(sm));
  2296.     *FoundAddress = sm.FoundAddress;
  2297. }
  2299. __inline ULONG
  2300. GetInputLine(
  2301.     PCSTR Prompt,
  2302.     PSTR Buffer,
  2303.     ULONG BufferSize
  2304.     )
  2305. {
  2306.     GET_INPUT_LINE InLine;
  2307.     InLine.Prompt = Prompt;
  2308.     InLine.Buffer = Buffer;
  2309.     InLine.BufferSize = BufferSize;
  2310.     if (Ioctl(IG_GET_INPUT_LINE, (PVOID)&InLine, sizeof(InLine)))
  2311.     {
  2312.         return InLine.InputSize;
  2313.     }
  2314.     else
  2315.     {
  2316.         return 0;
  2317.     }
  2318. }
  2320. __inline BOOL
  2321. GetExpressionEx(
  2322.     PCSTR Expression,
  2323.     ULONG64* Value,
  2324.     PCSTR* Remainder
  2325.     )
  2326. {
  2327.     GET_EXPRESSION_EX Expr;
  2328.     Expr.Expression = Expression;
  2329.     if (Ioctl(IG_GET_EXPRESSION_EX, (PVOID)&Expr, sizeof(Expr)))
  2330.     {
  2331.         *Value = Expr.Value;
  2333.         if (Remainder != NULL)
  2334.         {
  2335.             *Remainder = Expr.Remainder;
  2336.         }
  2338.         return TRUE;
  2339.     }
  2341.     return FALSE;
  2342. }
  2344. __inline BOOL
  2345. TranslateVirtualToPhysical(
  2346.     ULONG64 Virtual,
  2347.     ULONG64* Physical
  2348.     )
  2349. {
  2350.     TRANSLATE_VIRTUAL_TO_PHYSICAL VToP;
  2351.     VToP.Virtual = Virtual;
  2352.     if (Ioctl(IG_TRANSLATE_VIRTUAL_TO_PHYSICAL, (PVOID)&VToP, sizeof(VToP)))
  2353.     {
  2354.         *Physical = VToP.Physical;
  2355.         return TRUE;
  2356.     }
  2358.     return FALSE;
  2359. }
  2361. __inline BOOL
  2362. GetDebuggerCacheSize(
  2363.     OUT PULONG64 CacheSize
  2364.     )
  2365. {
  2366.     return Ioctl(IG_GET_CACHE_SIZE, (PVOID) CacheSize, sizeof(ULONG64));
  2367. }
  2369. #endif
  2372. #ifdef __cplusplus
  2373. }
  2374. #endif
  2376. #endif // _WDBGEXTS_