DBGCCommands.cpp@ 51287

Last change on this file since 51287 was 48696, checked in by vboxsync, 11 years ago
DBGC: Added unload command as well as loadimage32 and loadimage64 for mac os x and efi debugging.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 79.0 KB

Line
1	/* $Id: DBGCCommands.cpp 48696 2013-09-26 00:22:48Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console, Native Commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/*******************************************************************************
19	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_DBGC
22	#include <VBox/dbg.h>
23	#include <VBox/vmm/dbgf.h>
24	#include <VBox/vmm/vm.h>
25	#include <VBox/param.h>
26	#include <VBox/err.h>
27	#include <VBox/log.h>
28	#include <VBox/version.h>
29
30	#include <iprt/alloca.h>
31	#include <iprt/assert.h>
32	#include <iprt/ctype.h>
33	#include <iprt/dir.h>
34	#include <iprt/env.h>
35	#include <iprt/ldr.h>
36	#include <iprt/mem.h>
37	#include <iprt/rand.h>
38	#include <iprt/path.h>
39	#include <iprt/string.h>
40
41	#include <stdlib.h>
42	#include <stdio.h>
43
44	#include "DBGCInternal.h"
45
46
47	/*******************************************************************************
48	* Internal Functions *
49	*******************************************************************************/
50	static FNDBGCCMD dbgcCmdHelp;
51	static FNDBGCCMD dbgcCmdQuit;
52	static FNDBGCCMD dbgcCmdStop;
53	static FNDBGCCMD dbgcCmdDetect;
54	static FNDBGCCMD dbgcCmdCpu;
55	static FNDBGCCMD dbgcCmdInfo;
56	static FNDBGCCMD dbgcCmdLog;
57	static FNDBGCCMD dbgcCmdLogDest;
58	static FNDBGCCMD dbgcCmdLogFlags;
59	static FNDBGCCMD dbgcCmdLogFlush;
60	static FNDBGCCMD dbgcCmdFormat;
61	static FNDBGCCMD dbgcCmdLoadImage;
62	static FNDBGCCMD dbgcCmdLoadMap;
63	static FNDBGCCMD dbgcCmdLoadSeg;
64	static FNDBGCCMD dbgcCmdUnload;
65	static FNDBGCCMD dbgcCmdSet;
66	static FNDBGCCMD dbgcCmdUnset;
67	static FNDBGCCMD dbgcCmdLoadVars;
68	static FNDBGCCMD dbgcCmdShowVars;
69	static FNDBGCCMD dbgcCmdLoadPlugIn;
70	static FNDBGCCMD dbgcCmdUnloadPlugIn;
71	static FNDBGCCMD dbgcCmdShowPlugIns;
72	static FNDBGCCMD dbgcCmdHarakiri;
73	static FNDBGCCMD dbgcCmdEcho;
74	static FNDBGCCMD dbgcCmdRunScript;
75	static FNDBGCCMD dbgcCmdWriteCore;
76
77
78	/*******************************************************************************
79	* Global Variables *
80	*******************************************************************************/
81	/** One argument of any kind. */
82	static const DBGCVARDESC g_aArgAny[] =
83	{
84	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
85	{ 0, 1, DBGCVAR_CAT_ANY, 0, "var", "Any type of argument." },
86	};
87
88	/** Multiple string arguments (min 1). */
89	static const DBGCVARDESC g_aArgMultiStr[] =
90	{
91	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
92	{ 1, ~0U, DBGCVAR_CAT_STRING, 0, "strings", "One or more strings." },
93	};
94
95	/** Filename string. */
96	static const DBGCVARDESC g_aArgFilename[] =
97	{
98	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
99	{ 1, 1, DBGCVAR_CAT_STRING, 0, "path", "Filename string." },
100	};
101
102
103	/** 'cpu' arguments. */
104	static const DBGCVARDESC g_aArgCpu[] =
105	{
106	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
107	{ 0, 1, DBGCVAR_CAT_NUMBER_NO_RANGE, 0, "idCpu", "CPU ID" },
108	};
109
110
111	/** 'help' arguments. */
112	static const DBGCVARDESC g_aArgHelp[] =
113	{
114	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
115	{ 0, ~0U, DBGCVAR_CAT_STRING, 0, "cmd/op", "Zero or more command or operator names." },
116	};
117
118
119	/** 'info' arguments. */
120	static const DBGCVARDESC g_aArgInfo[] =
121	{
122	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
123	{ 1, 1, DBGCVAR_CAT_STRING, 0, "info", "The name of the info to display." },
124	{ 0, 1, DBGCVAR_CAT_STRING, 0, "args", "String arguments to the handler." },
125	};
126
127
128	/** loadimage arguments. */
129	static const DBGCVARDESC g_aArgLoadImage[] =
130	{
131	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
132	{ 1, 1, DBGCVAR_CAT_STRING, 0, "filename", "Filename string." },
133	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "The module address." },
134	{ 0, 1, DBGCVAR_CAT_STRING, 0, "name", "The module name. (optional)" },
135	};
136
137
138	/** loadmap arguments. */
139	static const DBGCVARDESC g_aArgLoadMap[] =
140	{
141	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
142	{ 1, 1, DBGCVAR_CAT_STRING, 0, "filename", "Filename string." },
143	{ 1, 1, DBGCVAR_CAT_POINTER, DBGCVD_FLAGS_DEP_PREV, "address", "The module address." },
144	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "name", "The module name. Empty string means default. (optional)" },
145	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "subtrahend", "Value to subtract from the addresses in the map file to rebase it correctly to address. (optional)" },
146	{ 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "seg", "The module segment number (0-based). (optional)" },
147	};
148
149
150	/** loadseg arguments. */
151	static const DBGCVARDESC g_aArgLoadSeg[] =
152	{
153	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
154	{ 1, 1, DBGCVAR_CAT_STRING, 0, "filename", "Filename string." },
155	{ 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "The module address." },
156	{ 1, 1, DBGCVAR_CAT_NUMBER, 0, "seg", "The module segment number (0-based)." },
157	{ 0, 1, DBGCVAR_CAT_STRING, DBGCVD_FLAGS_DEP_PREV, "name", "The module name. Empty string means default. (optional)" },
158	};
159
160
161	/** log arguments. */
162	static const DBGCVARDESC g_aArgLog[] =
163	{
164	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
165	{ 0, 1, DBGCVAR_CAT_STRING, 0, "groups", "Group modifier string (quote it!)." }
166	};
167
168
169	/** logdest arguments. */
170	static const DBGCVARDESC g_aArgLogDest[] =
171	{
172	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
173	{ 0, 1, DBGCVAR_CAT_STRING, 0, "dests", "Destination modifier string (quote it!)." }
174	};
175
176
177	/** logflags arguments. */
178	static const DBGCVARDESC g_aArgLogFlags[] =
179	{
180	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
181	{ 0, 1, DBGCVAR_CAT_STRING, 0, "flags", "Flag modifier string (quote it!)." }
182	};
183
184
185	/** loadplugin, unloadplugin. */
186	static const DBGCVARDESC g_aArgPlugIn[] =
187	{
188	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
189	{ 1, ~0U, DBGCVAR_CAT_STRING, 0, "plugin", "Plug-in name or filename." },
190	};
191
192
193	/** 'set' arguments */
194	static const DBGCVARDESC g_aArgSet[] =
195	{
196	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
197	{ 1, 1, DBGCVAR_CAT_SYMBOL, 0, "var", "Variable name." },
198	{ 1, 1, DBGCVAR_CAT_ANY, 0, "value", "Value to assign to the variable." },
199	};
200
201	/** loadplugin, unloadplugin. */
202	static const DBGCVARDESC g_aArgUnload[] =
203	{
204	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
205	{ 1, ~0U, DBGCVAR_CAT_STRING, 0, "modname", "Unloads all mappings of the given modules in the active address space." },
206	};
207
208	/** 'unset' arguments */
209	static const DBGCVARDESC g_aArgUnset[] =
210	{
211	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
212	{ 1, ~0U, DBGCVAR_CAT_SYMBOL, 0, "vars", "One or more variable names." },
213	};
214
215	/** writecore arguments. */
216	static const DBGCVARDESC g_aArgWriteCore[] =
217	{
218	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
219	{ 1, 1, DBGCVAR_CAT_STRING, 0, "path", "Filename string." },
220	};
221
222
223
224	/** Command descriptors for the basic commands. */
225	const DBGCCMD g_aDbgcCmds[] =
226	{
227	/* pszCmd, cArgsMin, cArgsMax, paArgDescs, cArgDescs, fFlags, pfnHandler pszSyntax, ....pszDescription */
228	{ "bye", 0, 0, NULL, 0, 0, dbgcCmdQuit, "", "Exits the debugger." },
229	{ "cpu", 0, 1, &g_aArgCpu[0], RT_ELEMENTS(g_aArgCpu), 0, dbgcCmdCpu, "[idCpu]", "If no argument, display the current CPU, else change to the specified CPU." },
230	{ "echo", 1, ~0U, &g_aArgMultiStr[0], RT_ELEMENTS(g_aArgMultiStr), 0, dbgcCmdEcho, "<str1> [str2..[strN]]", "Displays the strings separated by one blank space and the last one followed by a newline." },
231	{ "exit", 0, 0, NULL, 0, 0, dbgcCmdQuit, "", "Exits the debugger." },
232	{ "format", 1, 1, &g_aArgAny[0], RT_ELEMENTS(g_aArgAny), 0, dbgcCmdFormat, "", "Evaluates an expression and formats it." },
233	{ "detect", 0, 0, NULL, 0, 0, dbgcCmdDetect, "", "Detects or re-detects the guest os and starts the OS specific digger." },
234	{ "harakiri", 0, 0, NULL, 0, 0, dbgcCmdHarakiri, "", "Kills debugger process." },
235	{ "help", 0, ~0U, &g_aArgHelp[0], RT_ELEMENTS(g_aArgHelp), 0, dbgcCmdHelp, "[cmd/op [..]]", "Display help. For help about info items try 'info help'." },
236	{ "info", 1, 2, &g_aArgInfo[0], RT_ELEMENTS(g_aArgInfo), 0, dbgcCmdInfo, "<info> [args]", "Display info register in the DBGF. For a list of info items try 'info help'." },
237	{ "loadimage", 2, 3, &g_aArgLoadImage[0], RT_ELEMENTS(g_aArgLoadImage), 0, dbgcCmdLoadImage, "<filename> <address> [name]",
238	"Loads the symbols of an executable image at the specified address. "
239	/"Optionally giving the module a name other than the file name stem."/ }, /** @todo implement line breaks */
240	{ "loadimage32",2, 3, &g_aArgLoadImage[0], RT_ELEMENTS(g_aArgLoadImage), 0, dbgcCmdLoadImage, "<filename> <address> [name]", "loadimage variant for selecting 32-bit images (mach-o)." },
241	{ "loadimage64",2, 3, &g_aArgLoadImage[0], RT_ELEMENTS(g_aArgLoadImage), 0, dbgcCmdLoadImage, "<filename> <address> [name]", "loadimage variant for selecting 64-bit images (mach-o)." },
242	{ "loadmap", 2, 5, &g_aArgLoadMap[0], RT_ELEMENTS(g_aArgLoadMap), 0, dbgcCmdLoadMap, "<filename> <address> [name] [subtrahend] [seg]",
243	"Loads the symbols from a map file, usually at a specified address. "
244	/*"Optionally giving the module a name other than the file name stem "
245	"and a subtrahend to subtract from the addresses."*/ },
246	{ "loadplugin", 1, 1, &g_aArgPlugIn[0], RT_ELEMENTS(g_aArgPlugIn), 0, dbgcCmdLoadPlugIn,"<plugin1> [plugin2..N]", "Loads one or more plugins" },
247	{ "loadseg", 3, 4, &g_aArgLoadSeg[0], RT_ELEMENTS(g_aArgLoadSeg), 0, dbgcCmdLoadSeg, "<filename> <address> <seg> [name]",
248	"Loads the symbols of a segment in the executable image at the specified address. "
249	/"Optionally giving the module a name other than the file name stem."/ },
250	{ "loadvars", 1, 1, &g_aArgFilename[0], RT_ELEMENTS(g_aArgFilename), 0, dbgcCmdLoadVars, "<filename>", "Load variables from file. One per line, same as the args to the set command." },
251	{ "log", 0, 1, &g_aArgLog[0], RT_ELEMENTS(g_aArgLog), 0, dbgcCmdLog, "[group string]", "Displays or modifies the logging group settings (VBOX_LOG)" },
252	{ "logdest", 0, 1, &g_aArgLogDest[0], RT_ELEMENTS(g_aArgLogDest), 0, dbgcCmdLogDest, "[dest string]", "Displays or modifies the logging destination (VBOX_LOG_DEST)." },
253	{ "logflags", 0, 1, &g_aArgLogFlags[0], RT_ELEMENTS(g_aArgLogFlags), 0, dbgcCmdLogFlags, "[flags string]", "Displays or modifies the logging flags (VBOX_LOG_FLAGS)." },
254	{ "logflush", 0, 0, NULL, 0, 0, dbgcCmdLogFlush, "", "Flushes the log buffers." },
255	{ "quit", 0, 0, NULL, 0, 0, dbgcCmdQuit, "", "Exits the debugger." },
256	{ "runscript", 1, 1, &g_aArgFilename[0], RT_ELEMENTS(g_aArgFilename), 0, dbgcCmdRunScript, "<filename>", "Runs the command listed in the script. Lines starting with '#' "
257	"(after removing blanks) are comment. blank lines are ignored. Stops on failure." },
258	{ "set", 2, 2, &g_aArgSet[0], RT_ELEMENTS(g_aArgSet), 0, dbgcCmdSet, "<var> <value>", "Sets a global variable." },
259	{ "showplugins",0, 0, NULL, 0, 0, dbgcCmdShowPlugIns,"", "List loaded plugins." },
260	{ "showvars", 0, 0, NULL, 0, 0, dbgcCmdShowVars, "", "List all the defined variables." },
261	{ "stop", 0, 0, NULL, 0, 0, dbgcCmdStop, "", "Stop execution." },
262	{ "unload", 1, ~0U, &g_aArgUnload[0], RT_ELEMENTS(g_aArgUnload), 0, dbgcCmdUnload, "<modname1> [modname2..N]", "Unloads one or more modules in the current address space." },
263	{ "unloadplugin", 1, ~0U, &g_aArgPlugIn[0], RT_ELEMENTS(g_aArgPlugIn), 0, dbgcCmdUnloadPlugIn, "<plugin1> [plugin2..N]", "Unloads one or more plugins." },
264	{ "unset", 1, ~0U, &g_aArgUnset[0], RT_ELEMENTS(g_aArgUnset), 0, dbgcCmdUnset, "<var1> [var1..[varN]]", "Unsets (delete) one or more global variables." },
265	{ "writecore", 1, 1, &g_aArgWriteCore[0], RT_ELEMENTS(g_aArgWriteCore), 0, dbgcCmdWriteCore, "<filename>", "Write core to file." },
266	};
267	/** The number of native commands. */
268	const uint32_t g_cDbgcCmds = RT_ELEMENTS(g_aDbgcCmds);
269	/** Pointer to head of the list of external commands. */
270	static PDBGCEXTCMDS g_pExtCmdsHead;
271
272
273
274
275	/**
276	* Finds a routine.
277	*
278	* @returns Pointer to the command descriptor.
279	* If the request was for an external command, the caller is responsible for
280	* unlocking the external command list.
281	* @returns NULL if not found.
282	* @param pDbgc The debug console instance.
283	* @param pachName Pointer to the routine string (not terminated).
284	* @param cchName Length of the routine name.
285	* @param fExternal Whether or not the routine is external.
286	*/
287	PCDBGCCMD dbgcCommandLookup(PDBGC pDbgc, const char *pachName, size_t cchName, bool fExternal)
288	{
289	if (!fExternal)
290	{
291	/* emulation first, so commands can be overloaded (info ++). */
292	PCDBGCCMD pCmd = pDbgc->paEmulationCmds;
293	unsigned cLeft = pDbgc->cEmulationCmds;
294	while (cLeft-- > 0)
295	{
296	if ( !strncmp(pachName, pCmd->pszCmd, cchName)
297	&& !pCmd->pszCmd[cchName])
298	return pCmd;
299	pCmd++;
300	}
301
302	for (unsigned iCmd = 0; iCmd < RT_ELEMENTS(g_aDbgcCmds); iCmd++)
303	{
304	if ( !strncmp(pachName, g_aDbgcCmds[iCmd].pszCmd, cchName)
305	&& !g_aDbgcCmds[iCmd].pszCmd[cchName])
306	return &g_aDbgcCmds[iCmd];
307	}
308	}
309	else
310	{
311	DBGCEXTLISTS_LOCK_RD();
312	for (PDBGCEXTCMDS pExtCmds = g_pExtCmdsHead; pExtCmds; pExtCmds = pExtCmds->pNext)
313	{
314	for (unsigned iCmd = 0; iCmd < pExtCmds->cCmds; iCmd++)
315	{
316	if ( !strncmp(pachName, pExtCmds->paCmds[iCmd].pszCmd, cchName)
317	&& !pExtCmds->paCmds[iCmd].pszCmd[cchName])
318	return &pExtCmds->paCmds[iCmd];
319	}
320	}
321	DBGCEXTLISTS_UNLOCK_RD();
322	}
323
324	return NULL;
325	}
326
327
328	/**
329	* Register one or more external commands.
330	*
331	* @returns VBox status.
332	* @param paCommands Pointer to an array of command descriptors.
333	* The commands must be unique. It's not possible
334	* to register the same commands more than once.
335	* @param cCommands Number of commands.
336	*/
337	DBGDECL(int) DBGCRegisterCommands(PCDBGCCMD paCommands, unsigned cCommands)
338	{
339	/*
340	* Lock the list.
341	*/
342	DBGCEXTLISTS_LOCK_WR();
343	PDBGCEXTCMDS pCur = g_pExtCmdsHead;
344	while (pCur)
345	{
346	if (paCommands == pCur->paCmds)
347	{
348	DBGCEXTLISTS_UNLOCK_WR();
349	AssertMsgFailed(("Attempt at re-registering %d command(s)!\n", cCommands));
350	return VWRN_DBGC_ALREADY_REGISTERED;
351	}
352	pCur = pCur->pNext;
353	}
354
355	/*
356	* Allocate new chunk.
357	*/
358	int rc = 0;
359	pCur = (PDBGCEXTCMDS)RTMemAlloc(sizeof(*pCur));
360	if (pCur)
361	{
362	pCur->cCmds = cCommands;
363	pCur->paCmds = paCommands;
364	pCur->pNext = g_pExtCmdsHead;
365	g_pExtCmdsHead = pCur;
366	}
367	else
368	rc = VERR_NO_MEMORY;
369	DBGCEXTLISTS_UNLOCK_WR();
370
371	return rc;
372	}
373
374
375	/**
376	* Deregister one or more external commands previously registered by
377	* DBGCRegisterCommands().
378	*
379	* @returns VBox status.
380	* @param paCommands Pointer to an array of command descriptors
381	* as given to DBGCRegisterCommands().
382	* @param cCommands Number of commands.
383	*/
384	DBGDECL(int) DBGCDeregisterCommands(PCDBGCCMD paCommands, unsigned cCommands)
385	{
386	/*
387	* Lock the list.
388	*/
389	DBGCEXTLISTS_LOCK_WR();
390	PDBGCEXTCMDS pPrev = NULL;
391	PDBGCEXTCMDS pCur = g_pExtCmdsHead;
392	while (pCur)
393	{
394	if (paCommands == pCur->paCmds)
395	{
396	if (pPrev)
397	pPrev->pNext = pCur->pNext;
398	else
399	g_pExtCmdsHead = pCur->pNext;
400	DBGCEXTLISTS_UNLOCK_WR();
401
402	RTMemFree(pCur);
403	return VINF_SUCCESS;
404	}
405	pPrev = pCur;
406	pCur = pCur->pNext;
407	}
408	DBGCEXTLISTS_UNLOCK_WR();
409
410	NOREF(cCommands);
411	return VERR_DBGC_COMMANDS_NOT_REGISTERED;
412	}
413
414
415	/**
416	* Outputs a command or function summary line.
417	*
418	* @returns Output status code
419	* @param pCmdHlp The command helpers.
420	* @param pszName The name of the function or command.
421	* @param fExternal Whether it's external.
422	* @param pszSyntax The syntax.
423	* @param pszDescription The description.
424	*/
425	static int dbgcCmdHelpCmdOrFunc(PDBGCCMDHLP pCmdHlp, const char *pszName, bool fExternal,
426	const char pszSyntax, const char pszDescription)
427	{
428	/*
429	* Aiming for "%-11s %-30s %s". Need to adjust when any of the two
430	* columns are two wide as well as break the last column up if its
431	* too wide.
432	*/
433	size_t const cchMaxWidth = 100;
434	size_t const cchCol1 = 11;
435	size_t const cchCol2 = 30;
436	size_t const cchCol3 = cchMaxWidth - cchCol1 - cchCol2 - 2;
437
438	size_t const cchName = strlen(pszName) + fExternal;
439	size_t const cchSyntax = strlen(pszSyntax);
440	size_t cchDesc = strlen(pszDescription);
441
442	/* Can we do it the simple + fast way? */
443	if ( cchName <= cchCol1
444	&& cchSyntax <= cchCol2
445	&& cchDesc <= cchCol3)
446	return DBGCCmdHlpPrintf(pCmdHlp,
447	!fExternal ? "%-s %-s %s\n" : ".%-s %-s %s\n",
448	cchCol1, pszName,
449	cchCol2, pszSyntax,
450	pszDescription);
451
452	/* Column 1. */
453	size_t off = 0;
454	DBGCCmdHlpPrintf(pCmdHlp, !fExternal ? "%s" : ".%s", pszName);
455	off += cchName;
456	ssize_t cchPadding = cchCol1 - off;
457	if (cchPadding <= 0)
458	cchPadding = 0;
459
460	/* Column 2. */
461	DBGCCmdHlpPrintf(pCmdHlp, "%*s %s", cchPadding, "", pszSyntax);
462	off += cchPadding + 1 + cchSyntax;
463	cchPadding = cchCol1 + 1 + cchCol2 - off;
464	if (cchPadding <= 0)
465	cchPadding = 0;
466	off += cchPadding;
467
468	/* Column 3. */
469	for (;;)
470	{
471	ssize_t cchCurWidth = cchMaxWidth - off - 1;
472	if (cchCurWidth != (ssize_t)cchCol3)
473	DBGCCmdHlpPrintf(pCmdHlp, "\n");
474	else if ((ssize_t)cchDesc <= cchCurWidth)
475	return DBGCCmdHlpPrintf(pCmdHlp, "%*s %s\n", cchPadding, "", pszDescription);
476	else
477	{
478	/* Split on preceeding blank. */
479	const char *pszEnd = &pszDescription[cchCurWidth];
480	if (!RT_C_IS_BLANK(*pszEnd))
481	while (pszEnd != pszDescription && !RT_C_IS_BLANK(pszEnd[-1]))
482	pszEnd--;
483	const char *pszNext = pszEnd;
484
485	while (pszEnd != pszDescription && RT_C_IS_BLANK(pszEnd[-1]))
486	pszEnd--;
487	if (pszEnd == pszDescription)
488	{
489	while (pszEnd && !RT_C_IS_BLANK(pszEnd))
490	pszEnd++;
491	pszNext = pszEnd;
492	}
493
494	while (RT_C_IS_BLANK(*pszNext))
495	pszNext++;
496
497	/* Output it and advance to the next line. */
498	if (!*pszNext)
499	return DBGCCmdHlpPrintf(pCmdHlp, "%s %.s\n", cchPadding, "", pszEnd - pszDescription, pszDescription);
500	DBGCCmdHlpPrintf(pCmdHlp, "%s %.s\n", cchPadding, "", pszEnd - pszDescription, pszDescription);
501
502	/* next */
503	cchDesc -= pszNext - pszDescription;
504	pszDescription = pszNext;
505	}
506	off = cchCol1 + 1 + cchCol2;
507	cchPadding = off;
508	}
509	}
510
511
512	/**
513	* Prints full command help.
514	*/
515	static void dbgcCmdHelpCmdOrFuncFull(PDBGCCMDHLP pCmdHlp, const char *pszName, bool fExternal,
516	const char pszSyntax, const char pszDescription,
517	uint32_t cArgsMin, uint32_t cArgsMax,
518	PCDBGCVARDESC paArgDescs, uint32_t cArgDescs, uint32_t *pcHits)
519	{
520	if (*pcHits)
521	DBGCCmdHlpPrintf(pCmdHlp, "\n");
522	*pcHits += 1;
523
524	/* the command */
525	dbgcCmdHelpCmdOrFunc(pCmdHlp, pszName, fExternal, pszSyntax, pszDescription);
526	#if 1
527	char szTmp[80];
528	if (!cArgsMin && cArgsMin == cArgsMax)
529	RTStrPrintf(szTmp, sizeof(szTmp), "<no args>");
530	else if (cArgsMin == cArgsMax)
531	RTStrPrintf(szTmp, sizeof(szTmp), " <%u args>", cArgsMin);
532	else if (cArgsMax == ~0U)
533	RTStrPrintf(szTmp, sizeof(szTmp), " <%u+ args>", cArgsMin);
534	else
535	RTStrPrintf(szTmp, sizeof(szTmp), " <%u to %u args>", cArgsMin, cArgsMax);
536	dbgcCmdHelpCmdOrFunc(pCmdHlp, "", false, szTmp, "");
537	#endif
538
539	/* argument descriptions. */
540	for (uint32_t i = 0; i < cArgDescs; i++)
541	{
542	DBGCCmdHlpPrintf(pCmdHlp, " %-12s %s", paArgDescs[i].pszName, paArgDescs[i].pszDescription);
543	if (!paArgDescs[i].cTimesMin)
544	{
545	if (paArgDescs[i].cTimesMax == ~0U)
546	DBGCCmdHlpPrintf(pCmdHlp, " <optional+>\n");
547	else
548	DBGCCmdHlpPrintf(pCmdHlp, " <optional-%u>\n", paArgDescs[i].cTimesMax);
549	}
550	else
551	{
552	if (paArgDescs[i].cTimesMax == ~0U)
553	DBGCCmdHlpPrintf(pCmdHlp, " <%u+>\n", paArgDescs[i].cTimesMin);
554	else
555	DBGCCmdHlpPrintf(pCmdHlp, " <%u-%u>\n", paArgDescs[i].cTimesMin, paArgDescs[i].cTimesMax);
556	}
557	}
558	}
559
560
561
562	/**
563	* Prints full command help.
564	*/
565	static void dbgcPrintHelpCmd(PDBGCCMDHLP pCmdHlp, PCDBGCCMD pCmd, bool fExternal, uint32_t *pcHits)
566	{
567	dbgcCmdHelpCmdOrFuncFull(pCmdHlp, pCmd->pszCmd, fExternal, pCmd->pszSyntax, pCmd->pszDescription,
568	pCmd->cArgsMin, pCmd->cArgsMax, pCmd->paArgDescs, pCmd->cArgDescs, pcHits);
569	}
570
571
572	/**
573	* Prints full function help.
574	*/
575	static void dbgcPrintHelpFunction(PDBGCCMDHLP pCmdHlp, PCDBGCFUNC pFunc, bool fExternal, uint32_t *pcHits)
576	{
577	dbgcCmdHelpCmdOrFuncFull(pCmdHlp, pFunc->pszFuncNm, fExternal, pFunc->pszSyntax, pFunc->pszDescription,
578	pFunc->cArgsMin, pFunc->cArgsMax, pFunc->paArgDescs, pFunc->cArgDescs, pcHits);
579	}
580
581
582	static void dbgcCmdHelpCommandsWorker(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, PCDBGCCMD paCmds, uint32_t cCmds, bool fExternal,
583	const char *pszDescFmt, ...)
584	{
585	if (pszDescFmt)
586	{
587	va_list va;
588	va_start(va, pszDescFmt);
589	pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszDescFmt, va);
590	va_end(va);
591	}
592
593	for (uint32_t i = 0; i < cCmds; i++)
594	dbgcCmdHelpCmdOrFunc(pCmdHlp, paCmds[i].pszCmd, fExternal, paCmds[i].pszSyntax, paCmds[i].pszDescription);
595	}
596
597
598	static void dbgcCmdHelpCommands(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, uint32_t *pcHits)
599	{
600	if (*pcHits)
601	DBGCCmdHlpPrintf(pCmdHlp, "\n");
602	*pcHits += 1;
603
604	dbgcCmdHelpCommandsWorker(pDbgc, pCmdHlp, pDbgc->paEmulationCmds, pDbgc->cEmulationCmds, false,
605	"Commands for %s emulation:\n", pDbgc->pszEmulation);
606	dbgcCmdHelpCommandsWorker(pDbgc, pCmdHlp, g_aDbgcCmds, RT_ELEMENTS(g_aDbgcCmds), false,
607	"\nCommon Commands:\n");
608
609	DBGCEXTLISTS_LOCK_RD();
610	const char *pszDesc = "\nExternal Commands:\n";
611	for (PDBGCEXTCMDS pExtCmd = g_pExtCmdsHead; pExtCmd; pExtCmd = pExtCmd->pNext)
612	{
613	dbgcCmdHelpCommandsWorker(pDbgc, pCmdHlp, pExtCmd->paCmds, pExtCmd->cCmds, false, pszDesc);
614	pszDesc = NULL;
615	}
616	DBGCEXTLISTS_UNLOCK_RD();
617	}
618
619
620	static void dbgcCmdHelpFunctionsWorker(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, PCDBGCFUNC paFuncs, size_t cFuncs, bool fExternal,
621	const char *pszDescFmt, ...)
622	{
623	if (pszDescFmt)
624	{
625	va_list va;
626	va_start(va, pszDescFmt);
627	DBGCCmdHlpPrintf(pCmdHlp, pszDescFmt, va);
628	va_end(va);
629	}
630
631	for (uint32_t i = 0; i < cFuncs; i++)
632	dbgcCmdHelpCmdOrFunc(pCmdHlp, paFuncs[i].pszFuncNm, fExternal, paFuncs[i].pszSyntax, paFuncs[i].pszDescription);
633	}
634
635
636	static void dbgcCmdHelpFunctions(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, uint32_t *pcHits)
637	{
638	if (*pcHits)
639	DBGCCmdHlpPrintf(pCmdHlp, "\n");
640	*pcHits += 1;
641
642	dbgcCmdHelpFunctionsWorker(pDbgc, pCmdHlp, pDbgc->paEmulationFuncs, pDbgc->cEmulationFuncs, false,
643	"Functions for %s emulation:\n", pDbgc->pszEmulation);
644	dbgcCmdHelpFunctionsWorker(pDbgc, pCmdHlp, g_aDbgcFuncs, g_cDbgcFuncs, false,
645	"\nCommon Functions:\n");
646	#if 0
647	DBGCEXTLISTS_LOCK_RD();
648	const char *pszDesc = "\nExternal Functions:\n";
649	for (PDBGCEXTFUNCS pExtFunc = g_pExtFuncsHead; pExtFunc; pExtFunc = pExtFunc->pNext)
650	{
651	dbgcCmdHelpFunctionsWorker(pDbgc, pCmdHlp, pExtFunc->paFuncs, pExtFunc->cFuncs, false,
652	pszDesc);
653	pszDesc = NULL;
654	}
655	DBGCEXTLISTS_UNLOCK_RD();
656	#endif
657	}
658
659
660	static void dbgcCmdHelpOperators(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, uint32_t *pcHits)
661	{
662	DBGCCmdHlpPrintf(pCmdHlp, !*pcHits ? "Operators:\n" : "\nOperators:\n");
663	*pcHits += 1;
664
665	unsigned iPrecedence = 0;
666	unsigned cLeft = g_cDbgcOps;
667	while (cLeft > 0)
668	{
669	for (unsigned i = 0; i < g_cDbgcOps; i++)
670	if (g_aDbgcOps[i].iPrecedence == iPrecedence)
671	{
672	dbgcCmdHelpCmdOrFunc(pCmdHlp, g_aDbgcOps[i].szName, false,
673	g_aDbgcOps[i].fBinary ? "Binary" : "Unary ",
674	g_aDbgcOps[i].pszDescription);
675	cLeft--;
676	}
677	iPrecedence++;
678	}
679	}
680
681
682	static void dbgcCmdHelpAll(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, uint32_t *pcHits)
683	{
684	*pcHits += 1;
685	DBGCCmdHlpPrintf(pCmdHlp,
686	"\n"
687	"VirtualBox Debugger Help\n"
688	"------------------------\n"
689	"\n");
690	dbgcCmdHelpCommands(pDbgc, pCmdHlp, pcHits);
691	DBGCCmdHlpPrintf(pCmdHlp, "\n");
692	dbgcCmdHelpFunctions(pDbgc, pCmdHlp, pcHits);
693	DBGCCmdHlpPrintf(pCmdHlp, "\n");
694	dbgcCmdHelpOperators(pDbgc, pCmdHlp, pcHits);
695	}
696
697
698	static void dbgcCmdHelpSummary(PDBGC pDbgc, PDBGCCMDHLP pCmdHlp, uint32_t *pcHits)
699	{
700	*pcHits += 1;
701	DBGCCmdHlpPrintf(pCmdHlp,
702	"\n"
703	"VirtualBox Debugger Help Summary\n"
704	"--------------------------------\n"
705	"\n"
706	"help commands Show help on all commands.\n"
707	"help functions Show help on all functions.\n"
708	"help operators Show help on all operators.\n"
709	"help all All the above.\n"
710	"help <cmd-pattern> [...]\n"
711	" Show details help on individual commands, simple\n"
712	" patterns can be used to match several commands.\n"
713	"help [summary] Displays this message.\n"
714	);
715	}
716
717
718	/**
719	* @interface_method_impl{FNDBCCMD, The 'help' command.}
720	*/
721	static DECLCALLBACK(int) dbgcCmdHelp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
722	{
723	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
724	int rc = VINF_SUCCESS;
725	uint32_t cHits = 0;
726
727	if (!cArgs)
728	/*
729	* No arguments, show summary.
730	*/
731	dbgcCmdHelpSummary(pDbgc, pCmdHlp, &cHits);
732	else
733	{
734	/*
735	* Search for the arguments (strings).
736	*/
737	DBGCEXTCMDS aFixedCmds[] =
738	{
739	{ pDbgc->cEmulationCmds, pDbgc->paEmulationCmds, NULL },
740	{ g_cDbgcCmds, g_aDbgcCmds, NULL },
741	};
742	DBGCEXTFUNCS aFixedFuncs[] =
743	{
744	{ pDbgc->cEmulationFuncs, pDbgc->paEmulationFuncs, NULL },
745	{ g_cDbgcFuncs, g_aDbgcFuncs, NULL },
746	};
747
748	for (unsigned iArg = 0; iArg < cArgs; iArg++)
749	{
750	AssertReturn(paArgs[iArg].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_BUG);
751	const char *pszPattern = paArgs[iArg].u.pszString;
752
753	/* aliases */
754	if ( !strcmp(pszPattern, "commands")
755	\|\| !strcmp(pszPattern, "cmds") )
756	dbgcCmdHelpCommands(pDbgc, pCmdHlp, &cHits);
757	else if ( !strcmp(pszPattern, "functions")
758	\|\| !strcmp(pszPattern, "funcs") )
759	dbgcCmdHelpFunctions(pDbgc, pCmdHlp, &cHits);
760	else if ( !strcmp(pszPattern, "operators")
761	\|\| !strcmp(pszPattern, "ops") )
762	dbgcCmdHelpOperators(pDbgc, pCmdHlp, &cHits);
763	else if (!strcmp(pszPattern, "all"))
764	dbgcCmdHelpAll(pDbgc, pCmdHlp, &cHits);
765	else if (!strcmp(pszPattern, "summary"))
766	dbgcCmdHelpSummary(pDbgc, pCmdHlp, &cHits);
767	/* Individual commands. */
768	else
769	{
770	uint32_t const cPrevHits = cHits;
771
772	/* lookup in the emulation command list first */
773	for (unsigned j = 0; j < RT_ELEMENTS(aFixedCmds); j++)
774	for (unsigned i = 0; i < aFixedCmds[j].cCmds; i++)
775	if (RTStrSimplePatternMatch(pszPattern, aFixedCmds[j].paCmds[i].pszCmd))
776	dbgcPrintHelpCmd(pCmdHlp, &aFixedCmds[j].paCmds[i], false, &cHits);
777	for (unsigned j = 0; j < RT_ELEMENTS(aFixedFuncs); j++)
778	for (unsigned i = 0; i < aFixedFuncs[j].cFuncs; i++)
779	if (RTStrSimplePatternMatch(pszPattern, aFixedFuncs[j].paFuncs[i].pszFuncNm))
780	dbgcPrintHelpFunction(pCmdHlp, &aFixedFuncs[j].paFuncs[i], false, &cHits);
781
782	/* external commands */
783	if ( g_pExtCmdsHead
784	&& ( *pszPattern == '.'
785	\|\| *pszPattern == '?'
786	\|\| pszPattern == ''))
787	{
788	DBGCEXTLISTS_LOCK_RD();
789	const char pszPattern2 = pszPattern + (pszPattern == '.' \|\| *pszPattern == '?');
790	for (PDBGCEXTCMDS pExtCmd = g_pExtCmdsHead; pExtCmd; pExtCmd = pExtCmd->pNext)
791	for (unsigned i = 0; i < pExtCmd->cCmds; i++)
792	if (RTStrSimplePatternMatch(pszPattern2, pExtCmd->paCmds[i].pszCmd))
793	dbgcPrintHelpCmd(pCmdHlp, &pExtCmd->paCmds[i], true, &cHits);
794	#if 0
795	for (PDBGCEXTFUNCS pExtFunc = g_pExtFuncsHead; pExtFunc; pExtFunc = pExtFunc->pNext)
796	for (unsigned i = 0; i < pExtFunc->cFuncs; i++)
797	if (RTStrSimplePatternMatch(pszPattern2, pExtFunc->paFuncs[i].pszFuncNm))
798	dbgcPrintHelpFunction(pCmdHlp, &pExtFunc->paFuncs[i], true, &cHits);
799	#endif
800	DBGCEXTLISTS_UNLOCK_RD();
801	}
802
803	/* operators */
804	if (cHits == cPrevHits && strlen(paArgs[iArg].u.pszString) < sizeof(g_aDbgcOps[0].szName))
805	for (unsigned i = 0; i < g_cDbgcOps && RT_SUCCESS(rc); i++)
806	if (RTStrSimplePatternMatch(pszPattern, g_aDbgcOps[i].szName))
807	{
808	if (cHits++)
809	DBGCCmdHlpPrintf(pCmdHlp, "\n");
810	dbgcCmdHelpCmdOrFunc(pCmdHlp, g_aDbgcOps[i].szName, false,
811	g_aDbgcOps[i].fBinary ? "Binary" : "Unary ",
812	g_aDbgcOps[i].pszDescription);
813	}
814
815	/* found? */
816	if (cHits == cPrevHits)
817	{
818	DBGCCmdHlpPrintf(pCmdHlp, "error: '%s' was not found!\n",
819	paArgs[iArg].u.pszString);
820	rc = VERR_DBGC_COMMAND_FAILED;
821	}
822	}
823	} /* foreach argument */
824	}
825
826	NOREF(pCmd);
827	NOREF(pUVM);
828	return rc;
829	}
830
831
832	/**
833	* @interface_method_impl{FNDBCCMD, The 'quit', 'exit' and 'bye' commands. }
834	*/
835	static DECLCALLBACK(int) dbgcCmdQuit(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
836	{
837	DBGCCmdHlpPrintf(pCmdHlp, "Quitting console...\n");
838	NOREF(pCmd);
839	NOREF(pUVM);
840	NOREF(paArgs);
841	NOREF(cArgs);
842	return VERR_DBGC_QUIT;
843	}
844
845
846	/**
847	* @interface_method_impl{FNDBCCMD, The 'stop' command.}
848	*/
849	static DECLCALLBACK(int) dbgcCmdStop(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
850	{
851	/*
852	* Check if the VM is halted or not before trying to halt it.
853	*/
854	int rc;
855	if (DBGFR3IsHalted(pUVM))
856	rc = DBGCCmdHlpPrintf(pCmdHlp, "warning: The VM is already halted...\n");
857	else
858	{
859	rc = DBGFR3Halt(pUVM);
860	if (RT_SUCCESS(rc))
861	rc = VWRN_DBGC_CMD_PENDING;
862	else
863	rc = DBGCCmdHlpVBoxError(pCmdHlp, rc, "Executing DBGFR3Halt().");
864	}
865
866	NOREF(pCmd); NOREF(paArgs); NOREF(cArgs);
867	return rc;
868	}
869
870
871	/**
872	* @interface_method_impl{FNDBCCMD, The 'echo' command.}
873	*/
874	static DECLCALLBACK(int) dbgcCmdEcho(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
875	{
876	/*
877	* Loop thru the arguments and print them with one space between.
878	*/
879	int rc = 0;
880	for (unsigned i = 0; i < cArgs; i++)
881	{
882	AssertReturn(paArgs[i].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_BUG);
883	rc = DBGCCmdHlpPrintf(pCmdHlp, i ? " %s" : "%s", paArgs[i].u.pszString);
884	if (RT_FAILURE(rc))
885	return rc;
886	}
887	NOREF(pCmd); NOREF(pUVM);
888	return DBGCCmdHlpPrintf(pCmdHlp, "\n");
889	}
890
891
892	/**
893	* @interface_method_impl{FNDBCCMD, The 'runscript' command.}
894	*/
895	static DECLCALLBACK(int) dbgcCmdRunScript(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
896	{
897	/* check that the parser did what it's supposed to do. */
898	if ( cArgs != 1
899	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING)
900	return DBGCCmdHlpPrintf(pCmdHlp, "parser error\n");
901
902	/** @todo Load the script here, but someone else should do the actual
903	* evaluation and execution of it. */
904
905	/*
906	* Try open the script.
907	*/
908	const char *pszFilename = paArgs[0].u.pszString;
909	FILE *pFile = fopen(pszFilename, "r");
910	if (!pFile)
911	return DBGCCmdHlpPrintf(pCmdHlp, "Failed to open '%s'.\n", pszFilename);
912
913	/*
914	* Execute it line by line.
915	*/
916	int rc = 0;
917	unsigned iLine = 0;
918	char szLine[8192];
919	while (fgets(szLine, sizeof(szLine), pFile))
920	{
921	/* check that the line isn't too long. */
922	char *pszEnd = strchr(szLine, '\0');
923	if (pszEnd == &szLine[sizeof(szLine) - 1])
924	{
925	rc = DBGCCmdHlpPrintf(pCmdHlp, "runscript error: Line #%u is too long\n", iLine);
926	break;
927	}
928	iLine++;
929
930	/* strip leading blanks and check for comment / blank line. */
931	char *psz = RTStrStripL(szLine);
932	if ( *psz == '\0'
933	\|\| *psz == '\n'
934	\|\| *psz == '#')
935	continue;
936
937	/* strip trailing blanks and check for empty line (\r case). */
938	while ( pszEnd > psz
939	&& RT_C_IS_SPACE(pszEnd[-1])) /* RT_C_IS_SPACE includes \n and \r normally. */
940	*--pszEnd = '\0';
941
942	/** @todo check for Control-C / Cancel at this point... */
943
944	/*
945	* Execute the command.
946	*
947	* This is a bit wasteful with scratch space btw., can fix it later.
948	* The whole return code crap should be fixed too, so that it's possible
949	* to know whether a command succeeded (RT_SUCCESS()) or failed, and
950	* more importantly why it failed.
951	*/
952	rc = pCmdHlp->pfnExec(pCmdHlp, "%s", psz);
953	if (RT_FAILURE(rc))
954	{
955	if (rc == VERR_BUFFER_OVERFLOW)
956	rc = DBGCCmdHlpPrintf(pCmdHlp, "runscript error: Line #%u is too long (exec overflowed)\n", iLine);
957	break;
958	}
959	if (rc == VWRN_DBGC_CMD_PENDING)
960	{
961	rc = DBGCCmdHlpPrintf(pCmdHlp, "runscript error: VWRN_DBGC_CMD_PENDING on line #%u, script terminated\n", iLine);
962	break;
963	}
964	}
965
966	fclose(pFile);
967
968	NOREF(pCmd); NOREF(pUVM);
969	return rc;
970	}
971
972
973	/**
974	* @interface_method_impl{FNDBCCMD, The 'detect' command.}
975	*/
976	static DECLCALLBACK(int) dbgcCmdDetect(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
977	{
978	/* check that the parser did what it's supposed to do. */
979	if (cArgs != 0)
980	return DBGCCmdHlpPrintf(pCmdHlp, "parser error\n");
981
982	/*
983	* Perform the detection.
984	*/
985	char szName[64];
986	int rc = DBGFR3OSDetect(pUVM, szName, sizeof(szName));
987	if (RT_FAILURE(rc))
988	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Executing DBGFR3OSDetect().\n");
989	if (rc == VINF_SUCCESS)
990	{
991	rc = DBGCCmdHlpPrintf(pCmdHlp, "Guest OS: %s\n", szName);
992	char szVersion[512];
993	int rc2 = DBGFR3OSQueryNameAndVersion(pUVM, NULL, 0, szVersion, sizeof(szVersion));
994	if (RT_SUCCESS(rc2))
995	rc = DBGCCmdHlpPrintf(pCmdHlp, "Version : %s\n", szVersion);
996	}
997	else
998	rc = DBGCCmdHlpPrintf(pCmdHlp, "Unable to figure out which guest OS it is, sorry.\n");
999	NOREF(pCmd); NOREF(paArgs);
1000	return rc;
1001	}
1002
1003
1004	/**
1005	* @interface_method_impl{FNDBCCMD, The 'cpu' command.}
1006	*/
1007	static DECLCALLBACK(int) dbgcCmdCpu(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1008	{
1009	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1010
1011	/* check that the parser did what it's supposed to do. */
1012	if ( cArgs != 0
1013	&& ( cArgs != 1
1014	\|\| paArgs[0].enmType != DBGCVAR_TYPE_NUMBER))
1015	return DBGCCmdHlpPrintf(pCmdHlp, "parser error\n");
1016	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
1017
1018	int rc;
1019	if (!cArgs)
1020	rc = DBGCCmdHlpPrintf(pCmdHlp, "Current CPU ID: %u\n", pDbgc->idCpu);
1021	else
1022	{
1023	VMCPUID cCpus = DBGFR3CpuGetCount(pUVM);
1024	if (paArgs[0].u.u64Number >= cCpus)
1025	rc = DBGCCmdHlpPrintf(pCmdHlp, "error: idCpu %u is out of range! Highest ID is %u.\n",
1026	paArgs[0].u.u64Number, cCpus);
1027	else
1028	{
1029	rc = DBGCCmdHlpPrintf(pCmdHlp, "Changed CPU from %u to %u.\n",
1030	pDbgc->idCpu, (VMCPUID)paArgs[0].u.u64Number);
1031	pDbgc->idCpu = (VMCPUID)paArgs[0].u.u64Number;
1032	}
1033	}
1034	return rc;
1035	}
1036
1037
1038	/**
1039	* @interface_method_impl{FNDBCCMD, The 'info' command.}
1040	*/
1041	static DECLCALLBACK(int) dbgcCmdInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1042	{
1043	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1044
1045	/*
1046	* Validate input.
1047	*/
1048	if ( cArgs < 1
1049	\|\| cArgs > 2
1050	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING
1051	\|\| paArgs[cArgs - 1].enmType != DBGCVAR_TYPE_STRING)
1052	return DBGCCmdHlpPrintf(pCmdHlp, "internal error: The parser doesn't do its job properly yet.. quote the string.\n");
1053	DBGC_CMDHLP_REQ_UVM_RET(pCmdHlp, pCmd, pUVM);
1054
1055	/*
1056	* Dump it.
1057	*/
1058	int rc = DBGFR3InfoEx(pUVM, pDbgc->idCpu,
1059	paArgs[0].u.pszString,
1060	cArgs == 2 ? paArgs[1].u.pszString : NULL,
1061	DBGCCmdHlpGetDbgfOutputHlp(pCmdHlp));
1062	if (RT_FAILURE(rc))
1063	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3InfoEx()\n");
1064
1065	NOREF(pCmd);
1066	return 0;
1067	}
1068
1069
1070	/**
1071	* @interface_method_impl{FNDBCCMD, The 'log' command.}
1072	*/
1073	static DECLCALLBACK(int) dbgcCmdLog(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1074	{
1075	int rc;
1076	if (cArgs == 0)
1077	{
1078	char szBuf[_64K];
1079	rc = RTLogGetGroupSettings(NULL, szBuf, sizeof(szBuf));
1080	if (RT_FAILURE(rc))
1081	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "RTLogGetDestinations(NULL,,%#zx)\n", sizeof(szBuf));
1082	DBGCCmdHlpPrintf(pCmdHlp, "VBOX_LOG=%s\n", szBuf);
1083	}
1084	else
1085	{
1086	rc = DBGFR3LogModifyGroups(pUVM, paArgs[0].u.pszString);
1087	if (RT_FAILURE(rc))
1088	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3LogModifyGroups(%p,'%s')\n", pUVM, paArgs[0].u.pszString);
1089	}
1090	NOREF(pCmd);
1091	return VINF_SUCCESS;
1092	}
1093
1094
1095	/**
1096	* @interface_method_impl{FNDBCCMD, The 'logdest' command.}
1097	*/
1098	static DECLCALLBACK(int) dbgcCmdLogDest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1099	{
1100	int rc;
1101	if (cArgs == 0)
1102	{
1103	char szBuf[_16K];
1104	rc = RTLogGetDestinations(NULL, szBuf, sizeof(szBuf));
1105	if (RT_FAILURE(rc))
1106	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "RTLogGetDestinations(NULL,,%#zx)\n", sizeof(szBuf));
1107	DBGCCmdHlpPrintf(pCmdHlp, "VBOX_LOG_DEST=%s\n", szBuf);
1108	}
1109	else
1110	{
1111	rc = DBGFR3LogModifyDestinations(pUVM, paArgs[0].u.pszString);
1112	if (RT_FAILURE(rc))
1113	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3LogModifyDestinations(%p,'%s')\n", pUVM, paArgs[0].u.pszString);
1114	}
1115	NOREF(pCmd);
1116	return VINF_SUCCESS;
1117	}
1118
1119
1120	/**
1121	* @interface_method_impl{FNDBCCMD, The 'logflags' command.}
1122	*/
1123	static DECLCALLBACK(int) dbgcCmdLogFlags(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1124	{
1125	int rc;
1126	if (cArgs == 0)
1127	{
1128	char szBuf[_16K];
1129	rc = RTLogGetFlags(NULL, szBuf, sizeof(szBuf));
1130	if (RT_FAILURE(rc))
1131	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "RTLogGetFlags(NULL,,%#zx)\n", sizeof(szBuf));
1132	DBGCCmdHlpPrintf(pCmdHlp, "VBOX_LOG_FLAGS=%s\n", szBuf);
1133	}
1134	else
1135	{
1136	rc = DBGFR3LogModifyFlags(pUVM, paArgs[0].u.pszString);
1137	if (RT_FAILURE(rc))
1138	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3LogModifyFlags(%p,'%s')\n", pUVM, paArgs[0].u.pszString);
1139	}
1140
1141	NOREF(pCmd);
1142	return rc;
1143	}
1144
1145
1146	/**
1147	* @interface_method_impl{FNDBCCMD, The 'logflush' command.}
1148	*/
1149	static DECLCALLBACK(int) dbgcCmdLogFlush(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1150	{
1151	RTLogFlush(NULL);
1152	PRTLOGGER pLogRel = RTLogRelDefaultInstance();
1153	if (pLogRel)
1154	RTLogFlush(pLogRel);
1155
1156	NOREF(pCmd); NOREF(cArgs);
1157	return VINF_SUCCESS;
1158	}
1159
1160
1161	/**
1162	* @interface_method_impl{FNDBCCMD, The 'format' command.}
1163	*/
1164	static DECLCALLBACK(int) dbgcCmdFormat(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1165	{
1166	LogFlow(("dbgcCmdFormat\n"));
1167	static const char *apszRangeDesc[] =
1168	{
1169	"none", "bytes", "elements"
1170	};
1171	int rc;
1172
1173	for (unsigned iArg = 0; iArg < cArgs; iArg++)
1174	{
1175	switch (paArgs[iArg].enmType)
1176	{
1177	case DBGCVAR_TYPE_UNKNOWN:
1178	rc = DBGCCmdHlpPrintf(pCmdHlp,
1179	"Unknown variable type!\n");
1180	break;
1181	case DBGCVAR_TYPE_GC_FLAT:
1182	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
1183	rc = DBGCCmdHlpPrintf(pCmdHlp,
1184	"Guest flat address: %%%08x range %lld %s\n",
1185	paArgs[iArg].u.GCFlat,
1186	paArgs[iArg].u64Range,
1187	apszRangeDesc[paArgs[iArg].enmRangeType]);
1188	else
1189	rc = DBGCCmdHlpPrintf(pCmdHlp,
1190	"Guest flat address: %%%08x\n",
1191	paArgs[iArg].u.GCFlat);
1192	break;
1193	case DBGCVAR_TYPE_GC_FAR:
1194	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
1195	rc = DBGCCmdHlpPrintf(pCmdHlp,
1196	"Guest far address: %04x:%08x range %lld %s\n",
1197	paArgs[iArg].u.GCFar.sel,
1198	paArgs[iArg].u.GCFar.off,
1199	paArgs[iArg].u64Range,
1200	apszRangeDesc[paArgs[iArg].enmRangeType]);
1201	else
1202	rc = DBGCCmdHlpPrintf(pCmdHlp,
1203	"Guest far address: %04x:%08x\n",
1204	paArgs[iArg].u.GCFar.sel,
1205	paArgs[iArg].u.GCFar.off);
1206	break;
1207	case DBGCVAR_TYPE_GC_PHYS:
1208	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
1209	rc = DBGCCmdHlpPrintf(pCmdHlp,
1210	"Guest physical address: %%%%%08x range %lld %s\n",
1211	paArgs[iArg].u.GCPhys,
1212	paArgs[iArg].u64Range,
1213	apszRangeDesc[paArgs[iArg].enmRangeType]);
1214	else
1215	rc = DBGCCmdHlpPrintf(pCmdHlp,
1216	"Guest physical address: %%%%%08x\n",
1217	paArgs[iArg].u.GCPhys);
1218	break;
1219	case DBGCVAR_TYPE_HC_FLAT:
1220	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
1221	rc = DBGCCmdHlpPrintf(pCmdHlp,
1222	"Host flat address: %%%08x range %lld %s\n",
1223	paArgs[iArg].u.pvHCFlat,
1224	paArgs[iArg].u64Range,
1225	apszRangeDesc[paArgs[iArg].enmRangeType]);
1226	else
1227	rc = DBGCCmdHlpPrintf(pCmdHlp,
1228	"Host flat address: %%%08x\n",
1229	paArgs[iArg].u.pvHCFlat);
1230	break;
1231	case DBGCVAR_TYPE_HC_PHYS:
1232	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
1233	rc = DBGCCmdHlpPrintf(pCmdHlp,
1234	"Host physical address: %RHp range %lld %s\n",
1235	paArgs[iArg].u.HCPhys,
1236	paArgs[iArg].u64Range,
1237	apszRangeDesc[paArgs[iArg].enmRangeType]);
1238	else
1239	rc = DBGCCmdHlpPrintf(pCmdHlp,
1240	"Host physical address: %RHp\n",
1241	paArgs[iArg].u.HCPhys);
1242	break;
1243
1244	case DBGCVAR_TYPE_STRING:
1245	rc = DBGCCmdHlpPrintf(pCmdHlp,
1246	"String, %lld bytes long: %s\n",
1247	paArgs[iArg].u64Range,
1248	paArgs[iArg].u.pszString);
1249	break;
1250
1251	case DBGCVAR_TYPE_SYMBOL:
1252	rc = DBGCCmdHlpPrintf(pCmdHlp,
1253	"Symbol, %lld bytes long: %s\n",
1254	paArgs[iArg].u64Range,
1255	paArgs[iArg].u.pszString);
1256	break;
1257
1258	case DBGCVAR_TYPE_NUMBER:
1259	if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
1260	rc = DBGCCmdHlpPrintf(pCmdHlp,
1261	"Number: hex %llx dec 0i%lld oct 0t%llo range %lld %s\n",
1262	paArgs[iArg].u.u64Number,
1263	paArgs[iArg].u.u64Number,
1264	paArgs[iArg].u.u64Number,
1265	paArgs[iArg].u64Range,
1266	apszRangeDesc[paArgs[iArg].enmRangeType]);
1267	else
1268	rc = DBGCCmdHlpPrintf(pCmdHlp,
1269	"Number: hex %llx dec 0i%lld oct 0t%llo\n",
1270	paArgs[iArg].u.u64Number,
1271	paArgs[iArg].u.u64Number,
1272	paArgs[iArg].u.u64Number);
1273	break;
1274
1275	default:
1276	rc = DBGCCmdHlpPrintf(pCmdHlp,
1277	"Invalid argument type %d\n",
1278	paArgs[iArg].enmType);
1279	break;
1280	}
1281	} /* arg loop */
1282
1283	NOREF(pCmd); NOREF(pUVM);
1284	return 0;
1285	}
1286
1287
1288	/**
1289	* @interface_method_impl{FNDBCCMD, The 'loadimage' command.}
1290	*/
1291	static DECLCALLBACK(int) dbgcCmdLoadImage(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1292	{
1293	/*
1294	* Validate the parsing and make sense of the input.
1295	* This is a mess as usual because we don't trust the parser yet.
1296	*/
1297	AssertReturn( cArgs >= 2
1298	&& cArgs <= 3
1299	&& paArgs[0].enmType == DBGCVAR_TYPE_STRING
1300	&& DBGCVAR_ISPOINTER(paArgs[1].enmType),
1301	VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1302
1303	const char *pszFilename = paArgs[0].u.pszString;
1304
1305	DBGFADDRESS ModAddress;
1306	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[1], &ModAddress);
1307	if (RT_FAILURE(rc))
1308	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "pfnVarToDbgfAddr: %Dv\n", &paArgs[1]);
1309
1310	const char *pszModName = NULL;
1311	if (cArgs >= 3)
1312	{
1313	AssertReturn(paArgs[2].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1314	pszModName = paArgs[2].u.pszString;
1315	}
1316
1317	/*
1318	* Determine the desired image arch from the load command used.
1319	*/
1320	RTLDRARCH enmArch = RTLDRARCH_WHATEVER;
1321	if (pCmd->pszCmd[sizeof("loadimage") - 1] == '3')
1322	enmArch = RTLDRARCH_X86_32;
1323	else if (pCmd->pszCmd[sizeof("loadimage") - 1] == '6')
1324	enmArch = RTLDRARCH_AMD64;
1325
1326	/*
1327	* Try create a module for it.
1328	*/
1329	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1330	rc = DBGFR3AsLoadImage(pUVM, pDbgc->hDbgAs, pszFilename, pszModName, enmArch, &ModAddress, NIL_RTDBGSEGIDX, 0 /fFlags/);
1331	if (RT_FAILURE(rc))
1332	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3ModuleLoadImage(,,'%s','%s',%Dv,)\n",
1333	pszFilename, pszModName, &paArgs[1]);
1334
1335	return VINF_SUCCESS;
1336	}
1337
1338
1339	/**
1340	* @interface_method_impl{FNDBCCMD, The 'loadmap' command.}
1341	*/
1342	static DECLCALLBACK(int) dbgcCmdLoadMap(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1343	{
1344	/*
1345	* Validate the parsing and make sense of the input.
1346	* This is a mess as usual because we don't trust the parser yet.
1347	*/
1348	AssertReturn( cArgs >= 2
1349	&& cArgs <= 5
1350	&& paArgs[0].enmType == DBGCVAR_TYPE_STRING
1351	&& DBGCVAR_ISPOINTER(paArgs[1].enmType),
1352	VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1353
1354	const char *pszFilename = paArgs[0].u.pszString;
1355
1356	DBGFADDRESS ModAddress;
1357	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[1], &ModAddress);
1358	if (RT_FAILURE(rc))
1359	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "pfnVarToDbgfAddr: %Dv\n", &paArgs[1]);
1360
1361	const char *pszModName = NULL;
1362	if (cArgs >= 3)
1363	{
1364	AssertReturn(paArgs[2].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1365	pszModName = paArgs[2].u.pszString;
1366	}
1367
1368	RTGCUINTPTR uSubtrahend = 0;
1369	if (cArgs >= 4)
1370	{
1371	AssertReturn(paArgs[3].enmType == DBGCVAR_TYPE_NUMBER, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1372	uSubtrahend = paArgs[3].u.u64Number;
1373	}
1374
1375	RTDBGSEGIDX iModSeg = NIL_RTDBGSEGIDX;
1376	if (cArgs >= 5)
1377	{
1378	AssertReturn(paArgs[4].enmType == DBGCVAR_TYPE_NUMBER, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1379	iModSeg = (RTDBGSEGIDX)paArgs[4].u.u64Number;
1380	if ( iModSeg != paArgs[4].u.u64Number
1381	\|\| iModSeg > RTDBGSEGIDX_LAST)
1382	return DBGCCmdHlpPrintf(pCmdHlp, "Segment index out of range: %Dv; range={0..%#x}\n", &paArgs[1], RTDBGSEGIDX_LAST);
1383	}
1384
1385	/*
1386	* Try create a module for it.
1387	*/
1388	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1389	rc = DBGFR3AsLoadMap(pUVM, pDbgc->hDbgAs, pszFilename, pszModName, &ModAddress, NIL_RTDBGSEGIDX, uSubtrahend, 0 /fFlags/);
1390	if (RT_FAILURE(rc))
1391	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3AsLoadMap(,,'%s','%s',%Dv,)\n",
1392	pszFilename, pszModName, &paArgs[1]);
1393
1394	NOREF(pCmd);
1395	return VINF_SUCCESS;
1396	}
1397
1398
1399	/**
1400	* @interface_method_impl{FNDBCCMD, The 'loadseg' command.}
1401	*/
1402	static DECLCALLBACK(int) dbgcCmdLoadSeg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1403	{
1404	/*
1405	* Validate the parsing and make sense of the input.
1406	* This is a mess as usual because we don't trust the parser yet.
1407	*/
1408	AssertReturn( cArgs >= 3
1409	&& cArgs <= 4
1410	&& paArgs[0].enmType == DBGCVAR_TYPE_STRING
1411	&& DBGCVAR_ISPOINTER(paArgs[1].enmType)
1412	&& paArgs[2].enmType == DBGCVAR_TYPE_NUMBER,
1413	VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1414
1415	const char *pszFilename = paArgs[0].u.pszString;
1416
1417	DBGFADDRESS ModAddress;
1418	int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[1], &ModAddress);
1419	if (RT_FAILURE(rc))
1420	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "pfnVarToDbgfAddr: %Dv\n", &paArgs[1]);
1421
1422	RTDBGSEGIDX iModSeg = (RTDBGSEGIDX)paArgs[1].u.u64Number;
1423	if ( iModSeg != paArgs[2].u.u64Number
1424	\|\| iModSeg > RTDBGSEGIDX_LAST)
1425	return DBGCCmdHlpPrintf(pCmdHlp, "Segment index out of range: %Dv; range={0..%#x}\n", &paArgs[1], RTDBGSEGIDX_LAST);
1426
1427	const char *pszModName = NULL;
1428	if (cArgs >= 4)
1429	{
1430	AssertReturn(paArgs[3].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1431	pszModName = paArgs[3].u.pszString;
1432	}
1433
1434	/*
1435	* Call the debug info manager about this loading.
1436	*/
1437	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1438	rc = DBGFR3AsLoadImage(pUVM, pDbgc->hDbgAs, pszFilename, pszModName, RTLDRARCH_WHATEVER, &ModAddress, iModSeg, 0 /fFlags/);
1439	if (RT_FAILURE(rc))
1440	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3ModuleLoadImage(,,'%s','%s',%Dv,)\n",
1441	pszFilename, pszModName, &paArgs[1]);
1442
1443	NOREF(pCmd);
1444	return VINF_SUCCESS;
1445	}
1446
1447
1448	/**
1449	* @interface_method_impl{FNDBCCMD, The 'unload' command.}
1450	*/
1451	static DECLCALLBACK(int) dbgcCmdUnload(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1452	{
1453	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1454
1455	/*
1456	* Validate the parsing and make sense of the input.
1457	* This is a mess as usual because we don't trust the parser yet.
1458	*/
1459	AssertReturn( cArgs >= 1
1460	&& paArgs[0].enmType == DBGCVAR_TYPE_STRING,
1461	VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1462	for (unsigned i = 0; i < cArgs; i++)
1463	{
1464	AssertReturn(paArgs[i].enmType == DBGCVAR_TYPE_STRING, VERR_DBGC_PARSE_INCORRECT_ARG_TYPE);
1465
1466	int rc = DBGFR3AsUnlinkModuleByName(pUVM, pDbgc->hDbgAs, paArgs[i].u.pszString);
1467	if (RT_FAILURE(rc))
1468	return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGFR3AsUnlinkModuleByName(,,'%s')\n", paArgs[i].u.pszString);
1469	}
1470
1471	NOREF(pCmd);
1472	return VINF_SUCCESS;
1473	}
1474
1475
1476	/**
1477	* @interface_method_impl{FNDBCCMD, The 'set' command.}
1478	*/
1479	static DECLCALLBACK(int) dbgcCmdSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1480	{
1481	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1482
1483	/* parse sanity check. */
1484	AssertMsg(paArgs[0].enmType == DBGCVAR_TYPE_STRING, ("expected string not %d as first arg!\n", paArgs[0].enmType));
1485	if (paArgs[0].enmType != DBGCVAR_TYPE_STRING)
1486	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
1487
1488
1489	/*
1490	* A variable must start with an alpha chars and only contain alpha numerical chars.
1491	*/
1492	const char *pszVar = paArgs[0].u.pszString;
1493	if (!RT_C_IS_ALPHA(pszVar) \|\| pszVar == '_')
1494	return DBGCCmdHlpPrintf(pCmdHlp,
1495	"syntax error: Invalid variable name '%s'. Variable names must match regex '[_a-zA-Z][_a-zA-Z0-9*'!",
1496	paArgs[0].u.pszString);
1497
1498	while (RT_C_IS_ALNUM(pszVar) \|\| pszVar == '_')
1499	*pszVar++;
1500	if (*pszVar)
1501	return DBGCCmdHlpPrintf(pCmdHlp,
1502	"syntax error: Invalid variable name '%s'. Variable names must match regex '[_a-zA-Z][_a-zA-Z0-9*]'!",
1503	paArgs[0].u.pszString);
1504
1505
1506	/*
1507	* Calc variable size.
1508	*/
1509	size_t cbVar = (size_t)paArgs[0].u64Range + sizeof(DBGCNAMEDVAR);
1510	if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
1511	cbVar += 1 + (size_t)paArgs[1].u64Range;
1512
1513	/*
1514	* Look for existing one.
1515	*/
1516	pszVar = paArgs[0].u.pszString;
1517	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
1518	{
1519	if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
1520	{
1521	/*
1522	* Update existing variable.
1523	*/
1524	void *pv = RTMemRealloc(pDbgc->papVars[iVar], cbVar);
1525	if (!pv)
1526	return VERR_DBGC_PARSE_NO_MEMORY;
1527	PDBGCNAMEDVAR pVar = pDbgc->papVars[iVar] = (PDBGCNAMEDVAR)pv;
1528
1529	pVar->Var = paArgs[1];
1530	memcpy(pVar->szName, paArgs[0].u.pszString, (size_t)paArgs[0].u64Range + 1);
1531	if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
1532	pVar->Var.u.pszString = (char *)memcpy(&pVar->szName[paArgs[0].u64Range + 1], paArgs[1].u.pszString, (size_t)paArgs[1].u64Range + 1);
1533	return 0;
1534	}
1535	}
1536
1537	/*
1538	* Allocate another.
1539	*/
1540	PDBGCNAMEDVAR pVar = (PDBGCNAMEDVAR)RTMemAlloc(cbVar);
1541
1542	pVar->Var = paArgs[1];
1543	memcpy(pVar->szName, pszVar, (size_t)paArgs[0].u64Range + 1);
1544	if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
1545	pVar->Var.u.pszString = (char *)memcpy(&pVar->szName[paArgs[0].u64Range + 1], paArgs[1].u.pszString, (size_t)paArgs[1].u64Range + 1);
1546
1547	/* need to reallocate the pointer array too? */
1548	if (!(pDbgc->cVars % 0x20))
1549	{
1550	void pv = RTMemRealloc(pDbgc->papVars, (pDbgc->cVars + 0x20) sizeof(pDbgc->papVars[0]));
1551	if (!pv)
1552	{
1553	RTMemFree(pVar);
1554	return VERR_DBGC_PARSE_NO_MEMORY;
1555	}
1556	pDbgc->papVars = (PDBGCNAMEDVAR *)pv;
1557	}
1558	pDbgc->papVars[pDbgc->cVars++] = pVar;
1559
1560	NOREF(pCmd); NOREF(pUVM); NOREF(cArgs);
1561	return 0;
1562	}
1563
1564
1565	/**
1566	* @interface_method_impl{FNDBCCMD, The 'unset' command.}
1567	*/
1568	static DECLCALLBACK(int) dbgcCmdUnset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1569	{
1570	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1571	for (unsigned i = 0; i < cArgs; i++)
1572	AssertReturn(paArgs[i].enmType == DBGCVAR_TYPE_SYMBOL, VERR_DBGC_PARSE_BUG);
1573
1574	/*
1575	* Iterate the variables and unset them.
1576	*/
1577	for (unsigned iArg = 0; iArg < cArgs; iArg++)
1578	{
1579	const char *pszVar = paArgs[iArg].u.pszString;
1580
1581	/*
1582	* Look up the variable.
1583	*/
1584	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
1585	{
1586	if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
1587	{
1588	/*
1589	* Shuffle the array removing this entry.
1590	*/
1591	void *pvFree = pDbgc->papVars[iVar];
1592	if (iVar + 1 < pDbgc->cVars)
1593	memmove(&pDbgc->papVars[iVar],
1594	&pDbgc->papVars[iVar + 1],
1595	(pDbgc->cVars - iVar - 1) * sizeof(pDbgc->papVars[0]));
1596	pDbgc->papVars[--pDbgc->cVars] = NULL;
1597
1598	RTMemFree(pvFree);
1599	}
1600	} /* lookup */
1601	} /* arg loop */
1602
1603	NOREF(pCmd); NOREF(pUVM);
1604	return 0;
1605	}
1606
1607
1608	/**
1609	* @interface_method_impl{FNDBCCMD, The 'loadvars' command.}
1610	*/
1611	static DECLCALLBACK(int) dbgcCmdLoadVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1612	{
1613	/*
1614	* Don't trust the parser.
1615	*/
1616	if ( cArgs != 1
1617	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING)
1618	{
1619	AssertMsgFailed(("Expected one string exactly!\n"));
1620	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
1621	}
1622
1623	/*
1624	* Iterate the variables and unset them.
1625	*/
1626	FILE *pFile = fopen(paArgs[0].u.pszString, "r");
1627	if (pFile)
1628	{
1629	char szLine[4096];
1630	while (fgets(szLine, sizeof(szLine), pFile))
1631	{
1632	/* Strip it. */
1633	char *psz = szLine;
1634	while (RT_C_IS_BLANK(*psz))
1635	psz++;
1636	int i = (int)strlen(psz) - 1;
1637	while (i >= 0 && RT_C_IS_SPACE(psz[i]))
1638	psz[i--] ='\0';
1639	/* Execute it if not comment or empty line. */
1640	if ( *psz != '\0'
1641	&& *psz != '#'
1642	&& *psz != ';')
1643	{
1644	DBGCCmdHlpPrintf(pCmdHlp, "dbg: set %s", psz);
1645	pCmdHlp->pfnExec(pCmdHlp, "set %s", psz);
1646	}
1647	}
1648	fclose(pFile);
1649	}
1650	else
1651	return DBGCCmdHlpPrintf(pCmdHlp, "Failed to open file '%s'.\n", paArgs[0].u.pszString);
1652
1653	NOREF(pCmd); NOREF(pUVM);
1654	return 0;
1655	}
1656
1657
1658	/**
1659	* @interface_method_impl{FNDBCCMD, The 'showvars' command.}
1660	*/
1661	static DECLCALLBACK(int) dbgcCmdShowVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1662	{
1663	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1664
1665	for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
1666	{
1667	int rc = DBGCCmdHlpPrintf(pCmdHlp, "%-20s ", &pDbgc->papVars[iVar]->szName);
1668	if (!rc)
1669	rc = dbgcCmdFormat(pCmd, pCmdHlp, pUVM, &pDbgc->papVars[iVar]->Var, 1);
1670	if (rc)
1671	return rc;
1672	}
1673
1674	NOREF(paArgs); NOREF(cArgs);
1675	return 0;
1676	}
1677
1678
1679	/**
1680	* Extracts the plugin name from a plugin specifier that may or may not include
1681	* path and/or suffix.
1682	*
1683	* @returns VBox status code.
1684	*
1685	* @param pszDst Where to return the name. At least DBGCPLUGIN_MAX_NAME
1686	* worth of buffer space.
1687	* @param pszPlugIn The plugin specifier to parse.
1688	*/
1689	static int dbgcPlugInExtractName(char pszDst, const char pszPlugIn)
1690	{
1691	/*
1692	* Parse out the name stopping at the extension.
1693	*/
1694	const char *pszName = RTPathFilename(pszPlugIn);
1695	if (!pszName \|\| !*pszName)
1696	return VERR_INVALID_NAME;
1697	if (!RTStrNICmp(pszName, DBGC_PLUG_IN_PREFIX, sizeof(DBGC_PLUG_IN_PREFIX) - 1))
1698	{
1699	pszName += sizeof(DBGC_PLUG_IN_PREFIX) - 1;
1700	if (!*pszName)
1701	return VERR_INVALID_NAME;
1702	}
1703
1704	int ch;
1705	size_t cchName = 0;
1706	while ( (ch = pszName[cchName]) != '\0'
1707	&& ch != '.')
1708	{
1709	if ( !RT_C_IS_ALPHA(ch)
1710	&& ( !RT_C_IS_DIGIT(ch)
1711	\|\| cchName == 0))
1712	return VERR_INVALID_NAME;
1713	cchName++;
1714	}
1715
1716	if (cchName >= DBGCPLUGIN_MAX_NAME)
1717	return VERR_OUT_OF_RANGE;
1718
1719	/*
1720	* We're very picky about the extension if there is no path.
1721	*/
1722	if ( ch == '.'
1723	&& !RTPathHavePath(pszPlugIn)
1724	&& RTStrICmp(&pszName[cchName], RTLdrGetSuff()))
1725	return VERR_INVALID_NAME;
1726
1727	/*
1728	* Copy it.
1729	*/
1730	memcpy(pszDst, pszName, cchName);
1731	pszDst[cchName] = '\0';
1732	return VINF_SUCCESS;
1733	}
1734
1735
1736	/**
1737	* Locate a plug-in in list.
1738	*
1739	* @returns Pointer to the plug-in tracking structure.
1740	* @param pDbgc Pointer to the DBGC instance data.
1741	* @param pszName The name of the plug-in we're looking for.
1742	* @param ppPrev Where to optionally return the pointer to the
1743	* previous list member.
1744	*/
1745	static PDBGCPLUGIN dbgcPlugInLocate(PDBGC pDbgc, const char pszName, PDBGCPLUGIN ppPrev)
1746	{
1747	PDBGCPLUGIN pPrev = NULL;
1748	PDBGCPLUGIN pCur = pDbgc->pPlugInHead;
1749	while (pCur)
1750	{
1751	if (!RTStrICmp(pCur->szName, pszName))
1752	{
1753	if (ppPrev)
1754	*ppPrev = pPrev;
1755	return pCur;
1756	}
1757
1758	/* advance */
1759	pPrev = pCur;
1760	pCur = pCur->pNext;
1761	}
1762	return NULL;
1763	}
1764
1765
1766	/**
1767	* Try load the specified plug-in module.
1768	*
1769	* @returns VINF_SUCCESS on success, path error or loader error on failure.
1770	*
1771	* @param pPlugIn The plugin tracing record.
1772	* @param pszModule Module name.
1773	*/
1774	static int dbgcPlugInTryLoad(PDBGCPLUGIN pPlugIn, const char *pszModule)
1775	{
1776	/*
1777	* Load it and try resolve the entry point.
1778	*/
1779	int rc = RTLdrLoad(pszModule, &pPlugIn->hLdrMod);
1780	if (RT_SUCCESS(rc))
1781	{
1782	rc = RTLdrGetSymbol(pPlugIn->hLdrMod, DBGC_PLUG_IN_ENTRYPOINT, (void **)&pPlugIn->pfnEntry);
1783	if (RT_SUCCESS(rc))
1784	return VINF_SUCCESS;
1785	LogRel(("DBGC: RTLdrGetSymbol('%s', '%s',) -> %Rrc\n", pszModule, DBGC_PLUG_IN_ENTRYPOINT, rc));
1786
1787	RTLdrClose(pPlugIn->hLdrMod);
1788	pPlugIn->hLdrMod = NIL_RTLDRMOD;
1789	}
1790	return rc;
1791	}
1792
1793
1794	/**
1795	* RTPathTraverseList callback.
1796	*
1797	* @returns See FNRTPATHTRAVERSER.
1798	*
1799	* @param pchPath See FNRTPATHTRAVERSER.
1800	* @param cchPath See FNRTPATHTRAVERSER.
1801	* @param pvUser1 The plug-in specifier.
1802	* @param pvUser2 The plug-in tracking record.
1803	*/
1804	static DECLCALLBACK(int) dbgcPlugInLoadCallback(const char pchPath, size_t cchPath, void pvUser1, void *pvUser2)
1805	{
1806	PDBGCPLUGIN pPlugIn = (PDBGCPLUGIN)pvUser2;
1807	const char pszPlugIn = (const char )pvUser1;
1808
1809	/*
1810	* Join the path and the specified plug-in module name, first with the
1811	* prefix and then without it.
1812	*/
1813	size_t cchModule = cchPath + 1 + strlen(pszPlugIn) + sizeof(DBGC_PLUG_IN_PREFIX) + 8;
1814	char pszModule = (char )alloca(cchModule);
1815	AssertReturn(pszModule, VERR_TRY_AGAIN);
1816	memcpy(pszModule, pchPath, cchPath);
1817	pszModule[cchPath] = '\0';
1818
1819	int rc = RTPathAppend(pszModule, cchModule, DBGC_PLUG_IN_PREFIX);
1820	AssertRCReturn(rc, VERR_TRY_AGAIN);
1821	strcat(pszModule, pszPlugIn);
1822	rc = dbgcPlugInTryLoad(pPlugIn, pszModule);
1823	if (RT_SUCCESS(rc))
1824	return VINF_SUCCESS;
1825
1826	pszModule[cchPath] = '\0';
1827	rc = RTPathAppend(pszModule, cchModule, pszPlugIn);
1828	AssertRCReturn(rc, VERR_TRY_AGAIN);
1829	rc = dbgcPlugInTryLoad(pPlugIn, pszModule);
1830	if (RT_SUCCESS(rc))
1831	return VINF_SUCCESS;
1832
1833	return VERR_TRY_AGAIN;
1834	}
1835
1836
1837	/**
1838	* Loads a plug-in.
1839	*
1840	* @returns VBox status code. If pCmd is specified, it's the return from
1841	* DBGCCmdHlpFail.
1842	* @param pDbgc The DBGC instance data.
1843	* @param pszName The plug-in name.
1844	* @param pszPlugIn The plug-in module name.
1845	* @param pCmd The command pointer if invoked by the user, NULL
1846	* if invoked from elsewhere.
1847	*/
1848	static int dbgcPlugInLoad(PDBGC pDbgc, const char pszName, const char pszPlugIn, PCDBGCCMD pCmd)
1849	{
1850	PDBGCCMDHLP pCmdHlp = &pDbgc->CmdHlp;
1851
1852	/*
1853	* Try load it. If specified with a path, we're assuming the user
1854	* wants to load a plug-in from some specific location. Otherwise
1855	* search for it.
1856	*/
1857	PDBGCPLUGIN pPlugIn = (PDBGCPLUGIN)RTMemAllocZ(sizeof(*pPlugIn));
1858	if (!pPlugIn)
1859	return pCmd
1860	? DBGCCmdHlpFail(pCmdHlp, pCmd, "out of memory\n")
1861	: VERR_NO_MEMORY;
1862	strcpy(pPlugIn->szName, pszName);
1863
1864	int rc;
1865	if (RTPathHavePath(pszPlugIn))
1866	rc = dbgcPlugInTryLoad(pPlugIn, pszPlugIn);
1867	else
1868	{
1869	/* 1. The private architecture directory. */
1870	char szPath[4*_1K];
1871	rc = RTPathAppPrivateArch(szPath, sizeof(szPath));
1872	if (RT_SUCCESS(rc))
1873	rc = RTPathTraverseList(szPath, '\0', dbgcPlugInLoadCallback, (void *)pszPlugIn, pPlugIn);
1874	if (RT_FAILURE(rc))
1875	{
1876	/* 2. The DBGC PLUGIN_PATH variable. */
1877	DBGCVAR PathVar;
1878	int rc2 = DBGCCmdHlpEval(pCmdHlp, &PathVar, "$PLUGIN_PATH");
1879	if ( RT_SUCCESS(rc2)
1880	&& PathVar.enmType == DBGCVAR_TYPE_STRING)
1881	rc = RTPathTraverseList(PathVar.u.pszString, ';', dbgcPlugInLoadCallback, (void *)pszPlugIn, pPlugIn);
1882	if (RT_FAILURE_NP(rc))
1883	{
1884	/* 3. The DBGC_PLUGIN_PATH environment variable. */
1885	rc2 = RTEnvGetEx(RTENV_DEFAULT, "DBGC_PLUGIN_PATH", szPath, sizeof(szPath), NULL);
1886	if (RT_SUCCESS(rc2))
1887	rc = RTPathTraverseList(szPath, ';', dbgcPlugInLoadCallback, (void *)pszPlugIn, pPlugIn);
1888	}
1889	}
1890	}
1891	if (RT_FAILURE(rc))
1892	{
1893	RTMemFree(pPlugIn);
1894	return pCmd
1895	? DBGCCmdHlpFail(pCmdHlp, pCmd, "could not find/load '%s'\n", pszPlugIn)
1896	: rc;
1897	}
1898
1899	/*
1900	* Try initialize it.
1901	*/
1902	rc = pPlugIn->pfnEntry(DBGCPLUGINOP_INIT, pDbgc->pUVM, VBOX_VERSION);
1903	if (RT_FAILURE(rc))
1904	{
1905	RTLdrClose(pPlugIn->hLdrMod);
1906	RTMemFree(pPlugIn);
1907	return pCmd
1908	? DBGCCmdHlpFail(pCmdHlp, pCmd, "initialization of plug-in '%s' failed with rc=%Rrc\n", pszPlugIn, rc)
1909	: rc;
1910	}
1911
1912	/*
1913	* Link it and we're good.
1914	*/
1915	pPlugIn->pNext = pDbgc->pPlugInHead;
1916	pDbgc->pPlugInHead = pPlugIn;
1917	DBGCCmdHlpPrintf(pCmdHlp, "Loaded plug-in '%s'.\n", pPlugIn->szName);
1918	return VINF_SUCCESS;
1919	}
1920
1921
1922
1923
1924	/**
1925	* Automatically load plug-ins from the architecture private directory of
1926	* VirtualBox.
1927	*
1928	* This is called during console init.
1929	*
1930	* @param pDbgc The DBGC instance data.
1931	*/
1932	void dbgcPlugInAutoLoad(PDBGC pDbgc)
1933	{
1934	/*
1935	* Open the architecture specific directory with a filter on our prefix
1936	* and names including a dot.
1937	*/
1938	const char *pszSuff = RTLdrGetSuff();
1939	size_t cchSuff = strlen(pszSuff);
1940
1941	char szPath[RTPATH_MAX];
1942	int rc = RTPathAppPrivateArch(szPath, sizeof(szPath) - cchSuff);
1943	AssertRCReturnVoid(rc);
1944	size_t offDir = strlen(szPath);
1945
1946	rc = RTPathAppend(szPath, sizeof(szPath) - cchSuff, DBGC_PLUG_IN_PREFIX "*");
1947	AssertRCReturnVoid(rc);
1948	strcat(szPath, pszSuff);
1949
1950	PRTDIR pDir;
1951	rc = RTDirOpenFiltered(&pDir, szPath, RTDIRFILTER_WINNT, 0);
1952	if (RT_SUCCESS(rc))
1953	{
1954	/*
1955	* Now read it and try load each of the plug-in modules.
1956	*/
1957	RTDIRENTRY DirEntry;
1958	while (RT_SUCCESS(RTDirRead(pDir, &DirEntry, NULL)))
1959	{
1960	szPath[offDir] = '\0';
1961	rc = RTPathAppend(szPath, sizeof(szPath), DirEntry.szName);
1962	if (RT_SUCCESS(rc))
1963	{
1964	char szName[DBGCPLUGIN_MAX_NAME];
1965	rc = dbgcPlugInExtractName(szName, DirEntry.szName);
1966	if (RT_SUCCESS(rc))
1967	dbgcPlugInLoad(pDbgc, szName, szPath, NULL /pCmd/);
1968	}
1969	}
1970
1971	RTDirClose(pDir);
1972	}
1973	}
1974
1975
1976	/**
1977	* @interface_method_impl{FNDBCCMD, The 'loadplugin' command.}
1978	*/
1979	static DECLCALLBACK(int) dbgcCmdLoadPlugIn(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
1980	{
1981	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1982
1983	/*
1984	* Loop thru the plugin names.
1985	*/
1986	for (unsigned i = 0; i < cArgs; i++)
1987	{
1988	const char *pszPlugIn = paArgs[i].u.pszString;
1989
1990	/* Extract the plug-in name. */
1991	char szName[DBGCPLUGIN_MAX_NAME];
1992	int rc = dbgcPlugInExtractName(szName, pszPlugIn);
1993	if (RT_FAILURE(rc))
1994	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Malformed plug-in name: '%s'\n", pszPlugIn);
1995
1996	/* Loaded? */
1997	PDBGCPLUGIN pPlugIn = dbgcPlugInLocate(pDbgc, szName, NULL);
1998	if (pPlugIn)
1999	return DBGCCmdHlpFail(pCmdHlp, pCmd, "'%s' is already loaded\n", szName);
2000
2001	/* Load it. */
2002	rc = dbgcPlugInLoad(pDbgc, szName, pszPlugIn, pCmd);
2003	if (RT_FAILURE(rc))
2004	return rc;
2005	}
2006
2007	return VINF_SUCCESS;
2008	}
2009
2010
2011	/**
2012	* Unload all plug-ins.
2013	*
2014	* @param pDbgc The DBGC instance data.
2015	*/
2016	void dbgcPlugInUnloadAll(PDBGC pDbgc)
2017	{
2018	while (pDbgc->pPlugInHead)
2019	{
2020	PDBGCPLUGIN pPlugIn = pDbgc->pPlugInHead;
2021	pDbgc->pPlugInHead = pPlugIn->pNext;
2022
2023	if ( pDbgc->pVM /* prevents trouble during destruction. */
2024	&& pDbgc->pVM->enmVMState < VMSTATE_DESTROYING)
2025	{
2026	pPlugIn->pfnEntry(DBGCPLUGINOP_TERM, pDbgc->pUVM, 0);
2027	RTLdrClose(pPlugIn->hLdrMod);
2028	}
2029	pPlugIn->hLdrMod = NIL_RTLDRMOD;
2030
2031	RTMemFree(pPlugIn);
2032	}
2033	}
2034
2035
2036	/**
2037	* @interface_method_impl{FNDBCCMD, The 'unload' command.}
2038	*/
2039	static DECLCALLBACK(int) dbgcCmdUnloadPlugIn(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2040	{
2041	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2042
2043	/*
2044	* Loop thru the plugin names.
2045	*/
2046	for (unsigned i = 0; i < cArgs; i++)
2047	{
2048	const char *pszPlugIn = paArgs[i].u.pszString;
2049
2050	/* Extract the plug-in name. */
2051	char szName[DBGCPLUGIN_MAX_NAME];
2052	int rc = dbgcPlugInExtractName(szName, pszPlugIn);
2053	if (RT_FAILURE(rc))
2054	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Malformed plug-in name: '%s'\n", pszPlugIn);
2055
2056	/* Loaded? */
2057	PDBGCPLUGIN pPrevPlugIn;
2058	PDBGCPLUGIN pPlugIn = dbgcPlugInLocate(pDbgc, szName, &pPrevPlugIn);
2059	if (!pPlugIn)
2060	return DBGCCmdHlpFail(pCmdHlp, pCmd, "'%s' is not\n", szName);
2061
2062	/*
2063	* Terminate and unload it.
2064	*/
2065	pPlugIn->pfnEntry(DBGCPLUGINOP_TERM, pDbgc->pUVM, 0);
2066	RTLdrClose(pPlugIn->hLdrMod);
2067	pPlugIn->hLdrMod = NIL_RTLDRMOD;
2068
2069	if (pPrevPlugIn)
2070	pPrevPlugIn->pNext = pPlugIn->pNext;
2071	else
2072	pDbgc->pPlugInHead = pPlugIn->pNext;
2073	RTMemFree(pPlugIn->pNext);
2074	DBGCCmdHlpPrintf(pCmdHlp, "Unloaded plug-in '%s'\n", szName);
2075	}
2076
2077	return VINF_SUCCESS;
2078	}
2079
2080
2081	/**
2082	* @interface_method_impl{FNDBCCMD, The 'showplugins' command.}
2083	*/
2084	static DECLCALLBACK(int) dbgcCmdShowPlugIns(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2085	{
2086	PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2087	PDBGCPLUGIN pPlugIn = pDbgc->pPlugInHead;
2088	if (!pPlugIn)
2089	return DBGCCmdHlpPrintf(pCmdHlp, "No plug-ins loaded\n");
2090
2091	DBGCCmdHlpPrintf(pCmdHlp, "Plug-ins: %s", pPlugIn->szName);
2092	for (;;)
2093	{
2094	pPlugIn = pPlugIn->pNext;
2095	if (!pPlugIn)
2096	break;
2097	DBGCCmdHlpPrintf(pCmdHlp, ", %s", pPlugIn->szName);
2098	}
2099	return DBGCCmdHlpPrintf(pCmdHlp, "\n");
2100	}
2101
2102
2103
2104	/**
2105	* @interface_method_impl{FNDBCCMD, The 'harakiri' command.}
2106	*/
2107	static DECLCALLBACK(int) dbgcCmdHarakiri(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2108	{
2109	Log(("dbgcCmdHarakiri\n"));
2110	for (;;)
2111	exit(126);
2112	NOREF(pCmd); NOREF(pCmdHlp); NOREF(pUVM); NOREF(paArgs); NOREF(cArgs);
2113	}
2114
2115
2116	/**
2117	* @interface_method_impl{FNDBCCMD, The 'writecore' command.}
2118	*/
2119	static DECLCALLBACK(int) dbgcCmdWriteCore(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
2120	{
2121	Log(("dbgcCmdWriteCore\n"));
2122
2123	/*
2124	* Validate input, lots of paranoia here.
2125	*/
2126	if ( cArgs != 1
2127	\|\| paArgs[0].enmType != DBGCVAR_TYPE_STRING)
2128	{
2129	AssertMsgFailed(("Expected one string exactly!\n"));
2130	return VERR_DBGC_PARSE_INCORRECT_ARG_TYPE;
2131	}
2132
2133	const char *pszDumpPath = paArgs[0].u.pszString;
2134	if (!pszDumpPath)
2135	return DBGCCmdHlpFail(pCmdHlp, pCmd, "Missing file path.\n");
2136
2137	int rc = DBGFR3CoreWrite(pUVM, pszDumpPath, true /fReplaceFile/);
2138	if (RT_FAILURE(rc))
2139	return DBGCCmdHlpFail(pCmdHlp, pCmd, "DBGFR3WriteCore failed. rc=%Rrc\n", rc);
2140
2141	return VINF_SUCCESS;
2142	}
2143
2144
2145
2146	/**
2147	* @callback_method_impl{The randu32() function implementation.}
2148	*/
2149	static DECLCALLBACK(int) dbgcFuncRandU32(PCDBGCFUNC pFunc, PDBGCCMDHLP pCmdHlp, PVM pUVM, PCDBGCVAR paArgs, uint32_t cArgs,
2150	PDBGCVAR pResult)
2151	{
2152	AssertReturn(cArgs == 0, VERR_DBGC_PARSE_BUG);
2153	uint32_t u32 = RTRandU32();
2154	DBGCVAR_INIT_NUMBER(pResult, u32);
2155	NOREF(pFunc); NOREF(pCmdHlp); NOREF(pUVM); NOREF(paArgs);
2156	return VINF_SUCCESS;
2157	}
2158

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

source: vbox/trunk/src/VBox/Debugger/DBGCCommands.cpp@ 51287

Download in other formats: