DBGCCommands.cpp

Last change on this file was 105536, checked in by vboxsync, 7 weeks ago
VBoxDbg: Added a ntrbtree command for dumping the red-black trees in Windows 8 and later. bugref:10727
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 81.8 KB

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

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

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

Download in other formats: