Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1280 lines
22 KiB

/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
Od.h
Abstract:
This file contains types and prototypes which are exposed
to all OSDebug components and clients.
Author:
Kent Forschmiedt (kentf) 10-Sep-1993
Environment:
Win32, User Mode
--*/
#if ! defined _OD_
#define _OD_
#include "odtypes.h"
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Constants and other magic
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// OSDebug types and status codes
//
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
typedef XOSD (FAR PASCAL LOADDS *LPFNSVC) ( DBC, HPID, HTID, LPARAM, LPARAM );
typedef XOSD (FAR PASCAL LOADDS *TLFUNC)();
typedef XOSD (FAR PASCAL LOADDS *EMFUNC)();
// callback for EM or TL to get and set workspace params
typedef LONG (FAR * LPGETSETPROFILEPROC)(
LPSTR lpName,
LPSTR lpValue,
LPARAM lParam,
DWORD fSet
);
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// OSDebug API set
//
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// OSDebug Initialization/Termination
//
XOSD PASCAL
OSDInit(
LPDBF lpdbf
);
XOSD PASCAL
OSDTerm(
VOID
);
//
// EM Management
//
enum {
emNative,
emNonNative
};
typedef DWORD EMTYPE;
#define EMISINFOSIZE 80
typedef struct _EMIS {
DWORD fCanSetup;
DWORD dwMaxPacket;
DWORD dwOptPacket;
DWORD dwInfoSize;
TCHAR rgchInfo[EMISINFOSIZE];
} EMIS;
typedef EMIS FAR * LPEMIS;
typedef struct _EMSS {
DWORD fLoad;
DWORD fInteractive;
DWORD fSave;
LPVOID lpvPrivate;
LPARAM lParam;
LPGETSETPROFILEPROC lpfnGetSet;
} EMSS;
typedef EMSS FAR * LPEMSS;
XOSD PASCAL
OSDAddEM(
EMFUNC emfunc,
LPDBF lpdbf,
LPHEM lphem,
EMTYPE emtype
);
XOSD PASCAL
OSDDeleteEM(
HEM hem
);
XOSD PASCAL
OSDGetCurrentEM(
HPID hpid,
HTID htid,
LPHEM lphem
);
XOSD PASCAL
OSDNativeOnly(
HPID hpid,
HTID htid,
DWORD fNativeOnly
);
XOSD PASCAL
OSDUseEM(
HPID hpid,
HEM hem
);
XOSD PASCAL
OSDDiscardEM(
HPID hpid,
HTID htid,
HEM hem
);
XOSD PASCAL
OSDEMGetInfo(
HEM hem,
LPEMIS lpemis
);
XOSD PASCAL
OSDEMSetup(
HEM hem,
LPEMSS lpemss
);
//
// TL Management
//
#define TLISINFOSIZE 80
typedef struct _TLIS {
DWORD fCanSetup;
DWORD dwMaxPacket;
DWORD dwOptPacket;
DWORD dwInfoSize;
DWORD fRemote;
MPT mpt;
MPT mptRemote;
TCHAR rgchInfo[TLISINFOSIZE];
} TLIS;
typedef TLIS FAR * LPTLIS;
typedef struct _TLSS {
DWORD fLoad;
DWORD fInteractive;
DWORD fSave;
LPVOID lpvPrivate;
LPARAM lParam;
LPGETSETPROFILEPROC lpfnGetSet;
} TLSS;
typedef TLSS FAR * LPTLSS;
XOSD PASCAL
OSDAddTL(
TLFUNC tlfunc,
LPDBF lpdbf,
LPHTL lphtl
);
XOSD PASCAL
OSDStartTL(
HTL htl
);
XOSD PASCAL
OSDDeleteTL(
HTL htl
);
XOSD PASCAL
OSDTLGetInfo(
HTL htl,
LPTLIS lptlis
);
XOSD PASCAL
OSDTLSetup(
HTL htl,
LPTLSS lptlss
);
XOSD PASCAL
OSDDisconnect(
HPID hpid,
HTID htid
);
//
// Process, thread management
//
XOSD PASCAL
OSDCreateHpid(
LPFNSVC lpfnsvcCallBack,
HEM hemNative,
HTL htl,
LPHPID lphpid
);
XOSD PASCAL
OSDDestroyHpid(
HPID hpid
);
XOSD PASCAL
OSDDestroyHtid(
HPID hpid,
HTID htid
);
#define IDSTRINGSIZE 10
#define STATESTRINGSIZE 60
typedef struct _PST {
DWORD dwProcessID;
DWORD dwProcessState;
TCHAR rgchProcessID[IDSTRINGSIZE];
TCHAR rgchProcessState[STATESTRINGSIZE];
} PST;
typedef PST FAR * LPPST;
typedef struct _TST {
DWORD dwThreadID;
DWORD dwSuspendCount;
DWORD dwSuspendCountMax;
DWORD dwPriority;
DWORD dwPriorityMax;
DWORD dwState;
TCHAR rgchThreadID[IDSTRINGSIZE];
TCHAR rgchState[STATESTRINGSIZE];
TCHAR rgchPriority[STATESTRINGSIZE];
} TST;
typedef TST FAR * LPTST;
XOSD PASCAL
OSDGetThreadStatus(
HPID hpid,
HTID htid,
LPTST lptst
);
XOSD PASCAL
OSDGetProcessStatus(
HPID hpid,
LPPST lppst
);
XOSD PASCAL
OSDFreezeThread(
HPID hpid,
HTID htid,
DWORD fFreeze
);
XOSD PASCAL
OSDSetThreadPriority(
HPID hpid,
HTID htid,
DWORD dwPriority
);
//
// Address manipulation
//
enum {
adrReserved,
adrPC,
adrBase,
adrStack,
adrData,
adrTlsBase
};
typedef DWORD ADR;
XOSD PASCAL
OSDGetAddr(
HPID hpid,
HTID htid,
ADR adr,
LPADDR lpaddr
);
XOSD PASCAL
OSDSetAddr(
HPID hpid,
HTID htid,
ADR adr,
LPADDR lpaddr
);
XOSD PASCAL
OSDFixupAddr(
HPID hpid,
HTID htid,
LPADDR lpaddr
);
XOSD PASCAL
OSDUnFixupAddr(
HPID hpid,
HTID htid,
LPADDR lpaddr
);
XOSD PASCAL
OSDSetEmi(
HPID hpid,
HTID htid,
LPADDR lpaddr
);
XOSD PASCAL
OSDRegisterEmi(
HPID hpid,
HEMI hemi,
LPTSTR lsz
);
XOSD PASCAL
OSDUnRegisterEmi(
HPID hpid,
HEMI hemi
);
XOSD PASCAL
OSDCompareAddrs(
HPID hpid,
LPADDR lpaddr1,
LPADDR lpaddr2,
LPDWORD lpdwResult
);
XOSD PASCAL
OSDGetMemoryInformation(
HPID hpid,
HTID htid,
LPMEMINFO lpMemInfo
);
//
// Module lists
//
typedef struct _MODULE_LIST {
DWORD Count;
} MODULE_LIST;
typedef struct _MODULE_LIST FAR * LPMODULE_LIST;
typedef struct _MODULE_ENTRY {
DWORD Flat;
DWORD Real;
DWORD Segment;
DWORD Selector;
DWORD Base;
DWORD Limit;
DWORD Type;
DWORD SectionCount;
TCHAR Name[ MAX_PATH ];
} MODULE_ENTRY;
typedef struct _MODULE_ENTRY FAR * LPMODULE_ENTRY;
#define ModuleListCount(m) ((m)->Count)
#define FirstModuleEntry(m) ((LPMODULE_ENTRY)((m)+1))
#define NextModuleEntry(e) ((e)+1)
#define NthModuleEntry(m,n) (FirstModuleEntry(m)+(n))
#define ModuleEntryFlat(e) ((e)->Flat)
#define ModuleEntryReal(e) ((e)->Real)
#define ModuleEntrySegment(e) ((e)->Segment)
#define ModuleEntrySelector(e) ((e)->Selector)
#define ModuleEntryBase(e) ((e)->Base)
#define ModuleEntryLimit(e) ((e)->Limit)
#define ModuleEntryType(e) ((e)->Type)
#define ModuleEntrySectionCount(e) ((e)->SectionCount)
#define ModuleEntryName(e) ((e)->Name)
XOSD PASCAL
OSDGetModuleList(
HPID hpid,
HTID htid,
LPTSTR lszModuleName,
LPMODULE_LIST FAR * lplpModuleList
);
//
// Target Application load/unload
//
// Bit flags for dwFlags in ProgramLoad
#define ulfMultiProcess 0x0001L // OS2, NT, and ?MAC?
#define ulfMinimizeApp 0x0002L // Win32
#define ulfNoActivate 0x0004L // Win32
#define ulfInheritHandles 0x0008L // Win32 (DM only?)
#define ulfWowVdm 0x0010L // Win32
XOSD PASCAL
OSDProgramLoad(
HPID hpid,
LPTSTR lszRemoteExe,
LPTSTR lszArgs,
LPTSTR lszWorkingDir,
LPTSTR lszDebugger,
DWORD dwFlags
);
XOSD PASCAL
OSDProgramFree(
HPID hpid
);
XOSD PASCAL
OSDDebugActive(
HPID hpid,
LPVOID lpvData,
DWORD cbData
);
XOSD PASCAL
OSDSetPath(
HPID hpid,
DWORD fSet,
LPTSTR lszPath
);
//
// Target execution control
//
typedef struct _EXOP {
BYTE fSingleThread;
BYTE fStepOver;
BYTE fQueryStep;
BYTE fInitialBP;
BYTE fPassException;
BYTE fSetFocus;
BYTE fReturnValues; // send back dbcExitedFunction
} EXOP;
typedef EXOP FAR * LPEXOP;
XOSD PASCAL
OSDGo(
HPID hpid,
HTID htid,
LPEXOP lpexop
);
XOSD PASCAL
OSDSingleStep(
HPID hpid,
HTID htid,
LPEXOP lpexop
);
XOSD PASCAL
OSDRangeStep(
HPID hpid,
HTID htid,
LPADDR lpaddrMin,
LPADDR lpaddrMax,
LPEXOP lpexop
);
XOSD PASCAL
OSDReturnStep(
HPID hpid,
HTID htid,
LPEXOP lpexop
);
XOSD PASCAL
OSDAsyncStop(
HPID hpid,
DWORD fSetFocus
);
//
// Target function evaluation
//
XOSD PASCAL
OSDSetupExecute(
HPID hpid,
HTID htid,
LPHIND lphind
);
XOSD PASCAL
OSDStartExecute(
HPID hpid,
HIND hind,
LPADDR lpaddr,
DWORD fIgnoreEvents,
DWORD fFar
);
XOSD PASCAL
OSDCleanUpExecute(
HPID hpid,
HIND hind
);
//
// Target information
//
XOSD PASCAL
OSDGetDebugMetric(
HPID hpid,
HTID htid,
MTRC mtrc,
LPVOID lpv
);
//
// Target memory and objects
//
XOSD PASCAL
OSDReadMemory(
HPID hpid,
HTID htid,
LPADDR lpaddr,
LPVOID lpBuffer,
DWORD cbBuffer,
LPDWORD lpcbRead
);
XOSD PASCAL
OSDWriteMemory(
HPID hpid,
HTID htid,
LPADDR lpaddr,
LPVOID lpBuffer,
DWORD cbBuffer,
LPDWORD lpcbWritten
);
XOSD PASCAL
OSDGetObjectLength(
HPID hpid,
HTID htid,
LPADDR lpaddr,
LPUOFFSET lpuoffStart,
LPUOFFSET lpuoffLength
);
//
// Target register manipulation
//
/*
** Register types --- flags describing recommendations on
** register display
*/
enum {
rtProcessMask = 0x0f, // Mask for processor type bits
// these are enumerates, not bitfields.
rtCPU = 0x01, // Central Processing Unit
rtFPU = 0x02, // Floating Point Unit
rtMMU = 0x03, // Memory Manager Unit
rtGroupMask = 0xf0, // Which group(s) register falls into
// Bitfields
rtInvisible = 0x10, // Recommend no display
rtRegular = 0x20, // Recommend regular display
rtExtended = 0x40, // Recommend extended display
rtSpecial = 0x80, // Special and hidden regs, e.g. kernel mode
rtFmtTypeMask = 0xf00, // Mask of display formats
// these are enumerates, not bitfields.
rtInteger = 0x100, // Unsigned integer format
rtFloat = 0x200, // Floating point format
rtAddress = 0x300, // Address format
rtMiscMask = 0xf000, // misc info
// Bitfields
rtPC = 0x1000, // this is the PC
rtFrame = 0x2000, // this reg affects the stack frame
rtNewLine = 0x4000 // print a newline when listing
};
typedef DWORD RT; // Register Types
#define rtFmtTypeShift 8
enum {
ftProcessMask = 0x0f, // Mask for processor type bits
// these are enumerates, not bitfields.
ftCPU = 0x01, // Central Processing Unit
ftFPU = 0x02, // Floating Point Unit
ftMMU = 0x03, // Memory Manager Unit
ftGroupMask = 0xf0, // Which group(s) register falls into
// Bitfields
ftInvisible = 0x10, // Recommend no display
ftRegular = 0x20, // Recommend regular display
ftExtended = 0x40, // Recommend extended display
ftSpecial = 0x80, // Special and hidden regs, e.g. kernel mode
ftFmtTypeMask = 0xf00, // Mask of display formats
// these are enumerates, not bitfields.
ftInteger = 0x100, // Unsigned integer format
ftFloat = 0x200, // Floating point format
ftAddress = 0x300, // Address format
ftMiscMask = 0xf000, // misc info
// Bitfields
ftPC = 0x1000, // this is the PC
ftFrame = 0x2000, // this reg affects the stack frame
ftNewLine = 0x4000 // print a newline when listing
};
typedef DWORD FT; // Flag Types
#define ftFmtTypeShift 8
/*
** Register description: This structure contains the description for
** a register on the machine. Note that dwId must be used to get
** the value for this register but a different index is used to get
** this description structure.
*/
typedef struct {
LPTSTR lszName; /* Pointer into EM for registers name */
RT rt; /* Register Type flags */
DWORD dwcbits; /* Number of bits in the register */
DWORD dwGrp;
DWORD dwId; /* Value to use with Read/Write Register*/
} RD; // Register Description
typedef RD FAR * LPRD;
/*
** Flag Data description: This structure contains the description for
** a flag on the machine. Note that the dwId field contains the
** value to be used with Read/Write register to get the register which
** contains this flag.
*/
typedef struct _FD {
LPTSTR lszName;
FT ft;
DWORD dwcbits;
DWORD dwGrp;
DWORD dwId;
} FD;
typedef FD FAR * LPFD;
XOSD PASCAL
OSDGetRegDesc(
HPID hpid,
HTID htid,
DWORD ird,
LPRD lprd
);
XOSD PASCAL
OSDGetFlagDesc(
HPID hpid,
HTID htid,
DWORD ifd,
LPFD lpfd
);
XOSD PASCAL
OSDReadRegister(
HPID hpid,
HTID htid,
DWORD dwid,
LPVOID lpValue
);
XOSD PASCAL
OSDWriteRegister(
HPID hpid,
HTID htid,
DWORD dwId,
LPVOID lpValue
);
XOSD PASCAL
OSDReadFlag(
HPID hpid,
HTID htid,
DWORD dwId,
LPVOID lpValue
);
XOSD PASCAL
OSDWriteFlag(
HPID hpid,
HTID htid,
DWORD dwId,
LPVOID lpValue
);
XOSD PASCAL
OSDSaveRegs(
HPID hpid,
HTID htid,
LPHIND lphReg
);
XOSD PASCAL
OSDRestoreRegs(
HPID hpid,
HTID htid,
HIND hregs
);
//
// Breakpoints
//
enum {
bptpExec,
bptpDataC,
bptpDataW,
bptpDataR,
bptpRegC,
bptpRegW,
bptpRegR,
bptpMessage,
bptpMClass,
bptpInt,
bptpRange
};
typedef DWORD BPTP;
enum {
bpnsStop,
bpnsContinue,
bpnsCheck
};
typedef DWORD BPNS;
typedef struct _BPIS {
BPTP bptp;
BPNS bpns;
DWORD fOneThd;
HTID htid;
union {
struct {
ADDR addr;
} exec;
struct {
ADDR addr;
DWORD cb;
} data;
struct {
DWORD dwId;
} reg;
struct {
ADDR addr;
DWORD imsg;
DWORD cmsg;
} msg;
struct {
ADDR addr;
DWORD dwmask;
} mcls;
struct {
DWORD ipt;
} ipt;
struct {
ADDR addr;
DWORD cb;
} rng;
};
} BPIS;
typedef BPIS FAR * LPBPIS;
typedef struct _BPS {
DWORD cbpis;
DWORD cmsg;
DWORD fSet;
BPIS rgbpis[];
// DWORD rgdwMessage[];
// XOSD rgxosd[];
// DWORD rgdwNotification[];
} BPS;
typedef BPS FAR * LPBPS;
XOSD PASCAL
OSDBreakpoint(
HPID hpid,
LPBPS lpbps
);
//
// Assembly, Unassembly
//
enum {
dopNone = 0x00000000,
dopAddr = 0x00000001, // put address (w/ seg) in front of disassm
dopFlatAddr = 0x00000002, // put flat address (no seg)
dopOpcode = 0x00000004, // dump the Opcode
dopOperands = 0x00000008, // dump the Operands
dopRaw = 0x00000010, // dump the raw code bytes
dopEA = 0x00000020, // calculate the effective address
dopSym = 0x00000040, // output symbols
dopUpper = 0x00000080, // force upper case for all chars except syms
dopHexUpper = 0x00000100 // force upper case for all hex constants
// (implied true if dopUpper is set)
};
typedef DWORD DOP; // Disassembly OPtions
typedef struct _SDI {
DOP dop; // Disassembly OPtions (see above)
ADDR addr; // The address to disassemble
DWORD fAssocNext; // This instruction is associated w/ the next one
ADDR addrEA0; // First effective address
ADDR addrEA1; // Second effective address
ADDR addrEA2; // Third effective address
DWORD cbEA0; // First effective address size
DWORD cbEA1; // Second effective address size
DWORD cbEA2; // Third effective address size
LONG ichAddr;
LONG ichBytes;
LONG ichOpcode;
LONG ichOperands;
LONG ichComment;
LONG ichEA0;
LONG ichEA1;
LONG ichEA2;
LPTSTR lpch;
} SDI; // Structured DiSsassembly
typedef SDI FAR *LPSDI;
XOSD PASCAL
OSDUnassemble(
HPID hpid,
HTID htid,
LPSDI lpsdi
);
XOSD PASCAL
OSDGetPrevInst(
HPID hpid,
HTID htid,
LPADDR lpaddr,
LPUOFFSET lpuoff
);
XOSD PASCAL
OSDAssemble(
HPID hpid,
HTID htid,
LPADDR lpaddr,
LPTSTR lsz
);
//
// Stack tracing
//
XOSD PASCAL
OSDGetFrame(
HPID hpid,
HTID htid,
DWORD cFrame,
LPHTID lphtid
);
//
// Target host file i/o
//
XOSD PASCAL
OSDMakeFileHandle(
HPID hpid,
LPARAM lPrivateHandle,
HOSDFILE FAR * lphosdFile
);
XOSD PASCAL
OSDDupFileHandle(
HOSDFILE hosdFile,
HOSDFILE FAR * lphosdDup
);
XOSD PASCAL
OSDCloseFile(
HOSDFILE hosdFile
);
XOSD PASCAL
OSDSeekFile(
HOSDFILE hosdFile,
DWORD dwLocationLo,
DWORD dwLocationHi,
DWORD dwOrigin
);
XOSD PASCAL
OSDReadFile(
HOSDFILE hosdFile,
LPBYTE lpbBuffer,
DWORD cbData,
LPDWORD lpcbBytesRead
);
XOSD PASCAL
OSDWriteFile(
HOSDFILE hosdFile,
LPBYTE lpbBuffer,
DWORD cbData,
LPDWORD lpdwBytesWritten
);
//
// Exception handling
//
//
// These are the actions which the debugger may take
// in response to an exception raised in the debuggee.
//
typedef enum _EXCEPTION_FILTER_DEFAULT {
efdIgnore,
efdNotify,
efdCommand,
efdStop
} EXCEPTION_FILTER_DEFAULT;
typedef EXCEPTION_FILTER_DEFAULT FAR * LPEXCEPTION_FILTER_DEFAULT;
//
// commands understood by OSDGetExceptionState
//
typedef enum _EXCEPTION_CONTROL {
exfFirst,
exfNext,
exfSpecified
} EXCEPTION_CONTROL;
typedef EXCEPTION_CONTROL FAR * LPEXCEPTION_CONTROL;
//
// Exception information packet
//
#define EXCEPTION_STRING_SIZE 60
typedef struct _EXCEPTION_DESCRIPTION {
DWORD dwExceptionCode;
EXCEPTION_FILTER_DEFAULT efd;
TCHAR rgchDescription[EXCEPTION_STRING_SIZE];
} EXCEPTION_DESCRIPTION;
typedef EXCEPTION_DESCRIPTION FAR * LPEXCEPTION_DESCRIPTION;
XOSD PASCAL
OSDGetExceptionState(
HPID hpid,
HTID htid,
LPEXCEPTION_DESCRIPTION lpExd,
EXCEPTION_CONTROL exf
);
XOSD PASCAL
OSDSetExceptionState (
HPID hpid,
HTID htid,
LPEXCEPTION_DESCRIPTION lpExd
);
//
// Message information
//
enum {
msgMaskNone = 0x0,
msgMaskWin = 0x1,
msgMaskInit = 0x2,
msgMaskInput = 0x4,
msgMaskMouse = 0x8,
msgMaskSys = 0x10,
msgMaskClip = 0x20,
msgMaskNC = 0x40,
msgMaskDDE = 0x80,
msgMaskOther = 0x100,
msgMaskAll = 0x0FFF,
};
typedef struct _MESSAGEINFO {
DWORD dwMsg; // Message number
LPTSTR lszMsgText; // Message Text
DWORD dwMsgMask; // Message mask
} MESSAGEINFO;
typedef struct _MESSAGEINFO *LPMESSAGEINFO;
//
// MSG Map structure
//
typedef struct _MESSAGEMAP {
DWORD dwCount; // Number of elements
LPMESSAGEINFO lpMsgInfo; // Pointer to array
} MESSAGEMAP;
typedef struct _MESSAGEMAP *LPMESSAGEMAP;
XOSD PASCAL
OSDGetMessageMap(
HPID hpid,
HTID htid,
LPMESSAGEMAP FAR * lplpMessageMap
);
typedef struct _MASKINFO {
DWORD dwMask;
LPTSTR lszMaskText;
} MASKINFO;
typedef MASKINFO FAR * LPMASKINFO;
typedef struct _MASKMAP {
DWORD dwCount;
LPMASKINFO lpMaskInfo;
} MASKMAP;
typedef MASKMAP FAR * LPMASKMAP;
XOSD PASCAL
OSDGetMessageMaskMap(
HPID hpid,
HTID htid,
LPMASKMAP FAR * lplpMaskMap
);
//
// Miscellaneous control functions
//
XOSD PASCAL
OSDShowDebuggee(
HPID hpid,
DWORD fShow
);
//
// Communication and synchronization with DM
//
XOSD PASCAL
OSDInfoReply(
HPID hpid,
HTID htid,
LPVOID lpvData,
DWORD cbData
);
XOSD PASCAL
OSDContinue(
HPID hpid,
HTID htid
);
//
// OS Specific info and control
//
typedef struct _TASKENTRY {
DWORD dwProcessID;
TCHAR szProcessName[MAX_PATH];
} TASKENTRY;
typedef TASKENTRY FAR * LPTASKENTRY;
typedef struct _TASKLIST {
DWORD dwCount;
LPTASKENTRY lpTaskEntry;
} TASKLIST;
typedef TASKLIST FAR * LPTASKLIST;
XOSD PASCAL
OSDGetTaskList(
HPID hpid,
LPTASKLIST FAR * lplpTaskList
);
enum {
ssvcNull = 0,
ssvcDumpLocalHeap,
ssvcDumpGlobalHeap,
ssvcDumpModuleList,
ssvcCrackLocalHmem,
ssvcCrackGlobalHmem,
ssvcKillApplication,
ssvcFreeLibrary,
ssvcInput,
ssvcOutput,
ssvcOleRpc, // Enable/disable OLE Remote Procedure Call tracing
// Pass cb = 1, rgb[0] = fEnable. Before this is
// called the first time, OLE RPC debugging is
// disabled. Also see mtrcOleRpc.
ssvcHackFlipScreen, // Hack for testing: toggle switching previous
// foreground window back to foreground on F8/F10.
ssvcNativeDebugger, // Activate remote debugger
#if defined (TARGMAC68K) || defined (TARGMACPPC)
ssvcSetETS,
ssvcCvtRez2Seg,
#endif
};
typedef DWORD SSVC;
#define FIRST_PRIVATE_SSVC 0x8000
XOSD PASCAL
OSDSystemService(
HPID hpid,
HTID htid,
SSVC ssvc,
LPVOID lpvData,
DWORD cbData,
LPDWORD lpcbReturned
);
enum {
dbmSoftMode,
dbmHardMode
};
typedef DWORD DBM;
typedef struct _DBMI {
HWND hWndFrame;
HWND hWndMDIClient;
HANDLE hAccelTable;
} DBMI;
XOSD PASCAL
OSDSetDebugMode(
HPID hpid,
DBM dbmService,
LPVOID lpvData,
DWORD cbData
);
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// OSDebug notifications
//
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
// Data passed with dbc messages
//
#endif // _OD_