dbg.h@ 3810

Last change on this file since 3810 was 3633, checked in by vboxsync, 17 years ago
VBox_hdr_h -> _VBox_hdr_h
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.3 KB

Line
1	/** @file
2	* Debugger Interfaces.
3	*
4	* This header covers all external interfaces of the Debugger module.
5	* However, it does not cover the DBGF interface since that part of the
6	* VMM. Use dbgf.h for that.
7	*/
8
9	/*
10	* Copyright (C) 2006-2007 innotek GmbH
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License as published by the Free Software Foundation,
16	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
17	* distribution. VirtualBox OSE is distributed in the hope that it will
18	* be useful, but WITHOUT ANY WARRANTY of any kind.
19	*
20	* If you received this file as part of a commercial VirtualBox
21	* distribution, then only the terms of your commercial VirtualBox
22	* license agreement apply instead of the previous paragraph.
23	*/
24
25	#ifndef ___VBox_dbg_h
26	#define ___VBox_dbg_h
27
28	#include <VBox/cdefs.h>
29	#include <VBox/types.h>
30	#include <VBox/dbgf.h>
31
32	#include <iprt/stdarg.h>
33
34	__BEGIN_DECLS
35
36	/** @def VBOX_WITH_DEBUGGER
37	* The build is with debugger module. Test if this is defined before
38	* registering external debugger commands.
39	*/
40	#ifndef VBOX_WITH_DEBUGGER
41	# ifdef DEBUG
42	# define VBOX_WITH_DEBUGGER
43	# endif
44	#endif
45
46
47	/**
48	* DBGC variable category.
49	*
50	* Used to describe an argument to a command or function and a functions
51	* return value.
52	*/
53	typedef enum DBGCVARCAT
54	{
55	/** Any type is fine. */
56	DBGCVAR_CAT_ANY = 0,
57	/** Any kind of pointer. */
58	DBGCVAR_CAT_POINTER,
59	/** Any kind of pointer with no range option. */
60	DBGCVAR_CAT_POINTER_NO_RANGE,
61	/** GC pointer. */
62	DBGCVAR_CAT_GC_POINTER,
63	/** GC pointer with no range option. */
64	DBGCVAR_CAT_GC_POINTER_NO_RANGE,
65	/** Numeric argument. */
66	DBGCVAR_CAT_NUMBER,
67	/** Numeric argument with no range option. */
68	DBGCVAR_CAT_NUMBER_NO_RANGE,
69	/** String. */
70	DBGCVAR_CAT_STRING,
71	/** Symbol. */
72	DBGCVAR_CAT_SYMBOL
73	} DBGCVARCAT;
74
75
76	/**
77	* DBGC variable type.
78	*/
79	typedef enum DBGCVARTYPE
80	{
81	/** unknown... */
82	DBGCVAR_TYPE_UNKNOWN = 0,
83	/** Flat GC pointer. */
84	DBGCVAR_TYPE_GC_FLAT,
85	/** Segmented GC pointer. */
86	DBGCVAR_TYPE_GC_FAR,
87	/** Physical GC pointer. */
88	DBGCVAR_TYPE_GC_PHYS,
89	/** Flat HC pointer. */
90	DBGCVAR_TYPE_HC_FLAT,
91	/** Segmented HC pointer. */
92	DBGCVAR_TYPE_HC_FAR,
93	/** Physical HC pointer. */
94	DBGCVAR_TYPE_HC_PHYS,
95	/** String. */
96	DBGCVAR_TYPE_STRING,
97	/** Number. */
98	DBGCVAR_TYPE_NUMBER,
99	/** Symbol. */
100	DBGCVAR_TYPE_SYMBOL,
101	/** Special type used when querying symbols. */
102	DBGCVAR_TYPE_ANY
103	} DBGCVARTYPE;
104
105	/** Checks if the specified variable type is of a pointer persuasion. */
106	#define DBGCVAR_ISPOINTER(enmType) (enmType >= DBGCVAR_TYPE_GC_FLAT && enmType <= DBGCVAR_TYPE_HC_PHYS)
107	/** Checks if the specified variable type is of a pointer persuasion and of the guest context sort. */
108	#define DBGCVAR_ISGCPOINTER(enmType) (enmType >= DBGCVAR_TYPE_GC_FLAT && enmType <= DBGCVAR_TYPE_GC_PHYS)
109	/** Checks if the specified variable type is of a pointer persuasion and of the host context sort. */
110	#define DBGCVAR_ISHCPOINTER(enmType) (enmType >= DBGCVAR_TYPE_HC_FLAT && enmType <= DBGCVAR_TYPE_HC_PHYS)
111
112
113	/**
114	* DBGC variable range type.
115	*/
116	typedef enum DBGCVARRANGETYPE
117	{
118	/** No range appliable or no range specified. */
119	DBGCVAR_RANGE_NONE = 0,
120	/** Number of elements. */
121	DBGCVAR_RANGE_ELEMENTS,
122	/** Number of bytes. */
123	DBGCVAR_RANGE_BYTES
124	} DBGCVARRANGETYPE;
125
126
127	/**
128	* Variable descriptor.
129	*/
130	typedef struct DBGCVARDESC
131	{
132	/** The minimal number of times this argument may occur.
133	* Use 0 here to inidicate that the argument is optional. */
134	unsigned cTimesMin;
135	/** Maximum number of occurences.
136	* Use ~0 here to indicate infinite. */
137	unsigned cTimesMax;
138	/** Argument category. */
139	DBGCVARCAT enmCategory;
140	/** Flags, DBGCVD_FLAGS_* */
141	unsigned fFlags;
142	/** Argument name. */
143	const char *pszName;
144	/** Argument name. */
145	const char *pszDescription;
146	} DBGCVARDESC;
147	/** Pointer to an argument descriptor. */
148	typedef DBGCVARDESC *PDBGCVARDESC;
149	/** Pointer to a const argument descriptor. */
150	typedef const DBGCVARDESC *PCDBGCVARDESC;
151
152	/** Variable descriptor flags.
153	* @{ */
154	/** Indicates that the variable depends on the previous being present. */
155	#define DBGCVD_FLAGS_DEP_PREV BIT(1)
156	/** @} */
157
158
159	/**
160	* DBGC variable.
161	*/
162	typedef struct DBGCVAR
163	{
164	/** Pointer to the argument descriptor. */
165	PCDBGCVARDESC pDesc;
166	/** Pointer to the next argument. */
167	struct DBGCVAR *pNext;
168
169	/** Argument type. */
170	DBGCVARTYPE enmType;
171	/** Type specific. */
172	union
173	{
174	/** Flat GC Address. (DBGCVAR_TYPE_GC_FLAT) */
175	RTGCPTR GCFlat;
176	/** Far (16:32) GC Address. (DBGCVAR_TYPE_GC_FAR) */
177	RTFAR32 GCFar;
178	/** Physical GC Address. (DBGCVAR_TYPE_GC_PHYS) */
179	RTGCPHYS GCPhys;
180	/** Flat HC Address. (DBGCVAR_TYPE_HC_FLAT) */
181	void *pvHCFlat;
182	/** Far (16:32) HC Address. (DBGCVAR_TYPE_HC_FAR) */
183	RTFAR32 HCFar;
184	/** Physical GC Address. (DBGCVAR_TYPE_HC_PHYS) */
185	RTHCPHYS HCPhys;
186	/** String. (DBGCVAR_TYPE_STRING)
187	* The basic idea is the the this is a pointer to the expression we're
188	* parsing, so no messing with freeing. */
189	const char *pszString;
190	/** Number. (DBGCVAR_TYPE_NUMBER) */
191	uint64_t u64Number;
192	} u;
193
194	/** Range type. */
195	DBGCVARRANGETYPE enmRangeType;
196	/** Range. The use of the content depends on the enmRangeType. */
197	uint64_t u64Range;
198	} DBGCVAR;
199	/** Pointer to a command argument. */
200	typedef DBGCVAR *PDBGCVAR;
201	/** Pointer to a const command argument. */
202	typedef const DBGCVAR *PCDBGCVAR;
203
204
205	/** Pointer to helper functions for commands. */
206	typedef struct DBGCCMDHLP *PDBGCCMDHLP;
207
208	/**
209	* Command helper for writing text to the debug console.
210	*
211	* @returns VBox status.
212	* @param pCmdHlp Pointer to the command callback structure.
213	* @param pvBuf What to write.
214	* @param cbBuf Number of bytes to write.
215	* @param pcbWritten Where to store the number of bytes actually written.
216	* If NULL the entire buffer must be successfully written.
217	*/
218	typedef DECLCALLBACK(int) FNDBGCHLPWRITE(PDBGCCMDHLP pCmdHlp, const void pvBuf, size_t cbBuf, size_t pcbWritten);
219	/** Pointer to a FNDBGCHLPWRITE() function. */
220	typedef FNDBGCHLPWRITE *PFNDBGCHLPWRITE;
221
222	/**
223	* Command helper for writing formatted text to the debug console.
224	*
225	* @returns VBox status.
226	* @param pCmdHlp Pointer to the command callback structure.
227	* @param pcb Where to store the number of bytes written.
228	* @param pszFormat The format string.
229	* This is using the log formatter, so it's format extensions can be used.
230	* @param ... Arguments specified in the format string.
231	*/
232	typedef DECLCALLBACK(int) FNDBGCHLPPRINTF(PDBGCCMDHLP pCmdHlp, size_t pcbWritten, const char pszFormat, ...);
233	/** Pointer to a FNDBGCHLPPRINTF() function. */
234	typedef FNDBGCHLPPRINTF *PFNDBGCHLPPRINTF;
235
236	/**
237	* Command helper for writing formatted text to the debug console.
238	*
239	* @returns VBox status.
240	* @param pCmdHlp Pointer to the command callback structure.
241	* @param pcb Where to store the number of bytes written.
242	* @param pszFormat The format string.
243	* This is using the log formatter, so it's format extensions can be used.
244	* @param args Arguments specified in the format string.
245	*/
246	typedef DECLCALLBACK(int) FNDBGCHLPPRINTFV(PDBGCCMDHLP pCmdHlp, size_t pcbWritten, const char pszFormat, va_list args);
247	/** Pointer to a FNDBGCHLPPRINTFV() function. */
248	typedef FNDBGCHLPPRINTFV *PFNDBGCHLPPRINTFV;
249
250	/**
251	* Command helper for formatting and error message for a VBox status code.
252	*
253	* @returns VBox status code appropriate to return from a command.
254	* @param pCmdHlp Pointer to the command callback structure.
255	* @param rc The VBox status code.
256	* @param pcb Where to store the number of bytes written.
257	* @param pszFormat Format string for additional messages. Can be NULL.
258	* @param ... Format arguments, optional.
259	*/
260	typedef DECLCALLBACK(int) FNDBGCHLPVBOXERROR(PDBGCCMDHLP pCmdHlp, int rc, const char *pszFormat, ...);
261	/** Pointer to a FNDBGCHLPVBOXERROR() function. */
262	typedef FNDBGCHLPVBOXERROR *PFNDBGCHLPVBOXERROR;
263
264	/**
265	* Command helper for formatting and error message for a VBox status code.
266	*
267	* @returns VBox status code appropriate to return from a command.
268	* @param pCmdHlp Pointer to the command callback structure.
269	* @param rc The VBox status code.
270	* @param pcb Where to store the number of bytes written.
271	* @param pszFormat Format string for additional messages. Can be NULL.
272	* @param args Format arguments, optional.
273	*/
274	typedef DECLCALLBACK(int) FNDBGCHLPVBOXERRORV(PDBGCCMDHLP pCmdHlp, int rc, const char *pszFormat, va_list args);
275	/** Pointer to a FNDBGCHLPVBOXERRORV() function. */
276	typedef FNDBGCHLPVBOXERRORV *PFNDBGCHLPVBOXERRORV;
277
278	/**
279	* Command helper for reading memory specified by a DBGC variable.
280	*
281	* @returns VBox status code appropriate to return from a command.
282	* @param pCmdHlp Pointer to the command callback structure.
283	* @param pVM VM handle if GC or physical HC address.
284	* @param pvBuffer Where to store the read data.
285	* @param cbRead Number of bytes to read.
286	* @param pVarPointer DBGC variable specifying where to start reading.
287	* @param pcbRead Where to store the number of bytes actually read.
288	* This optional, but it's useful when read GC virtual memory where a
289	* page in the requested range might not be present.
290	* If not specified not-present failure or end of a HC physical page
291	* will cause failure.
292	*/
293	typedef DECLCALLBACK(int) FNDBGCHLPMEMREAD(PDBGCCMDHLP pCmdHlp, PVM pVM, void pvBuffer, size_t cbRead, PCDBGCVAR pVarPointer, size_t pcbRead);
294	/** Pointer to a FNDBGCHLPMEMREAD() function. */
295	typedef FNDBGCHLPMEMREAD *PFNDBGCHLPMEMREAD;
296
297	/**
298	* Command helper for writing memory specified by a DBGC variable.
299	*
300	* @returns VBox status code appropriate to return from a command.
301	* @param pCmdHlp Pointer to the command callback structure.
302	* @param pVM VM handle if GC or physical HC address.
303	* @param pvBuffer What to write.
304	* @param cbWrite Number of bytes to write.
305	* @param pVarPointer DBGC variable specifying where to start reading.
306	* @param pcbWritten Where to store the number of bytes written.
307	* This is optional. If NULL be aware that some of the buffer
308	* might have been written to the specified address.
309	*/
310	typedef DECLCALLBACK(int) FNDBGCHLPMEMWRITE(PDBGCCMDHLP pCmdHlp, PVM pVM, const void pvBuffer, size_t cbWrite, PCDBGCVAR pVarPointer, size_t pcbWritten);
311	/** Pointer to a FNDBGCHLPMEMWRITE() function. */
312	typedef FNDBGCHLPMEMWRITE *PFNDBGCHLPMEMWRITE;
313
314
315	/**
316	* Evaluates an expression.
317	* (Hopefully the parser and functions are fully reentrant.)
318	*
319	* @returns VBox status code appropriate to return from a command.
320	* @param pCmdHlp Pointer to the command callback structure.
321	* @param pResult Where to store the result.
322	* @param pszExpr The expression. Format string with the format DBGC extensions.
323	* @param ... Format arguments.
324	*/
325	typedef DECLCALLBACK(int) FNDBGCHLPEVAL(PDBGCCMDHLP pCmdHlp, PDBGCVAR pResult, const char *pszExpr, ...);
326	/** Pointer to a FNDBGCHLPEVAL() function. */
327	typedef FNDBGCHLPEVAL *PFNDBGCHLPEVAL;
328
329
330	/**
331	* Executes command an expression.
332	* (Hopefully the parser and functions are fully reentrant.)
333	*
334	* @returns VBox status code appropriate to return from a command.
335	* @param pCmdHlp Pointer to the command callback structure.
336	* @param pszExpr The expression. Format string with the format DBGC extensions.
337	* @param ... Format arguments.
338	*/
339	typedef DECLCALLBACK(int) FNDBGCHLPEXEC(PDBGCCMDHLP pCmdHlp, const char *pszExpr, ...);
340	/** Pointer to a FNDBGCHLPEVAL() function. */
341	typedef FNDBGCHLPEXEC *PFNDBGCHLPEXEC;
342
343
344	/**
345	* Helper functions for commands.
346	*/
347	typedef struct DBGCCMDHLP
348	{
349	/** Pointer to a FNDBCHLPWRITE() function. */
350	PFNDBGCHLPWRITE pfnWrite;
351	/** Pointer to a FNDBGCHLPPRINTF() function. */
352	PFNDBGCHLPPRINTF pfnPrintf;
353	/** Pointer to a FNDBGCHLPPRINTFV() function. */
354	PFNDBGCHLPPRINTFV pfnPrintfV;
355	/** Pointer to a FNDBGCHLPVBOXERROR() function. */
356	PFNDBGCHLPVBOXERROR pfnVBoxError;
357	/** Pointer to a FNDBGCHLPVBOXERRORV() function. */
358	PFNDBGCHLPVBOXERRORV pfnVBoxErrorV;
359	/** Pointer to a FNDBGCHLPMEMREAD() function. */
360	PFNDBGCHLPMEMREAD pfnMemRead;
361	/** Pointer to a FNDBGCHLPMEMWRITE() function. */
362	PFNDBGCHLPMEMWRITE pfnMemWrite;
363	/** Pointer to a FNDBGCHLPEVAL() function. */
364	PFNDBGCHLPEVAL pfnEval;
365	/** Pointer to a FNDBGCHLPEXEC() function. */
366	PFNDBGCHLPEXEC pfnExec;
367
368	/**
369	* Converts a DBGC variable to a DBGF address structure.
370	*
371	* @returns VBox status code.
372	* @param pCmdHlp Pointer to the command callback structure.
373	* @param pVar The variable to convert.
374	* @param pAddress The target address.
375	*/
376	DECLCALLBACKMEMBER(int, pfnVarToDbgfAddr)(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, PDBGFADDRESS pAddress);
377
378	/**
379	* Converts a DBGC variable to a boolean.
380	*
381	* @returns VBox status code.
382	* @param pCmdHlp Pointer to the command callback structure.
383	* @param pVar The variable to convert.
384	* @param pf Where to store the boolean.
385	*/
386	DECLCALLBACKMEMBER(int, pfnVarToBool)(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, bool *pf);
387
388	} DBGCCMDHLP;
389
390
391
392	/** Pointer to command descriptor. */
393	typedef struct DBGCCMD *PDBGCCMD;
394	/** Pointer to const command descriptor. */
395	typedef const struct DBGCCMD *PCDBGCCMD;
396
397	/**
398	* Command handler.
399	*
400	* The console will call the handler for a command once it's finished
401	* parsing the user input. The command handler function is responsible
402	* for executing the command itself.
403	*
404	* @returns VBox status.
405	* @param pCmd Pointer to the command descriptor (as registered).
406	* @param pCmdHlp Pointer to command helper functions.
407	* @param pVM Pointer to the current VM (if any).
408	* @param paArgs Pointer to (readonly) array of arguments.
409	* @param cArgs Number of arguments in the array.
410	* @param pResult Where to store the result. NULL if no result descriptor was specified.
411	*/
412	typedef DECLCALLBACK(int) FNDBGCCMD(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR pArgs, unsigned cArgs, PDBGCVAR pResult);
413	/** Pointer to a FNDBGCCMD() function. */
414	typedef FNDBGCCMD *PFNDBGCCMD;
415
416	/**
417	* DBGC command descriptor.
418	*
419	* If a pResultDesc is specified the command can be called and used
420	* as a function too. If it's a pure function, set fFlags to
421	* DBGCCMD_FLAGS_FUNCTION.
422	*/
423	typedef struct DBGCCMD
424	{
425	/** Command string. */
426	const char *pszCmd;
427	/** Minimum number of arguments. */
428	unsigned cArgsMin;
429	/** Max number of arguments. */
430	unsigned cArgsMax;
431	/** Argument descriptors (array). */
432	PCDBGCVARDESC paArgDescs;
433	/** Number of argument descriptors. */
434	unsigned cArgDescs;
435	/** Result descriptor. */
436	PCDBGCVARDESC pResultDesc;
437	/** flags. (reserved for now) */
438	unsigned fFlags;
439	/** Handler function. */
440	PFNDBGCCMD pfnHandler;
441	/** Command syntax. */
442	const char *pszSyntax;
443	/** Command description. */
444	const char *pszDescription;
445	} DBGCCMD;
446
447	/** DBGCCMD Flags.
448	* @{
449	*/
450	/** The description is of a pure function which cannot be invoked
451	* as a command from the commandline. */
452	#define DBGCCMD_FLAGS_FUNCTION 1
453	/** @} */
454
455
456
457	/** Pointer to a DBGC backend. */
458	typedef struct DBGCBACK *PDBGCBACK;
459
460	/**
461	* Checks if there is input.
462	*
463	* @returns true if there is input ready.
464	* @returns false if there not input ready.
465	* @param pBack Pointer to the backend structure supplied by
466	* the backend. The backend can use this to find
467	* it's instance data.
468	* @param cMillies Number of milliseconds to wait on input data.
469	*/
470	typedef DECLCALLBACK(bool) FNDBGCBACKINPUT(PDBGCBACK pBack, uint32_t cMillies);
471	/** Pointer to a FNDBGCBACKINPUT() callback. */
472	typedef FNDBGCBACKINPUT *PFNDBGCBACKINPUT;
473
474	/**
475	* Read input.
476	*
477	* @returns VBox status code.
478	* @param pBack Pointer to the backend structure supplied by
479	* the backend. The backend can use this to find
480	* it's instance data.
481	* @param pvBuf Where to put the bytes we read.
482	* @param cbBuf Maximum nymber of bytes to read.
483	* @param pcbRead Where to store the number of bytes actually read.
484	* If NULL the entire buffer must be filled for a
485	* successful return.
486	*/
487	typedef DECLCALLBACK(int) FNDBGCBACKREAD(PDBGCBACK pBack, void pvBuf, size_t cbBuf, size_t pcbRead);
488	/** Pointer to a FNDBGCBACKREAD() callback. */
489	typedef FNDBGCBACKREAD *PFNDBGCBACKREAD;
490
491	/**
492	* Write (output).
493	*
494	* @returns VBox status code.
495	* @param pBack Pointer to the backend structure supplied by
496	* the backend. The backend can use this to find
497	* it's instance data.
498	* @param pvBuf What to write.
499	* @param cbBuf Number of bytes to write.
500	* @param pcbWritten Where to store the number of bytes actually written.
501	* If NULL the entire buffer must be successfully written.
502	*/
503	typedef DECLCALLBACK(int) FNDBGCBACKWRITE(PDBGCBACK pBack, const void pvBuf, size_t cbBuf, size_t pcbWritten);
504	/** Pointer to a FNDBGCBACKWRITE() callback. */
505	typedef FNDBGCBACKWRITE *PFNDBGCBACKWRITE;
506
507
508	/**
509	* The communication backend provides the console with a number of callbacks
510	* which can be used
511	*/
512	typedef struct DBGCBACK
513	{
514	/** Check for input. */
515	PFNDBGCBACKINPUT pfnInput;
516	/** Read input. */
517	PFNDBGCBACKREAD pfnRead;
518	/** Write output. */
519	PFNDBGCBACKWRITE pfnWrite;
520	} DBGCBACK;
521
522
523	/**
524	* Make a console instance.
525	*
526	* This will not return until either an 'exit' command is issued or a error code
527	* indicating connection loss is encountered.
528	*
529	* @returns VINF_SUCCESS if console termination caused by the 'exit' command.
530	* @returns The VBox status code causing the console termination.
531	*
532	* @param pVM VM Handle.
533	* @param pBack Pointer to the backend structure. This must contain
534	* a full set of function pointers to service the console.
535	* @param fFlags Reserved, must be zero.
536	* @remark A forced termination of the console is easiest done by forcing the
537	* callbacks to return fatal failures.
538	*/
539	DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags);
540
541
542	/**
543	* Register one or more external commands.
544	*
545	* @returns VBox status.
546	* @param paCommands Pointer to an array of command descriptors.
547	* The commands must be unique. It's not possible
548	* to register the same commands more than once.
549	* @param cCommands Number of commands.
550	*/
551	DBGDECL(int) DBGCRegisterCommands(PCDBGCCMD paCommands, unsigned cCommands);
552
553
554	/**
555	* Deregister one or more external commands previously registered by
556	* DBGCRegisterCommands().
557	*
558	* @returns VBox status.
559	* @param paCommands Pointer to an array of command descriptors
560	* as given to DBGCRegisterCommands().
561	* @param cCommands Number of commands.
562	*/
563	DBGDECL(int) DBGCDeregisterCommands(PCDBGCCMD paCommands, unsigned cCommands);
564
565
566	/**
567	* Spawns a new thread with a TCP based debugging console service.
568	*
569	* @returns VBox status.
570	* @param pVM VM handle.
571	* @param ppvData Where to store the pointer to instance data.
572	*/
573	DBGDECL(int) DBGCTcpCreate(PVM pVM, void **ppvUser);
574
575	/**
576	* Terminates any running TCP base debugger consolse service.
577	*
578	* @returns VBox status.
579	* @param pVM VM handle.
580	* @param pvData Instance data set by DBGCTcpCreate().
581	*/
582	DBGDECL(int) DBGCTcpTerminate(PVM pVM, void *pvData);
583
584
585	__END_DECLS
586
587	#endif

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/VBox/dbg.h@ 3810

Download in other formats: