DBGCCommands.cpp@ 97793

Last change on this file since 97793 was 97727, checked in by vboxsync, 2 years ago
DBGC: Added 'sleep' command for delaying execution a given number of milliseconds.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 81.3 KB

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

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

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

Download in other formats: