VirtualBox

source: vbox/trunk/src/VBox/Debugger/DBGConsole.cpp@ 5666

Last change on this file since 5666 was 5666, checked in by vboxsync, 17 years ago

PFNSTRFORMAT should return size_t.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 348.5 KB
Line 
1/** $Id: DBGConsole.cpp 5666 2007-11-11 04:25:51Z vboxsync $ */
2/** @file
3 * DBGC - Debugger Console.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License as published by the Free Software Foundation,
13 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14 * distribution. VirtualBox OSE is distributed in the hope that it will
15 * be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/** @page pg_dbgc DBGC - The Debug Console
20 *
21 * The debugger console is a first attempt to make some interactive
22 * debugging facilities for the VirtualBox backend (i.e. the VM). At a later
23 * stage we'll make a fancy gui around this, but for the present a telnet (or
24 * serial terminal) will have to suffice.
25 *
26 * The debugger is only built into the VM with debug builds or when
27 * VBOX_WITH_DEBUGGER is defined. There might be need for \#ifdef'ing on this
28 * define to enable special debugger hooks, but the general approach is to
29 * make generic interfaces. The individual components also can register
30 * external commands, and such code must be within \#ifdef.
31 *
32 *
33 * @section sec_dbgc_op Operation (intentions)
34 *
35 * The console will process commands in a manner similar to the OS/2 and
36 * windows kernel debuggers. This means ';' is a command separator and
37 * that when possible we'll use the same command names as these two uses.
38 *
39 *
40 * @subsection sec_dbg_op_numbers Numbers
41 *
42 * Numbers are hexadecimal unless specified with a prefix indicating
43 * elsewise. Prefixes:
44 * - '0x' - hexadecimal.
45 * - '0i' - decimal
46 * - '0t' - octal.
47 * - '0y' - binary.
48 *
49 *
50 * @subsection sec_dbg_op_address Addressing modes
51 *
52 * - Default is flat. For compatability '%' also means flat.
53 * - Segmented addresses are specified selector:offset.
54 * - Physical addresses are specified using '%%'.
55 * - The default target for the addressing is the guest context, the '#'
56 * will override this and set it to the host.
57 *
58 *
59 * @subsection sec_dbg_op_evalution Evaluation
60 *
61 * As time permits support will be implemented support for a subset of the C
62 * binary operators, starting with '+', '-', '*' and '/'. Support for variables
63 * are provided thru commands 'set' and 'unset' and the unary operator '$'. The
64 * unary '@' operator will indicate function calls. The debugger needs a set of
65 * memory read functions, but we might later extend this to allow registration of
66 * external functions too.
67 *
68 * A special command '?' will then be added which evalutates a given expression
69 * and prints it in all the different formats.
70 *
71 *
72 * @subsection sec_dbg_op_registers Registers
73 *
74 * Registers are addressed using their name. Some registers which have several fields
75 * (like gdtr) will have separate names indicating the different fields. The default
76 * register set is the guest one. To access the hypervisor register one have to
77 * prefix the register names with '.'.
78 *
79 *
80 * @subsection sec_dbg_op_commands Commands
81 *
82 * The commands are all lowercase, case sensitive, and starting with a letter. We will
83 * later add some special commands ('?' for evaulation) and perhaps command classes ('.', '!')
84 *
85 *
86 * @section sec_dbg_tasks Tasks
87 *
88 * To implement DBGT and instrument VMM for basic state inspection and log
89 * viewing, the follwing task must be executed:
90 *
91 * -# Basic threading layer in RT.
92 * -# Basic tcpip server abstration in RT.
93 * -# Write DBGC.
94 * -# Write DBCTCP.
95 * -# Integrate with VMM and the rest.
96 * -# Start writing DBGF (VMM).
97 */
98
99
100
101
102/*******************************************************************************
103* Header Files *
104*******************************************************************************/
105#define LOG_GROUP LOG_GROUP_DBGC
106#include <VBox/dbg.h>
107#include <VBox/dbgf.h>
108#include <VBox/vm.h>
109#include <VBox/vmm.h>
110#include <VBox/mm.h>
111#include <VBox/pgm.h>
112#include <VBox/selm.h>
113#include <VBox/dis.h>
114#include <VBox/param.h>
115#include <VBox/err.h>
116#include <VBox/log.h>
117
118#include <iprt/alloc.h>
119#include <iprt/alloca.h>
120#include <iprt/string.h>
121#include <iprt/assert.h>
122#include <iprt/ctype.h>
123
124#include <stdlib.h>
125#include <stdio.h>
126
127/* to err.h! */
128#define VERR_DBGC_QUIT (-11999)
129#define VERR_PARSE_FIRST (-11000)
130#define VERR_PARSE_TOO_FEW_ARGUMENTS (VERR_PARSE_FIRST - 0)
131#define VERR_PARSE_TOO_MANY_ARGUMENTS (VERR_PARSE_FIRST - 1)
132#define VERR_PARSE_ARGUMENT_OVERFLOW (VERR_PARSE_FIRST - 2)
133#define VERR_PARSE_ARGUMENT_TYPE_MISMATCH (VERR_PARSE_FIRST - 3)
134#define VERR_PARSE_NO_RANGE_ALLOWED (VERR_PARSE_FIRST - 4)
135#define VERR_PARSE_UNBALANCED_QUOTE (VERR_PARSE_FIRST - 5)
136#define VERR_PARSE_UNBALANCED_PARENTHESIS (VERR_PARSE_FIRST - 6)
137#define VERR_PARSE_EMPTY_ARGUMENT (VERR_PARSE_FIRST - 7)
138#define VERR_PARSE_UNEXPECTED_OPERATOR (VERR_PARSE_FIRST - 8)
139#define VERR_PARSE_INVALID_NUMBER (VERR_PARSE_FIRST - 9)
140#define VERR_PARSE_NUMBER_TOO_BIG (VERR_PARSE_FIRST - 10)
141#define VERR_PARSE_INVALID_OPERATION (VERR_PARSE_FIRST - 11)
142#define VERR_PARSE_FUNCTION_NOT_FOUND (VERR_PARSE_FIRST - 12)
143#define VERR_PARSE_NOT_A_FUNCTION (VERR_PARSE_FIRST - 13)
144#define VERR_PARSE_NO_MEMORY (VERR_PARSE_FIRST - 14)
145#define VERR_PARSE_INCORRECT_ARG_TYPE (VERR_PARSE_FIRST - 15)
146#define VERR_PARSE_VARIABLE_NOT_FOUND (VERR_PARSE_FIRST - 16)
147#define VERR_PARSE_CONVERSION_FAILED (VERR_PARSE_FIRST - 17)
148#define VERR_PARSE_NOT_IMPLEMENTED (VERR_PARSE_FIRST - 18)
149#define VERR_PARSE_BAD_RESULT_TYPE (VERR_PARSE_FIRST - 19)
150#define VERR_PARSE_WRITEONLY_SYMBOL (VERR_PARSE_FIRST - 20)
151#define VERR_PARSE_NO_ARGUMENT_MATCH (VERR_PARSE_FIRST - 21)
152#define VERR_PARSE_LAST (VERR_PARSE_FIRST - 30)
153
154#define VWRN_DBGC_CMD_PENDING 12000
155#define VWRN_DBGC_ALREADY_REGISTERED 12001
156#define VERR_DBGC_COMMANDS_NOT_REGISTERED (-12002)
157#define VERR_DBGC_BP_NOT_FOUND (-12003)
158#define VERR_DBGC_BP_EXISTS (-12004)
159#define VINF_DBGC_BP_NO_COMMAND 12005
160
161
162
163/*******************************************************************************
164* Defined Constants And Macros *
165*******************************************************************************/
166/** Makes a DBGC variable type pair.
167 * Typically used by binary operators. */
168#define BINARY_TYPE_PAIR(type1, type2) (type1 | (type2 << 16))
169
170
171/*******************************************************************************
172* Structures and Typedefs *
173*******************************************************************************/
174
175/**
176 * Debugger console per breakpoint data.
177 */
178typedef struct DBGCBP
179{
180 /** Pointer to the next breakpoint in the list. */
181 struct DBGCBP *pNext;
182 /** The breakpoint identifier. */
183 RTUINT iBp;
184 /** The size of the command. */
185 size_t cchCmd;
186 /** The command to execute when the breakpoint is hit. */
187 char szCmd[1];
188} DBGCBP;
189/** Pointer to a breakpoint. */
190typedef DBGCBP *PDBGCBP;
191
192
193/**
194 * Named variable.
195 *
196 * Always allocated from heap in one signle block.
197 */
198typedef struct DBGCNAMEDVAR
199{
200 /** The variable. */
201 DBGCVAR Var;
202 /** It's name. */
203 char szName[1];
204} DBGCNAMEDVAR;
205/** Pointer to named variable. */
206typedef DBGCNAMEDVAR *PDBGCNAMEDVAR;
207
208
209/**
210 * Debugger console status
211 */
212typedef enum DBGCSTATUS
213{
214 /** Normal status, .*/
215 DBGC_HALTED
216
217} DBGCSTATUS;
218
219
220/**
221 * Debugger console instance data.
222 */
223typedef struct DBGC
224{
225 /** Command helpers. */
226 DBGCCMDHLP CmdHlp;
227 /** Pointer to backend callback structure. */
228 PDBGCBACK pBack;
229
230 /** Pointer to the current VM. */
231 PVM pVM;
232 /** The current debugger emulation. */
233 const char *pszEmulation;
234 /** Pointer to the command and functions for the current debugger emulation. */
235 PCDBGCCMD paEmulationCmds;
236 /** The number of commands paEmulationCmds points to. */
237 unsigned cEmulationCmds;
238 /** Log indicator. (If set we're writing the log to the console.) */
239 bool fLog;
240
241 /** Indicates whether we're in guest (true) or hypervisor (false) register context. */
242 bool fRegCtxGuest;
243 /** Indicates whether the register are terse or sparse. */
244 bool fRegTerse;
245
246 /** Current dissassembler position. */
247 DBGCVAR DisasmPos;
248 /** Current source position. (flat GC) */
249 DBGCVAR SourcePos;
250 /** Current memory dump position. */
251 DBGCVAR DumpPos;
252 /** Size of the previous dump element. */
253 unsigned cbDumpElement;
254
255 /** Number of variables in papVars. */
256 unsigned cVars;
257 /** Array of global variables.
258 * Global variables can be referenced using the $ operator and set
259 * and unset using command with those names. */
260 PDBGCNAMEDVAR *papVars;
261
262 /** The list of breakpoints. (singly linked) */
263 PDBGCBP pFirstBp;
264
265 /** @name Parsing and Execution
266 * @{ */
267
268 /** Input buffer. */
269 char achInput[2048];
270 /** To ease debugging. */
271 unsigned uInputZero;
272 /** Write index in the input buffer. */
273 unsigned iWrite;
274 /** Read index in the input buffer. */
275 unsigned iRead;
276 /** The number of lines in the buffer. */
277 unsigned cInputLines;
278 /** Indicates that we have a buffer overflow condition.
279 * This means that input is ignored up to the next newline. */
280 bool fInputOverflow;
281 /** Indicates whether or we're ready for input. */
282 bool fReady;
283
284 /** Scratch buffer position. */
285 char *pszScratch;
286 /** Scratch buffer. */
287 char achScratch[16384];
288 /** Argument array position. */
289 unsigned iArg;
290 /** Array of argument variables. */
291 DBGCVAR aArgs[100];
292
293 /** rc from last dbgcHlpPrintfV(). */
294 int rcOutput;
295
296 /** @} */
297} DBGC;
298/** Pointer to debugger console instance data. */
299typedef DBGC *PDBGC;
300
301/** Converts a Command Helper pointer to a pointer to DBGC instance data. */
302#define DBGC_CMDHLP2DBGC(pCmdHlp) ( (PDBGC)((uintptr_t)(pCmdHlp) - RT_OFFSETOF(DBGC, CmdHlp)) )
303
304
305/**
306 * Chunk of external commands.
307 */
308typedef struct DBGCEXTCMDS
309{
310 /** Number of commands descriptors. */
311 unsigned cCmds;
312 /** Pointer to array of command descriptors. */
313 PCDBGCCMD paCmds;
314 /** Pointer to the next chunk. */
315 struct DBGCEXTCMDS *pNext;
316} DBGCEXTCMDS;
317/** Pointer to chunk of external commands. */
318typedef DBGCEXTCMDS *PDBGCEXTCMDS;
319
320
321
322/**
323 * Unary operator handler function.
324 *
325 * @returns 0 on success.
326 * @returns VBox evaluation / parsing error code on failure.
327 * The caller does the bitching.
328 * @param pDbgc Debugger console instance data.
329 * @param pArg The argument.
330 * @param pResult Where to store the result.
331 */
332typedef DECLCALLBACK(int) FNDBGCOPUNARY(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
333/** Pointer to a unary operator handler function. */
334typedef FNDBGCOPUNARY *PFNDBGCOPUNARY;
335
336
337/**
338 * Binary operator handler function.
339 *
340 * @returns 0 on success.
341 * @returns VBox evaluation / parsing error code on failure.
342 * The caller does the bitching.
343 * @param pDbgc Debugger console instance data.
344 * @param pArg1 The first argument.
345 * @param pArg2 The 2nd argument.
346 * @param pResult Where to store the result.
347 */
348typedef DECLCALLBACK(int) FNDBGCOPBINARY(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
349/** Pointer to a binary operator handler function. */
350typedef FNDBGCOPBINARY *PFNDBGCOPBINARY;
351
352
353/**
354 * Operator descriptor.
355 */
356typedef struct DBGCOP
357{
358 /** Operator mnemonic. */
359 char szName[4];
360 /** Length of name. */
361 const unsigned cchName;
362 /** Whether or not this is a binary operator.
363 * Unary operators are evaluated right-to-left while binary are left-to-right. */
364 bool fBinary;
365 /** Precedence level. */
366 unsigned iPrecedence;
367 /** Unary operator handler. */
368 PFNDBGCOPUNARY pfnHandlerUnary;
369 /** Binary operator handler. */
370 PFNDBGCOPBINARY pfnHandlerBinary;
371 /** Operator description. */
372 const char *pszDescription;
373} DBGCOP;
374/** Pointer to an operator descriptor. */
375typedef DBGCOP *PDBGCOP;
376/** Pointer to a const operator descriptor. */
377typedef const DBGCOP *PCDBGCOP;
378
379
380
381/** Pointer to symbol descriptor. */
382typedef struct DBGCSYM *PDBGCSYM;
383/** Pointer to const symbol descriptor. */
384typedef const struct DBGCSYM *PCDBGCSYM;
385
386/**
387 * Get builtin symbol.
388 *
389 * @returns 0 on success.
390 * @returns VBox evaluation / parsing error code on failure.
391 * The caller does the bitching.
392 * @param pSymDesc Pointer to the symbol descriptor.
393 * @param pCmdHlp Pointer to the command callback structure.
394 * @param enmType The result type.
395 * @param pResult Where to store the result.
396 */
397typedef DECLCALLBACK(int) FNDBGCSYMGET(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult);
398/** Pointer to get function for a builtin symbol. */
399typedef FNDBGCSYMGET *PFNDBGCSYMGET;
400
401/**
402 * Set builtin symbol.
403 *
404 * @returns 0 on success.
405 * @returns VBox evaluation / parsing error code on failure.
406 * The caller does the bitching.
407 * @param pSymDesc Pointer to the symbol descriptor.
408 * @param pCmdHlp Pointer to the command callback structure.
409 * @param pValue The value to assign the symbol.
410 */
411typedef DECLCALLBACK(int) FNDBGCSYMSET(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue);
412/** Pointer to set function for a builtin symbol. */
413typedef FNDBGCSYMSET *PFNDBGCSYMSET;
414
415
416/**
417 * Symbol description (for builtin symbols).
418 */
419typedef struct DBGCSYM
420{
421 /** Symbol name. */
422 const char *pszName;
423 /** Get function. */
424 PFNDBGCSYMGET pfnGet;
425 /** Set function. (NULL if readonly) */
426 PFNDBGCSYMSET pfnSet;
427 /** User data. */
428 unsigned uUser;
429} DBGCSYM;
430
431
432/*******************************************************************************
433* Internal Functions *
434*******************************************************************************/
435static DECLCALLBACK(int) dbgcCmdBrkREM(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
436static DECLCALLBACK(int) dbgcCmdHelp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
437static DECLCALLBACK(int) dbgcCmdQuit(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
438static DECLCALLBACK(int) dbgcCmdStop(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
439static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
440static DECLCALLBACK(int) dbgcCmdDumpDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
441static DECLCALLBACK(int) dbgcCmdDumpIDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
442static DECLCALLBACK(int) dbgcCmdDumpPageDir(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
443static DECLCALLBACK(int) dbgcCmdDumpPageDirBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
444static DECLCALLBACK(int) dbgcCmdDumpPageTable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
445static DECLCALLBACK(int) dbgcCmdDumpPageTableBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
446static DECLCALLBACK(int) dbgcCmdDumpTSS(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
447static DECLCALLBACK(int) dbgcCmdInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
448static DECLCALLBACK(int) dbgcCmdLog(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
449static DECLCALLBACK(int) dbgcCmdLogDest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
450static DECLCALLBACK(int) dbgcCmdLogFlags(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
451static DECLCALLBACK(int) dbgcCmdMemoryInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
452static DECLCALLBACK(int) dbgcCmdFormat(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
453static DECLCALLBACK(int) dbgcCmdLoadSyms(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
454static DECLCALLBACK(int) dbgcCmdSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
455static DECLCALLBACK(int) dbgcCmdUnset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
456static DECLCALLBACK(int) dbgcCmdLoadVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
457static DECLCALLBACK(int) dbgcCmdShowVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
458static DECLCALLBACK(int) dbgcCmdHarakiri(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
459static DECLCALLBACK(int) dbgcCmdEcho(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
460static DECLCALLBACK(int) dbgcCmdRunScript(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
461
462static DECLCALLBACK(int) dbgcCmdBrkAccess(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
463static DECLCALLBACK(int) dbgcCmdBrkClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
464static DECLCALLBACK(int) dbgcCmdBrkDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
465static DECLCALLBACK(int) dbgcCmdBrkEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
466static DECLCALLBACK(int) dbgcCmdBrkList(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
467static DECLCALLBACK(int) dbgcCmdBrkSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
468static DECLCALLBACK(int) dbgcCmdDumpMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
469static DECLCALLBACK(int) dbgcCmdGo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
470static DECLCALLBACK(int) dbgcCmdListSource(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
471static DECLCALLBACK(int) dbgcCmdListNear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
472static DECLCALLBACK(int) dbgcCmdReg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
473static DECLCALLBACK(int) dbgcCmdRegGuest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
474static DECLCALLBACK(int) dbgcCmdRegHyper(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
475static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
476static DECLCALLBACK(int) dbgcCmdSearchMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
477static DECLCALLBACK(int) dbgcCmdTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
478static DECLCALLBACK(int) dbgcCmdUnassemble(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
479
480static DECLCALLBACK(int) dbgcOpMinus(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
481static DECLCALLBACK(int) dbgcOpPluss(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
482static DECLCALLBACK(int) dbgcOpBooleanNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
483static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
484static DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
485static DECLCALLBACK(int) dbgcOpAddrPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
486static DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
487static DECLCALLBACK(int) dbgcOpAddrHostPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
488static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult);
489
490static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
491static DECLCALLBACK(int) dbgcOpMult(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
492static DECLCALLBACK(int) dbgcOpDiv(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
493static DECLCALLBACK(int) dbgcOpMod(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
494static DECLCALLBACK(int) dbgcOpAdd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
495static DECLCALLBACK(int) dbgcOpSub(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
496static DECLCALLBACK(int) dbgcOpBitwiseShiftLeft(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
497static DECLCALLBACK(int) dbgcOpBitwiseShiftRight(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
498static DECLCALLBACK(int) dbgcOpBitwiseAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
499static DECLCALLBACK(int) dbgcOpBitwiseXor(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
500static DECLCALLBACK(int) dbgcOpBitwiseOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
501static DECLCALLBACK(int) dbgcOpBooleanAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
502static DECLCALLBACK(int) dbgcOpBooleanOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
503static DECLCALLBACK(int) dbgcOpRangeLength(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
504static DECLCALLBACK(int) dbgcOpRangeLengthBytes(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
505static DECLCALLBACK(int) dbgcOpRangeTo(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult);
506
507static DECLCALLBACK(int) dbgcSymGetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult);
508static DECLCALLBACK(int) dbgcSymSetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue);
509
510static void dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat);
511static void dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb);
512static void dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2);
513static void dbgcVarSetNoRange(PDBGCVAR pVar);
514static void dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb);
515static int dbgcVarToDbgfAddr(PDBGC pDbgc, PCDBGCVAR pVar, PDBGFADDRESS pAddress);
516
517static int dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
518static int dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd);
519static int dbgcBpDelete(PDBGC pDbgc, RTUINT iBp);
520static PDBGCBP dbgcBpGet(PDBGC pDbgc, RTUINT iBp);
521static int dbgcBpExec(PDBGC pDbgc, RTUINT iBp);
522
523static PCDBGCSYM dbgcLookupRegisterSymbol(PDBGC pDbgc, const char *pszSymbol);
524static int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult);
525static int dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult);
526static int dbgcProcessCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd);
527
528
529/*******************************************************************************
530* Global Variables *
531*******************************************************************************/
532/**
533 * Pointer to head of the list of external commands.
534 */
535static PDBGCEXTCMDS g_pExtCmdsHead; /** @todo rw protect g_pExtCmdsHead! */
536/** Locks the g_pExtCmdsHead list for reading. */
537#define DBGCEXTCMDS_LOCK_RD() do { } while (0)
538/** Locks the g_pExtCmdsHead list for writing. */
539#define DBGCEXTCMDS_LOCK_WR() do { } while (0)
540/** UnLocks the g_pExtCmdsHead list after reading. */
541#define DBGCEXTCMDS_UNLOCK_RD() do { } while (0)
542/** UnLocks the g_pExtCmdsHead list after writing. */
543#define DBGCEXTCMDS_UNLOCK_WR() do { } while (0)
544
545
546/** One argument of any kind. */
547static const DBGCVARDESC g_aArgAny[] =
548{
549 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
550 { 0, 1, DBGCVAR_CAT_ANY, 0, "var", "Any type of argument." },
551};
552
553/** Multiple string arguments (min 1). */
554static const DBGCVARDESC g_aArgMultiStr[] =
555{
556 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
557 { 1, ~0, DBGCVAR_CAT_STRING, 0, "strings", "One or more strings." },
558};
559
560/** Filename string. */
561static const DBGCVARDESC g_aArgFilename[] =
562{
563 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
564 { 1, 1, DBGCVAR_CAT_STRING, 0, "path", "Filename string." },
565};
566
567
568/** 'br' arguments. */
569static const DBGCVARDESC g_aArgBrkREM[] =
570{
571 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
572 { 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
573 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
574 { 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "max passes", "The number of passes after which we stop triggering the breakpoint. (~0 is default)" },
575 { 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
576};
577
578
579/** 'dg', 'dga', 'dl', 'dla' arguments. */
580static const DBGCVARDESC g_aArgDumpDT[] =
581{
582 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
583 { 0, ~0, DBGCVAR_CAT_NUMBER, 0, "sel", "Selector or selector range." },
584 { 0, ~0, DBGCVAR_CAT_POINTER, 0, "address", "Far address which selector should be dumped." },
585};
586
587
588/** 'di', 'dia' arguments. */
589static const DBGCVARDESC g_aArgDumpIDT[] =
590{
591 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
592 { 0, ~0, DBGCVAR_CAT_NUMBER, 0, "int", "The interrupt vector or interrupt vector range." },
593};
594
595
596/** 'dpd*' arguments. */
597static const DBGCVARDESC g_aArgDumpPD[] =
598{
599 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
600 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "index", "Index into the page directory." },
601 { 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from. Range is applied to the page directory." },
602};
603
604
605/** 'dpda' arguments. */
606static const DBGCVARDESC g_aArgDumpPDAddr[] =
607{
608 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
609 { 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page directory entry to start dumping from." },
610};
611
612
613/** 'dpt?' arguments. */
614static const DBGCVARDESC g_aArgDumpPT[] =
615{
616 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
617 { 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address which page directory entry to start dumping from." },
618};
619
620
621/** 'dpta' arguments. */
622static const DBGCVARDESC g_aArgDumpPTAddr[] =
623{
624 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
625 { 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address of the page table entry to start dumping from." },
626};
627
628
629/** 'dt' arguments. */
630static const DBGCVARDESC g_aArgDumpTSS[] =
631{
632 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
633 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "tss", "TSS selector number." },
634 { 0, 1, DBGCVAR_CAT_POINTER, 0, "tss:ign|addr", "TSS address. If the selector is a TSS selector, the offset will be ignored." }
635};
636
637
638/** 'help' arguments. */
639static const DBGCVARDESC g_aArgHelp[] =
640{
641 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
642 { 0, ~0, DBGCVAR_CAT_STRING, 0, "cmd/op", "Zero or more command or operator names." },
643};
644
645
646/** 'info' arguments. */
647static const DBGCVARDESC g_aArgInfo[] =
648{
649 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
650 { 1, 1, DBGCVAR_CAT_STRING, 0, "info", "The name of the info to display." },
651 { 0, 1, DBGCVAR_CAT_STRING, 0, "args", "String arguments to the handler." },
652};
653
654
655/** loadsyms arguments. */
656static const DBGCVARDESC g_aArgLoadSyms[] =
657{
658 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
659 { 1, 1, DBGCVAR_CAT_STRING, 0, "path", "Filename string." },
660 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "delta", "Delta to add to the loaded symbols. (optional)" },
661 { 0, 1, DBGCVAR_CAT_STRING, 0, "module name", "Module name." },
662 { 0, 1, DBGCVAR_CAT_POINTER, DBGCVD_FLAGS_DEP_PREV, "module address", "Module address." },
663 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "module size", "The module size. (optional)" },
664};
665
666
667/** log arguments. */
668static const DBGCVARDESC g_aArgLog[] =
669{
670 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
671 { 1, 1, DBGCVAR_CAT_STRING, 0, "groups", "Group modifier string (quote it!)." }
672};
673
674
675/** logdest arguments. */
676static const DBGCVARDESC g_aArgLogDest[] =
677{
678 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
679 { 1, 1, DBGCVAR_CAT_STRING, 0, "dests", "Destination modifier string (quote it!)." }
680};
681
682
683/** logflags arguments. */
684static const DBGCVARDESC g_aArgLogFlags[] =
685{
686 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
687 { 1, 1, DBGCVAR_CAT_STRING, 0, "flags", "Flag modifier string (quote it!)." }
688};
689
690
691/** 'set' arguments */
692static const DBGCVARDESC g_aArgSet[] =
693{
694 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
695 { 1, 1, DBGCVAR_CAT_STRING, 0, "var", "Variable name." },
696 { 1, 1, DBGCVAR_CAT_ANY, 0, "value", "Value to assign to the variable." },
697};
698
699
700
701
702
703/** Command descriptors for the basic commands. */
704static const DBGCCMD g_aCmds[] =
705{
706 /* pszCmd, cArgsMin, cArgsMax, paArgDescs, cArgDescs, pResultDesc, fFlags, pfnHandler pszSyntax, ....pszDescription */
707 { "br", 1, 4, &g_aArgBrkREM[0], ELEMENTS(g_aArgBrkREM), NULL, 0, dbgcCmdBrkREM, "<address> [passes [max passes]] [cmds]",
708 "Sets a recompiler specific breakpoint." },
709 { "bye", 0, 0, NULL, 0, NULL, 0, dbgcCmdQuit, "", "Exits the debugger." },
710 { "dg", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT)." },
711 { "dga", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the global descriptor table (GDT) including not-present entries." },
712 { "di", 0, ~0, &g_aArgDumpIDT[0], ELEMENTS(g_aArgDumpIDT), NULL, 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT)." },
713 { "dia", 0, ~0, &g_aArgDumpIDT[0], ELEMENTS(g_aArgDumpIDT), NULL, 0, dbgcCmdDumpIDT, "[int [..]]", "Dump the interrupt descriptor table (IDT) including not-present entries." },
714 { "dl", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT)." },
715 { "dla", 0, ~0, &g_aArgDumpDT[0], ELEMENTS(g_aArgDumpDT), NULL, 0, dbgcCmdDumpDT, "[sel [..]]", "Dump the local descriptor table (LDT) including not-present entries." },
716 { "dpd", 0, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDir, "[addr] [index]", "Dumps page directory entries of the default context." },
717 { "dpda", 0, 1, &g_aArgDumpPDAddr[0],ELEMENTS(g_aArgDumpPDAddr),NULL, 0, dbgcCmdDumpPageDir, "[addr]", "Dumps specified page directory." },
718 { "dpdb", 1, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDirBoth, "[addr] [index]", "Dumps page directory entries of the guest and the hypervisor. " },
719 { "dpdg", 0, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDir, "[addr] [index]", "Dumps page directory entries of the guest." },
720 { "dpdh", 0, 1, &g_aArgDumpPD[0], ELEMENTS(g_aArgDumpPD), NULL, 0, dbgcCmdDumpPageDir, "[addr] [index]", "Dumps page directory entries of the hypervisor. " },
721 { "dpt", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the default context." },
722 { "dpta", 1, 1, &g_aArgDumpPTAddr[0],ELEMENTS(g_aArgDumpPTAddr), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps specified page table." },
723 { "dptb", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTableBoth,"<addr>", "Dumps page table entries of the guest and the hypervisor." },
724 { "dptg", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the guest." },
725 { "dpth", 1, 1, &g_aArgDumpPT[0], ELEMENTS(g_aArgDumpPT), NULL, 0, dbgcCmdDumpPageTable,"<addr>", "Dumps page table entries of the hypervisor." },
726 { "dt", 0, 1, &g_aArgDumpTSS[0], ELEMENTS(g_aArgDumpTSS), NULL, 0, dbgcCmdDumpTSS, "[tss|tss:ign|addr]", "Dump the task state segment (TSS)." },
727 { "echo", 1, ~0, &g_aArgMultiStr[0], ELEMENTS(g_aArgMultiStr), NULL, 0, dbgcCmdEcho, "<str1> [str2..[strN]]", "Displays the strings separated by one blank space and the last one followed by a newline." },
728 { "exit", 0, 0, NULL, 0, NULL, 0, dbgcCmdQuit, "", "Exits the debugger." },
729 { "format", 1, 1, &g_aArgAny[0], ELEMENTS(g_aArgAny), NULL, 0, dbgcCmdFormat, "", "Evaluates an expression and formats it." },
730 { "harakiri", 0, 0, NULL, 0, NULL, 0, dbgcCmdHarakiri, "", "Kills debugger process." },
731 { "help", 0, ~0, &g_aArgHelp[0], ELEMENTS(g_aArgHelp), NULL, 0, dbgcCmdHelp, "[cmd/op [..]]", "Display help. For help about info items try 'info help'." },
732 { "info", 1, 2, &g_aArgInfo[0], ELEMENTS(g_aArgInfo), NULL, 0, dbgcCmdInfo, "<info> [args]", "Display info register in the DBGF. For a list of info items try 'info help'." },
733 { "loadsyms", 1, 5, &g_aArgLoadSyms[0], ELEMENTS(g_aArgLoadSyms), NULL, 0, dbgcCmdLoadSyms, "<filename> [delta] [module] [module address]", "Loads symbols from a text file. Optionally giving a delta and a module." },
734 { "loadvars", 1, 1, &g_aArgFilename[0], ELEMENTS(g_aArgFilename), NULL, 0, dbgcCmdLoadVars, "<filename>", "Load variables from file. One per line, same as the args to the set command." },
735 { "log", 1, 1, &g_aArgLog[0], ELEMENTS(g_aArgLog), NULL, 0, dbgcCmdLog, "<group string>", "Modifies the logging group settings (VBOX_LOG)" },
736 { "logdest", 1, 1, &g_aArgLogDest[0], ELEMENTS(g_aArgLogDest), NULL, 0, dbgcCmdLogDest, "<dest string>", "Modifies the logging destination (VBOX_LOG_DEST)." },
737 { "logflags", 1, 1, &g_aArgLogFlags[0], ELEMENTS(g_aArgLogFlags), NULL, 0, dbgcCmdLogFlags, "<flags string>", "Modifies the logging flags (VBOX_LOG_FLAGS)." },
738 { "quit", 0, 0, NULL, 0, NULL, 0, dbgcCmdQuit, "", "Exits the debugger." },
739 { "runscript", 1, 1, &g_aArgFilename[0], ELEMENTS(g_aArgFilename), NULL, 0, dbgcCmdRunScript, "<filename>", "Runs the command listed in the script. Lines starting with '#' (after removing blanks) are comment. blank lines are ignored. Stops on failure." },
740 { "set", 2, 2, &g_aArgSet[0], ELEMENTS(g_aArgSet), NULL, 0, dbgcCmdSet, "<var> <value>", "Sets a global variable." },
741 { "showvars", 0, 0, NULL, 0, NULL, 0, dbgcCmdShowVars, "", "List all the defined variables." },
742 { "stop", 0, 0, NULL, 0, NULL, 0, dbgcCmdStop, "", "Stop execution." },
743 { "unset", 1, ~0, &g_aArgMultiStr[0], ELEMENTS(g_aArgMultiStr), NULL, 0, dbgcCmdUnset, "<var1> [var1..[varN]]", "Unsets (delete) one or more global variables." },
744};
745
746
747/** 'ba' arguments. */
748static const DBGCVARDESC g_aArgBrkAcc[] =
749{
750 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
751 { 1, 1, DBGCVAR_CAT_STRING, 0, "access", "The access type: x=execute, rw=read/write (alias r), w=write, i=not implemented." },
752 { 1, 1, DBGCVAR_CAT_NUMBER, 0, "size", "The access size: 1, 2, 4, or 8. 'x' access requires 1, and 8 requires amd64 long mode." },
753 { 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
754 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
755 { 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "max passes", "The number of passes after which we stop triggering the breakpoint. (~0 is default)" },
756 { 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
757};
758
759
760/** 'bc', 'bd', 'be' arguments. */
761static const DBGCVARDESC g_aArgBrks[] =
762{
763 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
764 { 0, ~0, DBGCVAR_CAT_NUMBER, 0, "#bp", "Breakpoint number." },
765 { 0, 1, DBGCVAR_CAT_STRING, 0, "all", "All breakpoints." },
766};
767
768
769/** 'bp' arguments. */
770static const DBGCVARDESC g_aArgBrkSet[] =
771{
772 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
773 { 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "address", "The address." },
774 { 0, 1, DBGCVAR_CAT_NUMBER, 0, "passes", "The number of passes before we trigger the breakpoint. (0 is default)" },
775 { 0, 1, DBGCVAR_CAT_NUMBER, DBGCVD_FLAGS_DEP_PREV, "max passes", "The number of passes after which we stop triggering the breakpoint. (~0 is default)" },
776 { 0, 1, DBGCVAR_CAT_STRING, 0, "cmds", "String of commands to be executed when the breakpoint is hit. Quote it!" },
777};
778
779
780/** 'd?' arguments. */
781static const DBGCVARDESC g_aArgDumpMem[] =
782{
783 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
784 { 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start dumping memory." },
785};
786
787
788/** 'ln' arguments. */
789static const DBGCVARDESC g_aArgListNear[] =
790{
791 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
792 { 0, ~0, DBGCVAR_CAT_POINTER, 0, "address", "Address of the symbol to look up." },
793 { 0, ~0, DBGCVAR_CAT_SYMBOL, 0, "symbol", "Symbol to lookup." },
794};
795
796/** 'ln' return. */
797static const DBGCVARDESC g_RetListNear =
798{
799 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "The last resolved symbol/address with adjusted range."
800};
801
802
803/** 'ls' arguments. */
804static const DBGCVARDESC g_aArgListSource[] =
805{
806 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
807 { 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start looking for source lines." },
808};
809
810
811/** 'm' argument. */
812static const DBGCVARDESC g_aArgMemoryInfo[] =
813{
814 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
815 { 1, 1, DBGCVAR_CAT_POINTER, 0, "address", "Pointer to obtain info about." },
816};
817
818
819/** 'r' arguments. */
820static const DBGCVARDESC g_aArgReg[] =
821{
822 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
823 { 0, 1, DBGCVAR_CAT_SYMBOL, 0, "register", "Register to show or set." },
824 { 0, 1, DBGCVAR_CAT_NUMBER_NO_RANGE, DBGCVD_FLAGS_DEP_PREV, "value", "New register value." },
825};
826
827
828/** 's' arguments. */
829static const DBGCVARDESC g_aArgSearchMem[] =
830{
831 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
832 { 1, 1, DBGCVAR_CAT_GC_POINTER, 0, "range", "Register to show or set." },
833 { 1, ~0, DBGCVAR_CAT_ANY, 0, "pattern", "Pattern to search for." },
834};
835
836
837/** 'u' arguments. */
838static const DBGCVARDESC g_aArgUnassemble[] =
839{
840 /* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
841 { 0, 1, DBGCVAR_CAT_POINTER, 0, "address", "Address where to start disassembling." },
842};
843
844
845/** Command descriptors for the CodeView / WinDbg emulation.
846 * The emulation isn't attempting to be identical, only somewhat similar.
847 */
848static const DBGCCMD g_aCmdsCodeView[] =
849{
850 /* pszCmd, cArgsMin, cArgsMax, paArgDescs, cArgDescs, pResultDesc, fFlags, pfnHandler pszSyntax, ....pszDescription */
851 { "ba", 3, 6, &g_aArgBrkAcc[0], RT_ELEMENTS(g_aArgBrkAcc), NULL, 0, dbgcCmdBrkAccess, "<access> <size> <address> [passes [max passes]] [cmds]",
852 "Sets a data access breakpoint." },
853 { "bc", 1, ~0, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), NULL, 0, dbgcCmdBrkClear, "all | <bp#> [bp# []]", "Enabled a set of breakpoints." },
854 { "bd", 1, ~0, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), NULL, 0, dbgcCmdBrkDisable, "all | <bp#> [bp# []]", "Disables a set of breakpoints." },
855 { "be", 1, ~0, &g_aArgBrks[0], RT_ELEMENTS(g_aArgBrks), NULL, 0, dbgcCmdBrkEnable, "all | <bp#> [bp# []]", "Enabled a set of breakpoints." },
856 { "bl", 0, 0, NULL, 0, NULL, 0, dbgcCmdBrkList, "", "Lists all the breakpoints." },
857 { "bp", 1, 4, &g_aArgBrkSet[0], RT_ELEMENTS(g_aArgBrkSet), NULL, 0, dbgcCmdBrkSet, "<address> [passes [max passes]] [cmds]",
858 "Sets a breakpoint (int 3)." },
859 { "d", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory using last element size." },
860 { "da", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory as ascii string." },
861 { "db", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in bytes." },
862 { "dd", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in double words." },
863 { "dq", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in quad words." },
864 { "dw", 0, 1, &g_aArgDumpMem[0], RT_ELEMENTS(g_aArgDumpMem), NULL, 0, dbgcCmdDumpMem, "[addr]", "Dump memory in words." },
865 { "g", 0, 0, NULL, 0, NULL, 0, dbgcCmdGo, "", "Continue execution." },
866 { "k", 0, 0, NULL, 0, NULL, 0, dbgcCmdStack, "", "Callstack." },
867 { "kg", 0, 0, NULL, 0, NULL, 0, dbgcCmdStack, "", "Callstack - guest." },
868 { "kh", 0, 0, NULL, 0, NULL, 0, dbgcCmdStack, "", "Callstack - hypervisor." },
869 { "ln", 0, ~0, &g_aArgListNear[0], RT_ELEMENTS(g_aArgListNear), &g_RetListNear, 0, dbgcCmdListNear, "[addr/sym [..]]", "List symbols near to the address. Default address is CS:EIP." },
870 { "ls", 0, 1, &g_aArgListSource[0],RT_ELEMENTS(g_aArgListSource),NULL, 0, dbgcCmdListSource, "[addr]", "Source." },
871 { "m", 1, 1, &g_aArgMemoryInfo[0],RT_ELEMENTS(g_aArgMemoryInfo),NULL, 0, dbgcCmdMemoryInfo, "<addr>", "Display information about that piece of memory." },
872 { "r", 0, 2, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), NULL, 0, dbgcCmdReg, "[reg [newval]]", "Show or set register(s) - active reg set." },
873 { "rg", 0, 2, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), NULL, 0, dbgcCmdRegGuest, "[reg [newval]]", "Show or set register(s) - guest reg set." },
874 { "rh", 0, 2, &g_aArgReg[0], RT_ELEMENTS(g_aArgReg), NULL, 0, dbgcCmdRegHyper, "[reg [newval]]", "Show or set register(s) - hypervisor reg set." },
875 { "rt", 0, 0, NULL, 0, NULL, 0, dbgcCmdRegTerse, "", "Toggles terse / verbose register info." },
876 //{ "s", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Continue last search." },
877 { "sa", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Search memory for an ascii string." },
878 { "sb", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Search memory for one or more bytes." },
879 { "sd", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Search memory for one or more double words." },
880 { "sq", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Search memory for one or more quad words." },
881 { "su", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Search memory for an unicode string." },
882 { "sw", 2, ~0, &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem), NULL, 0, dbgcCmdSearchMem, "<range> <pattern>", "Search memory for one or more words." },
883 { "t", 0, 0, NULL, 0, NULL, 0, dbgcCmdTrace, "", "Instruction trace (step into)." },
884 { "u", 0, 1, &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble),NULL, 0, dbgcCmdUnassemble, "[addr]", "Unassemble." },
885};
886
887
888/** Operators. */
889static const DBGCOP g_aOps[] =
890{
891 /* szName is initialized as a 4 char array because of M$C elsewise optimizing it away in /Ox mode (the 'const char' vs 'char' problem). */
892 /* szName, cchName, fBinary, iPrecedence, pfnHandlerUnary, pfnHandlerBitwise */
893 { {'-'}, 1, false, 1, dbgcOpMinus, NULL, "Unary minus." },
894 { {'+'}, 1, false, 1, dbgcOpPluss, NULL, "Unary pluss." },
895 { {'!'}, 1, false, 1, dbgcOpBooleanNot, NULL, "Boolean not." },
896 { {'~'}, 1, false, 1, dbgcOpBitwiseNot, NULL, "Bitwise complement." },
897 { {':'}, 1, true, 2, NULL, dbgcOpAddrFar, "Far pointer." },
898 { {'%'}, 1, false, 3, dbgcOpAddrFlat, NULL, "Flat address." },
899 { {'%','%'}, 2, false, 3, dbgcOpAddrPhys, NULL, "Physical address." },
900 { {'#'}, 1, false, 3, dbgcOpAddrHost, NULL, "Flat host address." },
901 { {'#','%','%'}, 3, false, 3, dbgcOpAddrHostPhys, NULL, "Physical host address." },
902 { {'$'}, 1, false, 3, dbgcOpVar, NULL, "Reference a variable." },
903 { {'*'}, 1, true, 10, NULL, dbgcOpMult, "Multiplication." },
904 { {'/'}, 1, true, 11, NULL, dbgcOpDiv, "Division." },
905 { {'%'}, 1, true, 12, NULL, dbgcOpMod, "Modulus." },
906 { {'+'}, 1, true, 13, NULL, dbgcOpAdd, "Addition." },
907 { {'-'}, 1, true, 14, NULL, dbgcOpSub, "Subtraction." },
908 { {'<','<'}, 2, true, 15, NULL, dbgcOpBitwiseShiftLeft, "Bitwise left shift." },
909 { {'>','>'}, 2, true, 16, NULL, dbgcOpBitwiseShiftRight, "Bitwise right shift." },
910 { {'&'}, 1, true, 17, NULL, dbgcOpBitwiseAnd, "Bitwise and." },
911 { {'^'}, 1, true, 18, NULL, dbgcOpBitwiseXor, "Bitwise exclusiv or." },
912 { {'|'}, 1, true, 19, NULL, dbgcOpBitwiseOr, "Bitwise inclusive or." },
913 { {'&','&'}, 2, true, 20, NULL, dbgcOpBooleanAnd, "Boolean and." },
914 { {'|','|'}, 2, true, 21, NULL, dbgcOpBooleanOr, "Boolean or." },
915 { {'L'}, 1, true, 22, NULL, dbgcOpRangeLength, "Range elements." },
916 { {'L','B'}, 2, true, 23, NULL, dbgcOpRangeLengthBytes, "Range bytes." },
917 { {'T'}, 1, true, 24, NULL, dbgcOpRangeTo, "Range to." }
918};
919
920/** Bitmap where set bits indicates the characters the may start an operator name. */
921static uint32_t g_bmOperatorChars[256 / (4*8)];
922
923/** Register symbol uUser value.
924 * @{
925 */
926/** If set the register set is the hypervisor and not the guest one. */
927#define SYMREG_FLAGS_HYPER RT_BIT(20)
928/** If set a far conversion of the value will use the high 16 bit for the selector.
929 * If clear the low 16 bit will be used. */
930#define SYMREG_FLAGS_HIGH_SEL RT_BIT(21)
931/** The shift value to calc the size of a register symbol from the uUser value. */
932#define SYMREG_SIZE_SHIFT (24)
933/** Get the offset */
934#define SYMREG_OFFSET(uUser) (uUser & ((1 << 20) - 1))
935/** Get the size. */
936#define SYMREG_SIZE(uUser) ((uUser >> SYMREG_SIZE_SHIFT) & 0xff)
937/** 1 byte. */
938#define SYMREG_SIZE_1 ( 1 << SYMREG_SIZE_SHIFT)
939/** 2 byte. */
940#define SYMREG_SIZE_2 ( 2 << SYMREG_SIZE_SHIFT)
941/** 4 byte. */
942#define SYMREG_SIZE_4 ( 4 << SYMREG_SIZE_SHIFT)
943/** 6 byte. */
944#define SYMREG_SIZE_6 ( 6 << SYMREG_SIZE_SHIFT)
945/** 8 byte. */
946#define SYMREG_SIZE_8 ( 8 << SYMREG_SIZE_SHIFT)
947/** 12 byte. */
948#define SYMREG_SIZE_12 (12 << SYMREG_SIZE_SHIFT)
949/** 16 byte. */
950#define SYMREG_SIZE_16 (16 << SYMREG_SIZE_SHIFT)
951/** @} */
952
953/** Builtin Symbols.
954 * ASSUMES little endian register representation!
955 */
956static const DBGCSYM g_aSyms[] =
957{
958 { "eax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_4 },
959 { "ax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_2 },
960 { "al", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_1 },
961 { "ah", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) + 1 | SYMREG_SIZE_1 },
962
963 { "ebx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_4 },
964 { "bx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_2 },
965 { "bl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_1 },
966 { "bh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) + 1 | SYMREG_SIZE_1 },
967
968 { "ecx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_4 },
969 { "cx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_2 },
970 { "cl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_1 },
971 { "ch", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) + 1 | SYMREG_SIZE_1 },
972
973 { "edx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_4 },
974 { "dx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_2 },
975 { "dl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_1 },
976 { "dh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) + 1 | SYMREG_SIZE_1 },
977
978 { "edi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_4 },
979 { "di", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_2 },
980
981 { "esi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_4 },
982 { "si", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_2 },
983
984 { "ebp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_4 },
985 { "bp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_2 },
986
987 { "esp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_4 },
988 { "sp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_2 },
989
990 { "eip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_4 },
991 { "ip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_2 },
992
993 { "efl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 },
994 { "eflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 },
995 { "fl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 },
996 { "flags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 },
997
998 { "cs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cs) | SYMREG_SIZE_2 },
999 { "ds", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ds) | SYMREG_SIZE_2 },
1000 { "es", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, es) | SYMREG_SIZE_2 },
1001 { "fs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, fs) | SYMREG_SIZE_2 },
1002 { "gs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gs) | SYMREG_SIZE_2 },
1003 { "ss", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ss) | SYMREG_SIZE_2 },
1004
1005 { "cr0", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr0) | SYMREG_SIZE_4 },
1006 { "cr2", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr2) | SYMREG_SIZE_4 },
1007 { "cr3", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr3) | SYMREG_SIZE_4 },
1008 { "cr4", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr4) | SYMREG_SIZE_4 },
1009
1010 { "tr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, tr) | SYMREG_SIZE_2 },
1011 { "ldtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ldtr) | SYMREG_SIZE_2 },
1012
1013 { "gdtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr) | SYMREG_SIZE_6 },
1014 { "gdtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.cbGdt)| SYMREG_SIZE_2 },
1015 { "gdtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.pGdt)| SYMREG_SIZE_4 },
1016
1017 { "idtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr) | SYMREG_SIZE_6 },
1018 { "idtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.cbIdt)| SYMREG_SIZE_2 },
1019 { "idtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.pIdt)| SYMREG_SIZE_4 },
1020
1021 /* hypervisor */
1022
1023 {".eax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1024 {".ax", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1025 {".al", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1026 {".ah", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eax) + 1 | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1027
1028 {".ebx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1029 {".bx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1030 {".bl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1031 {".bh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebx) + 1 | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1032
1033 {".ecx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1034 {".cx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1035 {".cl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1036 {".ch", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ecx) + 1 | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1037
1038 {".edx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1039 {".dx", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1040 {".dl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1041 {".dh", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edx) + 1 | SYMREG_SIZE_1 | SYMREG_FLAGS_HYPER },
1042
1043 {".edi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1044 {".di", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, edi) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1045
1046 {".esi", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1047 {".si", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esi) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1048
1049 {".ebp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1050 {".bp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ebp) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1051
1052 {".esp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1053 {".sp", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, esp) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1054
1055 {".eip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1056 {".ip", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eip) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1057
1058 {".efl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1059 {".eflags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1060 {".fl", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1061 {".flags", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, eflags) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1062
1063 {".cs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cs) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1064 {".ds", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ds) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1065 {".es", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, es) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1066 {".fs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, fs) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1067 {".gs", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gs) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1068 {".ss", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ss) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1069
1070 {".cr0", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr0) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1071 {".cr2", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr2) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1072 {".cr3", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr3) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1073 {".cr4", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, cr4) | SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1074
1075 {".tr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, tr) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1076 {".ldtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, ldtr) | SYMREG_SIZE_2 | SYMREG_FLAGS_HYPER },
1077
1078 {".gdtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr) | SYMREG_SIZE_6 | SYMREG_FLAGS_HYPER },
1079 {".gdtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.cbGdt)| SYMREG_SIZE_2| SYMREG_FLAGS_HYPER },
1080 {".gdtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, gdtr.pGdt)| SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1081
1082 {".idtr", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr) | SYMREG_SIZE_6 | SYMREG_FLAGS_HYPER },
1083 {".idtr.limit", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.cbIdt)| SYMREG_SIZE_2| SYMREG_FLAGS_HYPER },
1084 {".idtr.base", dbgcSymGetReg, dbgcSymSetReg, offsetof(CPUMCTX, idtr.pIdt)| SYMREG_SIZE_4 | SYMREG_FLAGS_HYPER },
1085
1086};
1087
1088
1089/**
1090 * Prints full command help.
1091 */
1092static int dbgcPrintHelp(PDBGCCMDHLP pCmdHlp, PCDBGCCMD pCmd, bool fExternal)
1093{
1094 int rc;
1095
1096 /* the command */
1097 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1098 "%s%-*s %-30s %s",
1099 fExternal ? "." : "",
1100 fExternal ? 10 : 11,
1101 pCmd->pszCmd,
1102 pCmd->pszSyntax,
1103 pCmd->pszDescription);
1104 if (!pCmd->cArgsMin && pCmd->cArgsMin == pCmd->cArgsMax)
1105 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <no args>\n");
1106 else if (pCmd->cArgsMin == pCmd->cArgsMax)
1107 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u args>\n", pCmd->cArgsMin);
1108 else if (pCmd->cArgsMax == ~0U)
1109 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u+ args>\n", pCmd->cArgsMin);
1110 else
1111 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u to %u args>\n", pCmd->cArgsMin, pCmd->cArgsMax);
1112
1113 /* argument descriptions. */
1114 for (unsigned i = 0; i < pCmd->cArgDescs; i++)
1115 {
1116 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1117 " %-12s %s",
1118 pCmd->paArgDescs[i].pszName,
1119 pCmd->paArgDescs[i].pszDescription);
1120 if (!pCmd->paArgDescs[i].cTimesMin)
1121 {
1122 if (pCmd->paArgDescs[i].cTimesMax == ~0U)
1123 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <optional+>\n");
1124 else
1125 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <optional-%u>\n", pCmd->paArgDescs[i].cTimesMax);
1126 }
1127 else
1128 {
1129 if (pCmd->paArgDescs[i].cTimesMax == ~0U)
1130 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u+>\n", pCmd->paArgDescs[i].cTimesMin);
1131 else
1132 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " <%u-%u>\n", pCmd->paArgDescs[i].cTimesMin, pCmd->paArgDescs[i].cTimesMax);
1133 }
1134 }
1135 return rc;
1136}
1137
1138
1139/**
1140 * The 'help' command.
1141 *
1142 * @returns VBox status.
1143 * @param pCmd Pointer to the command descriptor (as registered).
1144 * @param pCmdHlp Pointer to command helper functions.
1145 * @param pVM Pointer to the current VM (if any).
1146 * @param paArgs Pointer to (readonly) array of arguments.
1147 * @param cArgs Number of arguments in the array.
1148 */
1149static DECLCALLBACK(int) dbgcCmdHelp(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1150{
1151 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1152 int rc = VINF_SUCCESS;
1153 unsigned i;
1154
1155 if (!cArgs)
1156 {
1157 /*
1158 * All the stuff.
1159 */
1160 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1161 "VirtualBox Debugger\n"
1162 "-------------------\n"
1163 "\n"
1164 "Commands and Functions:\n");
1165 for (i = 0; i < ELEMENTS(g_aCmds); i++)
1166 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1167 "%-11s %-30s %s\n",
1168 g_aCmds[i].pszCmd,
1169 g_aCmds[i].pszSyntax,
1170 g_aCmds[i].pszDescription);
1171 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1172 "\n"
1173 "Emulation: %s\n", pDbgc->pszEmulation);
1174 PCDBGCCMD pCmd = pDbgc->paEmulationCmds;
1175 for (i = 0; i < pDbgc->cEmulationCmds; i++, pCmd++)
1176 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1177 "%-11s %-30s %s\n",
1178 pCmd->pszCmd,
1179 pCmd->pszSyntax,
1180 pCmd->pszDescription);
1181
1182 if (g_pExtCmdsHead)
1183 {
1184 DBGCEXTCMDS_LOCK_RD();
1185 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1186 "\n"
1187 "External Commands and Functions:\n");
1188 for (PDBGCEXTCMDS pExtCmd = g_pExtCmdsHead; pExtCmd; pExtCmd = pExtCmd->pNext)
1189 for (i = 0; i < pExtCmd->cCmds; i++)
1190 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1191 ".%-10s %-30s %s\n",
1192 pExtCmd->paCmds[i].pszCmd,
1193 pExtCmd->paCmds[i].pszSyntax,
1194 pExtCmd->paCmds[i].pszDescription);
1195 DBGCEXTCMDS_UNLOCK_RD();
1196 }
1197
1198 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1199 "\n"
1200 "Operators:\n");
1201 unsigned iPrecedence = 0;
1202 unsigned cLeft = ELEMENTS(g_aOps);
1203 while (cLeft > 0)
1204 {
1205 for (i = 0; i < ELEMENTS(g_aOps); i++)
1206 if (g_aOps[i].iPrecedence == iPrecedence)
1207 {
1208 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1209 "%-10s %s %s\n",
1210 g_aOps[i].szName,
1211 g_aOps[i].fBinary ? "Binary" : "Unary ",
1212 g_aOps[i].pszDescription);
1213 cLeft--;
1214 }
1215 iPrecedence++;
1216 }
1217 }
1218 else
1219 {
1220 /*
1221 * Search for the arguments (strings).
1222 */
1223 for (unsigned iArg = 0; iArg < cArgs; iArg++)
1224 {
1225 Assert(paArgs[iArg].enmType == DBGCVAR_TYPE_STRING);
1226 bool fFound = false;
1227
1228 /* lookup in the emulation command list first */
1229 for (i = 0; i < pDbgc->cEmulationCmds; i++)
1230 if (!strcmp(pDbgc->paEmulationCmds[i].pszCmd, paArgs[iArg].u.pszString))
1231 {
1232 rc = dbgcPrintHelp(pCmdHlp, &pDbgc->paEmulationCmds[i], false);
1233 fFound = true;
1234 break;
1235 }
1236
1237 /* lookup in the command list (even when found in the emulation) */
1238 for (i = 0; i < ELEMENTS(g_aCmds); i++)
1239 if (!strcmp(g_aCmds[i].pszCmd, paArgs[iArg].u.pszString))
1240 {
1241 rc = dbgcPrintHelp(pCmdHlp, &g_aCmds[i], false);
1242 fFound = true;
1243 break;
1244 }
1245
1246 /* external commands */
1247 if ( !fFound
1248 && g_pExtCmdsHead
1249 && paArgs[iArg].u.pszString[0] == '.')
1250 {
1251 DBGCEXTCMDS_LOCK_RD();
1252 for (PDBGCEXTCMDS pExtCmd = g_pExtCmdsHead; pExtCmd; pExtCmd = pExtCmd->pNext)
1253 for (i = 0; i < pExtCmd->cCmds; i++)
1254 if (!strcmp(pExtCmd->paCmds[i].pszCmd, paArgs[iArg].u.pszString + 1))
1255 {
1256 rc = dbgcPrintHelp(pCmdHlp, &g_aCmds[i], true);
1257 fFound = true;
1258 break;
1259 }
1260 DBGCEXTCMDS_UNLOCK_RD();
1261 }
1262
1263 /* operators */
1264 if (!fFound && strlen(paArgs[iArg].u.pszString) < sizeof(g_aOps[i].szName))
1265 {
1266 for (i = 0; i < ELEMENTS(g_aOps); i++)
1267 if (!strcmp(g_aOps[i].szName, paArgs[iArg].u.pszString))
1268 {
1269 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1270 "%-10s %s %s\n",
1271 g_aOps[i].szName,
1272 g_aOps[i].fBinary ? "Binary" : "Unary ",
1273 g_aOps[i].pszDescription);
1274 fFound = true;
1275 break;
1276 }
1277 }
1278
1279 /* found? */
1280 if (!fFound)
1281 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
1282 "error: '%s' was not found!\n",
1283 paArgs[iArg].u.pszString);
1284 } /* foreach argument */
1285 }
1286
1287 NOREF(pCmd);
1288 NOREF(pVM);
1289 NOREF(pResult);
1290 return rc;
1291}
1292
1293
1294/**
1295 * The 'quit', 'exit' and 'bye' commands.
1296 *
1297 * @returns VBox status.
1298 * @param pCmd Pointer to the command descriptor (as registered).
1299 * @param pCmdHlp Pointer to command helper functions.
1300 * @param pVM Pointer to the current VM (if any).
1301 * @param paArgs Pointer to (readonly) array of arguments.
1302 * @param cArgs Number of arguments in the array.
1303 */
1304static DECLCALLBACK(int) dbgcCmdQuit(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1305{
1306 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Quitting console...\n");
1307 NOREF(pCmd);
1308 NOREF(pVM);
1309 NOREF(paArgs);
1310 NOREF(cArgs);
1311 NOREF(pResult);
1312 return VERR_DBGC_QUIT;
1313}
1314
1315
1316/**
1317 * The 'go' command.
1318 *
1319 * @returns VBox status.
1320 * @param pCmd Pointer to the command descriptor (as registered).
1321 * @param pCmdHlp Pointer to command helper functions.
1322 * @param pVM Pointer to the current VM (if any).
1323 * @param paArgs Pointer to (readonly) array of arguments.
1324 * @param cArgs Number of arguments in the array.
1325 */
1326static DECLCALLBACK(int) dbgcCmdGo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1327{
1328 /*
1329 * Check if the VM is halted or not before trying to resume it.
1330 */
1331 if (!DBGFR3IsHalted(pVM))
1332 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "warning: The VM is already running...\n");
1333 else
1334 {
1335 int rc = DBGFR3Resume(pVM);
1336 if (VBOX_FAILURE(rc))
1337 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Executing DBGFR3Resume().");
1338 }
1339
1340 NOREF(pCmd);
1341 NOREF(paArgs);
1342 NOREF(cArgs);
1343 NOREF(pResult);
1344 return 0;
1345}
1346
1347/**
1348 * The 'stop' command.
1349 *
1350 * @returns VBox status.
1351 * @param pCmd Pointer to the command descriptor (as registered).
1352 * @param pCmdHlp Pointer to command helper functions.
1353 * @param pVM Pointer to the current VM (if any).
1354 * @param paArgs Pointer to (readonly) array of arguments.
1355 * @param cArgs Number of arguments in the array.
1356 */
1357static DECLCALLBACK(int) dbgcCmdStop(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1358{
1359 /*
1360 * Check if the VM is halted or not before trying to halt it.
1361 */
1362 int rc;
1363 if (DBGFR3IsHalted(pVM))
1364 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "warning: The VM is already halted...\n");
1365 else
1366 {
1367 rc = DBGFR3Halt(pVM);
1368 if (VBOX_SUCCESS(rc))
1369 rc = VWRN_DBGC_CMD_PENDING;
1370 else
1371 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Executing DBGFR3Halt().");
1372 }
1373
1374 NOREF(pCmd); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
1375 return rc;
1376}
1377
1378
1379/**
1380 * The 'ba' command.
1381 *
1382 * @returns VBox status.
1383 * @param pCmd Pointer to the command descriptor (as registered).
1384 * @param pCmdHlp Pointer to command helper functions.
1385 * @param pVM Pointer to the current VM (if any).
1386 * @param paArgs Pointer to (readonly) array of arguments.
1387 * @param cArgs Number of arguments in the array.
1388 */
1389static DECLCALLBACK(int) dbgcCmdBrkAccess(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /*pResult*/)
1390{
1391 /*
1392 * Interpret access type.
1393 */
1394 if ( !strchr("xrwi", paArgs[0].u.pszString[0])
1395 || paArgs[0].u.pszString[1])
1396 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid access type '%s' for '%s'. Valid types are 'e', 'r', 'w' and 'i'.\n",
1397 paArgs[0].u.pszString, pCmd->pszCmd);
1398 uint8_t fType = 0;
1399 switch (paArgs[0].u.pszString[0])
1400 {
1401 case 'x': fType = X86_DR7_RW_EO; break;
1402 case 'r': fType = X86_DR7_RW_RW; break;
1403 case 'w': fType = X86_DR7_RW_WO; break;
1404 case 'i': fType = X86_DR7_RW_IO; break;
1405 }
1406
1407 /*
1408 * Validate size.
1409 */
1410 if (fType == X86_DR7_RW_EO && paArgs[1].u.u64Number != 1)
1411 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid access size %RX64 for '%s'. 'x' access type requires size 1!\n",
1412 paArgs[1].u.u64Number, pCmd->pszCmd);
1413 switch (paArgs[1].u.u64Number)
1414 {
1415 case 1:
1416 case 2:
1417 case 4:
1418 break;
1419 /*case 8: - later*/
1420 default:
1421 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid access size %RX64 for '%s'. 1, 2 or 4!\n",
1422 paArgs[1].u.u64Number, pCmd->pszCmd);
1423 }
1424 uint8_t cb = (uint8_t)paArgs[1].u.u64Number;
1425
1426 /*
1427 * Convert the pointer to a DBGF address.
1428 */
1429 DBGFADDRESS Address;
1430 int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[2], &Address);
1431 if (VBOX_FAILURE(rc))
1432 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Couldn't convert '%DV' to a DBGF address, rc=%Vrc.\n", &paArgs[2], rc);
1433
1434 /*
1435 * Pick out the optional arguments.
1436 */
1437 uint64_t iHitTrigger = 0;
1438 uint64_t iHitDisable = ~0;
1439 const char *pszCmds = NULL;
1440 unsigned iArg = 3;
1441 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1442 {
1443 iHitTrigger = paArgs[iArg].u.u64Number;
1444 iArg++;
1445 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1446 {
1447 iHitDisable = paArgs[iArg].u.u64Number;
1448 iArg++;
1449 }
1450 }
1451 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1452 {
1453 pszCmds = paArgs[iArg].u.pszString;
1454 iArg++;
1455 }
1456
1457 /*
1458 * Try set the breakpoint.
1459 */
1460 RTUINT iBp;
1461 rc = DBGFR3BpSetReg(pVM, &Address, iHitTrigger, iHitDisable, fType, cb, &iBp);
1462 if (VBOX_SUCCESS(rc))
1463 {
1464 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1465 rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1466 if (VBOX_SUCCESS(rc))
1467 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Set access breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1468 if (rc == VERR_DBGC_BP_EXISTS)
1469 {
1470 rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1471 if (VBOX_SUCCESS(rc))
1472 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Updated access breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1473 }
1474 int rc2 = DBGFR3BpClear(pDbgc->pVM, iBp);
1475 AssertRC(rc2);
1476 }
1477 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Failed to set access breakpoint at %VGv, rc=%Vrc.\n", Address.FlatPtr, rc);
1478}
1479
1480
1481/**
1482 * The 'bc' command.
1483 *
1484 * @returns VBox status.
1485 * @param pCmd Pointer to the command descriptor (as registered).
1486 * @param pCmdHlp Pointer to command helper functions.
1487 * @param pVM Pointer to the current VM (if any).
1488 * @param paArgs Pointer to (readonly) array of arguments.
1489 * @param cArgs Number of arguments in the array.
1490 */
1491static DECLCALLBACK(int) dbgcCmdBrkClear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /*pResult*/)
1492{
1493 /*
1494 * Enumerate the arguments.
1495 */
1496 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1497 int rc = VINF_SUCCESS;
1498 for (unsigned iArg = 0; iArg < cArgs && VBOX_SUCCESS(rc); iArg++)
1499 {
1500 if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
1501 {
1502 /* one */
1503 RTUINT iBp = (RTUINT)paArgs[iArg].u.u64Number;
1504 if (iBp != paArgs[iArg].u.u64Number)
1505 {
1506 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Breakpoint id %RX64 is too large!\n", paArgs[iArg].u.u64Number);
1507 break;
1508 }
1509 int rc2 = DBGFR3BpClear(pVM, iBp);
1510 if (VBOX_FAILURE(rc2))
1511 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc2, "DBGFR3BpClear failed for breakpoint %u!\n", iBp);
1512 if (VBOX_SUCCESS(rc2) || rc2 == VERR_DBGF_BP_NOT_FOUND)
1513 dbgcBpDelete(pDbgc, iBp);
1514 }
1515 else if (!strcmp(paArgs[iArg].u.pszString, "all"))
1516 {
1517 /* all */
1518 PDBGCBP pBp = pDbgc->pFirstBp;
1519 while (pBp)
1520 {
1521 RTUINT iBp = pBp->iBp;
1522 pBp = pBp->pNext;
1523
1524 int rc2 = DBGFR3BpClear(pVM, iBp);
1525 if (VBOX_FAILURE(rc2))
1526 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc2, "DBGFR3BpClear failed for breakpoint %u!\n", iBp);
1527 if (VBOX_SUCCESS(rc2) || rc2 == VERR_DBGF_BP_NOT_FOUND)
1528 dbgcBpDelete(pDbgc, iBp);
1529 }
1530 }
1531 else
1532 {
1533 /* invalid parameter */
1534 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid argument '%s' to '%s'!\n", paArgs[iArg].u.pszString, pCmd->pszCmd);
1535 break;
1536 }
1537 }
1538 return rc;
1539}
1540
1541
1542/**
1543 * The 'bd' command.
1544 *
1545 * @returns VBox status.
1546 * @param pCmd Pointer to the command descriptor (as registered).
1547 * @param pCmdHlp Pointer to command helper functions.
1548 * @param pVM Pointer to the current VM (if any).
1549 * @param paArgs Pointer to (readonly) array of arguments.
1550 * @param cArgs Number of arguments in the array.
1551 */
1552static DECLCALLBACK(int) dbgcCmdBrkDisable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /*pResult*/)
1553{
1554 /*
1555 * Enumerate the arguments.
1556 */
1557 int rc = VINF_SUCCESS;
1558 for (unsigned iArg = 0; iArg < cArgs && VBOX_SUCCESS(rc); iArg++)
1559 {
1560 if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
1561 {
1562 /* one */
1563 RTUINT iBp = (RTUINT)paArgs[iArg].u.u64Number;
1564 if (iBp != paArgs[iArg].u.u64Number)
1565 {
1566 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Breakpoint id %RX64 is too large!\n", paArgs[iArg].u.u64Number);
1567 break;
1568 }
1569 rc = DBGFR3BpDisable(pVM, iBp);
1570 if (VBOX_FAILURE(rc))
1571 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpDisable failed for breakpoint %u!\n", iBp);
1572 }
1573 else if (!strcmp(paArgs[iArg].u.pszString, "all"))
1574 {
1575 /* all */
1576 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1577 for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
1578 {
1579 rc = DBGFR3BpDisable(pVM, pBp->iBp);
1580 if (VBOX_FAILURE(rc))
1581 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpDisable failed for breakpoint %u!\n", pBp->iBp);
1582 }
1583 }
1584 else
1585 {
1586 /* invalid parameter */
1587 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid argument '%s' to '%s'!\n", paArgs[iArg].u.pszString, pCmd->pszCmd);
1588 break;
1589 }
1590 }
1591 return rc;
1592}
1593
1594
1595/**
1596 * The 'be' command.
1597 *
1598 * @returns VBox status.
1599 * @param pCmd Pointer to the command descriptor (as registered).
1600 * @param pCmdHlp Pointer to command helper functions.
1601 * @param pVM Pointer to the current VM (if any).
1602 * @param paArgs Pointer to (readonly) array of arguments.
1603 * @param cArgs Number of arguments in the array.
1604 */
1605static DECLCALLBACK(int) dbgcCmdBrkEnable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /*pResult*/)
1606{
1607 /*
1608 * Enumerate the arguments.
1609 */
1610 int rc = VINF_SUCCESS;
1611 for (unsigned iArg = 0; iArg < cArgs && VBOX_SUCCESS(rc); iArg++)
1612 {
1613 if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
1614 {
1615 /* one */
1616 RTUINT iBp = (RTUINT)paArgs[iArg].u.u64Number;
1617 if (iBp != paArgs[iArg].u.u64Number)
1618 {
1619 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Breakpoint id %RX64 is too large!\n", paArgs[iArg].u.u64Number);
1620 break;
1621 }
1622 rc = DBGFR3BpEnable(pVM, iBp);
1623 if (VBOX_FAILURE(rc))
1624 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpEnable failed for breakpoint %u!\n", iBp);
1625 }
1626 else if (!strcmp(paArgs[iArg].u.pszString, "all"))
1627 {
1628 /* all */
1629 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1630 for (PDBGCBP pBp = pDbgc->pFirstBp; pBp; pBp = pBp->pNext)
1631 {
1632 rc = DBGFR3BpEnable(pVM, pBp->iBp);
1633 if (VBOX_FAILURE(rc))
1634 rc = pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpEnable failed for breakpoint %u!\n", pBp->iBp);
1635 }
1636 }
1637 else
1638 {
1639 /* invalid parameter */
1640 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid argument '%s' to '%s'!\n", paArgs[iArg].u.pszString, pCmd->pszCmd);
1641 break;
1642 }
1643 }
1644 return rc;
1645}
1646
1647
1648/**
1649 * Breakpoint enumeration callback function.
1650 *
1651 * @returns VBox status code. Any failure will stop the enumeration.
1652 * @param pVM The VM handle.
1653 * @param pvUser The user argument.
1654 * @param pBp Pointer to the breakpoint information. (readonly)
1655 */
1656static DECLCALLBACK(int) dbgcEnumBreakpointsCallback(PVM pVM, void *pvUser, PCDBGFBP pBp)
1657{
1658 PDBGC pDbgc = (PDBGC)pvUser;
1659 PDBGCBP pDbgcBp = dbgcBpGet(pDbgc, pBp->iBp);
1660
1661 /*
1662 * BP type and size.
1663 */
1664 char chType;
1665 char cb = 1;
1666 switch (pBp->enmType)
1667 {
1668 case DBGFBPTYPE_INT3:
1669 chType = 'p';
1670 break;
1671 case DBGFBPTYPE_REG:
1672 switch (pBp->u.Reg.fType)
1673 {
1674 case X86_DR7_RW_EO: chType = 'x'; break;
1675 case X86_DR7_RW_WO: chType = 'w'; break;
1676 case X86_DR7_RW_IO: chType = 'i'; break;
1677 case X86_DR7_RW_RW: chType = 'r'; break;
1678 default: chType = '?'; break;
1679
1680 }
1681 cb = pBp->u.Reg.cb;
1682 break;
1683 case DBGFBPTYPE_REM:
1684 chType = 'r';
1685 break;
1686 default:
1687 chType = '?';
1688 break;
1689 }
1690
1691 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%2u %c %d %c %VGv %04RX64 (%04RX64 to ",
1692 pBp->iBp, pBp->fEnabled ? 'e' : 'd', cb, chType,
1693 pBp->GCPtr, pBp->cHits, pBp->iHitTrigger);
1694 if (pBp->iHitDisable == ~(uint64_t)0)
1695 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "~0) ");
1696 else
1697 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%04RX64)");
1698
1699 /*
1700 * Try resolve the address.
1701 */
1702 DBGFSYMBOL Sym;
1703 RTGCINTPTR off;
1704 int rc = DBGFR3SymbolByAddr(pVM, pBp->GCPtr, &off, &Sym);
1705 if (VBOX_SUCCESS(rc))
1706 {
1707 if (!off)
1708 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%s", Sym.szName);
1709 else if (off > 0)
1710 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%s+%VGv", Sym.szName, off);
1711 else
1712 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "%s+%VGv", Sym.szName, -off);
1713 }
1714
1715 /*
1716 * The commands.
1717 */
1718 if (pDbgcBp)
1719 {
1720 if (pDbgcBp->cchCmd)
1721 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\n cmds: '%s'\n",
1722 pDbgcBp->szCmd);
1723 else
1724 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\n");
1725 }
1726 else
1727 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, " [unknown bp]\n");
1728
1729 return VINF_SUCCESS;
1730}
1731
1732
1733/**
1734 * The 'bl' command.
1735 *
1736 * @returns VBox status.
1737 * @param pCmd Pointer to the command descriptor (as registered).
1738 * @param pCmdHlp Pointer to command helper functions.
1739 * @param pVM Pointer to the current VM (if any).
1740 * @param paArgs Pointer to (readonly) array of arguments.
1741 * @param cArgs Number of arguments in the array.
1742 */
1743static DECLCALLBACK(int) dbgcCmdBrkList(PCDBGCCMD /*pCmd*/, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR /*paArgs*/, unsigned /*cArgs*/, PDBGCVAR /*pResult*/)
1744{
1745 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1746
1747 /*
1748 * Enumerate the breakpoints.
1749 */
1750 int rc = DBGFR3BpEnum(pVM, dbgcEnumBreakpointsCallback, pDbgc);
1751 if (VBOX_FAILURE(rc))
1752 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3BpEnum failed.\n");
1753 return rc;
1754}
1755
1756
1757/**
1758 * The 'bp' command.
1759 *
1760 * @returns VBox status.
1761 * @param pCmd Pointer to the command descriptor (as registered).
1762 * @param pCmdHlp Pointer to command helper functions.
1763 * @param pVM Pointer to the current VM (if any).
1764 * @param paArgs Pointer to (readonly) array of arguments.
1765 * @param cArgs Number of arguments in the array.
1766 */
1767static DECLCALLBACK(int) dbgcCmdBrkSet(PCDBGCCMD /*pCmd*/, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /*pResult*/)
1768{
1769 /*
1770 * Convert the pointer to a DBGF address.
1771 */
1772 DBGFADDRESS Address;
1773 int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1774 if (VBOX_FAILURE(rc))
1775 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Couldn't convert '%DV' to a DBGF address, rc=%Vrc.\n", &paArgs[0], rc);
1776
1777 /*
1778 * Pick out the optional arguments.
1779 */
1780 uint64_t iHitTrigger = 0;
1781 uint64_t iHitDisable = ~0;
1782 const char *pszCmds = NULL;
1783 unsigned iArg = 1;
1784 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1785 {
1786 iHitTrigger = paArgs[iArg].u.u64Number;
1787 iArg++;
1788 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1789 {
1790 iHitDisable = paArgs[iArg].u.u64Number;
1791 iArg++;
1792 }
1793 }
1794 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1795 {
1796 pszCmds = paArgs[iArg].u.pszString;
1797 iArg++;
1798 }
1799
1800 /*
1801 * Try set the breakpoint.
1802 */
1803 RTUINT iBp;
1804 rc = DBGFR3BpSet(pVM, &Address, iHitTrigger, iHitDisable, &iBp);
1805 if (VBOX_SUCCESS(rc))
1806 {
1807 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1808 rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1809 if (VBOX_SUCCESS(rc))
1810 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Set breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1811 if (rc == VERR_DBGC_BP_EXISTS)
1812 {
1813 rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1814 if (VBOX_SUCCESS(rc))
1815 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Updated breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1816 }
1817 int rc2 = DBGFR3BpClear(pDbgc->pVM, iBp);
1818 AssertRC(rc2);
1819 }
1820 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Failed to set breakpoint at %VGv, rc=%Vrc.\n", Address.FlatPtr, rc);
1821}
1822
1823
1824/**
1825 * The 'br' command.
1826 *
1827 * @returns VBox status.
1828 * @param pCmd Pointer to the command descriptor (as registered).
1829 * @param pCmdHlp Pointer to command helper functions.
1830 * @param pVM Pointer to the current VM (if any).
1831 * @param paArgs Pointer to (readonly) array of arguments.
1832 * @param cArgs Number of arguments in the array.
1833 */
1834static DECLCALLBACK(int) dbgcCmdBrkREM(PCDBGCCMD /*pCmd*/, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR /*pResult*/)
1835{
1836 /*
1837 * Convert the pointer to a DBGF address.
1838 */
1839 DBGFADDRESS Address;
1840 int rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, &paArgs[0], &Address);
1841 if (VBOX_FAILURE(rc))
1842 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Couldn't convert '%DV' to a DBGF address, rc=%Vrc.\n", &paArgs[0], rc);
1843
1844 /*
1845 * Pick out the optional arguments.
1846 */
1847 uint64_t iHitTrigger = 0;
1848 uint64_t iHitDisable = ~0;
1849 const char *pszCmds = NULL;
1850 unsigned iArg = 1;
1851 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1852 {
1853 iHitTrigger = paArgs[iArg].u.u64Number;
1854 iArg++;
1855 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
1856 {
1857 iHitDisable = paArgs[iArg].u.u64Number;
1858 iArg++;
1859 }
1860 }
1861 if (iArg < cArgs && paArgs[iArg].enmType == DBGCVAR_TYPE_STRING)
1862 {
1863 pszCmds = paArgs[iArg].u.pszString;
1864 iArg++;
1865 }
1866
1867 /*
1868 * Try set the breakpoint.
1869 */
1870 RTUINT iBp;
1871 rc = DBGFR3BpSetREM(pVM, &Address, iHitTrigger, iHitDisable, &iBp);
1872 if (VBOX_SUCCESS(rc))
1873 {
1874 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1875 rc = dbgcBpAdd(pDbgc, iBp, pszCmds);
1876 if (VBOX_SUCCESS(rc))
1877 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Set REM breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1878 if (rc == VERR_DBGC_BP_EXISTS)
1879 {
1880 rc = dbgcBpUpdate(pDbgc, iBp, pszCmds);
1881 if (VBOX_SUCCESS(rc))
1882 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Updated REM breakpoint %u at %VGv\n", iBp, Address.FlatPtr);
1883 }
1884 int rc2 = DBGFR3BpClear(pDbgc->pVM, iBp);
1885 AssertRC(rc2);
1886 }
1887 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Failed to set REM breakpoint at %VGv, rc=%Vrc.\n", Address.FlatPtr, rc);
1888}
1889
1890
1891/**
1892 * The 'u' command.
1893 *
1894 * @returns VBox status.
1895 * @param pCmd Pointer to the command descriptor (as registered).
1896 * @param pCmdHlp Pointer to command helper functions.
1897 * @param pVM Pointer to the current VM (if any).
1898 * @param paArgs Pointer to (readonly) array of arguments.
1899 * @param cArgs Number of arguments in the array.
1900 */
1901static DECLCALLBACK(int) dbgcCmdUnassemble(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1902{
1903 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
1904
1905 /*
1906 * Validate input.
1907 */
1908 if ( cArgs > 1
1909 || (cArgs == 1 && !DBGCVAR_ISPOINTER(paArgs[0].enmType)))
1910 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
1911 if (!pVM && !cArgs && !DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1912 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Don't know where to start disassembling...\n");
1913 if (!pVM && cArgs && DBGCVAR_ISGCPOINTER(paArgs[0].enmType))
1914 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: GC address but no VM.\n");
1915
1916 /*
1917 * Find address.
1918 */
1919 unsigned fFlags = DBGF_DISAS_FLAGS_NO_ADDRESS;
1920 if (!cArgs)
1921 {
1922 if (!DBGCVAR_ISPOINTER(pDbgc->DisasmPos.enmType))
1923 {
1924 pDbgc->DisasmPos.enmType = DBGCVAR_TYPE_GC_FAR;
1925 pDbgc->SourcePos.u.GCFar.off = pDbgc->fRegCtxGuest ? CPUMGetGuestEIP(pVM) : CPUMGetHyperEIP(pVM);
1926 pDbgc->SourcePos.u.GCFar.sel = pDbgc->fRegCtxGuest ? CPUMGetGuestCS(pVM) : CPUMGetHyperCS(pVM);
1927 if (pDbgc->fRegCtxGuest)
1928 fFlags |= DBGF_DISAS_FLAGS_CURRENT_GUEST;
1929 else
1930 fFlags |= DBGF_DISAS_FLAGS_CURRENT_HYPER;
1931 }
1932 pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_NONE;
1933 }
1934 else
1935 pDbgc->DisasmPos = paArgs[0];
1936
1937 /*
1938 * Range.
1939 */
1940 switch (pDbgc->DisasmPos.enmRangeType)
1941 {
1942 case DBGCVAR_RANGE_NONE:
1943 pDbgc->DisasmPos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
1944 pDbgc->DisasmPos.u64Range = 10;
1945 break;
1946
1947 case DBGCVAR_RANGE_ELEMENTS:
1948 if (pDbgc->DisasmPos.u64Range > 2048)
1949 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Too many lines requested. Max is 2048 lines.\n");
1950 break;
1951
1952 case DBGCVAR_RANGE_BYTES:
1953 if (pDbgc->DisasmPos.u64Range > 65536)
1954 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The requested range is too big. Max is 64KB.\n");
1955 break;
1956
1957 default:
1958 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: Unknown range type %d.\n", pDbgc->DisasmPos.enmRangeType);
1959 }
1960
1961 /*
1962 * Convert physical and host addresses to guest addresses.
1963 */
1964 int rc;
1965 switch (pDbgc->DisasmPos.enmType)
1966 {
1967 case DBGCVAR_TYPE_GC_FLAT:
1968 case DBGCVAR_TYPE_GC_FAR:
1969 break;
1970 case DBGCVAR_TYPE_GC_PHYS:
1971 case DBGCVAR_TYPE_HC_FLAT:
1972 case DBGCVAR_TYPE_HC_PHYS:
1973 case DBGCVAR_TYPE_HC_FAR:
1974 {
1975 DBGCVAR VarTmp;
1976 rc = pCmdHlp->pfnEval(pCmdHlp, &VarTmp, "%%(%Dv)", &pDbgc->DisasmPos);
1977 if (VBOX_FAILURE(rc))
1978 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: failed to evaluate '%%(%Dv)' -> %Vrc .\n", pDbgc->DisasmPos, rc);
1979 pDbgc->DisasmPos = VarTmp;
1980 break;
1981 }
1982 default: AssertFailed(); break;
1983 }
1984
1985 /*
1986 * Print address.
1987 * todo: Change to list near.
1988 */
1989#if 0
1990 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV:\n", &pDbgc->DisasmPos);
1991 if (VBOX_FAILURE(rc))
1992 return rc;
1993#endif
1994
1995 /*
1996 * Do the disassembling.
1997 */
1998 unsigned cTries = 32;
1999 int iRangeLeft = (int)pDbgc->DisasmPos.u64Range;
2000 if (iRangeLeft == 0) /* klugde for 'r'. */
2001 iRangeLeft = -1;
2002 for (;;)
2003 {
2004 /*
2005 * Disassemble the instruction.
2006 */
2007 char szDis[256];
2008 uint32_t cbInstr = 1;
2009 if (pDbgc->DisasmPos.enmType == DBGCVAR_TYPE_GC_FLAT)
2010 rc = DBGFR3DisasInstrEx(pVM, DBGF_SEL_FLAT, pDbgc->DisasmPos.u.GCFlat, fFlags, &szDis[0], sizeof(szDis), &cbInstr);
2011 else
2012 rc = DBGFR3DisasInstrEx(pVM, pDbgc->DisasmPos.u.GCFar.sel, pDbgc->DisasmPos.u.GCFar.off, fFlags, &szDis[0], sizeof(szDis), &cbInstr);
2013 if (VBOX_SUCCESS(rc))
2014 {
2015 /* print it */
2016 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%-16DV %s\n", &pDbgc->DisasmPos, &szDis[0]);
2017 if (VBOX_FAILURE(rc))
2018 return rc;
2019 }
2020 else
2021 {
2022 /* bitch. */
2023 int rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to disassemble instruction, skipping one byte.\n");
2024 if (VBOX_FAILURE(rc))
2025 return rc;
2026 if (cTries-- > 0)
2027 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Too many disassembly failures. Giving up.\n");
2028 cbInstr = 1;
2029 }
2030
2031 /* advance */
2032 if (iRangeLeft < 0) /* 'r' */
2033 break;
2034 if (pDbgc->DisasmPos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
2035 iRangeLeft--;
2036 else
2037 iRangeLeft -= cbInstr;
2038 rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->DisasmPos, "(%Dv) + %x", &pDbgc->DisasmPos, cbInstr);
2039 if (VBOX_FAILURE(rc))
2040 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->DisasmPos, cbInstr);
2041 if (iRangeLeft <= 0)
2042 break;
2043 fFlags &= ~(DBGF_DISAS_FLAGS_CURRENT_GUEST | DBGF_DISAS_FLAGS_CURRENT_HYPER);
2044 }
2045
2046 NOREF(pCmd); NOREF(pResult);
2047 return 0;
2048}
2049
2050
2051/**
2052 * The 'ls' command.
2053 *
2054 * @returns VBox status.
2055 * @param pCmd Pointer to the command descriptor (as registered).
2056 * @param pCmdHlp Pointer to command helper functions.
2057 * @param pVM Pointer to the current VM (if any).
2058 * @param paArgs Pointer to (readonly) array of arguments.
2059 * @param cArgs Number of arguments in the array.
2060 */
2061static DECLCALLBACK(int) dbgcCmdListSource(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2062{
2063 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2064
2065 /*
2066 * Validate input.
2067 */
2068 if ( cArgs > 1
2069 || (cArgs == 1 && !DBGCVAR_ISPOINTER(paArgs[0].enmType)))
2070 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
2071 if (!pVM && !cArgs && !DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2072 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Don't know where to start disassembling...\n");
2073 if (!pVM && cArgs && DBGCVAR_ISGCPOINTER(paArgs[0].enmType))
2074 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: GC address but no VM.\n");
2075
2076 /*
2077 * Find address.
2078 */
2079 if (!cArgs)
2080 {
2081 if (!DBGCVAR_ISPOINTER(pDbgc->SourcePos.enmType))
2082 {
2083 pDbgc->SourcePos.enmType = DBGCVAR_TYPE_GC_FAR;
2084 pDbgc->SourcePos.u.GCFar.off = pDbgc->fRegCtxGuest ? CPUMGetGuestEIP(pVM) : CPUMGetHyperEIP(pVM);
2085 pDbgc->SourcePos.u.GCFar.sel = pDbgc->fRegCtxGuest ? CPUMGetGuestCS(pVM) : CPUMGetHyperCS(pVM);
2086 }
2087 pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_NONE;
2088 }
2089 else
2090 pDbgc->SourcePos = paArgs[0];
2091
2092 /*
2093 * Ensure the the source address is flat GC.
2094 */
2095 switch (pDbgc->SourcePos.enmType)
2096 {
2097 case DBGCVAR_TYPE_GC_FLAT:
2098 break;
2099 case DBGCVAR_TYPE_GC_PHYS:
2100 case DBGCVAR_TYPE_GC_FAR:
2101 case DBGCVAR_TYPE_HC_FLAT:
2102 case DBGCVAR_TYPE_HC_PHYS:
2103 case DBGCVAR_TYPE_HC_FAR:
2104 {
2105 int rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->SourcePos, "%%(%Dv)", &pDbgc->SourcePos);
2106 if (VBOX_FAILURE(rc))
2107 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid address or address type. (rc=%d)\n", rc);
2108 break;
2109 }
2110 default: AssertFailed(); break;
2111 }
2112
2113 /*
2114 * Range.
2115 */
2116 switch (pDbgc->SourcePos.enmRangeType)
2117 {
2118 case DBGCVAR_RANGE_NONE:
2119 pDbgc->SourcePos.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2120 pDbgc->SourcePos.u64Range = 10;
2121 break;
2122
2123 case DBGCVAR_RANGE_ELEMENTS:
2124 if (pDbgc->SourcePos.u64Range > 2048)
2125 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Too many lines requested. Max is 2048 lines.\n");
2126 break;
2127
2128 case DBGCVAR_RANGE_BYTES:
2129 if (pDbgc->SourcePos.u64Range > 65536)
2130 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The requested range is too big. Max is 64KB.\n");
2131 break;
2132
2133 default:
2134 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: Unknown range type %d.\n", pDbgc->SourcePos.enmRangeType);
2135 }
2136
2137 /*
2138 * Do the disassembling.
2139 */
2140 bool fFirst = 1;
2141 DBGFLINE LinePrev = { 0, 0, "" };
2142 int iRangeLeft = (int)pDbgc->SourcePos.u64Range;
2143 if (iRangeLeft == 0) /* klugde for 'r'. */
2144 iRangeLeft = -1;
2145 for (;;)
2146 {
2147 /*
2148 * Get line info.
2149 */
2150 DBGFLINE Line;
2151 RTGCINTPTR off;
2152 int rc = DBGFR3LineByAddr(pVM, pDbgc->SourcePos.u.GCFlat, &off, &Line);
2153 if (VBOX_FAILURE(rc))
2154 return VINF_SUCCESS;
2155
2156 unsigned cLines = 0;
2157 if (memcmp(&Line, &LinePrev, sizeof(Line)))
2158 {
2159 /*
2160 * Print filenamename
2161 */
2162 if (!fFirst && strcmp(Line.szFilename, LinePrev.szFilename))
2163 fFirst = true;
2164 if (fFirst)
2165 {
2166 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "[%s @ %d]\n", Line.szFilename, Line.uLineNo);
2167 if (VBOX_FAILURE(rc))
2168 return rc;
2169 }
2170
2171 /*
2172 * Try open the file and read the line.
2173 */
2174 FILE *phFile = fopen(Line.szFilename, "r");
2175 if (phFile)
2176 {
2177 /* Skip ahead to the desired line. */
2178 char szLine[4096];
2179 unsigned cBefore = fFirst ? RT_MIN(2, Line.uLineNo - 1) : Line.uLineNo - LinePrev.uLineNo - 1;
2180 if (cBefore > 7)
2181 cBefore = 0;
2182 unsigned cLeft = Line.uLineNo - cBefore;
2183 while (cLeft > 0)
2184 {
2185 szLine[0] = '\0';
2186 if (!fgets(szLine, sizeof(szLine), phFile))
2187 break;
2188 cLeft--;
2189 }
2190 if (!cLeft)
2191 {
2192 /* print the before lines */
2193 for (;;)
2194 {
2195 size_t cch = strlen(szLine);
2196 while (cch > 0 && (szLine[cch - 1] == '\r' || szLine[cch - 1] == '\n' || isspace(szLine[cch - 1])) )
2197 szLine[--cch] = '\0';
2198 if (cBefore-- <= 0)
2199 break;
2200
2201 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %4d: %s\n", Line.uLineNo - cBefore - 1, szLine);
2202 szLine[0] = '\0';
2203 fgets(szLine, sizeof(szLine), phFile);
2204 cLines++;
2205 }
2206 /* print the actual line */
2207 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%08llx %4d: %s\n", Line.Address, Line.uLineNo, szLine);
2208 }
2209 fclose(phFile);
2210 if (VBOX_FAILURE(rc))
2211 return rc;
2212 fFirst = false;
2213 }
2214 else
2215 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Warning: couldn't open source file '%s'\n", Line.szFilename);
2216
2217 LinePrev = Line;
2218 }
2219
2220
2221 /*
2222 * Advance
2223 */
2224 if (iRangeLeft < 0) /* 'r' */
2225 break;
2226 if (pDbgc->SourcePos.enmRangeType == DBGCVAR_RANGE_ELEMENTS)
2227 iRangeLeft -= cLines;
2228 else
2229 iRangeLeft -= 1;
2230 rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->SourcePos, "(%Dv) + %x", &pDbgc->SourcePos, 1);
2231 if (VBOX_FAILURE(rc))
2232 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->SourcePos, 1);
2233 if (iRangeLeft <= 0)
2234 break;
2235 }
2236
2237 NOREF(pCmd); NOREF(pResult);
2238 return 0;
2239}
2240
2241
2242/**
2243 * The 'r' command.
2244 *
2245 * @returns VBox status.
2246 * @param pCmd Pointer to the command descriptor (as registered).
2247 * @param pCmdHlp Pointer to command helper functions.
2248 * @param pVM Pointer to the current VM (if any).
2249 * @param paArgs Pointer to (readonly) array of arguments.
2250 * @param cArgs Number of arguments in the array.
2251 */
2252static DECLCALLBACK(int) dbgcCmdReg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2253{
2254 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2255
2256 if (pDbgc->fRegCtxGuest)
2257 return dbgcCmdRegGuest(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult);
2258 else
2259 return dbgcCmdRegHyper(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult);
2260}
2261
2262
2263/**
2264 * Common worker for the dbgcCmdReg*() commands.
2265 *
2266 * @returns VBox status.
2267 * @param pCmd Pointer to the command descriptor (as registered).
2268 * @param pCmdHlp Pointer to command helper functions.
2269 * @param pVM Pointer to the current VM (if any).
2270 * @param paArgs Pointer to (readonly) array of arguments.
2271 * @param cArgs Number of arguments in the array.
2272 * @param pszPrefix The symbol prefix.
2273 */
2274static DECLCALLBACK(int) dbgcCmdRegCommon(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult, const char *pszPrefix)
2275{
2276 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2277
2278 /*
2279 * cArgs == 0: Show all
2280 */
2281 if (cArgs == 0)
2282 {
2283 /*
2284 * Get register context.
2285 */
2286 int rc;
2287 PCPUMCTX pCtx;
2288 PCCPUMCTXCORE pCtxCore;
2289 if (!*pszPrefix)
2290 {
2291 rc = CPUMQueryGuestCtxPtr(pVM, &pCtx);
2292 pCtxCore = CPUMGetGuestCtxCore(pVM);
2293 }
2294 else
2295 {
2296 rc = CPUMQueryHyperCtxPtr(pVM, &pCtx);
2297 pCtxCore = CPUMGetHyperCtxCore(pVM);
2298 }
2299 if (VBOX_FAILURE(rc))
2300 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Getting register context\n");
2301
2302 /*
2303 * Format the flags.
2304 */
2305 static struct
2306 {
2307 const char *pszSet; const char *pszClear; uint32_t fFlag;
2308 } aFlags[] =
2309 {
2310 { "vip",NULL, X86_EFL_VIP },
2311 { "vif",NULL, X86_EFL_VIF },
2312 { "ac", NULL, X86_EFL_AC },
2313 { "vm", NULL, X86_EFL_VM },
2314 { "rf", NULL, X86_EFL_RF },
2315 { "nt", NULL, X86_EFL_NT },
2316 { "ov", "nv", X86_EFL_OF },
2317 { "dn", "up", X86_EFL_DF },
2318 { "ei", "di", X86_EFL_IF },
2319 { "tf", NULL, X86_EFL_TF },
2320 { "nt", "pl", X86_EFL_SF },
2321 { "nz", "zr", X86_EFL_ZF },
2322 { "ac", "na", X86_EFL_AF },
2323 { "po", "pe", X86_EFL_PF },
2324 { "cy", "nc", X86_EFL_CF },
2325 };
2326 char szEFlags[80];
2327 char *psz = szEFlags;
2328 uint32_t efl = pCtxCore->eflags.u32;
2329 for (unsigned i = 0; i < ELEMENTS(aFlags); i++)
2330 {
2331 const char *pszAdd = aFlags[i].fFlag & efl ? aFlags[i].pszSet : aFlags[i].pszClear;
2332 if (pszAdd)
2333 {
2334 strcpy(psz, pszAdd);
2335 psz += strlen(pszAdd);
2336 *psz++ = ' ';
2337 }
2338 }
2339 psz[-1] = '\0';
2340
2341
2342 /*
2343 * Format the registers.
2344 */
2345 if (pDbgc->fRegTerse)
2346 {
2347 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
2348 "%seax=%08x %sebx=%08x %secx=%08x %sedx=%08x %sesi=%08x %sedi=%08x\n"
2349 "%seip=%08x %sesp=%08x %sebp=%08x %siopl=%d %*s\n"
2350 "%scs=%04x %sds=%04x %ses=%04x %sfs=%04x %sgs=%04x %sss=%04x %seflags=%08x\n",
2351 pszPrefix, pCtxCore->eax, pszPrefix, pCtxCore->ebx, pszPrefix, pCtxCore->ecx, pszPrefix, pCtxCore->edx, pszPrefix, pCtxCore->esi, pszPrefix, pCtxCore->edi,
2352 pszPrefix, pCtxCore->eip, pszPrefix, pCtxCore->esp, pszPrefix, pCtxCore->ebp, pszPrefix, X86_EFL_GET_IOPL(efl), *pszPrefix ? 34 : 31, szEFlags,
2353 pszPrefix, (RTSEL)pCtxCore->cs, pszPrefix, (RTSEL)pCtxCore->ds, pszPrefix, (RTSEL)pCtxCore->es,
2354 pszPrefix, (RTSEL)pCtxCore->fs, pszPrefix, (RTSEL)pCtxCore->gs, pszPrefix, (RTSEL)pCtxCore->ss, pszPrefix, efl);
2355 }
2356 else
2357 {
2358 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
2359 "%seax=%08x %sebx=%08x %secx=%08x %sedx=%08x %sesi=%08x %sedi=%08x\n"
2360 "%seip=%08x %sesp=%08x %sebp=%08x %siopl=%d %*s\n"
2361 "%scs={%04x base=%08x limit=%08x flags=%08x} %sdr0=%08x %sdr1=%08x\n"
2362 "%sds={%04x base=%08x limit=%08x flags=%08x} %sdr2=%08x %sdr3=%08x\n"
2363 "%ses={%04x base=%08x limit=%08x flags=%08x} %sdr4=%08x %sdr5=%08x\n"
2364 "%sfs={%04x base=%08x limit=%08x flags=%08x} %sdr6=%08x %sdr7=%08x\n"
2365 "%sgs={%04x base=%08x limit=%08x flags=%08x} %scr0=%08x %scr2=%08x\n"
2366 "%sss={%04x base=%08x limit=%08x flags=%08x} %scr3=%08x %scr4=%08x\n"
2367 "%sgdtr=%08x:%04x %sidtr=%08x:%04x %seflags=%08x\n"
2368 "%sldtr={%04x base=%08x limit=%08x flags=%08x}\n"
2369 "%str ={%04x base=%08x limit=%08x flags=%08x}\n"
2370 "%sSysEnter={cs=%04llx eip=%08llx esp=%08llx}\n"
2371 "%sFCW=%04x %sFSW=%04x %sFTW=%04x\n"
2372 ,
2373 pszPrefix, pCtxCore->eax, pszPrefix, pCtxCore->ebx, pszPrefix, pCtxCore->ecx, pszPrefix, pCtxCore->edx, pszPrefix, pCtxCore->esi, pszPrefix, pCtxCore->edi,
2374 pszPrefix, pCtxCore->eip, pszPrefix, pCtxCore->esp, pszPrefix, pCtxCore->ebp, pszPrefix, X86_EFL_GET_IOPL(efl), *pszPrefix ? 33 : 31, szEFlags,
2375 pszPrefix, (RTSEL)pCtxCore->cs, pCtx->csHid.u32Base, pCtx->csHid.u32Limit, pCtx->csHid.Attr.u, pszPrefix, pCtx->dr0, pszPrefix, pCtx->dr1,
2376 pszPrefix, (RTSEL)pCtxCore->ds, pCtx->dsHid.u32Base, pCtx->dsHid.u32Limit, pCtx->dsHid.Attr.u, pszPrefix, pCtx->dr2, pszPrefix, pCtx->dr3,
2377 pszPrefix, (RTSEL)pCtxCore->es, pCtx->esHid.u32Base, pCtx->esHid.u32Limit, pCtx->esHid.Attr.u, pszPrefix, pCtx->dr4, pszPrefix, pCtx->dr5,
2378 pszPrefix, (RTSEL)pCtxCore->fs, pCtx->fsHid.u32Base, pCtx->fsHid.u32Limit, pCtx->fsHid.Attr.u, pszPrefix, pCtx->dr6, pszPrefix, pCtx->dr7,
2379 pszPrefix, (RTSEL)pCtxCore->gs, pCtx->gsHid.u32Base, pCtx->gsHid.u32Limit, pCtx->gsHid.Attr.u, pszPrefix, pCtx->cr0, pszPrefix, pCtx->cr2,
2380 pszPrefix, (RTSEL)pCtxCore->ss, pCtx->ssHid.u32Base, pCtx->ssHid.u32Limit, pCtx->ssHid.Attr.u, pszPrefix, pCtx->cr3, pszPrefix, pCtx->cr4,
2381 pszPrefix, pCtx->gdtr.pGdt,pCtx->gdtr.cbGdt, pszPrefix, pCtx->idtr.pIdt, pCtx->idtr.cbIdt, pszPrefix, pCtxCore->eflags,
2382 pszPrefix, (RTSEL)pCtx->ldtr, pCtx->ldtrHid.u32Base, pCtx->ldtrHid.u32Limit, pCtx->ldtrHid.Attr.u,
2383 pszPrefix, (RTSEL)pCtx->tr, pCtx->trHid.u32Base, pCtx->trHid.u32Limit, pCtx->trHid.Attr.u,
2384 pszPrefix, pCtx->SysEnter.cs, pCtx->SysEnter.eip, pCtx->SysEnter.esp,
2385 pszPrefix, pCtx->fpu.FCW, pszPrefix, pCtx->fpu.FSW, pszPrefix, pCtx->fpu.FTW);
2386 }
2387
2388 /*
2389 * Disassemble one instruction at cs:eip.
2390 */
2391 return pCmdHlp->pfnExec(pCmdHlp, "u %04x:%08x L 0", pCtx->cs, pCtx->eip);
2392 }
2393
2394 /*
2395 * cArgs == 1: Show the register.
2396 * cArgs == 2: Modify the register.
2397 */
2398 if ( cArgs == 1
2399 || cArgs == 2)
2400 {
2401 /* locate the register symbol. */
2402 const char *pszReg = paArgs[0].u.pszString;
2403 if ( *pszPrefix
2404 && pszReg[0] != *pszPrefix)
2405 {
2406 /* prepend the prefix. */
2407 char *psz = (char *)alloca(strlen(pszReg) + 2);
2408 psz[0] = *pszPrefix;
2409 strcpy(psz + 1, paArgs[0].u.pszString);
2410 pszReg = psz;
2411 }
2412 PCDBGCSYM pSym = dbgcLookupRegisterSymbol(pDbgc, pszReg);
2413 if (!pSym)
2414 return pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INVALID_PARAMETER /* VERR_DBGC_INVALID_REGISTER */, "Invalid register name '%s'.\n", pszReg);
2415
2416 /* show the register */
2417 if (cArgs == 1)
2418 {
2419 DBGCVAR Var;
2420 memset(&Var, 0, sizeof(Var));
2421 int rc = pSym->pfnGet(pSym, pCmdHlp, DBGCVAR_TYPE_NUMBER, &Var);
2422 if (VBOX_FAILURE(rc))
2423 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Failed getting value for register '%s'.\n", pszReg);
2424 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s=%Dv\n", pszReg, &Var);
2425 }
2426
2427 /* change the register */
2428 int rc = pSym->pfnSet(pSym, pCmdHlp, &paArgs[1]);
2429 if (VBOX_FAILURE(rc))
2430 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Failed setting value for register '%s'.\n", pszReg);
2431 return VINF_SUCCESS;
2432 }
2433
2434
2435 NOREF(pCmd); NOREF(paArgs); NOREF(pResult);
2436 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Huh? cArgs=%d Expected 0, 1 or 2!\n", cArgs);
2437}
2438
2439
2440/**
2441 * The 'rg' command.
2442 *
2443 * @returns VBox status.
2444 * @param pCmd Pointer to the command descriptor (as registered).
2445 * @param pCmdHlp Pointer to command helper functions.
2446 * @param pVM Pointer to the current VM (if any).
2447 * @param paArgs Pointer to (readonly) array of arguments.
2448 * @param cArgs Number of arguments in the array.
2449 */
2450static DECLCALLBACK(int) dbgcCmdRegGuest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2451{
2452 return dbgcCmdRegCommon(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult, "");
2453}
2454
2455
2456/**
2457 * The 'rh' command.
2458 *
2459 * @returns VBox status.
2460 * @param pCmd Pointer to the command descriptor (as registered).
2461 * @param pCmdHlp Pointer to command helper functions.
2462 * @param pVM Pointer to the current VM (if any).
2463 * @param paArgs Pointer to (readonly) array of arguments.
2464 * @param cArgs Number of arguments in the array.
2465 */
2466static DECLCALLBACK(int) dbgcCmdRegHyper(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2467{
2468 return dbgcCmdRegCommon(pCmd, pCmdHlp, pVM, paArgs, cArgs, pResult, ".");
2469}
2470
2471
2472/**
2473 * The 'rt' command.
2474 *
2475 * @returns VBox status.
2476 * @param pCmd Pointer to the command descriptor (as registered).
2477 * @param pCmdHlp Pointer to command helper functions.
2478 * @param pVM Pointer to the current VM (if any).
2479 * @param paArgs Pointer to (readonly) array of arguments.
2480 * @param cArgs Number of arguments in the array.
2481 */
2482static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2483{
2484 NOREF(pCmd); NOREF(pVM); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
2485
2486 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2487 pDbgc->fRegTerse = !pDbgc->fRegTerse;
2488 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, pDbgc->fRegTerse ? "info: Terse register info.\n" : "info: Verbose register info.\n");
2489}
2490
2491
2492/**
2493 * The 't' command.
2494 *
2495 * @returns VBox status.
2496 * @param pCmd Pointer to the command descriptor (as registered).
2497 * @param pCmdHlp Pointer to command helper functions.
2498 * @param pVM Pointer to the current VM (if any).
2499 * @param paArgs Pointer to (readonly) array of arguments.
2500 * @param cArgs Number of arguments in the array.
2501 */
2502static DECLCALLBACK(int) dbgcCmdTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2503{
2504 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2505
2506 int rc = DBGFR3Step(pVM);
2507 if (VBOX_SUCCESS(rc))
2508 pDbgc->fReady = false;
2509 else
2510 rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to single step VM %p\n", pDbgc->pVM);
2511
2512 NOREF(pCmd); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
2513 return rc;
2514}
2515
2516
2517/**
2518 * The 'k', 'kg' and 'kh' commands.
2519 *
2520 * @returns VBox status.
2521 * @param pCmd Pointer to the command descriptor (as registered).
2522 * @param pCmdHlp Pointer to command helper functions.
2523 * @param pVM Pointer to the current VM (if any).
2524 * @param paArgs Pointer to (readonly) array of arguments.
2525 * @param cArgs Number of arguments in the array.
2526 */
2527static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2528{
2529 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
2530
2531 /*
2532 * Figure which context we're called for.
2533 */
2534 bool fGuest = pCmd->pszCmd[1] == 'g'
2535 || (!pCmd->pszCmd[1] && pDbgc->fRegCtxGuest);
2536
2537
2538 DBGFSTACKFRAME Frame;
2539 memset(&Frame, 0, sizeof(Frame));
2540 int rc;
2541 if (fGuest)
2542 rc = DBGFR3StackWalkBeginGuest(pVM, &Frame);
2543 else
2544 rc = DBGFR3StackWalkBeginHyper(pVM, &Frame);
2545 if (VBOX_FAILURE(rc))
2546 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to begin stack walk, rc=%Vrc\n", rc);
2547
2548 /*
2549 * Print header.
2550 * 12345678 12345678 0023:87654321 12345678 87654321 12345678 87654321 symbol
2551 */
2552 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP / Symbol [line]\n");
2553 if (VBOX_FAILURE(rc))
2554 return rc;
2555 do
2556 {
2557 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
2558 (uint32_t)Frame.AddrFrame.off,
2559 (uint32_t)Frame.AddrReturnFrame.off,
2560 (uint32_t)Frame.AddrReturnPC.Sel,
2561 (uint32_t)Frame.AddrReturnPC.off,
2562 Frame.Args.au32[0],
2563 Frame.Args.au32[1],
2564 Frame.Args.au32[2],
2565 Frame.Args.au32[3]);
2566 if (VBOX_FAILURE(rc))
2567 return rc;
2568 if (!Frame.pSymPC)
2569 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %RTsel:%08RGv", Frame.AddrPC.Sel, Frame.AddrPC.off);
2570 else
2571 {
2572 RTGCINTPTR offDisp = Frame.AddrPC.FlatPtr - Frame.pSymPC->Value; /** @todo this isn't 100% correct for segemnted stuff. */
2573 if (offDisp > 0)
2574 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %s+%llx", Frame.pSymPC->szName, (int64_t)offDisp);
2575 else if (offDisp < 0)
2576 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %s-%llx", Frame.pSymPC->szName, -(int64_t)offDisp);
2577 else
2578 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " %s", Frame.pSymPC->szName);
2579 }
2580 if (VBOX_SUCCESS(rc) && Frame.pLinePC)
2581 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " [%s @ 0i%d]", Frame.pLinePC->szFilename, Frame.pLinePC->uLineNo);
2582 if (VBOX_SUCCESS(rc))
2583 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
2584 if (VBOX_FAILURE(rc))
2585 return rc;
2586
2587 /* next */
2588 rc = DBGFR3StackWalkNext(pVM, &Frame);
2589 } while (VBOX_SUCCESS(rc));
2590
2591 NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
2592 return VINF_SUCCESS;
2593}
2594
2595
2596static int dbgcCmdDumpDTWorker64(PDBGCCMDHLP /*pCmdHlp*/, PCX86DESC64 /*pDesc*/, unsigned /*iEntry*/, bool /* fHyper */, bool * /*fDblEntry*/)
2597{
2598 /* GUEST64 */
2599 return VINF_SUCCESS;
2600}
2601
2602
2603/**
2604 * Wroker function that displays one descriptor entry (GDT, LDT, IDT).
2605 *
2606 * @returns pfnPrintf status code.
2607 * @param pCmdHlp The DBGC command helpers.
2608 * @param pDesc The descriptor to display.
2609 * @param iEntry The descriptor entry number.
2610 * @param fHyper Whether the selector belongs to the hypervisor or not.
2611 */
2612static int dbgcCmdDumpDTWorker32(PDBGCCMDHLP pCmdHlp, PCX86DESC pDesc, unsigned iEntry, bool fHyper)
2613{
2614 int rc;
2615
2616 const char *pszHyper = fHyper ? " HYPER" : "";
2617 const char *pszPresent = pDesc->Gen.u1Present ? "P " : "NP";
2618 if (pDesc->Gen.u1DescType)
2619 {
2620 static const char * const s_apszTypes[] =
2621 {
2622 "DataRO", /* 0 Read-Only */
2623 "DataRO", /* 1 Read-Only - Accessed */
2624 "DataRW", /* 2 Read/Write */
2625 "DataRW", /* 3 Read/Write - Accessed */
2626 "DownRO", /* 4 Expand-down, Read-Only */
2627 "DownRO", /* 5 Expand-down, Read-Only - Accessed */
2628 "DownRW", /* 6 Expand-down, Read/Write */
2629 "DownRO", /* 7 Expand-down, Read/Write - Accessed */
2630 "CodeEO", /* 8 Execute-Only */
2631 "CodeEO", /* 9 Execute-Only - Accessed */
2632 "CodeER", /* A Execute/Readable */
2633 "CodeER", /* B Execute/Readable - Accessed */
2634 "ConfE0", /* C Conforming, Execute-Only */
2635 "ConfE0", /* D Conforming, Execute-Only - Accessed */
2636 "ConfER", /* E Conforming, Execute/Readable */
2637 "ConfER" /* F Conforming, Execute/Readable - Accessed */
2638 };
2639 const char *pszAccessed = pDesc->Gen.u4Type & RT_BIT(0) ? "A " : "NA";
2640 const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
2641 const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2642 uint32_t u32Base = pDesc->Gen.u16BaseLow
2643 | ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
2644 | ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
2645 uint32_t cbLimit = pDesc->Gen.u16LimitLow | (pDesc->Gen.u4LimitHigh << 16);
2646 if (pDesc->Gen.u1Granularity)
2647 cbLimit <<= PAGE_SHIFT;
2648
2649 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d R=%d%s\n",
2650 iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
2651 pDesc->Gen.u2Dpl, pszPresent, pszAccessed, pszGranularity, pszBig,
2652 pDesc->Gen.u1Available, pDesc->Gen.u1Reserved, pszHyper);
2653 }
2654 else
2655 {
2656 static const char * const s_apszTypes[] =
2657 {
2658 "Ill-0 ", /* 0 0000 Reserved (Illegal) */
2659 "Tss16A", /* 1 0001 Available 16-bit TSS */
2660 "LDT ", /* 2 0010 LDT */
2661 "Tss16B", /* 3 0011 Busy 16-bit TSS */
2662 "Call16", /* 4 0100 16-bit Call Gate */
2663 "TaskG ", /* 5 0101 Task Gate */
2664 "Int16 ", /* 6 0110 16-bit Interrupt Gate */
2665 "Trap16", /* 7 0111 16-bit Trap Gate */
2666 "Ill-8 ", /* 8 1000 Reserved (Illegal) */
2667 "Tss32A", /* 9 1001 Available 32-bit TSS */
2668 "Ill-A ", /* A 1010 Reserved (Illegal) */
2669 "Tss32B", /* B 1011 Busy 32-bit TSS */
2670 "Call32", /* C 1100 32-bit Call Gate */
2671 "Ill-D ", /* D 1101 Reserved (Illegal) */
2672 "Int32 ", /* E 1110 32-bit Interrupt Gate */
2673 "Trap32" /* F 1111 32-bit Trap Gate */
2674 };
2675 switch (pDesc->Gen.u4Type)
2676 {
2677 /* raw */
2678 case X86_SEL_TYPE_SYS_UNDEFINED:
2679 case X86_SEL_TYPE_SYS_UNDEFINED2:
2680 case X86_SEL_TYPE_SYS_UNDEFINED4:
2681 case X86_SEL_TYPE_SYS_UNDEFINED3:
2682 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s %.8Rhxs DPL=%d %s%s\n",
2683 iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc,
2684 pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2685 break;
2686
2687 case X86_SEL_TYPE_SYS_286_TSS_AVAIL:
2688 case X86_SEL_TYPE_SYS_386_TSS_AVAIL:
2689 case X86_SEL_TYPE_SYS_286_TSS_BUSY:
2690 case X86_SEL_TYPE_SYS_386_TSS_BUSY:
2691 case X86_SEL_TYPE_SYS_LDT:
2692 {
2693 const char *pszGranularity = pDesc->Gen.u1Granularity ? "G" : " ";
2694 const char *pszBusy = pDesc->Gen.u4Type & RT_BIT(1) ? "B " : "NB";
2695 const char *pszBig = pDesc->Gen.u1DefBig ? "BIG" : " ";
2696 uint32_t u32Base = pDesc->Gen.u16BaseLow
2697 | ((uint32_t)pDesc->Gen.u8BaseHigh1 << 16)
2698 | ((uint32_t)pDesc->Gen.u8BaseHigh2 << 24);
2699 uint32_t cbLimit = pDesc->Gen.u16LimitLow | (pDesc->Gen.u4LimitHigh << 16);
2700 if (pDesc->Gen.u1Granularity)
2701 cbLimit <<= PAGE_SHIFT;
2702
2703 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Bas=%08x Lim=%08x DPL=%d %s %s %s %s AVL=%d R=%d%s\n",
2704 iEntry, s_apszTypes[pDesc->Gen.u4Type], u32Base, cbLimit,
2705 pDesc->Gen.u2Dpl, pszPresent, pszBusy, pszGranularity, pszBig,
2706 pDesc->Gen.u1Available, pDesc->Gen.u1Reserved | (pDesc->Gen.u1DefBig << 1),
2707 pszHyper);
2708 break;
2709 }
2710
2711 case X86_SEL_TYPE_SYS_TASK_GATE:
2712 {
2713 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s TSS=%04x DPL=%d %s%s\n",
2714 iEntry, s_apszTypes[pDesc->Gen.u4Type], pDesc->au16[1],
2715 pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2716 break;
2717 }
2718
2719 case X86_SEL_TYPE_SYS_286_CALL_GATE:
2720 case X86_SEL_TYPE_SYS_386_CALL_GATE:
2721 {
2722 unsigned cParams = pDesc->au8[0] & 0x1f;
2723 const char *pszCountOf = pDesc->Gen.u4Type & RT_BIT(3) ? "DC" : "WC";
2724 RTSEL sel = pDesc->au16[1];
2725 uint32_t off = pDesc->au16[0] | ((uint32_t)pDesc->au16[3] << 16);
2726 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Sel:Off=%04x:%08x DPL=%d %s %s=%d%s\n",
2727 iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
2728 pDesc->Gen.u2Dpl, pszPresent, pszCountOf, cParams, pszHyper);
2729 break;
2730 }
2731
2732 case X86_SEL_TYPE_SYS_286_INT_GATE:
2733 case X86_SEL_TYPE_SYS_386_INT_GATE:
2734 case X86_SEL_TYPE_SYS_286_TRAP_GATE:
2735 case X86_SEL_TYPE_SYS_386_TRAP_GATE:
2736 {
2737 RTSEL sel = pDesc->au16[1];
2738 uint32_t off = pDesc->au16[0] | ((uint32_t)pDesc->au16[3] << 16);
2739 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %s Sel:Off=%04x:%08x DPL=%d %s%s\n",
2740 iEntry, s_apszTypes[pDesc->Gen.u4Type], sel, off,
2741 pDesc->Gen.u2Dpl, pszPresent, pszHyper);
2742 break;
2743 }
2744
2745 /* impossible, just it's necessary to keep gcc happy. */
2746 default:
2747 return VINF_SUCCESS;
2748 }
2749 }
2750 return rc;
2751}
2752
2753
2754/**
2755 * The 'dg', 'dga', 'dl' and 'dla' commands.
2756 *
2757 * @returns VBox status.
2758 * @param pCmd Pointer to the command descriptor (as registered).
2759 * @param pCmdHlp Pointer to command helper functions.
2760 * @param pVM Pointer to the current VM (if any).
2761 * @param paArgs Pointer to (readonly) array of arguments.
2762 * @param cArgs Number of arguments in the array.
2763 */
2764static DECLCALLBACK(int) dbgcCmdDumpDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2765{
2766 /*
2767 * Validate input.
2768 */
2769 if (!pVM)
2770 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
2771
2772 /*
2773 * Get the CPU mode, check which command variation this is
2774 * and fix a default parameter if needed.
2775 */
2776 CPUMMODE enmMode = CPUMGetGuestMode(pVM);
2777 bool fGdt = pCmd->pszCmd[1] == 'g';
2778 bool fAll = pCmd->pszCmd[2] == 'a';
2779
2780 DBGCVAR Var;
2781 if (!cArgs)
2782 {
2783 cArgs = 1;
2784 paArgs = &Var;
2785 Var.enmType = DBGCVAR_TYPE_NUMBER;
2786 Var.u.u64Number = fGdt ? 0 : 4;
2787 Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2788 Var.u64Range = 1024;
2789 }
2790
2791 /*
2792 * Process the arguments.
2793 */
2794 for (unsigned i = 0; i < cArgs; i++)
2795 {
2796 /*
2797 * Retrive the selector value from the argument.
2798 * The parser may confuse pointers and numbers if more than one
2799 * argument is given, that that into account.
2800 */
2801 /* check that what've got makes sense as we don't trust the parser yet. */
2802 if ( paArgs[i].enmType != DBGCVAR_TYPE_NUMBER
2803 && !DBGCVAR_ISPOINTER(paArgs[i].enmType))
2804 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: arg #%u isn't of number or pointer type but %d.\n", i, paArgs[i].enmType);
2805 uint64_t u64;
2806 unsigned cSels = 1;
2807 switch (paArgs[i].enmType)
2808 {
2809 case DBGCVAR_TYPE_NUMBER:
2810 u64 = paArgs[i].u.u64Number;
2811 if (paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE)
2812 cSels = RT_MIN(paArgs[i].u64Range, 1024);
2813 break;
2814 case DBGCVAR_TYPE_GC_FAR: u64 = paArgs[i].u.GCFar.sel; break;
2815 case DBGCVAR_TYPE_GC_FLAT: u64 = paArgs[i].u.GCFlat; break;
2816 case DBGCVAR_TYPE_GC_PHYS: u64 = paArgs[i].u.GCPhys; break;
2817 case DBGCVAR_TYPE_HC_FAR: u64 = paArgs[i].u.HCFar.sel; break;
2818 case DBGCVAR_TYPE_HC_FLAT: u64 = (uintptr_t)paArgs[i].u.pvHCFlat; break;
2819 case DBGCVAR_TYPE_HC_PHYS: u64 = paArgs[i].u.HCPhys; break;
2820 default: u64 = _64K; break;
2821 }
2822 if (u64 < _64K)
2823 {
2824 unsigned Sel = (RTSEL)u64;
2825
2826 /*
2827 * Dump the specified range.
2828 */
2829 bool fSingle = cSels == 1;
2830 while ( cSels-- > 0
2831 && Sel < _64K)
2832 {
2833 SELMSELINFO SelInfo;
2834 int rc = SELMR3GetSelectorInfo(pVM, Sel, &SelInfo);
2835 if (RT_SUCCESS(rc))
2836 {
2837 if (SelInfo.fRealMode)
2838 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x RealM Bas=%04x Lim=%04x\n",
2839 Sel, (unsigned)SelInfo.GCPtrBase, (unsigned)SelInfo.cbLimit);
2840 else if (fAll || fSingle || SelInfo.Raw.Gen.u1Present)
2841 {
2842 if (enmMode == CPUMMODE_PROTECTED)
2843 rc = dbgcCmdDumpDTWorker32(pCmdHlp, (PX86DESC)&SelInfo.Raw, Sel, SelInfo.fHyper);
2844 else
2845 {
2846 bool fDblSkip = false;
2847 rc = dbgcCmdDumpDTWorker64(pCmdHlp, (PX86DESC64)&SelInfo.Raw, Sel, SelInfo.fHyper, &fDblSkip);
2848 if (fDblSkip)
2849 Sel += 4;
2850 }
2851 }
2852 }
2853 else
2854 {
2855 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %Vrc\n", Sel, rc);
2856 if (!fAll)
2857 return rc;
2858 }
2859 if (RT_FAILURE(rc))
2860 return rc;
2861
2862 /* next */
2863 Sel += 4;
2864 }
2865 }
2866 else
2867 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %llx is out of bounds\n", u64);
2868 }
2869
2870 NOREF(pResult);
2871 return VINF_SUCCESS;
2872}
2873
2874
2875/**
2876 * The 'di' and 'dia' commands.
2877 *
2878 * @returns VBox status.
2879 * @param pCmd Pointer to the command descriptor (as registered).
2880 * @param pCmdHlp Pointer to command helper functions.
2881 * @param pVM Pointer to the current VM (if any).
2882 * @param paArgs Pointer to (readonly) array of arguments.
2883 * @param cArgs Number of arguments in the array.
2884 */
2885static DECLCALLBACK(int) dbgcCmdDumpIDT(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
2886{
2887 /*
2888 * Validate input.
2889 */
2890 if (!pVM)
2891 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
2892
2893 /*
2894 * Establish some stuff like the current IDTR and CPU mode,
2895 * and fix a default parameter.
2896 */
2897 uint16_t cbLimit;
2898 RTGCUINTPTR GCPtrBase = CPUMGetGuestIDTR(pVM, &cbLimit);
2899 CPUMMODE enmMode = CPUMGetGuestMode(pVM);
2900 unsigned cbEntry;
2901 switch (enmMode)
2902 {
2903 case CPUMMODE_REAL: cbEntry = sizeof(RTFAR16); break;
2904 case CPUMMODE_PROTECTED: cbEntry = sizeof(X86DESC); break;
2905 case CPUMMODE_LONG: cbEntry = sizeof(X86DESC64); break;
2906 default:
2907 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Invalid CPU mode %d.\n", enmMode);
2908 }
2909
2910 bool fAll = pCmd->pszCmd[2] == 'a';
2911 DBGCVAR Var;
2912 if (!cArgs)
2913 {
2914 cArgs = 1;
2915 paArgs = &Var;
2916 Var.enmType = DBGCVAR_TYPE_NUMBER;
2917 Var.u.u64Number = 0;
2918 Var.enmRangeType = DBGCVAR_RANGE_ELEMENTS;
2919 Var.u64Range = 256;
2920 }
2921
2922 /*
2923 * Process the arguments.
2924 */
2925 for (unsigned i = 0; i < cArgs; i++)
2926 {
2927 /* check that what've got makes sense as we don't trust the parser yet. */
2928 if (paArgs[i].enmType != DBGCVAR_TYPE_NUMBER)
2929 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: arg #%u isn't of number type but %d.\n", i, paArgs[i].enmType);
2930 if (paArgs[i].u.u64Number < 256)
2931 {
2932 RTGCUINTPTR iInt = (RTGCUINTPTR)paArgs[i].u.u64Number;
2933 unsigned cInts = paArgs[i].enmRangeType != DBGCVAR_RANGE_NONE
2934 ? paArgs[i].u64Range
2935 : 1;
2936 bool fSingle = cInts == 1;
2937 while ( cInts-- > 0
2938 && iInt < 256)
2939 {
2940 /*
2941 * Try read it.
2942 */
2943 union
2944 {
2945 RTFAR16 Real;
2946 X86DESC Prot;
2947 X86DESC64 Long;
2948 } u;
2949 if (iInt * cbEntry + (cbEntry - 1) > cbLimit)
2950 {
2951 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x not within the IDT\n", (unsigned)iInt);
2952 if (!fAll && !fSingle)
2953 return VINF_SUCCESS;
2954 }
2955 DBGCVAR AddrVar;
2956 AddrVar.enmType = DBGCVAR_TYPE_GC_FLAT;
2957 AddrVar.u.GCFlat = GCPtrBase + iInt * cbEntry;
2958 AddrVar.enmRangeType = DBGCVAR_RANGE_NONE;
2959 int rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &u, cbEntry, &AddrVar, NULL);
2960 if (VBOX_FAILURE(rc))
2961 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading IDT entry %#04x.\n", (unsigned)iInt);
2962
2963 /*
2964 * Display it.
2965 */
2966 switch (enmMode)
2967 {
2968 case CPUMMODE_REAL:
2969 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%04x %RTfp16\n", (unsigned)iInt, u.Real);
2970 /** @todo resolve 16:16 IDTE to a symbol */
2971 break;
2972 case CPUMMODE_PROTECTED:
2973 if (fAll || fSingle || u.Prot.Gen.u1Present)
2974 rc = dbgcCmdDumpDTWorker32(pCmdHlp, &u.Prot, iInt, false);
2975 break;
2976 case CPUMMODE_LONG:
2977 if (fAll || fSingle || u.Long.Gen.u1Present)
2978 rc = dbgcCmdDumpDTWorker64(pCmdHlp, &u.Long, iInt, false, NULL);
2979 break;
2980 default: break; /* to shut up gcc */
2981 }
2982 if (RT_FAILURE(rc))
2983 return rc;
2984
2985 /* next */
2986 iInt++;
2987 }
2988 }
2989 else
2990 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %llx is out of bounds (max 256)\n", paArgs[i].u.u64Number);
2991 }
2992
2993 NOREF(pResult);
2994 return VINF_SUCCESS;
2995}
2996
2997
2998/**
2999 * The 'da', 'dq', 'dd', 'dw' and 'db' commands.
3000 *
3001 * @returns VBox status.
3002 * @param pCmd Pointer to the command descriptor (as registered).
3003 * @param pCmdHlp Pointer to command helper functions.
3004 * @param pVM Pointer to the current VM (if any).
3005 * @param paArgs Pointer to (readonly) array of arguments.
3006 * @param cArgs Number of arguments in the array.
3007 */
3008static DECLCALLBACK(int) dbgcCmdDumpMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3009{
3010 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3011
3012 /*
3013 * Validate input.
3014 */
3015 if ( cArgs > 1
3016 || (cArgs == 1 && !DBGCVAR_ISPOINTER(paArgs[0].enmType)))
3017 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
3018 if (!pVM)
3019 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3020
3021 /*
3022 * Figure out the element size.
3023 */
3024 unsigned cbElement;
3025 bool fAscii = false;
3026 switch (pCmd->pszCmd[1])
3027 {
3028 default:
3029 case 'b': cbElement = 1; break;
3030 case 'w': cbElement = 2; break;
3031 case 'd': cbElement = 4; break;
3032 case 'q': cbElement = 8; break;
3033 case 'a':
3034 cbElement = 1;
3035 fAscii = true;
3036 break;
3037 case '\0':
3038 fAscii = !!(pDbgc->cbDumpElement & 0x80000000);
3039 cbElement = pDbgc->cbDumpElement & 0x7fffffff;
3040 if (!cbElement)
3041 cbElement = 1;
3042 break;
3043 }
3044
3045 /*
3046 * Find address.
3047 */
3048 if (!cArgs)
3049 pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_NONE;
3050 else
3051 pDbgc->DumpPos = paArgs[0];
3052
3053 /*
3054 * Range.
3055 */
3056 switch (pDbgc->DumpPos.enmRangeType)
3057 {
3058 case DBGCVAR_RANGE_NONE:
3059 pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3060 pDbgc->DumpPos.u64Range = 0x60;
3061 break;
3062
3063 case DBGCVAR_RANGE_ELEMENTS:
3064 if (pDbgc->DumpPos.u64Range > 2048)
3065 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: Too many elements requested. Max is 2048 elements.\n");
3066 pDbgc->DumpPos.enmRangeType = DBGCVAR_RANGE_BYTES;
3067 pDbgc->DumpPos.u64Range = (cbElement ? cbElement : 1) * pDbgc->DumpPos.u64Range;
3068 break;
3069
3070 case DBGCVAR_RANGE_BYTES:
3071 if (pDbgc->DumpPos.u64Range > 65536)
3072 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The requested range is too big. Max is 64KB.\n");
3073 break;
3074
3075 default:
3076 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: Unknown range type %d.\n", pDbgc->DumpPos.enmRangeType);
3077 }
3078
3079 /*
3080 * Do the dumping.
3081 */
3082 pDbgc->cbDumpElement = cbElement | (fAscii << 31);
3083 int cbLeft = (int)pDbgc->DumpPos.u64Range;
3084 uint8_t u8Prev = '\0';
3085 for (;;)
3086 {
3087 /*
3088 * Read memory.
3089 */
3090 char achBuffer[16];
3091 size_t cbReq = RT_MIN((int)sizeof(achBuffer), cbLeft);
3092 size_t cb = RT_MIN((int)sizeof(achBuffer), cbLeft);
3093 int rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &achBuffer, cbReq, &pDbgc->DumpPos, &cb);
3094 if (VBOX_FAILURE(rc))
3095 {
3096 if (u8Prev && u8Prev != '\n')
3097 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3098 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading memory at %DV.\n", &pDbgc->DumpPos);
3099 }
3100
3101 /*
3102 * Display it.
3103 */
3104 memset(&achBuffer[cb], 0, sizeof(achBuffer) - cb);
3105 if (!fAscii)
3106 {
3107 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV:", &pDbgc->DumpPos);
3108 unsigned i;
3109 for (i = 0; i < cb; i += cbElement)
3110 {
3111 const char *pszSpace = " ";
3112 if (cbElement <= 2 && i == 8 && !fAscii)
3113 pszSpace = "-";
3114 switch (cbElement)
3115 {
3116 case 1: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%02x", pszSpace, *(uint8_t *)&achBuffer[i]); break;
3117 case 2: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%04x", pszSpace, *(uint16_t *)&achBuffer[i]); break;
3118 case 4: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%08x", pszSpace, *(uint32_t *)&achBuffer[i]); break;
3119 case 8: pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%s%016llx", pszSpace, *(uint64_t *)&achBuffer[i]); break;
3120 }
3121 }
3122
3123 /* chars column */
3124 if (pDbgc->cbDumpElement == 1)
3125 {
3126 while (i++ < sizeof(achBuffer))
3127 pCmdHlp->pfnPrintf(pCmdHlp, NULL, " ");
3128 pCmdHlp->pfnPrintf(pCmdHlp, NULL, " ");
3129 for (i = 0; i < cb; i += cbElement)
3130 {
3131 uint8_t u8 = *(uint8_t *)&achBuffer[i];
3132 if (isprint(u8) && u8 < 127)
3133 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%c", u8);
3134 else
3135 pCmdHlp->pfnPrintf(pCmdHlp, NULL, ".");
3136 }
3137 }
3138 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3139 }
3140 else
3141 {
3142 /*
3143 * We print up to the first zero and stop there.
3144 * Only printables + '\t' and '\n' are printed.
3145 */
3146 if (!u8Prev)
3147 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV:\n", &pDbgc->DumpPos);
3148 uint8_t u8 = '\0';
3149 unsigned i;
3150 for (i = 0; i < cb; i++)
3151 {
3152 u8Prev = u8;
3153 u8 = *(uint8_t *)&achBuffer[i];
3154 if ( u8 < 127
3155 && ( isprint(u8)
3156 || u8 == '\t'
3157 || u8 == '\n'))
3158 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%c", u8);
3159 else if (!u8)
3160 break;
3161 else
3162 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\\x%x", u8);
3163 }
3164 if (u8 == '\0')
3165 cb = cbLeft = i + 1;
3166 if (cbLeft - cb <= 0 && u8Prev != '\n')
3167 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3168 }
3169
3170 /*
3171 * Advance
3172 */
3173 cbLeft -= (int)cb;
3174 rc = pCmdHlp->pfnEval(pCmdHlp, &pDbgc->DumpPos, "(%Dv) + %x", &pDbgc->DumpPos, cb);
3175 if (VBOX_FAILURE(rc))
3176 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Expression: (%Dv) + %x\n", &pDbgc->DumpPos, cb);
3177 if (cbLeft <= 0)
3178 break;
3179 }
3180
3181 NOREF(pCmd); NOREF(pResult);
3182 return VINF_SUCCESS;
3183}
3184
3185
3186/**
3187 * Best guess at which paging mode currently applies to the guest
3188 * paging structures.
3189 *
3190 * This have to come up with a decent answer even when the guest
3191 * is in non-paged protected mode or real mode.
3192 *
3193 * @returns cr3.
3194 * @param pDbgc The DBGC instance.
3195 * @param pfPAE Where to store the page address extension indicator.
3196 * @param pfLME Where to store the long mode enabled indicator.
3197 * @param pfPSE Where to store the page size extension indicator.
3198 * @param pfPGE Where to store the page global enabled indicator.
3199 * @param pfNXE Where to store the no-execution enabled inidicator.
3200 */
3201static RTGCPHYS dbgcGetGuestPageMode(PDBGC pDbgc, bool *pfPAE, bool *pfLME, bool *pfPSE, bool *pfPGE, bool *pfNXE)
3202{
3203 RTGCUINTREG cr4 = CPUMGetGuestCR4(pDbgc->pVM);
3204 *pfPSE = !!(cr4 & X86_CR4_PSE);
3205 *pfPGE = !!(cr4 & X86_CR4_PGE);
3206 *pfPAE = !!(cr4 & X86_CR4_PAE);
3207 *pfLME = CPUMGetGuestMode(pDbgc->pVM) == CPUMMODE_LONG;
3208 *pfNXE = false; /* GUEST64 GUESTNX */
3209 return CPUMGetGuestCR3(pDbgc->pVM);
3210}
3211
3212
3213/**
3214 * Determin the shadow paging mode.
3215 *
3216 * @returns cr3.
3217 * @param pDbgc The DBGC instance.
3218 * @param pfPAE Where to store the page address extension indicator.
3219 * @param pfLME Where to store the long mode enabled indicator.
3220 * @param pfPSE Where to store the page size extension indicator.
3221 * @param pfPGE Where to store the page global enabled indicator.
3222 * @param pfNXE Where to store the no-execution enabled inidicator.
3223 */
3224static RTHCPHYS dbgcGetShadowPageMode(PDBGC pDbgc, bool *pfPAE, bool *pfLME, bool *pfPSE, bool *pfPGE, bool *pfNXE)
3225{
3226 *pfPSE = true;
3227 *pfPGE = false;
3228 switch (PGMGetShadowMode(pDbgc->pVM))
3229 {
3230 default:
3231 case PGMMODE_32_BIT:
3232 *pfPAE = *pfLME = *pfNXE = false;
3233 break;
3234 case PGMMODE_PAE:
3235 *pfLME = *pfNXE = false;
3236 *pfPAE = true;
3237 break;
3238 case PGMMODE_PAE_NX:
3239 *pfLME = false;
3240 *pfPAE = *pfNXE = true;
3241 break;
3242 case PGMMODE_AMD64:
3243 *pfNXE = false;
3244 *pfPAE = *pfLME = true;
3245 break;
3246 case PGMMODE_AMD64_NX:
3247 *pfPAE = *pfLME = *pfNXE = true;
3248 break;
3249 }
3250 return PGMGetHyperCR3(pDbgc->pVM);
3251}
3252
3253
3254/**
3255 * The 'dpd', 'dpda', 'dpdb', 'dpdg' and 'dpdh' commands.
3256 *
3257 * @returns VBox status.
3258 * @param pCmd Pointer to the command descriptor (as registered).
3259 * @param pCmdHlp Pointer to command helper functions.
3260 * @param pVM Pointer to the current VM (if any).
3261 * @param paArgs Pointer to (readonly) array of arguments.
3262 * @param cArgs Number of arguments in the array.
3263 */
3264static DECLCALLBACK(int) dbgcCmdDumpPageDir(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3265{
3266 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3267
3268 /*
3269 * Validate input.
3270 */
3271 if ( cArgs > 1
3272 || (cArgs == 1 && pCmd->pszCmd[3] == 'a' && !DBGCVAR_ISPOINTER(paArgs[0].enmType))
3273 || (cArgs == 1 && pCmd->pszCmd[3] != 'a' && !(paArgs[0].enmType == DBGCVAR_TYPE_NUMBER || DBGCVAR_ISPOINTER(paArgs[0].enmType)))
3274 )
3275 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
3276 if (!pVM)
3277 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3278
3279 /*
3280 * Guest or shadow page directories? Get the paging parameters.
3281 */
3282 bool fGuest = pCmd->pszCmd[3] != 'h';
3283 if (!pCmd->pszCmd[3] || pCmd->pszCmd[3] == 'a')
3284 fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
3285 ? pDbgc->fRegCtxGuest
3286 : DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
3287
3288 bool fPAE, fLME, fPSE, fPGE, fNXE;
3289 uint64_t cr3 = fGuest
3290 ? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
3291 : dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
3292 const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
3293
3294 /*
3295 * Setup default arugment if none was specified.
3296 * Fix address / index confusion.
3297 */
3298 DBGCVAR VarDefault;
3299 if (!cArgs)
3300 {
3301 if (pCmd->pszCmd[3] == 'a')
3302 {
3303 if (fLME || fPAE)
3304 return DBGCCmdHlpPrintf(pCmdHlp, "Default argument for 'dpda' hasn't been fully implemented yet. Try with an address or use one of the other commands.\n");
3305 if (fGuest)
3306 DBGCVAR_INIT_GC_PHYS(&VarDefault, cr3);
3307 else
3308 DBGCVAR_INIT_HC_PHYS(&VarDefault, cr3);
3309 }
3310 else
3311 DBGCVAR_INIT_GC_FLAT(&VarDefault, 0);
3312 paArgs = &VarDefault;
3313 cArgs = 1;
3314 }
3315 else if (paArgs[0].enmType == DBGCVAR_TYPE_NUMBER)
3316 {
3317 Assert(pCmd->pszCmd[3] != 'a');
3318 VarDefault = paArgs[0];
3319 if (VarDefault.u.u64Number <= 1024)
3320 {
3321 if (fPAE)
3322 return DBGCCmdHlpPrintf(pCmdHlp, "PDE indexing is only implemented for 32-bit paging.\n");
3323 if (VarDefault.u.u64Number >= PAGE_SIZE / cbEntry)
3324 return DBGCCmdHlpPrintf(pCmdHlp, "PDE index is out of range [0..%d].\n", PAGE_SIZE / cbEntry - 1);
3325 VarDefault.u.u64Number <<= X86_PD_SHIFT;
3326 }
3327 VarDefault.enmType = DBGCVAR_TYPE_GC_FLAT;
3328 paArgs = &VarDefault;
3329 }
3330
3331 /*
3332 * Locate the PDE to start displaying at.
3333 *
3334 * The 'dpda' command takes the address of a PDE, while the others are guest
3335 * virtual address which PDEs should be displayed. So, 'dpda' is rather simple
3336 * while the others require us to do all the tedious walking thru the paging
3337 * hierarchy to find the intended PDE.
3338 */
3339 unsigned iEntry = ~0U; /* The page directory index. ~0U for 'dpta'. */
3340 DBGCVAR VarGCPtr; /* The GC address corresponding to the current PDE (iEntry != ~0U). */
3341 DBGCVAR VarPDEAddr; /* The address of the current PDE. */
3342 unsigned cEntries; /* The number of entries to display. */
3343 unsigned cEntriesMax; /* The max number of entries to display. */
3344 int rc;
3345 if (pCmd->pszCmd[3] == 'a')
3346 {
3347 VarPDEAddr = paArgs[0];
3348 switch (VarPDEAddr.enmRangeType)
3349 {
3350 case DBGCVAR_RANGE_BYTES: cEntries = VarPDEAddr.u64Range / cbEntry; break;
3351 case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPDEAddr.u64Range; break;
3352 default: cEntries = 10; break;
3353 }
3354 cEntriesMax = PAGE_SIZE / cbEntry;
3355 }
3356 else
3357 {
3358 /*
3359 * Determin the range.
3360 */
3361 switch (paArgs[0].enmRangeType)
3362 {
3363 case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
3364 case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
3365 default: cEntries = 10; break;
3366 }
3367
3368 /*
3369 * Normalize the input address, it must be a flat GC address.
3370 */
3371 rc = pCmdHlp->pfnEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
3372 if (VBOX_FAILURE(rc))
3373 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
3374 if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
3375 {
3376 VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
3377 VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
3378 }
3379 if (fPAE)
3380 VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_PAE_SHIFT) - 1);
3381 else
3382 VarGCPtr.u.GCFlat &= ~(((RTGCPTR)1 << X86_PD_SHIFT) - 1);
3383
3384 /*
3385 * Do the paging walk until we get to the page directory.
3386 */
3387 DBGCVAR VarCur;
3388 if (fGuest)
3389 DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
3390 else
3391 DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
3392 if (fLME)
3393 {
3394 /* Page Map Level 4 Lookup. */
3395 /* Check if it's a valid address first? */
3396 VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
3397 VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
3398 X86PML4E Pml4e;
3399 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
3400 if (VBOX_FAILURE(rc))
3401 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
3402 if (!Pml4e.n.u1Present)
3403 return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
3404
3405 VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
3406 Assert(fPAE);
3407 }
3408 if (fPAE)
3409 {
3410 /* Page directory pointer table. */
3411 X86PDPE Pdpe;
3412 VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPTR_SHIFT) & X86_PDPTR_MASK) * sizeof(Pdpe);
3413 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
3414 if (VBOX_FAILURE(rc))
3415 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
3416 if (!Pdpe.n.u1Present)
3417 return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
3418
3419 iEntry = (VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
3420 VarPDEAddr = VarCur;
3421 VarPDEAddr.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
3422 VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDEPAE);
3423 }
3424 else
3425 {
3426 /* 32-bit legacy - CR3 == page directory. */
3427 iEntry = (VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK;
3428 VarPDEAddr = VarCur;
3429 VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDE);
3430 }
3431 cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
3432 iEntry /= cbEntry;
3433 }
3434
3435 /* adjust cEntries */
3436 cEntries = RT_MAX(1, cEntries);
3437 cEntries = RT_MIN(cEntries, cEntriesMax);
3438
3439 /*
3440 * The display loop.
3441 */
3442 DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (index %#x):\n" : "%DV:\n",
3443 &VarPDEAddr, iEntry);
3444 do
3445 {
3446 /*
3447 * Read.
3448 */
3449 X86PDEPAE Pde;
3450 Pde.u = 0;
3451 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pde, cbEntry, &VarPDEAddr, NULL);
3452 if (VBOX_FAILURE(rc))
3453 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarPDEAddr);
3454
3455 /*
3456 * Display.
3457 */
3458 if (iEntry != ~0U)
3459 {
3460 DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
3461 iEntry++;
3462 }
3463 if (fPSE && Pde.b.u1Size)
3464 DBGCCmdHlpPrintf(pCmdHlp,
3465 fPAE
3466 ? "%016llx big phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
3467 : "%08llx big phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
3468 Pde.u,
3469 Pde.u & X86_PDE_PAE_PG_MASK,
3470 Pde.b.u1Present ? "p " : "np",
3471 Pde.b.u1Write ? "w" : "r",
3472 Pde.b.u1User ? "u" : "s",
3473 Pde.b.u1Accessed ? "a " : "na",
3474 Pde.b.u1Dirty ? "d " : "nd",
3475 Pde.b.u3Available,
3476 Pde.b.u1Global ? (fPGE ? "g" : "G") : " ",
3477 Pde.b.u1WriteThru ? "pwt" : " ",
3478 Pde.b.u1CacheDisable ? "pcd" : " ",
3479 Pde.b.u1PAT ? "pat" : "",
3480 Pde.b.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3481 else
3482 DBGCCmdHlpPrintf(pCmdHlp,
3483 fPAE
3484 ? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s"
3485 : "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s",
3486 Pde.u,
3487 Pde.u & X86_PDE_PAE_PG_MASK,
3488 Pde.n.u1Present ? "p " : "np",
3489 Pde.n.u1Write ? "w" : "r",
3490 Pde.n.u1User ? "u" : "s",
3491 Pde.n.u1Accessed ? "a " : "na",
3492 Pde.u & RT_BIT(6) ? "6 " : " ",
3493 Pde.n.u3Available,
3494 Pde.u & RT_BIT(8) ? "8" : " ",
3495 Pde.n.u1WriteThru ? "pwt" : " ",
3496 Pde.n.u1CacheDisable ? "pcd" : " ",
3497 Pde.u & RT_BIT(7) ? "7" : "",
3498 Pde.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " ");
3499 if (Pde.u & UINT64_C(0x7fff000000000000))
3500 DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pde.u & UINT64_C(0x7fff000000000000)));
3501 rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3502 if (VBOX_FAILURE(rc))
3503 return rc;
3504
3505 /*
3506 * Advance.
3507 */
3508 VarPDEAddr.u.u64Number += cbEntry;
3509 if (iEntry != ~0U)
3510 VarGCPtr.u.GCFlat += 1 << (fPAE ? X86_PD_PAE_SHIFT : X86_PD_SHIFT);
3511 } while (cEntries-- > 0);
3512
3513 NOREF(pResult);
3514 return VINF_SUCCESS;
3515}
3516
3517
3518/**
3519 * The 'dpdb' command.
3520 *
3521 * @returns VBox status.
3522 * @param pCmd Pointer to the command descriptor (as registered).
3523 * @param pCmdHlp Pointer to command helper functions.
3524 * @param pVM Pointer to the current VM (if any).
3525 * @param paArgs Pointer to (readonly) array of arguments.
3526 * @param cArgs Number of arguments in the array.
3527 */
3528static DECLCALLBACK(int) dbgcCmdDumpPageDirBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3529{
3530 if (!pVM)
3531 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3532 int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dpdg %DV", &paArgs[0]);
3533 int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpdh %DV", &paArgs[0]);
3534 if (VBOX_FAILURE(rc1))
3535 return rc1;
3536 NOREF(pCmd); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
3537 return rc2;
3538}
3539
3540
3541/**
3542 * The 'dpg*' commands.
3543 *
3544 * @returns VBox status.
3545 * @param pCmd Pointer to the command descriptor (as registered).
3546 * @param pCmdHlp Pointer to command helper functions.
3547 * @param pVM Pointer to the current VM (if any).
3548 * @param paArgs Pointer to (readonly) array of arguments.
3549 * @param cArgs Number of arguments in the array.
3550 */
3551static DECLCALLBACK(int) dbgcCmdDumpPageTable(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3552{
3553 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
3554
3555 /*
3556 * Validate input.
3557 */
3558 if ( cArgs != 1
3559 || (pCmd->pszCmd[3] == 'a' && !DBGCVAR_ISPOINTER(paArgs[0].enmType))
3560 || (pCmd->pszCmd[3] != 'a' && !(paArgs[0].enmType == DBGCVAR_TYPE_NUMBER || DBGCVAR_ISPOINTER(paArgs[0].enmType)))
3561 )
3562 return DBGCCmdHlpPrintf(pCmdHlp, "internal error: The parser doesn't do its job properly yet.. It might help to use the '%%' operator.\n");
3563 if (!pVM)
3564 return DBGCCmdHlpPrintf(pCmdHlp, "error: No VM.\n");
3565
3566 /*
3567 * Guest or shadow page tables? Get the paging parameters.
3568 */
3569 bool fGuest = pCmd->pszCmd[3] != 'h';
3570 if (!pCmd->pszCmd[3] || pCmd->pszCmd[3] == 'a')
3571 fGuest = paArgs[0].enmType == DBGCVAR_TYPE_NUMBER
3572 ? pDbgc->fRegCtxGuest
3573 : DBGCVAR_ISGCPOINTER(paArgs[0].enmType);
3574
3575 bool fPAE, fLME, fPSE, fPGE, fNXE;
3576 uint64_t cr3 = fGuest
3577 ? dbgcGetGuestPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE)
3578 : dbgcGetShadowPageMode(pDbgc, &fPAE, &fLME, &fPSE, &fPGE, &fNXE);
3579 const unsigned cbEntry = fPAE ? sizeof(X86PTEPAE) : sizeof(X86PTE);
3580
3581 /*
3582 * Locate the PTE to start displaying at.
3583 *
3584 * The 'dpta' command takes the address of a PTE, while the others are guest
3585 * virtual address which PTEs should be displayed. So, 'pdta' is rather simple
3586 * while the others require us to do all the tedious walking thru the paging
3587 * hierarchy to find the intended PTE.
3588 */
3589 unsigned iEntry = ~0U; /* The page table index. ~0U for 'dpta'. */
3590 DBGCVAR VarGCPtr; /* The GC address corresponding to the current PTE (iEntry != ~0U). */
3591 DBGCVAR VarPTEAddr; /* The address of the current PTE. */
3592 unsigned cEntries; /* The number of entries to display. */
3593 unsigned cEntriesMax; /* The max number of entries to display. */
3594 int rc;
3595 if (pCmd->pszCmd[3] == 'a')
3596 {
3597 VarPTEAddr = paArgs[0];
3598 switch (VarPTEAddr.enmRangeType)
3599 {
3600 case DBGCVAR_RANGE_BYTES: cEntries = VarPTEAddr.u64Range / cbEntry; break;
3601 case DBGCVAR_RANGE_ELEMENTS: cEntries = VarPTEAddr.u64Range; break;
3602 default: cEntries = 10; break;
3603 }
3604 cEntriesMax = PAGE_SIZE / cbEntry;
3605 }
3606 else
3607 {
3608 /*
3609 * Determin the range.
3610 */
3611 switch (paArgs[0].enmRangeType)
3612 {
3613 case DBGCVAR_RANGE_BYTES: cEntries = paArgs[0].u64Range / PAGE_SIZE; break;
3614 case DBGCVAR_RANGE_ELEMENTS: cEntries = paArgs[0].u64Range; break;
3615 default: cEntries = 10; break;
3616 }
3617
3618 /*
3619 * Normalize the input address, it must be a flat GC address.
3620 */
3621 rc = pCmdHlp->pfnEval(pCmdHlp, &VarGCPtr, "%%(%Dv)", &paArgs[0]);
3622 if (VBOX_FAILURE(rc))
3623 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "%%(%Dv)", &paArgs[0]);
3624 if (VarGCPtr.enmType == DBGCVAR_TYPE_HC_FLAT)
3625 {
3626 VarGCPtr.u.GCFlat = (uintptr_t)VarGCPtr.u.pvHCFlat;
3627 VarGCPtr.enmType = DBGCVAR_TYPE_GC_FLAT;
3628 }
3629 VarGCPtr.u.GCFlat &= ~(RTGCPTR)PAGE_OFFSET_MASK;
3630
3631 /*
3632 * Do the paging walk until we get to the page table.
3633 */
3634 DBGCVAR VarCur;
3635 if (fGuest)
3636 DBGCVAR_INIT_GC_PHYS(&VarCur, cr3);
3637 else
3638 DBGCVAR_INIT_HC_PHYS(&VarCur, cr3);
3639 if (fLME)
3640 {
3641 /* Page Map Level 4 Lookup. */
3642 /* Check if it's a valid address first? */
3643 VarCur.u.u64Number &= X86_PTE_PAE_PG_MASK;
3644 VarCur.u.u64Number += (((uint64_t)VarGCPtr.u.GCFlat >> X86_PML4_SHIFT) & X86_PML4_MASK) * sizeof(X86PML4E);
3645 X86PML4E Pml4e;
3646 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pml4e, sizeof(Pml4e), &VarCur, NULL);
3647 if (VBOX_FAILURE(rc))
3648 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PML4E memory at %DV.\n", &VarCur);
3649 if (!Pml4e.n.u1Present)
3650 return DBGCCmdHlpPrintf(pCmdHlp, "Page directory pointer table is not present for %Dv.\n", &VarGCPtr);
3651
3652 VarCur.u.u64Number = Pml4e.u & X86_PML4E_PG_MASK;
3653 Assert(fPAE);
3654 }
3655 if (fPAE)
3656 {
3657 /* Page directory pointer table. */
3658 X86PDPE Pdpe;
3659 VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PDPTR_SHIFT) & X86_PDPTR_MASK) * sizeof(Pdpe);
3660 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pdpe, sizeof(Pdpe), &VarCur, NULL);
3661 if (VBOX_FAILURE(rc))
3662 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDPE memory at %DV.\n", &VarCur);
3663 if (!Pdpe.n.u1Present)
3664 return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
3665
3666 VarCur.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
3667
3668 /* Page directory (PAE). */
3669 X86PDEPAE Pde;
3670 VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK) * sizeof(Pde);
3671 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pde, sizeof(Pde), &VarCur, NULL);
3672 if (VBOX_FAILURE(rc))
3673 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarCur);
3674 if (!Pde.n.u1Present)
3675 return DBGCCmdHlpPrintf(pCmdHlp, "Page table is not present for %Dv.\n", &VarGCPtr);
3676 if (fPSE && Pde.n.u1Size)
3677 return pCmdHlp->pfnExec(pCmdHlp, "dpd%s %Dv L3", &pCmd->pszCmd[3], &VarGCPtr);
3678
3679 iEntry = (VarGCPtr.u.GCFlat >> X86_PT_PAE_SHIFT) & X86_PT_PAE_MASK;
3680 VarPTEAddr = VarCur;
3681 VarPTEAddr.u.u64Number = Pde.u & X86_PDE_PAE_PG_MASK;
3682 VarPTEAddr.u.u64Number += iEntry * sizeof(X86PTEPAE);
3683 }
3684 else
3685 {
3686 /* Page directory (legacy). */
3687 X86PDE Pde;
3688 VarCur.u.u64Number += ((VarGCPtr.u.GCFlat >> X86_PD_SHIFT) & X86_PD_MASK) * sizeof(Pde);
3689 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pde, sizeof(Pde), &VarCur, NULL);
3690 if (VBOX_FAILURE(rc))
3691 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PDE memory at %DV.\n", &VarCur);
3692 if (!Pde.n.u1Present)
3693 return DBGCCmdHlpPrintf(pCmdHlp, "Page table is not present for %Dv.\n", &VarGCPtr);
3694 if (fPSE && Pde.n.u1Size)
3695 return pCmdHlp->pfnExec(pCmdHlp, "dpd%s %Dv L3", &pCmd->pszCmd[3], &VarGCPtr);
3696
3697 iEntry = (VarGCPtr.u.GCFlat >> X86_PT_SHIFT) & X86_PT_MASK;
3698 VarPTEAddr = VarCur;
3699 VarPTEAddr.u.u64Number = Pde.u & X86_PDE_PG_MASK;
3700 VarPTEAddr.u.u64Number += iEntry * sizeof(X86PTE);
3701 }
3702 cEntriesMax = (PAGE_SIZE - iEntry) / cbEntry;
3703 iEntry /= cbEntry;
3704 }
3705
3706 /* adjust cEntries */
3707 cEntries = RT_MAX(1, cEntries);
3708 cEntries = RT_MIN(cEntries, cEntriesMax);
3709
3710 /*
3711 * The display loop.
3712 */
3713 DBGCCmdHlpPrintf(pCmdHlp, iEntry != ~0U ? "%DV (base %DV / index %#x):\n" : "%DV:\n",
3714 &VarPTEAddr, &VarGCPtr, iEntry);
3715 do
3716 {
3717 /*
3718 * Read.
3719 */
3720 X86PTEPAE Pte;
3721 Pte.u = 0;
3722 rc = pCmdHlp->pfnMemRead(pCmdHlp, pVM, &Pte, cbEntry, &VarPTEAddr, NULL);
3723 if (VBOX_FAILURE(rc))
3724 return DBGCCmdHlpVBoxError(pCmdHlp, rc, "Reading PTE memory at %DV.\n", &VarPTEAddr);
3725
3726 /*
3727 * Display.
3728 */
3729 if (iEntry != ~0U)
3730 {
3731 DBGCCmdHlpPrintf(pCmdHlp, "%03x %DV: ", iEntry, &VarGCPtr);
3732 iEntry++;
3733 }
3734 DBGCCmdHlpPrintf(pCmdHlp,
3735 fPAE
3736 ? "%016llx 4kb phys=%016llx %s %s %s %s %s avl=%02x %s %s %s %s %s"
3737 : "%08llx 4kb phys=%08llx %s %s %s %s %s avl=%02x %s %s %s %s %s",
3738 Pte.u,
3739 Pte.u & X86_PTE_PAE_PG_MASK,
3740 Pte.n.u1Present ? "p " : "np",
3741 Pte.n.u1Write ? "w" : "r",
3742 Pte.n.u1User ? "u" : "s",
3743 Pte.n.u1Accessed ? "a " : "na",
3744 Pte.n.u1Dirty ? "d " : "nd",
3745 Pte.n.u3Available,
3746 Pte.n.u1Global ? (fPGE ? "g" : "G") : " ",
3747 Pte.n.u1WriteThru ? "pwt" : " ",
3748 Pte.n.u1CacheDisable ? "pcd" : " ",
3749 Pte.n.u1PAT ? "pat" : " ",
3750 Pte.n.u1NoExecute ? (fNXE ? "nx" : "NX") : " "
3751 );
3752 if (Pte.u & UINT64_C(0x7fff000000000000))
3753 DBGCCmdHlpPrintf(pCmdHlp, " weird=%RX64", (Pte.u & UINT64_C(0x7fff000000000000)));
3754 rc = DBGCCmdHlpPrintf(pCmdHlp, "\n");
3755 if (VBOX_FAILURE(rc))
3756 return rc;
3757
3758 /*
3759 * Advance.
3760 */
3761 VarPTEAddr.u.u64Number += cbEntry;
3762 if (iEntry != ~0U)
3763 VarGCPtr.u.GCFlat += PAGE_SIZE;
3764 } while (cEntries-- > 0);
3765
3766 NOREF(pResult);
3767 return VINF_SUCCESS;
3768}
3769
3770
3771/**
3772 * The 'dptb' command.
3773 *
3774 * @returns VBox status.
3775 * @param pCmd Pointer to the command descriptor (as registered).
3776 * @param pCmdHlp Pointer to command helper functions.
3777 * @param pVM Pointer to the current VM (if any).
3778 * @param paArgs Pointer to (readonly) array of arguments.
3779 * @param cArgs Number of arguments in the array.
3780 */
3781static DECLCALLBACK(int) dbgcCmdDumpPageTableBoth(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3782{
3783 if (!pVM)
3784 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3785 int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dptg %DV", &paArgs[0]);
3786 int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpth %DV", &paArgs[0]);
3787 if (VBOX_FAILURE(rc1))
3788 return rc1;
3789 NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
3790 return rc2;
3791}
3792
3793
3794/**
3795 * The 'dt' command.
3796 *
3797 * @returns VBox status.
3798 * @param pCmd Pointer to the command descriptor (as registered).
3799 * @param pCmdHlp Pointer to command helper functions.
3800 * @param pVM Pointer to the current VM (if any).
3801 * @param paArgs Pointer to (readonly) array of arguments.
3802 * @param cArgs Number of arguments in the array.
3803 */
3804static DECLCALLBACK(int) dbgcCmdDumpTSS(PCDBGCCMD /*pCmd*/, PDBGCCMDHLP pCmdHlp, PVM /*pVM*/, PCDBGCVAR /*paArgs*/, unsigned /*cArgs*/, PDBGCVAR /*pResult*/)
3805{
3806 /*
3807 * We can get a TSS selector (number), a far pointer using a TSS selector, or some kind of TSS pointer.
3808 */
3809
3810 /** @todo */
3811 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "dt is not implemented yet, feel free to do it. \n");
3812}
3813
3814
3815/**
3816 * The 'm' command.
3817 *
3818 * @returns VBox status.
3819 * @param pCmd Pointer to the command descriptor (as registered).
3820 * @param pCmdHlp Pointer to command helper functions.
3821 * @param pVM Pointer to the current VM (if any).
3822 * @param paArgs Pointer to (readonly) array of arguments.
3823 * @param cArgs Number of arguments in the array.
3824 */
3825static DECLCALLBACK(int) dbgcCmdMemoryInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3826{
3827 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Address: %DV\n", &paArgs[0]);
3828 if (!pVM)
3829 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
3830 int rc1 = pCmdHlp->pfnExec(pCmdHlp, "dpdg %DV", &paArgs[0]);
3831 int rc2 = pCmdHlp->pfnExec(pCmdHlp, "dpdh %DV", &paArgs[0]);
3832 int rc3 = pCmdHlp->pfnExec(pCmdHlp, "dptg %DV", &paArgs[0]);
3833 int rc4 = pCmdHlp->pfnExec(pCmdHlp, "dpth %DV", &paArgs[0]);
3834 if (VBOX_FAILURE(rc1))
3835 return rc1;
3836 if (VBOX_FAILURE(rc2))
3837 return rc2;
3838 if (VBOX_FAILURE(rc3))
3839 return rc3;
3840 NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
3841 return rc4;
3842}
3843
3844
3845/**
3846 * The 'echo' command.
3847 *
3848 * @returns VBox status.
3849 * @param pCmd Pointer to the command descriptor (as registered).
3850 * @param pCmdHlp Pointer to command helper functions.
3851 * @param pVM Pointer to the current VM (if any).
3852 * @param paArgs Pointer to (readonly) array of arguments.
3853 * @param cArgs Number of arguments in the array.
3854 */
3855static DECLCALLBACK(int) dbgcCmdEcho(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3856{
3857 /*
3858 * Loop thru the arguments and print them with one space between.
3859 */
3860 int rc = 0;
3861 for (unsigned i = 0; i < cArgs; i++)
3862 {
3863 if (paArgs[i].enmType == DBGCVAR_TYPE_STRING)
3864 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " %s" : "%s", paArgs[i].u.pszString);
3865 else
3866 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, i ? " <parser error>" : "<parser error>");
3867 if (VBOX_FAILURE(rc))
3868 return rc;
3869 }
3870 NOREF(pCmd); NOREF(pResult); NOREF(pVM);
3871 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
3872}
3873
3874
3875/**
3876 * The 'runscript' command.
3877 *
3878 * @returns VBox status.
3879 * @param pCmd Pointer to the command descriptor (as registered).
3880 * @param pCmdHlp Pointer to command helper functions.
3881 * @param pVM Pointer to the current VM (if any).
3882 * @param paArgs Pointer to (readonly) array of arguments.
3883 * @param cArgs Number of arguments in the array.
3884 */
3885static DECLCALLBACK(int) dbgcCmdRunScript(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3886{
3887 /* check that the parser did what it's supposed to do. */
3888 if ( cArgs != 1
3889 || paArgs[0].enmType != DBGCVAR_TYPE_STRING)
3890 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "parser error\n");
3891
3892 /*
3893 * Try open the script.
3894 */
3895 const char *pszFilename = paArgs[0].u.pszString;
3896 FILE *pFile = fopen(pszFilename, "r");
3897 if (!pFile)
3898 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to open '%s'.\n", pszFilename);
3899
3900 /*
3901 * Execute it line by line.
3902 */
3903 int rc = 0;
3904 unsigned iLine = 0;
3905 char szLine[8192];
3906 while (fgets(szLine, sizeof(szLine), pFile))
3907 {
3908 /* check that the line isn't too long. */
3909 char *pszEnd = strchr(szLine, '\0');
3910 if (pszEnd == &szLine[sizeof(szLine) - 1])
3911 {
3912 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "runscript error: Line #%u is too long\n", iLine);
3913 break;
3914 }
3915 iLine++;
3916
3917 /* strip leading blanks and check for comment / blank line. */
3918 char *psz = RTStrStripL(szLine);
3919 if ( *psz == '\0'
3920 || *psz == '\n'
3921 || *psz == '#')
3922 continue;
3923
3924 /* strip trailing blanks and check for empty line (\r case). */
3925 while ( pszEnd > psz
3926 && isspace(pszEnd[-1])) /* isspace includes \n and \r normally. */
3927 *--pszEnd = '\0';
3928
3929 /** @todo check for Control-C / Cancel at this point... */
3930
3931 /*
3932 * Execute the command.
3933 *
3934 * This is a bit wasteful with scratch space btw., can fix it later.
3935 * The whole return code crap should be fixed too, so that it's possible
3936 * to know whether a command succeeded (VBOX_SUCCESS()) or failed, and
3937 * more importantly why it failed.
3938 */
3939 rc = pCmdHlp->pfnExec(pCmdHlp, "%s", psz);
3940 if (VBOX_FAILURE(rc))
3941 {
3942 if (rc == VERR_BUFFER_OVERFLOW)
3943 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "runscript error: Line #%u is too long (exec overflowed)\n", iLine);
3944 break;
3945 }
3946 if (rc == VWRN_DBGC_CMD_PENDING)
3947 {
3948 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "runscript error: VWRN_DBGC_CMD_PENDING on line #%u, script terminated\n", iLine);
3949 break;
3950 }
3951 }
3952
3953 fclose(pFile);
3954
3955 NOREF(pCmd); NOREF(pResult); NOREF(pVM);
3956 return rc;
3957}
3958
3959
3960/**
3961 * The 's' command.
3962 *
3963 * @returns VBox status.
3964 * @param pCmd Pointer to the command descriptor (as registered).
3965 * @param pCmdHlp Pointer to command helper functions.
3966 * @param pVM Pointer to the current VM (if any).
3967 * @param paArgs Pointer to (readonly) array of arguments.
3968 * @param cArgs Number of arguments in the array.
3969 */
3970static DECLCALLBACK(int) dbgcCmdSearchMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
3971{
3972 /* check that the parser did what it's supposed to do. */
3973 if ( cArgs != 1
3974 || paArgs[0].enmType != DBGCVAR_TYPE_STRING)
3975 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "parser error\n");
3976 return -1;
3977}
3978
3979
3980
3981/**
3982 * Print formatted string.
3983 *
3984 * @param pHlp Pointer to this structure.
3985 * @param pszFormat The format string.
3986 * @param ... Arguments.
3987 */
3988static DECLCALLBACK(void) dbgcCmdInfo_Printf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
3989{
3990 PDBGCCMDHLP pCmdHlp = *(PDBGCCMDHLP *)(pHlp + 1);
3991 va_list args;
3992 va_start(args, pszFormat);
3993 pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
3994 va_end(args);
3995}
3996
3997
3998/**
3999 * Print formatted string.
4000 *
4001 * @param pHlp Pointer to this structure.
4002 * @param pszFormat The format string.
4003 * @param args Argument list.
4004 */
4005static DECLCALLBACK(void) dbgcCmdInfo_PrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
4006{
4007 PDBGCCMDHLP pCmdHlp = *(PDBGCCMDHLP *)(pHlp + 1);
4008 pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
4009}
4010
4011
4012/**
4013 * The 'info' command.
4014 *
4015 * @returns VBox status.
4016 * @param pCmd Pointer to the command descriptor (as registered).
4017 * @param pCmdHlp Pointer to command helper functions.
4018 * @param pVM Pointer to the current VM (if any).
4019 * @param paArgs Pointer to (readonly) array of arguments.
4020 * @param cArgs Number of arguments in the array.
4021 */
4022static DECLCALLBACK(int) dbgcCmdInfo(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4023{
4024 /*
4025 * Validate input.
4026 */
4027 if ( cArgs < 1
4028 || cArgs > 2
4029 || paArgs[0].enmType != DBGCVAR_TYPE_STRING
4030 || paArgs[cArgs - 1].enmType != DBGCVAR_TYPE_STRING)
4031 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "internal error: The parser doesn't do its job properly yet.. quote the string.\n");
4032 if (!pVM)
4033 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: No VM.\n");
4034
4035 /*
4036 * Dump it.
4037 */
4038 struct
4039 {
4040 DBGFINFOHLP Hlp;
4041 PDBGCCMDHLP pCmdHlp;
4042 } Hlp = { { dbgcCmdInfo_Printf, dbgcCmdInfo_PrintfV }, pCmdHlp };
4043 int rc = DBGFR3Info(pVM, paArgs[0].u.pszString, cArgs == 2 ? paArgs[1].u.pszString : NULL, &Hlp.Hlp);
4044 if (VBOX_FAILURE(rc))
4045 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3Info()\n");
4046
4047 NOREF(pCmd); NOREF(pResult);
4048 return 0;
4049}
4050
4051
4052/**
4053 * The 'log' command.
4054 *
4055 * @returns VBox status.
4056 * @param pCmd Pointer to the command descriptor (as registered).
4057 * @param pCmdHlp Pointer to command helper functions.
4058 * @param pVM Pointer to the current VM (if any).
4059 * @param paArgs Pointer to (readonly) array of arguments.
4060 * @param cArgs Number of arguments in the array.
4061 */
4062static DECLCALLBACK(int) dbgcCmdLog(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4063{
4064 int rc = DBGFR3LogModifyGroups(pVM, paArgs[0].u.pszString);
4065 if (VBOX_SUCCESS(rc))
4066 return VINF_SUCCESS;
4067 NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
4068 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3LogModifyGroups(%p,'%s')\n", pVM, paArgs[0].u.pszString);
4069}
4070
4071
4072/**
4073 * The 'logdest' command.
4074 *
4075 * @returns VBox status.
4076 * @param pCmd Pointer to the command descriptor (as registered).
4077 * @param pCmdHlp Pointer to command helper functions.
4078 * @param pVM Pointer to the current VM (if any).
4079 * @param paArgs Pointer to (readonly) array of arguments.
4080 * @param cArgs Number of arguments in the array.
4081 */
4082static DECLCALLBACK(int) dbgcCmdLogDest(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4083{
4084 int rc = DBGFR3LogModifyDestinations(pVM, paArgs[0].u.pszString);
4085 if (VBOX_SUCCESS(rc))
4086 return VINF_SUCCESS;
4087 NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
4088 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3LogModifyDestinations(%p,'%s')\n", pVM, paArgs[0].u.pszString);
4089}
4090
4091
4092/**
4093 * The 'logflags' command.
4094 *
4095 * @returns VBox status.
4096 * @param pCmd Pointer to the command descriptor (as registered).
4097 * @param pCmdHlp Pointer to command helper functions.
4098 * @param pVM Pointer to the current VM (if any).
4099 * @param paArgs Pointer to (readonly) array of arguments.
4100 * @param cArgs Number of arguments in the array.
4101 */
4102static DECLCALLBACK(int) dbgcCmdLogFlags(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4103{
4104 int rc = DBGFR3LogModifyFlags(pVM, paArgs[0].u.pszString);
4105 if (VBOX_SUCCESS(rc))
4106 return VINF_SUCCESS;
4107 NOREF(pCmd); NOREF(cArgs); NOREF(pResult);
4108 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3LogModifyFlags(%p,'%s')\n", pVM, paArgs[0].u.pszString);
4109}
4110
4111
4112/**
4113 * The 'format' command.
4114 *
4115 * @returns VBox status.
4116 * @param pCmd Pointer to the command descriptor (as registered).
4117 * @param pCmdHlp Pointer to command helper functions.
4118 * @param pVM Pointer to the current VM (if any).
4119 * @param paArgs Pointer to (readonly) array of arguments.
4120 * @param cArgs Number of arguments in the array.
4121 */
4122static DECLCALLBACK(int) dbgcCmdFormat(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4123{
4124 LogFlow(("dbgcCmdFormat\n"));
4125 static const char *apszRangeDesc[] =
4126 {
4127 "none", "bytes", "elements"
4128 };
4129 int rc;
4130
4131 for (unsigned iArg = 0; iArg < cArgs; iArg++)
4132 {
4133 switch (paArgs[iArg].enmType)
4134 {
4135 case DBGCVAR_TYPE_UNKNOWN:
4136 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4137 "Unknown variable type!\n");
4138 break;
4139 case DBGCVAR_TYPE_GC_FLAT:
4140 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4141 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4142 "Guest flat address: %%%08x range %lld %s\n",
4143 paArgs[iArg].u.GCFlat,
4144 paArgs[iArg].u64Range,
4145 apszRangeDesc[paArgs[iArg].enmRangeType]);
4146 else
4147 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4148 "Guest flat address: %%%08x\n",
4149 paArgs[iArg].u.GCFlat);
4150 break;
4151 case DBGCVAR_TYPE_GC_FAR:
4152 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4153 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4154 "Guest far address: %04x:%08x range %lld %s\n",
4155 paArgs[iArg].u.GCFar.sel,
4156 paArgs[iArg].u.GCFar.off,
4157 paArgs[iArg].u64Range,
4158 apszRangeDesc[paArgs[iArg].enmRangeType]);
4159 else
4160 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4161 "Guest far address: %04x:%08x\n",
4162 paArgs[iArg].u.GCFar.sel,
4163 paArgs[iArg].u.GCFar.off);
4164 break;
4165 case DBGCVAR_TYPE_GC_PHYS:
4166 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4167 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4168 "Guest physical address: %%%%%08x range %lld %s\n",
4169 paArgs[iArg].u.GCPhys,
4170 paArgs[iArg].u64Range,
4171 apszRangeDesc[paArgs[iArg].enmRangeType]);
4172 else
4173 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4174 "Guest physical address: %%%%%08x\n",
4175 paArgs[iArg].u.GCPhys);
4176 break;
4177 case DBGCVAR_TYPE_HC_FLAT:
4178 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4179 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4180 "Host flat address: %%%08x range %lld %s\n",
4181 paArgs[iArg].u.pvHCFlat,
4182 paArgs[iArg].u64Range,
4183 apszRangeDesc[paArgs[iArg].enmRangeType]);
4184 else
4185 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4186 "Host flat address: %%%08x\n",
4187 paArgs[iArg].u.pvHCFlat);
4188 break;
4189 case DBGCVAR_TYPE_HC_FAR:
4190 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4191 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4192 "Host far address: %04x:%08x range %lld %s\n",
4193 paArgs[iArg].u.HCFar.sel,
4194 paArgs[iArg].u.HCFar.off,
4195 paArgs[iArg].u64Range,
4196 apszRangeDesc[paArgs[iArg].enmRangeType]);
4197 else
4198 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4199 "Host far address: %04x:%08x\n",
4200 paArgs[iArg].u.HCFar.sel,
4201 paArgs[iArg].u.HCFar.off);
4202 break;
4203 case DBGCVAR_TYPE_HC_PHYS:
4204 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4205 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4206 "Host physical address: %VHp range %lld %s\n",
4207 paArgs[iArg].u.HCPhys,
4208 paArgs[iArg].u64Range,
4209 apszRangeDesc[paArgs[iArg].enmRangeType]);
4210 else
4211 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4212 "Host physical address: %VHp\n",
4213 paArgs[iArg].u.HCPhys);
4214 break;
4215
4216 case DBGCVAR_TYPE_STRING:
4217 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4218 "String, %lld bytes long: %s\n",
4219 paArgs[iArg].u64Range,
4220 paArgs[iArg].u.pszString);
4221 break;
4222
4223 case DBGCVAR_TYPE_NUMBER:
4224 if (paArgs[iArg].enmRangeType != DBGCVAR_RANGE_NONE)
4225 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4226 "Number: hex %llx dec 0i%lld oct 0t%llo range %lld %s\n",
4227 paArgs[iArg].u.u64Number,
4228 paArgs[iArg].u.u64Number,
4229 paArgs[iArg].u.u64Number,
4230 paArgs[iArg].u64Range,
4231 apszRangeDesc[paArgs[iArg].enmRangeType]);
4232 else
4233 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4234 "Number: hex %llx dec 0i%lld oct 0t%llo\n",
4235 paArgs[iArg].u.u64Number,
4236 paArgs[iArg].u.u64Number,
4237 paArgs[iArg].u.u64Number);
4238 break;
4239
4240 default:
4241 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4242 "Invalid argument type %d\n",
4243 paArgs[iArg].enmType);
4244 break;
4245 }
4246 } /* arg loop */
4247
4248 NOREF(pCmd); NOREF(pVM); NOREF(pResult);
4249 return 0;
4250}
4251
4252
4253/**
4254 * List near symbol.
4255 *
4256 * @returns VBox status code.
4257 * @param pCmdHlp Pointer to command helper functions.
4258 * @param pVM Pointer to the current VM (if any).
4259 * @param pArg Pointer to the address or symbol to lookup.
4260 */
4261static int dbgcDoListNear(PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR pArg, PDBGCVAR pResult)
4262{
4263 dbgcVarSetGCFlat(pResult, 0);
4264
4265 DBGFSYMBOL Symbol;
4266 int rc;
4267 if (pArg->enmType == DBGCVAR_TYPE_SYMBOL)
4268 {
4269 /*
4270 * Lookup the symbol address.
4271 */
4272 rc = DBGFR3SymbolByName(pVM, pArg->u.pszString, &Symbol);
4273 if (VBOX_FAILURE(rc))
4274 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3SymbolByName(, %s,)\n", pArg->u.pszString);
4275
4276 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%VGv %s\n", (RTGCUINTPTR)Symbol.Value, Symbol.szName); /** @todo remove the RTUINGCPTR cast once DBGF got correct interfaces! */
4277 dbgcVarSetGCFlatByteRange(pResult, Symbol.Value, Symbol.cb);
4278 }
4279 else
4280 {
4281 /*
4282 * Convert it to a flat GC address and lookup that address.
4283 */
4284 DBGCVAR AddrVar;
4285 rc = pCmdHlp->pfnEval(pCmdHlp, &AddrVar, "%%(%DV)", pArg);
4286 if (VBOX_FAILURE(rc))
4287 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%%(%DV)\n", pArg);
4288
4289 dbgcVarSetVar(pResult, &AddrVar);
4290
4291 RTGCINTPTR offDisp = 0;
4292 rc = DBGFR3SymbolByAddr(pVM, AddrVar.u.GCFlat, &offDisp, &Symbol);
4293 if (VBOX_FAILURE(rc))
4294 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3SymbolByAddr(, %VGv,,)\n", AddrVar.u.GCFlat);
4295
4296 if (!offDisp)
4297 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV %s", &AddrVar, Symbol.szName);
4298 else if (offDisp > 0)
4299 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV %s + %RGv", &AddrVar, Symbol.szName, offDisp);
4300 else
4301 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%DV %s - %RGv", &AddrVar, Symbol.szName, -offDisp);
4302 if ((RTGCINTPTR)Symbol.cb > -offDisp)
4303 {
4304 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " LB %RGv\n", Symbol.cb + offDisp);
4305 dbgcVarSetByteRange(pResult, Symbol.cb + offDisp);
4306 }
4307 else
4308 {
4309 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
4310 dbgcVarSetNoRange(pResult);
4311 }
4312 }
4313
4314 return rc;
4315}
4316
4317
4318/**
4319 * The 'ln' (listnear) command.
4320 *
4321 * @returns VBox status.
4322 * @param pCmd Pointer to the command descriptor (as registered).
4323 * @param pCmdHlp Pointer to command helper functions.
4324 * @param pVM Pointer to the current VM (if any).
4325 * @param paArgs Pointer to (readonly) array of arguments.
4326 * @param cArgs Number of arguments in the array.
4327 */
4328static DECLCALLBACK(int) dbgcCmdListNear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4329{
4330 dbgcVarSetGCFlat(pResult, 0);
4331 if (!cArgs)
4332 {
4333 /*
4334 * Current cs:eip symbol.
4335 */
4336 DBGCVAR AddrVar;
4337 int rc = pCmdHlp->pfnEval(pCmdHlp, &AddrVar, "%%(cs:eip)");
4338 if (VBOX_FAILURE(rc))
4339 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%%(cs:eip)\n");
4340 return dbgcDoListNear(pCmdHlp, pVM, &AddrVar, pResult);
4341 }
4342
4343 /*
4344 * Iterate arguments.
4345 */
4346 for (unsigned iArg = 0; iArg < cArgs; iArg++)
4347 {
4348 int rc = dbgcDoListNear(pCmdHlp, pVM, &paArgs[iArg], pResult);
4349 if (VBOX_FAILURE(rc))
4350 return rc;
4351 }
4352
4353 NOREF(pCmd); NOREF(pResult);
4354 return VINF_SUCCESS;
4355}
4356
4357
4358/**
4359 * The 'loadsyms' command.
4360 *
4361 * @returns VBox status.
4362 * @param pCmd Pointer to the command descriptor (as registered).
4363 * @param pCmdHlp Pointer to command helper functions.
4364 * @param pVM Pointer to the current VM (if any).
4365 * @param paArgs Pointer to (readonly) array of arguments.
4366 * @param cArgs Number of arguments in the array.
4367 */
4368static DECLCALLBACK(int) dbgcCmdLoadSyms(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4369{
4370 /*
4371 * Validate the parsing and make sense of the input.
4372 * This is a mess as usual because we don't trust the parser yet.
4373 */
4374 if ( cArgs < 1
4375 || paArgs[0].enmType != DBGCVAR_TYPE_STRING)
4376 {
4377 AssertMsgFailed(("Parse error, first argument required to be string!\n"));
4378 return VERR_PARSE_INCORRECT_ARG_TYPE;
4379 }
4380 DBGCVAR AddrVar;
4381 RTGCUINTPTR Delta = 0;
4382 const char *pszModule = NULL;
4383 RTGCUINTPTR ModuleAddress = 0;
4384 unsigned cbModule = 0;
4385 if (cArgs > 1)
4386 {
4387 unsigned iArg = 1;
4388 if (paArgs[iArg].enmType == DBGCVAR_TYPE_NUMBER)
4389 {
4390 Delta = (RTGCUINTPTR)paArgs[iArg].u.u64Number;
4391 iArg++;
4392 }
4393 if (iArg < cArgs)
4394 {
4395 if (paArgs[iArg].enmType != DBGCVAR_TYPE_STRING)
4396 {
4397 AssertMsgFailed(("Parse error, module argument required to be string!\n"));
4398 return VERR_PARSE_INCORRECT_ARG_TYPE;
4399 }
4400 pszModule = paArgs[iArg].u.pszString;
4401 iArg++;
4402 if (iArg < cArgs)
4403 {
4404 if (DBGCVAR_ISPOINTER(paArgs[iArg].enmType))
4405 {
4406 AssertMsgFailed(("Parse error, module argument required to be GC pointer!\n"));
4407 return VERR_PARSE_INCORRECT_ARG_TYPE;
4408 }
4409 int rc = pCmdHlp->pfnEval(pCmdHlp, &AddrVar, "%%(%Dv)", &paArgs[iArg]);
4410 if (VBOX_FAILURE(rc))
4411 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Module address cast %%(%Dv) failed.", &paArgs[iArg]);
4412 ModuleAddress = paArgs[iArg].u.GCFlat;
4413 iArg++;
4414 if (iArg < cArgs)
4415 {
4416 if (paArgs[iArg].enmType != DBGCVAR_TYPE_NUMBER)
4417 {
4418 AssertMsgFailed(("Parse error, module argument required to be an interger!\n"));
4419 return VERR_PARSE_INCORRECT_ARG_TYPE;
4420 }
4421 cbModule = (unsigned)paArgs[iArg].u.u64Number;
4422 iArg++;
4423 if (iArg < cArgs)
4424 {
4425 AssertMsgFailed(("Parse error, too many arguments!\n"));
4426 return VERR_PARSE_TOO_MANY_ARGUMENTS;
4427 }
4428 }
4429 }
4430 }
4431 }
4432
4433 /*
4434 * Call the debug info manager about this loading...
4435 */
4436 int rc = DBGFR3ModuleLoad(pVM, paArgs[0].u.pszString, Delta, pszModule, ModuleAddress, cbModule);
4437 if (VBOX_FAILURE(rc))
4438 return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGInfoSymbolLoad(, '%s', %VGv, '%s', %VGv, 0)\n",
4439 paArgs[0].u.pszString, Delta, pszModule, ModuleAddress);
4440
4441 NOREF(pCmd); NOREF(pResult);
4442 return VINF_SUCCESS;
4443}
4444
4445
4446/**
4447 * The 'set' command.
4448 *
4449 * @returns VBox status.
4450 * @param pCmd Pointer to the command descriptor (as registered).
4451 * @param pCmdHlp Pointer to command helper functions.
4452 * @param pVM Pointer to the current VM (if any).
4453 * @param paArgs Pointer to (readonly) array of arguments.
4454 * @param cArgs Number of arguments in the array.
4455 */
4456static DECLCALLBACK(int) dbgcCmdSet(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4457{
4458 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4459
4460 /* parse sanity check. */
4461 AssertMsg(paArgs[0].enmType == DBGCVAR_TYPE_STRING, ("expected string not %d as first arg!\n", paArgs[0].enmType));
4462 if (paArgs[0].enmType != DBGCVAR_TYPE_STRING)
4463 return VERR_PARSE_INCORRECT_ARG_TYPE;
4464
4465
4466 /*
4467 * A variable must start with an alpha chars and only contain alpha numerical chars.
4468 */
4469 const char *pszVar = paArgs[0].u.pszString;
4470 if (!isalpha(*pszVar) || *pszVar == '_')
4471 return pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4472 "syntax error: Invalid variable name '%s'. Variable names must match regex '[_a-zA-Z][_a-zA-Z0-9*'!", paArgs[0].u.pszString);
4473
4474 while (isalnum(*pszVar) || *pszVar == '_')
4475 *pszVar++;
4476 if (*pszVar)
4477 return pCmdHlp->pfnPrintf(pCmdHlp, NULL,
4478 "syntax error: Invalid variable name '%s'. Variable names must match regex '[_a-zA-Z][_a-zA-Z0-9*]'!", paArgs[0].u.pszString);
4479
4480
4481 /*
4482 * Calc variable size.
4483 */
4484 size_t cbVar = (size_t)paArgs[0].u64Range + sizeof(DBGCNAMEDVAR);
4485 if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
4486 cbVar += 1 + (size_t)paArgs[1].u64Range;
4487
4488 /*
4489 * Look for existing one.
4490 */
4491 pszVar = paArgs[0].u.pszString;
4492 for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
4493 {
4494 if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
4495 {
4496 /*
4497 * Update existing variable.
4498 */
4499 void *pv = RTMemRealloc(pDbgc->papVars[iVar], cbVar);
4500 if (!pv)
4501 return VERR_PARSE_NO_MEMORY;
4502 PDBGCNAMEDVAR pVar = pDbgc->papVars[iVar] = (PDBGCNAMEDVAR)pv;
4503
4504 pVar->Var = paArgs[1];
4505 memcpy(pVar->szName, paArgs[0].u.pszString, (size_t)paArgs[0].u64Range + 1);
4506 if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
4507 pVar->Var.u.pszString = (char *)memcpy(&pVar->szName[paArgs[0].u64Range + 1], paArgs[1].u.pszString, (size_t)paArgs[1].u64Range + 1);
4508 return 0;
4509 }
4510 }
4511
4512 /*
4513 * Allocate another.
4514 */
4515 PDBGCNAMEDVAR pVar = (PDBGCNAMEDVAR)RTMemAlloc(cbVar);
4516
4517 pVar->Var = paArgs[1];
4518 memcpy(pVar->szName, pszVar, (size_t)paArgs[0].u64Range + 1);
4519 if (paArgs[1].enmType == DBGCVAR_TYPE_STRING)
4520 pVar->Var.u.pszString = (char *)memcpy(&pVar->szName[paArgs[0].u64Range + 1], paArgs[1].u.pszString, (size_t)paArgs[1].u64Range + 1);
4521
4522 /* need to reallocate the pointer array too? */
4523 if (!(pDbgc->cVars % 0x20))
4524 {
4525 void *pv = RTMemRealloc(pDbgc->papVars, (pDbgc->cVars + 0x20) * sizeof(pDbgc->papVars[0]));
4526 if (!pv)
4527 {
4528 RTMemFree(pVar);
4529 return VERR_PARSE_NO_MEMORY;
4530 }
4531 pDbgc->papVars = (PDBGCNAMEDVAR *)pv;
4532 }
4533 pDbgc->papVars[pDbgc->cVars++] = pVar;
4534
4535 NOREF(pCmd); NOREF(pVM); NOREF(cArgs); NOREF(pResult);
4536 return 0;
4537}
4538
4539
4540/**
4541 * The 'unset' command.
4542 *
4543 * @returns VBox status.
4544 * @param pCmd Pointer to the command descriptor (as registered).
4545 * @param pCmdHlp Pointer to command helper functions.
4546 * @param pVM Pointer to the current VM (if any).
4547 * @param paArgs Pointer to (readonly) array of arguments.
4548 * @param cArgs Number of arguments in the array.
4549 */
4550static DECLCALLBACK(int) dbgcCmdUnset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4551{
4552 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4553
4554 /*
4555 * Don't trust the parser.
4556 */
4557 for (unsigned i = 0; i < cArgs; i++)
4558 if (paArgs[i].enmType != DBGCVAR_TYPE_STRING)
4559 {
4560 AssertMsgFailed(("expected strings only. (arg=%d)!\n", i));
4561 return VERR_PARSE_INCORRECT_ARG_TYPE;
4562 }
4563
4564 /*
4565 * Iterate the variables and unset them.
4566 */
4567 for (unsigned iArg = 0; iArg < cArgs; iArg++)
4568 {
4569 const char *pszVar = paArgs[iArg].u.pszString;
4570
4571 /*
4572 * Look up the variable.
4573 */
4574 for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
4575 {
4576 if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
4577 {
4578 /*
4579 * Shuffle the array removing this entry.
4580 */
4581 void *pvFree = pDbgc->papVars[iVar];
4582 if (iVar + 1 < pDbgc->cVars)
4583 memmove(&pDbgc->papVars[iVar],
4584 &pDbgc->papVars[iVar + 1],
4585 (pDbgc->cVars - iVar - 1) * sizeof(pDbgc->papVars[0]));
4586 pDbgc->papVars[--pDbgc->cVars] = NULL;
4587
4588 RTMemFree(pvFree);
4589 }
4590 } /* lookup */
4591 } /* arg loop */
4592
4593 NOREF(pCmd); NOREF(pVM); NOREF(pResult);
4594 return 0;
4595}
4596
4597
4598/**
4599 * The 'loadvars' command.
4600 *
4601 * @returns VBox status.
4602 * @param pCmd Pointer to the command descriptor (as registered).
4603 * @param pCmdHlp Pointer to command helper functions.
4604 * @param pVM Pointer to the current VM (if any).
4605 * @param paArgs Pointer to (readonly) array of arguments.
4606 * @param cArgs Number of arguments in the array.
4607 */
4608static DECLCALLBACK(int) dbgcCmdLoadVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4609{
4610 /*
4611 * Don't trust the parser.
4612 */
4613 if ( cArgs != 1
4614 || paArgs[0].enmType != DBGCVAR_TYPE_STRING)
4615 {
4616 AssertMsgFailed(("Expected one string exactly!\n"));
4617 return VERR_PARSE_INCORRECT_ARG_TYPE;
4618 }
4619
4620 /*
4621 * Iterate the variables and unset them.
4622 */
4623 FILE *pFile = fopen(paArgs[0].u.pszString, "r");
4624 if (pFile)
4625 {
4626 char szLine[4096];
4627 while (fgets(szLine, sizeof(szLine), pFile))
4628 {
4629 /* Strip it. */
4630 char *psz = szLine;
4631 while (isblank(*psz))
4632 psz++;
4633 int i = (int)strlen(psz) - 1;
4634 while (i >= 0 && isspace(psz[i]))
4635 psz[i--] ='\0';
4636 /* Execute it if not comment or empty line. */
4637 if ( *psz != '\0'
4638 && *psz != '#'
4639 && *psz != ';')
4640 {
4641 pCmdHlp->pfnPrintf(pCmdHlp, NULL, "dbg: set %s", psz);
4642 pCmdHlp->pfnExec(pCmdHlp, "set %s", psz);
4643 }
4644 }
4645 fclose(pFile);
4646 }
4647 else
4648 return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Failed to open file '%s'.\n", paArgs[0].u.pszString);
4649
4650 NOREF(pCmd); NOREF(pVM); NOREF(pResult);
4651 return 0;
4652}
4653
4654
4655/**
4656 * The 'showvars' command.
4657 *
4658 * @returns VBox status.
4659 * @param pCmd Pointer to the command descriptor (as registered).
4660 * @param pCmdHlp Pointer to command helper functions.
4661 * @param pVM Pointer to the current VM (if any).
4662 * @param paArgs Pointer to (readonly) array of arguments.
4663 * @param cArgs Number of arguments in the array.
4664 */
4665static DECLCALLBACK(int) dbgcCmdShowVars(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4666{
4667 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4668
4669 for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
4670 {
4671 int rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%-20s ", &pDbgc->papVars[iVar]->szName);
4672 if (!rc)
4673 rc = dbgcCmdFormat(pCmd, pCmdHlp, pVM, &pDbgc->papVars[iVar]->Var, 1, NULL);
4674 if (rc)
4675 return rc;
4676 }
4677
4678 NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
4679 return 0;
4680}
4681
4682
4683/**
4684 * The 'harakiri' command.
4685 *
4686 * @returns VBox status.
4687 * @param pCmd Pointer to the command descriptor (as registered).
4688 * @param pCmdHlp Pointer to command helper functions.
4689 * @param pVM Pointer to the current VM (if any).
4690 * @param paArgs Pointer to (readonly) array of arguments.
4691 * @param cArgs Number of arguments in the array.
4692 */
4693static DECLCALLBACK(int) dbgcCmdHarakiri(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
4694{
4695 Log(("dbgcCmdHarakiri\n"));
4696 for (;;)
4697 exit(126);
4698 NOREF(pCmd); NOREF(pCmdHlp); NOREF(pVM); NOREF(paArgs); NOREF(cArgs); NOREF(pResult);
4699}
4700
4701
4702
4703
4704
4705//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4706//
4707//
4708// B u l t i n S y m b o l s
4709//
4710//
4711//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4712
4713
4714
4715/**
4716 * Get builtin register symbol.
4717 *
4718 * The uUser is special for these symbol descriptors. See the SYMREG_* \#defines.
4719 *
4720 * @returns 0 on success.
4721 * @returns VBox evaluation / parsing error code on failure.
4722 * The caller does the bitching.
4723 * @param pSymDesc Pointer to the symbol descriptor.
4724 * @param pCmdHlp Pointer to the command callback structure.
4725 * @param enmType The result type.
4726 * @param pResult Where to store the result.
4727 */
4728static DECLCALLBACK(int) dbgcSymGetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, DBGCVARTYPE enmType, PDBGCVAR pResult)
4729{
4730 LogFlow(("dbgcSymSetReg: pSymDesc->pszName=%d\n", pSymDesc->pszName));
4731
4732 /*
4733 * pVM is required.
4734 */
4735 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4736 Assert(pDbgc->pVM);
4737
4738 /*
4739 * Get the right CPU context.
4740 */
4741 PCPUMCTX pCtx;
4742 int rc;
4743 if (!(pSymDesc->uUser & SYMREG_FLAGS_HYPER))
4744 rc = CPUMQueryGuestCtxPtr(pDbgc->pVM, &pCtx);
4745 else
4746 rc = CPUMQueryHyperCtxPtr(pDbgc->pVM, &pCtx);
4747 if (VBOX_FAILURE(rc))
4748 return rc;
4749
4750 /*
4751 * Get the value.
4752 */
4753 void *pvValue = (char *)pCtx + SYMREG_OFFSET(pSymDesc->uUser);
4754 uint64_t u64;
4755 switch (SYMREG_SIZE(pSymDesc->uUser))
4756 {
4757 case 1: u64 = *(uint8_t *)pvValue; break;
4758 case 2: u64 = *(uint16_t *)pvValue; break;
4759 case 4: u64 = *(uint32_t *)pvValue; break;
4760 case 6: u64 = *(uint32_t *)pvValue | ((uint64_t)*(uint16_t *)((char *)pvValue + sizeof(uint32_t)) << 32); break;
4761 case 8: u64 = *(uint64_t *)pvValue; break;
4762 default:
4763 return VERR_PARSE_NOT_IMPLEMENTED;
4764 }
4765
4766 /*
4767 * Construct the desired result.
4768 */
4769 if (enmType == DBGCVAR_TYPE_ANY)
4770 enmType = DBGCVAR_TYPE_NUMBER;
4771 pResult->pDesc = NULL;
4772 pResult->pNext = NULL;
4773 pResult->enmType = enmType;
4774 pResult->enmRangeType = DBGCVAR_RANGE_NONE;
4775 pResult->u64Range = 0;
4776
4777 switch (enmType)
4778 {
4779 case DBGCVAR_TYPE_GC_FLAT:
4780 pResult->u.GCFlat = (RTGCPTR)u64;
4781 break;
4782
4783 case DBGCVAR_TYPE_GC_FAR:
4784 switch (SYMREG_SIZE(pSymDesc->uUser))
4785 {
4786 case 4:
4787 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4788 {
4789 pResult->u.GCFar.off = (uint16_t)u64;
4790 pResult->u.GCFar.sel = (uint16_t)(u64 >> 16);
4791 }
4792 else
4793 {
4794 pResult->u.GCFar.sel = (uint16_t)u64;
4795 pResult->u.GCFar.off = (uint16_t)(u64 >> 16);
4796 }
4797 break;
4798 case 6:
4799 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4800 {
4801 pResult->u.GCFar.off = (uint32_t)u64;
4802 pResult->u.GCFar.sel = (uint16_t)(u64 >> 32);
4803 }
4804 else
4805 {
4806 pResult->u.GCFar.sel = (uint32_t)u64;
4807 pResult->u.GCFar.off = (uint16_t)(u64 >> 32);
4808 }
4809 break;
4810
4811 default:
4812 return VERR_PARSE_BAD_RESULT_TYPE;
4813 }
4814 break;
4815
4816 case DBGCVAR_TYPE_GC_PHYS:
4817 pResult->u.GCPhys = (RTGCPHYS)u64;
4818 break;
4819
4820 case DBGCVAR_TYPE_HC_FLAT:
4821 pResult->u.pvHCFlat = (void *)(uintptr_t)u64;
4822 break;
4823
4824 case DBGCVAR_TYPE_HC_FAR:
4825 switch (SYMREG_SIZE(pSymDesc->uUser))
4826 {
4827 case 4:
4828 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4829 {
4830 pResult->u.HCFar.off = (uint16_t)u64;
4831 pResult->u.HCFar.sel = (uint16_t)(u64 >> 16);
4832 }
4833 else
4834 {
4835 pResult->u.HCFar.sel = (uint16_t)u64;
4836 pResult->u.HCFar.off = (uint16_t)(u64 >> 16);
4837 }
4838 break;
4839 case 6:
4840 if (!(pSymDesc->uUser & SYMREG_FLAGS_HIGH_SEL))
4841 {
4842 pResult->u.HCFar.off = (uint32_t)u64;
4843 pResult->u.HCFar.sel = (uint16_t)(u64 >> 32);
4844 }
4845 else
4846 {
4847 pResult->u.HCFar.sel = (uint32_t)u64;
4848 pResult->u.HCFar.off = (uint16_t)(u64 >> 32);
4849 }
4850 break;
4851
4852 default:
4853 return VERR_PARSE_BAD_RESULT_TYPE;
4854 }
4855 break;
4856
4857 case DBGCVAR_TYPE_HC_PHYS:
4858 pResult->u.GCPhys = (RTGCPHYS)u64;
4859 break;
4860
4861 case DBGCVAR_TYPE_NUMBER:
4862 pResult->u.u64Number = u64;
4863 break;
4864
4865 case DBGCVAR_TYPE_STRING:
4866 case DBGCVAR_TYPE_UNKNOWN:
4867 default:
4868 return VERR_PARSE_BAD_RESULT_TYPE;
4869
4870 }
4871
4872 return 0;
4873}
4874
4875
4876/**
4877 * Set builtin register symbol.
4878 *
4879 * The uUser is special for these symbol descriptors. See the SYMREG_* #defines.
4880 *
4881 * @returns 0 on success.
4882 * @returns VBox evaluation / parsing error code on failure.
4883 * The caller does the bitching.
4884 * @param pSymDesc Pointer to the symbol descriptor.
4885 * @param pCmdHlp Pointer to the command callback structure.
4886 * @param pValue The value to assign the symbol.
4887 */
4888static DECLCALLBACK(int) dbgcSymSetReg(PCDBGCSYM pSymDesc, PDBGCCMDHLP pCmdHlp, PCDBGCVAR pValue)
4889{
4890 LogFlow(("dbgcSymSetReg: pSymDesc->pszName=%d\n", pSymDesc->pszName));
4891
4892 /*
4893 * pVM is required.
4894 */
4895 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
4896 Assert(pDbgc->pVM);
4897
4898 /*
4899 * Get the right CPU context.
4900 */
4901 PCPUMCTX pCtx;
4902 int rc;
4903 if (!(pSymDesc->uUser & SYMREG_FLAGS_HYPER))
4904 rc = CPUMQueryGuestCtxPtr(pDbgc->pVM, &pCtx);
4905 else
4906 rc = CPUMQueryHyperCtxPtr(pDbgc->pVM, &pCtx);
4907 if (VBOX_FAILURE(rc))
4908 return rc;
4909
4910 /*
4911 * Check the new value.
4912 */
4913 if (pValue->enmType != DBGCVAR_TYPE_NUMBER)
4914 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
4915
4916 /*
4917 * Set the value.
4918 */
4919 void *pvValue = (char *)pCtx + SYMREG_OFFSET(pSymDesc->uUser);
4920 switch (SYMREG_SIZE(pSymDesc->uUser))
4921 {
4922 case 1:
4923 *(uint8_t *)pvValue = (uint8_t)pValue->u.u64Number;
4924 break;
4925 case 2:
4926 *(uint16_t *)pvValue = (uint16_t)pValue->u.u64Number;
4927 break;
4928 case 4:
4929 *(uint32_t *)pvValue = (uint32_t)pValue->u.u64Number;
4930 break;
4931 case 6:
4932 *(uint32_t *)pvValue = (uint32_t)pValue->u.u64Number;
4933 ((uint16_t *)pvValue)[3] = (uint16_t)(pValue->u.u64Number >> 32);
4934 break;
4935 case 8:
4936 *(uint64_t *)pvValue = pValue->u.u64Number;
4937 break;
4938 default:
4939 return VERR_PARSE_NOT_IMPLEMENTED;
4940 }
4941
4942 return VINF_SUCCESS;
4943}
4944
4945
4946
4947
4948
4949
4950
4951//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4952//
4953//
4954// O p e r a t o r s
4955//
4956//
4957//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
4958
4959
4960/**
4961 * Minus (unary).
4962 *
4963 * @returns 0 on success.
4964 * @returns VBox evaluation / parsing error code on failure.
4965 * The caller does the bitching.
4966 * @param pDbgc Debugger console instance data.
4967 * @param pArg The argument.
4968 * @param pResult Where to store the result.
4969 */
4970static DECLCALLBACK(int) dbgcOpMinus(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
4971{
4972// LogFlow(("dbgcOpMinus\n"));
4973 *pResult = *pArg;
4974 switch (pArg->enmType)
4975 {
4976 case DBGCVAR_TYPE_GC_FLAT:
4977 pResult->u.GCFlat = -(RTGCINTPTR)pResult->u.GCFlat;
4978 break;
4979 case DBGCVAR_TYPE_GC_FAR:
4980 pResult->u.GCFar.off = -(int32_t)pResult->u.GCFar.off;
4981 break;
4982 case DBGCVAR_TYPE_GC_PHYS:
4983 pResult->u.GCPhys = (RTGCPHYS) -(int64_t)pResult->u.GCPhys;
4984 break;
4985 case DBGCVAR_TYPE_HC_FLAT:
4986 pResult->u.pvHCFlat = (void *) -(intptr_t)pResult->u.pvHCFlat;
4987 break;
4988 case DBGCVAR_TYPE_HC_FAR:
4989 pResult->u.HCFar.off = -(int32_t)pResult->u.HCFar.off;
4990 break;
4991 case DBGCVAR_TYPE_HC_PHYS:
4992 pResult->u.HCPhys = (RTHCPHYS) -(int64_t)pResult->u.HCPhys;
4993 break;
4994 case DBGCVAR_TYPE_NUMBER:
4995 pResult->u.u64Number = -(int64_t)pResult->u.u64Number;
4996 break;
4997
4998 case DBGCVAR_TYPE_UNKNOWN:
4999 case DBGCVAR_TYPE_STRING:
5000 default:
5001 return VERR_PARSE_INCORRECT_ARG_TYPE;
5002 }
5003 NOREF(pDbgc);
5004 return 0;
5005}
5006
5007
5008/**
5009 * Pluss (unary).
5010 *
5011 * @returns 0 on success.
5012 * @returns VBox evaluation / parsing error code on failure.
5013 * The caller does the bitching.
5014 * @param pDbgc Debugger console instance data.
5015 * @param pArg The argument.
5016 * @param pResult Where to store the result.
5017 */
5018static DECLCALLBACK(int) dbgcOpPluss(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5019{
5020// LogFlow(("dbgcOpPluss\n"));
5021 *pResult = *pArg;
5022 switch (pArg->enmType)
5023 {
5024 case DBGCVAR_TYPE_GC_FLAT:
5025 case DBGCVAR_TYPE_GC_FAR:
5026 case DBGCVAR_TYPE_GC_PHYS:
5027 case DBGCVAR_TYPE_HC_FLAT:
5028 case DBGCVAR_TYPE_HC_FAR:
5029 case DBGCVAR_TYPE_HC_PHYS:
5030 case DBGCVAR_TYPE_NUMBER:
5031 break;
5032
5033 case DBGCVAR_TYPE_UNKNOWN:
5034 case DBGCVAR_TYPE_STRING:
5035 default:
5036 return VERR_PARSE_INCORRECT_ARG_TYPE;
5037 }
5038 NOREF(pDbgc);
5039 return 0;
5040}
5041
5042
5043/**
5044 * Boolean not (unary).
5045 *
5046 * @returns 0 on success.
5047 * @returns VBox evaluation / parsing error code on failure.
5048 * The caller does the bitching.
5049 * @param pDbgc Debugger console instance data.
5050 * @param pArg The argument.
5051 * @param pResult Where to store the result.
5052 */
5053static DECLCALLBACK(int) dbgcOpBooleanNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5054{
5055// LogFlow(("dbgcOpBooleanNot\n"));
5056 *pResult = *pArg;
5057 switch (pArg->enmType)
5058 {
5059 case DBGCVAR_TYPE_GC_FLAT:
5060 pResult->u.u64Number = !pResult->u.GCFlat;
5061 break;
5062 case DBGCVAR_TYPE_GC_FAR:
5063 pResult->u.u64Number = !pResult->u.GCFar.off && pResult->u.GCFar.sel <= 3;
5064 break;
5065 case DBGCVAR_TYPE_GC_PHYS:
5066 pResult->u.u64Number = !pResult->u.GCPhys;
5067 break;
5068 case DBGCVAR_TYPE_HC_FLAT:
5069 pResult->u.u64Number = !pResult->u.pvHCFlat;
5070 break;
5071 case DBGCVAR_TYPE_HC_FAR:
5072 pResult->u.u64Number = !pResult->u.HCFar.off && pResult->u.HCFar.sel <= 3;
5073 break;
5074 case DBGCVAR_TYPE_HC_PHYS:
5075 pResult->u.u64Number = !pResult->u.HCPhys;
5076 break;
5077 case DBGCVAR_TYPE_NUMBER:
5078 pResult->u.u64Number = !pResult->u.u64Number;
5079 break;
5080 case DBGCVAR_TYPE_STRING:
5081 pResult->u.u64Number = !pResult->u64Range;
5082 break;
5083
5084 case DBGCVAR_TYPE_UNKNOWN:
5085 default:
5086 return VERR_PARSE_INCORRECT_ARG_TYPE;
5087 }
5088 pResult->enmType = DBGCVAR_TYPE_NUMBER;
5089 NOREF(pDbgc);
5090 return 0;
5091}
5092
5093
5094/**
5095 * Bitwise not (unary).
5096 *
5097 * @returns 0 on success.
5098 * @returns VBox evaluation / parsing error code on failure.
5099 * The caller does the bitching.
5100 * @param pDbgc Debugger console instance data.
5101 * @param pArg The argument.
5102 * @param pResult Where to store the result.
5103 */
5104static DECLCALLBACK(int) dbgcOpBitwiseNot(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5105{
5106// LogFlow(("dbgcOpBitwiseNot\n"));
5107 *pResult = *pArg;
5108 switch (pArg->enmType)
5109 {
5110 case DBGCVAR_TYPE_GC_FLAT:
5111 pResult->u.GCFlat = ~pResult->u.GCFlat;
5112 break;
5113 case DBGCVAR_TYPE_GC_FAR:
5114 pResult->u.GCFar.off = ~pResult->u.GCFar.off;
5115 break;
5116 case DBGCVAR_TYPE_GC_PHYS:
5117 pResult->u.GCPhys = ~pResult->u.GCPhys;
5118 break;
5119 case DBGCVAR_TYPE_HC_FLAT:
5120 pResult->u.pvHCFlat = (void *)~(uintptr_t)pResult->u.pvHCFlat;
5121 break;
5122 case DBGCVAR_TYPE_HC_FAR:
5123 pResult->u.HCFar.off= ~pResult->u.HCFar.off;
5124 break;
5125 case DBGCVAR_TYPE_HC_PHYS:
5126 pResult->u.HCPhys = ~pResult->u.HCPhys;
5127 break;
5128 case DBGCVAR_TYPE_NUMBER:
5129 pResult->u.u64Number = ~pResult->u.u64Number;
5130 break;
5131
5132 case DBGCVAR_TYPE_UNKNOWN:
5133 case DBGCVAR_TYPE_STRING:
5134 default:
5135 return VERR_PARSE_INCORRECT_ARG_TYPE;
5136 }
5137 NOREF(pDbgc);
5138 return 0;
5139}
5140
5141
5142/**
5143 * Reference variable (unary).
5144 *
5145 * @returns 0 on success.
5146 * @returns VBox evaluation / parsing error code on failure.
5147 * The caller does the bitching.
5148 * @param pDbgc Debugger console instance data.
5149 * @param pArg The argument.
5150 * @param pResult Where to store the result.
5151 */
5152static DECLCALLBACK(int) dbgcOpVar(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5153{
5154// LogFlow(("dbgcOpVar: %s\n", pArg->u.pszString));
5155 /*
5156 * Parse sanity.
5157 */
5158 if (pArg->enmType != DBGCVAR_TYPE_STRING)
5159 return VERR_PARSE_INCORRECT_ARG_TYPE;
5160
5161 /*
5162 * Lookup the variable.
5163 */
5164 const char *pszVar = pArg->u.pszString;
5165 for (unsigned iVar = 0; iVar < pDbgc->cVars; iVar++)
5166 {
5167 if (!strcmp(pszVar, pDbgc->papVars[iVar]->szName))
5168 {
5169 *pResult = pDbgc->papVars[iVar]->Var;
5170 return 0;
5171 }
5172 }
5173
5174 return VERR_PARSE_VARIABLE_NOT_FOUND;
5175}
5176
5177
5178/**
5179 * Flat address (unary).
5180 *
5181 * @returns VINF_SUCCESS on success.
5182 * @returns VBox evaluation / parsing error code on failure.
5183 * The caller does the bitching.
5184 * @param pDbgc Debugger console instance data.
5185 * @param pArg The argument.
5186 * @param pResult Where to store the result.
5187 */
5188static DECLCALLBACK(int) dbgcOpAddrFlat(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5189{
5190// LogFlow(("dbgcOpAddrFlat\n"));
5191 int rc;
5192 *pResult = *pArg;
5193
5194 switch (pArg->enmType)
5195 {
5196 case DBGCVAR_TYPE_GC_FLAT:
5197 return VINF_SUCCESS;
5198
5199 case DBGCVAR_TYPE_GC_FAR:
5200 {
5201 Assert(pDbgc->pVM);
5202 DBGFADDRESS Address;
5203 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5204 if (VBOX_SUCCESS(rc))
5205 {
5206 pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
5207 pResult->u.GCFlat = Address.FlatPtr;
5208 return VINF_SUCCESS;
5209 }
5210 return VERR_PARSE_CONVERSION_FAILED;
5211 }
5212
5213 case DBGCVAR_TYPE_GC_PHYS:
5214 //rc = MMR3PhysGCPhys2GCVirtEx(pDbgc->pVM, pResult->u.GCPhys, ..., &pResult->u.GCFlat); - yea, sure.
5215 return VERR_PARSE_INCORRECT_ARG_TYPE;
5216
5217 case DBGCVAR_TYPE_HC_FLAT:
5218 return VINF_SUCCESS;
5219
5220 case DBGCVAR_TYPE_HC_FAR:
5221 return VERR_PARSE_INCORRECT_ARG_TYPE;
5222
5223 case DBGCVAR_TYPE_HC_PHYS:
5224 Assert(pDbgc->pVM);
5225 pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5226 rc = MMR3HCPhys2HCVirt(pDbgc->pVM, pResult->u.HCPhys, &pResult->u.pvHCFlat);
5227 if (VBOX_SUCCESS(rc))
5228 return VINF_SUCCESS;
5229 return VERR_PARSE_CONVERSION_FAILED;
5230
5231 case DBGCVAR_TYPE_NUMBER:
5232 pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
5233 pResult->u.GCFlat = (RTGCPTR)pResult->u.u64Number;
5234 return VINF_SUCCESS;
5235
5236 case DBGCVAR_TYPE_STRING:
5237 return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_FLAT, pResult);
5238
5239 case DBGCVAR_TYPE_UNKNOWN:
5240 default:
5241 return VERR_PARSE_INCORRECT_ARG_TYPE;
5242 }
5243}
5244
5245
5246/**
5247 * Physical address (unary).
5248 *
5249 * @returns 0 on success.
5250 * @returns VBox evaluation / parsing error code on failure.
5251 * The caller does the bitching.
5252 * @param pDbgc Debugger console instance data.
5253 * @param pArg The argument.
5254 * @param pResult Where to store the result.
5255 */
5256static DECLCALLBACK(int) dbgcOpAddrPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5257{
5258// LogFlow(("dbgcOpAddrPhys\n"));
5259 int rc;
5260
5261 *pResult = *pArg;
5262 switch (pArg->enmType)
5263 {
5264 case DBGCVAR_TYPE_GC_FLAT:
5265 Assert(pDbgc->pVM);
5266 pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5267 rc = PGMPhysGCPtr2GCPhys(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.GCPhys);
5268 if (VBOX_SUCCESS(rc))
5269 return 0;
5270 /** @todo more memory types! */
5271 return VERR_PARSE_CONVERSION_FAILED;
5272
5273 case DBGCVAR_TYPE_GC_FAR:
5274 {
5275 Assert(pDbgc->pVM);
5276 DBGFADDRESS Address;
5277 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5278 if (VBOX_SUCCESS(rc))
5279 {
5280 pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5281 rc = PGMPhysGCPtr2GCPhys(pDbgc->pVM, Address.FlatPtr, &pResult->u.GCPhys);
5282 if (VBOX_SUCCESS(rc))
5283 return 0;
5284 /** @todo more memory types! */
5285 }
5286 return VERR_PARSE_CONVERSION_FAILED;
5287 }
5288
5289 case DBGCVAR_TYPE_GC_PHYS:
5290 return 0;
5291
5292 case DBGCVAR_TYPE_HC_FLAT:
5293 Assert(pDbgc->pVM);
5294 pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5295 rc = PGMR3DbgHCPtr2GCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.GCPhys);
5296 if (VBOX_SUCCESS(rc))
5297 return 0;
5298 /** @todo more memory types! */
5299 return VERR_PARSE_CONVERSION_FAILED;
5300
5301 case DBGCVAR_TYPE_HC_FAR:
5302 return VERR_PARSE_INCORRECT_ARG_TYPE;
5303
5304 case DBGCVAR_TYPE_HC_PHYS:
5305 return 0;
5306
5307 case DBGCVAR_TYPE_NUMBER:
5308 pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
5309 pResult->u.GCPhys = (RTGCPHYS)pResult->u.u64Number;
5310 return 0;
5311
5312 case DBGCVAR_TYPE_STRING:
5313 return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_PHYS, pResult);
5314
5315 case DBGCVAR_TYPE_UNKNOWN:
5316 default:
5317 return VERR_PARSE_INCORRECT_ARG_TYPE;
5318 }
5319 return 0;
5320}
5321
5322
5323/**
5324 * Physical host address (unary).
5325 *
5326 * @returns 0 on success.
5327 * @returns VBox evaluation / parsing error code on failure.
5328 * The caller does the bitching.
5329 * @param pDbgc Debugger console instance data.
5330 * @param pArg The argument.
5331 * @param pResult Where to store the result.
5332 */
5333static DECLCALLBACK(int) dbgcOpAddrHostPhys(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5334{
5335// LogFlow(("dbgcOpAddrPhys\n"));
5336 int rc;
5337
5338 *pResult = *pArg;
5339 switch (pArg->enmType)
5340 {
5341 case DBGCVAR_TYPE_GC_FLAT:
5342 Assert(pDbgc->pVM);
5343 pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5344 rc = PGMPhysGCPtr2HCPhys(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.HCPhys);
5345 if (VBOX_SUCCESS(rc))
5346 return 0;
5347 /** @todo more memory types. */
5348 return VERR_PARSE_CONVERSION_FAILED;
5349
5350 case DBGCVAR_TYPE_GC_FAR:
5351 {
5352 Assert(pDbgc->pVM);
5353 DBGFADDRESS Address;
5354 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5355 if (VBOX_SUCCESS(rc))
5356 {
5357 pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5358 rc = PGMPhysGCPtr2HCPhys(pDbgc->pVM, Address.FlatPtr, &pResult->u.HCPhys);
5359 if (VBOX_SUCCESS(rc))
5360 return 0;
5361 /** @todo more memory types. */
5362 }
5363 return VERR_PARSE_CONVERSION_FAILED;
5364 }
5365
5366 case DBGCVAR_TYPE_GC_PHYS:
5367 Assert(pDbgc->pVM);
5368 pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5369 rc = PGMPhysGCPhys2HCPhys(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.HCPhys);
5370 if (VBOX_SUCCESS(rc))
5371 return 0;
5372 return VERR_PARSE_CONVERSION_FAILED;
5373
5374 case DBGCVAR_TYPE_HC_FLAT:
5375 Assert(pDbgc->pVM);
5376 pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5377 rc = PGMR3DbgHCPtr2HCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.HCPhys);
5378 if (VBOX_SUCCESS(rc))
5379 return 0;
5380 /** @todo more memory types! */
5381 return VERR_PARSE_CONVERSION_FAILED;
5382
5383 case DBGCVAR_TYPE_HC_FAR:
5384 return VERR_PARSE_INCORRECT_ARG_TYPE;
5385
5386 case DBGCVAR_TYPE_HC_PHYS:
5387 return 0;
5388
5389 case DBGCVAR_TYPE_NUMBER:
5390 pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
5391 pResult->u.HCPhys = (RTGCPHYS)pResult->u.u64Number;
5392 return 0;
5393
5394 case DBGCVAR_TYPE_STRING:
5395 return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_HC_PHYS, pResult);
5396
5397 case DBGCVAR_TYPE_UNKNOWN:
5398 default:
5399 return VERR_PARSE_INCORRECT_ARG_TYPE;
5400 }
5401 return 0;
5402}
5403
5404
5405/**
5406 * Host address (unary).
5407 *
5408 * @returns 0 on success.
5409 * @returns VBox evaluation / parsing error code on failure.
5410 * The caller does the bitching.
5411 * @param pDbgc Debugger console instance data.
5412 * @param pArg The argument.
5413 * @param pResult Where to store the result.
5414 */
5415static DECLCALLBACK(int) dbgcOpAddrHost(PDBGC pDbgc, PCDBGCVAR pArg, PDBGCVAR pResult)
5416{
5417// LogFlow(("dbgcOpAddrHost\n"));
5418 int rc;
5419
5420 *pResult = *pArg;
5421 switch (pArg->enmType)
5422 {
5423 case DBGCVAR_TYPE_GC_FLAT:
5424 Assert(pDbgc->pVM);
5425 pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5426 rc = PGMPhysGCPtr2HCPtr(pDbgc->pVM, pArg->u.GCFlat, &pResult->u.pvHCFlat);
5427 if (VBOX_SUCCESS(rc))
5428 return 0;
5429 /** @todo more memory types. */
5430 return VERR_PARSE_CONVERSION_FAILED;
5431
5432 case DBGCVAR_TYPE_GC_FAR:
5433 {
5434 Assert(pDbgc->pVM);
5435 DBGFADDRESS Address;
5436 rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
5437 if (VBOX_SUCCESS(rc))
5438 {
5439 pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5440 rc = PGMPhysGCPtr2HCPtr(pDbgc->pVM, Address.FlatPtr, &pResult->u.pvHCFlat);
5441 if (VBOX_SUCCESS(rc))
5442 return 0;
5443 /** @todo more memory types. */
5444 }
5445 return VERR_PARSE_CONVERSION_FAILED;
5446 }
5447
5448 case DBGCVAR_TYPE_GC_PHYS:
5449 Assert(pDbgc->pVM);
5450 pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5451 rc = PGMPhysGCPhys2HCPtr(pDbgc->pVM, pArg->u.GCPhys, 1, &pResult->u.pvHCFlat);
5452 if (VBOX_SUCCESS(rc))
5453 return 0;
5454 return VERR_PARSE_CONVERSION_FAILED;
5455
5456 case DBGCVAR_TYPE_HC_FLAT:
5457 return 0;
5458
5459 case DBGCVAR_TYPE_HC_FAR:
5460 case DBGCVAR_TYPE_HC_PHYS:
5461 /** @todo !*/
5462 return VERR_PARSE_CONVERSION_FAILED;
5463
5464 case DBGCVAR_TYPE_NUMBER:
5465 pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
5466 pResult->u.pvHCFlat = (void *)(uintptr_t)pResult->u.u64Number;
5467 return 0;
5468
5469 case DBGCVAR_TYPE_STRING:
5470 return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_HC_FLAT, pResult);
5471
5472 case DBGCVAR_TYPE_UNKNOWN:
5473 default:
5474 return VERR_PARSE_INCORRECT_ARG_TYPE;
5475 }
5476}
5477
5478/**
5479 * Bitwise not (unary).
5480 *
5481 * @returns 0 on success.
5482 * @returns VBox evaluation / parsing error code on failure.
5483 * The caller does the bitching.
5484 * @param pDbgc Debugger console instance data.
5485 * @param pArg The argument.
5486 * @param pResult Where to store the result.
5487 */
5488static DECLCALLBACK(int) dbgcOpAddrFar(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5489{
5490// LogFlow(("dbgcOpAddrFar\n"));
5491 int rc;
5492
5493 switch (pArg1->enmType)
5494 {
5495 case DBGCVAR_TYPE_STRING:
5496 rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
5497 if (VBOX_FAILURE(rc))
5498 return rc;
5499 break;
5500 case DBGCVAR_TYPE_NUMBER:
5501 *pResult = *pArg1;
5502 break;
5503
5504 case DBGCVAR_TYPE_GC_FLAT:
5505 case DBGCVAR_TYPE_GC_FAR:
5506 case DBGCVAR_TYPE_GC_PHYS:
5507 case DBGCVAR_TYPE_HC_FLAT:
5508 case DBGCVAR_TYPE_HC_FAR:
5509 case DBGCVAR_TYPE_HC_PHYS:
5510 case DBGCVAR_TYPE_UNKNOWN:
5511 default:
5512 return VERR_PARSE_INCORRECT_ARG_TYPE;
5513 }
5514 pResult->u.GCFar.sel = (RTSEL)pResult->u.u64Number;
5515
5516 /* common code for the two types we support. */
5517 switch (pArg2->enmType)
5518 {
5519 case DBGCVAR_TYPE_GC_FLAT:
5520 pResult->u.GCFar.off = pArg2->u.GCFlat;
5521 pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5522 break;
5523
5524 case DBGCVAR_TYPE_HC_FLAT:
5525 pResult->u.HCFar.off = pArg2->u.GCFlat;
5526 pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5527 break;
5528
5529 case DBGCVAR_TYPE_NUMBER:
5530 pResult->u.GCFar.off = (RTGCPTR)pArg2->u.u64Number;
5531 pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5532 break;
5533
5534 case DBGCVAR_TYPE_STRING:
5535 {
5536 DBGCVAR Var;
5537 rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
5538 if (VBOX_FAILURE(rc))
5539 return rc;
5540 pResult->u.GCFar.off = (RTGCPTR)Var.u.u64Number;
5541 pResult->enmType = DBGCVAR_TYPE_GC_FAR;
5542 break;
5543 }
5544
5545 case DBGCVAR_TYPE_GC_FAR:
5546 case DBGCVAR_TYPE_GC_PHYS:
5547 case DBGCVAR_TYPE_HC_FAR:
5548 case DBGCVAR_TYPE_HC_PHYS:
5549 case DBGCVAR_TYPE_UNKNOWN:
5550 default:
5551 return VERR_PARSE_INCORRECT_ARG_TYPE;
5552 }
5553 return 0;
5554
5555}
5556
5557
5558/**
5559 * Multiplication operator (binary).
5560 *
5561 * @returns 0 on success.
5562 * @returns VBox evaluation / parsing error code on failure.
5563 * The caller does the bitching.
5564 * @param pDbgc Debugger console instance data.
5565 * @param pArg1 The first argument.
5566 * @param pArg2 The 2nd argument.
5567 * @param pResult Where to store the result.
5568 */
5569static DECLCALLBACK(int) dbgcOpMult(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5570{
5571// LogFlow(("dbgcOpMult\n"));
5572 int rc;
5573
5574 /*
5575 * Switch the factors so we preserve pointers, far pointers are considered more
5576 * important that physical and flat pointers.
5577 */
5578 if ( DBGCVAR_ISPOINTER(pArg2->enmType)
5579 && ( !DBGCVAR_ISPOINTER(pArg1->enmType)
5580 || ( DBGCVAR_IS_FAR_PTR(pArg2->enmType)
5581 && !DBGCVAR_IS_FAR_PTR(pArg1->enmType))))
5582 {
5583 PCDBGCVAR pTmp = pArg1;
5584 pArg2 = pArg1;
5585 pArg1 = pTmp;
5586 }
5587
5588 /*
5589 * Convert the 2nd number into a number we use multiply the first with.
5590 */
5591 DBGCVAR Factor2 = *pArg2;
5592 if ( Factor2.enmType == DBGCVAR_TYPE_STRING
5593 || Factor2.enmType == DBGCVAR_TYPE_SYMBOL)
5594 {
5595 rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Factor2);
5596 if (VBOX_FAILURE(rc))
5597 return rc;
5598 }
5599 uint64_t u64Factor;
5600 switch (Factor2.enmType)
5601 {
5602 case DBGCVAR_TYPE_GC_FLAT: u64Factor = Factor2.u.GCFlat; break;
5603 case DBGCVAR_TYPE_GC_FAR: u64Factor = Factor2.u.GCFar.off; break;
5604 case DBGCVAR_TYPE_GC_PHYS: u64Factor = Factor2.u.GCPhys; break;
5605 case DBGCVAR_TYPE_HC_FLAT: u64Factor = (uintptr_t)Factor2.u.pvHCFlat; break;
5606 case DBGCVAR_TYPE_HC_FAR: u64Factor = Factor2.u.HCFar.off; break;
5607 case DBGCVAR_TYPE_HC_PHYS: u64Factor = Factor2.u.HCPhys; break;
5608 case DBGCVAR_TYPE_NUMBER: u64Factor = Factor2.u.u64Number; break;
5609 default:
5610 return VERR_PARSE_INCORRECT_ARG_TYPE;
5611 }
5612
5613 /*
5614 * Fix symbols in the 1st factor.
5615 */
5616 *pResult = *pArg1;
5617 if ( pResult->enmType == DBGCVAR_TYPE_STRING
5618 || pResult->enmType == DBGCVAR_TYPE_SYMBOL)
5619 {
5620 rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, pResult);
5621 if (VBOX_FAILURE(rc))
5622 return rc;
5623 }
5624
5625 /*
5626 * Do the multiplication.
5627 */
5628 switch (pArg1->enmType)
5629 {
5630 case DBGCVAR_TYPE_GC_FLAT: pResult->u.GCFlat *= u64Factor; break;
5631 case DBGCVAR_TYPE_GC_FAR: pResult->u.GCFar.off *= u64Factor; break;
5632 case DBGCVAR_TYPE_GC_PHYS: pResult->u.GCPhys *= u64Factor; break;
5633 case DBGCVAR_TYPE_HC_FLAT:
5634 pResult->u.pvHCFlat = (void *)(uintptr_t)((uintptr_t)pResult->u.pvHCFlat * u64Factor);
5635 break;
5636 case DBGCVAR_TYPE_HC_FAR: pResult->u.HCFar.off *= u64Factor; break;
5637 case DBGCVAR_TYPE_HC_PHYS: pResult->u.HCPhys *= u64Factor; break;
5638 case DBGCVAR_TYPE_NUMBER: pResult->u.u64Number *= u64Factor; break;
5639 default:
5640 return VERR_PARSE_INCORRECT_ARG_TYPE;
5641 }
5642 return 0;
5643}
5644
5645
5646/**
5647 * Division operator (binary).
5648 *
5649 * @returns 0 on success.
5650 * @returns VBox evaluation / parsing error code on failure.
5651 * The caller does the bitching.
5652 * @param pDbgc Debugger console instance data.
5653 * @param pArg1 The first argument.
5654 * @param pArg2 The 2nd argument.
5655 * @param pResult Where to store the result.
5656 */
5657static DECLCALLBACK(int) dbgcOpDiv(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5658{
5659 LogFlow(("dbgcOpDiv\n"));
5660 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
5661 return -1;
5662}
5663
5664
5665/**
5666 * Modulus operator (binary).
5667 *
5668 * @returns 0 on success.
5669 * @returns VBox evaluation / parsing error code on failure.
5670 * The caller does the bitching.
5671 * @param pDbgc Debugger console instance data.
5672 * @param pArg1 The first argument.
5673 * @param pArg2 The 2nd argument.
5674 * @param pResult Where to store the result.
5675 */
5676static DECLCALLBACK(int) dbgcOpMod(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5677{
5678 LogFlow(("dbgcOpMod\n"));
5679 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
5680 return -1;
5681}
5682
5683
5684/**
5685 * Addition operator (binary).
5686 *
5687 * @returns 0 on success.
5688 * @returns VBox evaluation / parsing error code on failure.
5689 * The caller does the bitching.
5690 * @param pDbgc Debugger console instance data.
5691 * @param pArg1 The first argument.
5692 * @param pArg2 The 2nd argument.
5693 * @param pResult Where to store the result.
5694 */
5695static DECLCALLBACK(int) dbgcOpAdd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5696{
5697// LogFlow(("dbgcOpAdd\n"));
5698
5699 /*
5700 * An addition operation will return (when possible) the left side type in the
5701 * expression. We make an omission for numbers, where we'll take the right side
5702 * type instead. An expression where only the left hand side is a string we'll
5703 * use the right hand type assuming that the string is a symbol.
5704 */
5705 if ( (pArg1->enmType == DBGCVAR_TYPE_NUMBER && pArg2->enmType != DBGCVAR_TYPE_STRING)
5706 || (pArg1->enmType == DBGCVAR_TYPE_STRING && pArg2->enmType != DBGCVAR_TYPE_STRING))
5707 {
5708 PCDBGCVAR pTmp = pArg2;
5709 pArg2 = pArg1;
5710 pArg1 = pTmp;
5711 }
5712 DBGCVAR Sym1, Sym2;
5713 if (pArg1->enmType == DBGCVAR_TYPE_STRING)
5714 {
5715 int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
5716 if (VBOX_FAILURE(rc))
5717 return rc;
5718 pArg1 = &Sym1;
5719
5720 rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
5721 if (VBOX_FAILURE(rc))
5722 return rc;
5723 pArg2 = &Sym2;
5724 }
5725
5726 int rc;
5727 DBGCVAR Var;
5728 DBGCVAR Var2;
5729 switch (pArg1->enmType)
5730 {
5731 /*
5732 * GC Flat
5733 */
5734 case DBGCVAR_TYPE_GC_FLAT:
5735 switch (pArg2->enmType)
5736 {
5737 case DBGCVAR_TYPE_HC_FLAT:
5738 case DBGCVAR_TYPE_HC_FAR:
5739 case DBGCVAR_TYPE_HC_PHYS:
5740 return VERR_PARSE_INVALID_OPERATION;
5741 default:
5742 *pResult = *pArg1;
5743 rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
5744 if (VBOX_FAILURE(rc))
5745 return rc;
5746 pResult->u.GCFlat += pArg2->u.GCFlat;
5747 break;
5748 }
5749 break;
5750
5751 /*
5752 * GC Far
5753 */
5754 case DBGCVAR_TYPE_GC_FAR:
5755 switch (pArg2->enmType)
5756 {
5757 case DBGCVAR_TYPE_HC_FLAT:
5758 case DBGCVAR_TYPE_HC_FAR:
5759 case DBGCVAR_TYPE_HC_PHYS:
5760 return VERR_PARSE_INVALID_OPERATION;
5761 case DBGCVAR_TYPE_NUMBER:
5762 *pResult = *pArg1;
5763 pResult->u.GCFar.off += (RTGCPTR)pArg2->u.u64Number;
5764 break;
5765 default:
5766 rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
5767 if (VBOX_FAILURE(rc))
5768 return rc;
5769 rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
5770 if (VBOX_FAILURE(rc))
5771 return rc;
5772 pResult->u.GCFlat += pArg2->u.GCFlat;
5773 break;
5774 }
5775 break;
5776
5777 /*
5778 * GC Phys
5779 */
5780 case DBGCVAR_TYPE_GC_PHYS:
5781 switch (pArg2->enmType)
5782 {
5783 case DBGCVAR_TYPE_HC_FLAT:
5784 case DBGCVAR_TYPE_HC_FAR:
5785 case DBGCVAR_TYPE_HC_PHYS:
5786 return VERR_PARSE_INVALID_OPERATION;
5787 default:
5788 *pResult = *pArg1;
5789 rc = dbgcOpAddrPhys(pDbgc, pArg2, &Var);
5790 if (VBOX_FAILURE(rc))
5791 return rc;
5792 if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
5793 return VERR_PARSE_INVALID_OPERATION;
5794 pResult->u.GCPhys += Var.u.GCPhys;
5795 break;
5796 }
5797 break;
5798
5799 /*
5800 * HC Flat
5801 */
5802 case DBGCVAR_TYPE_HC_FLAT:
5803 *pResult = *pArg1;
5804 rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
5805 if (VBOX_FAILURE(rc))
5806 return rc;
5807 rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
5808 if (VBOX_FAILURE(rc))
5809 return rc;
5810 pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat + (uintptr_t)Var.u.pvHCFlat;
5811 break;
5812
5813 /*
5814 * HC Far
5815 */
5816 case DBGCVAR_TYPE_HC_FAR:
5817 switch (pArg2->enmType)
5818 {
5819 case DBGCVAR_TYPE_NUMBER:
5820 *pResult = *pArg1;
5821 pResult->u.HCFar.off += (uintptr_t)pArg2->u.u64Number;
5822 break;
5823
5824 default:
5825 rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
5826 if (VBOX_FAILURE(rc))
5827 return rc;
5828 rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
5829 if (VBOX_FAILURE(rc))
5830 return rc;
5831 rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
5832 if (VBOX_FAILURE(rc))
5833 return rc;
5834 pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat + (uintptr_t)Var.u.pvHCFlat;
5835 break;
5836 }
5837 break;
5838
5839 /*
5840 * HC Phys
5841 */
5842 case DBGCVAR_TYPE_HC_PHYS:
5843 *pResult = *pArg1;
5844 rc = dbgcOpAddrHostPhys(pDbgc, pArg2, &Var);
5845 if (VBOX_FAILURE(rc))
5846 return rc;
5847 pResult->u.HCPhys += Var.u.HCPhys;
5848 break;
5849
5850 /*
5851 * Numbers (see start of function)
5852 */
5853 case DBGCVAR_TYPE_NUMBER:
5854 *pResult = *pArg1;
5855 switch (pArg2->enmType)
5856 {
5857 case DBGCVAR_TYPE_SYMBOL:
5858 case DBGCVAR_TYPE_STRING:
5859 rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
5860 if (VBOX_FAILURE(rc))
5861 return rc;
5862 case DBGCVAR_TYPE_NUMBER:
5863 pResult->u.u64Number += pArg2->u.u64Number;
5864 break;
5865 default:
5866 return VERR_PARSE_INVALID_OPERATION;
5867 }
5868 break;
5869
5870 default:
5871 return VERR_PARSE_INVALID_OPERATION;
5872
5873 }
5874 return 0;
5875}
5876
5877
5878/**
5879 * Subtration operator (binary).
5880 *
5881 * @returns 0 on success.
5882 * @returns VBox evaluation / parsing error code on failure.
5883 * The caller does the bitching.
5884 * @param pDbgc Debugger console instance data.
5885 * @param pArg1 The first argument.
5886 * @param pArg2 The 2nd argument.
5887 * @param pResult Where to store the result.
5888 */
5889static DECLCALLBACK(int) dbgcOpSub(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
5890{
5891// LogFlow(("dbgcOpSub\n"));
5892
5893 /*
5894 * An subtraction operation will return the left side type in the expression.
5895 * However, if the left hand side is a number and the right hand a pointer of
5896 * some kind we'll convert the left hand side to the same type as the right hand.
5897 * Any strings will be attempted resolved as symbols.
5898 */
5899 DBGCVAR Sym1, Sym2;
5900 if ( pArg2->enmType == DBGCVAR_TYPE_STRING
5901 && ( pArg1->enmType == DBGCVAR_TYPE_NUMBER
5902 || pArg1->enmType == DBGCVAR_TYPE_STRING))
5903 {
5904 int rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_ANY, &Sym2);
5905 if (VBOX_FAILURE(rc))
5906 return rc;
5907 pArg2 = &Sym2;
5908 }
5909
5910 if (pArg1->enmType == DBGCVAR_TYPE_STRING)
5911 {
5912 DBGCVARTYPE enmType;
5913 switch (pArg2->enmType)
5914 {
5915 case DBGCVAR_TYPE_NUMBER:
5916 enmType = DBGCVAR_TYPE_ANY;
5917 break;
5918 case DBGCVAR_TYPE_GC_FLAT:
5919 case DBGCVAR_TYPE_GC_PHYS:
5920 case DBGCVAR_TYPE_HC_FLAT:
5921 case DBGCVAR_TYPE_HC_PHYS:
5922 enmType = pArg2->enmType;
5923 break;
5924 case DBGCVAR_TYPE_GC_FAR:
5925 enmType = DBGCVAR_TYPE_GC_FLAT;
5926 break;
5927 case DBGCVAR_TYPE_HC_FAR:
5928 enmType = DBGCVAR_TYPE_HC_FLAT;
5929 break;
5930
5931 default:
5932 case DBGCVAR_TYPE_STRING:
5933 AssertMsgFailed(("Can't happen\n"));
5934 enmType = DBGCVAR_TYPE_STRING;
5935 break;
5936 }
5937 if (enmType != DBGCVAR_TYPE_STRING)
5938 {
5939 int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, &Sym1);
5940 if (VBOX_FAILURE(rc))
5941 return rc;
5942 pArg1 = &Sym1;
5943 }
5944 }
5945 else if (pArg1->enmType == DBGCVAR_TYPE_NUMBER)
5946 {
5947 PFNDBGCOPUNARY pOp = NULL;
5948 switch (pArg2->enmType)
5949 {
5950 case DBGCVAR_TYPE_GC_FAR:
5951 case DBGCVAR_TYPE_GC_FLAT:
5952 pOp = dbgcOpAddrFlat;
5953 break;
5954 case DBGCVAR_TYPE_GC_PHYS:
5955 pOp = dbgcOpAddrPhys;
5956 break;
5957 case DBGCVAR_TYPE_HC_FAR:
5958 case DBGCVAR_TYPE_HC_FLAT:
5959 pOp = dbgcOpAddrHost;
5960 break;
5961 case DBGCVAR_TYPE_HC_PHYS:
5962 pOp = dbgcOpAddrHostPhys;
5963 break;
5964 case DBGCVAR_TYPE_NUMBER:
5965 break;
5966 default:
5967 case DBGCVAR_TYPE_STRING:
5968 AssertMsgFailed(("Can't happen\n"));
5969 break;
5970 }
5971 if (pOp)
5972 {
5973 int rc = pOp(pDbgc, pArg1, &Sym1);
5974 if (VBOX_FAILURE(rc))
5975 return rc;
5976 pArg1 = &Sym1;
5977 }
5978 }
5979
5980
5981 /*
5982 * Normal processing.
5983 */
5984 int rc;
5985 DBGCVAR Var;
5986 DBGCVAR Var2;
5987 switch (pArg1->enmType)
5988 {
5989 /*
5990 * GC Flat
5991 */
5992 case DBGCVAR_TYPE_GC_FLAT:
5993 switch (pArg2->enmType)
5994 {
5995 case DBGCVAR_TYPE_HC_FLAT:
5996 case DBGCVAR_TYPE_HC_FAR:
5997 case DBGCVAR_TYPE_HC_PHYS:
5998 return VERR_PARSE_INVALID_OPERATION;
5999 default:
6000 *pResult = *pArg1;
6001 rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
6002 if (VBOX_FAILURE(rc))
6003 return rc;
6004 pResult->u.GCFlat -= pArg2->u.GCFlat;
6005 break;
6006 }
6007 break;
6008
6009 /*
6010 * GC Far
6011 */
6012 case DBGCVAR_TYPE_GC_FAR:
6013 switch (pArg2->enmType)
6014 {
6015 case DBGCVAR_TYPE_HC_FLAT:
6016 case DBGCVAR_TYPE_HC_FAR:
6017 case DBGCVAR_TYPE_HC_PHYS:
6018 return VERR_PARSE_INVALID_OPERATION;
6019 case DBGCVAR_TYPE_NUMBER:
6020 *pResult = *pArg1;
6021 pResult->u.GCFar.off -= (RTGCPTR)pArg2->u.u64Number;
6022 break;
6023 default:
6024 rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
6025 if (VBOX_FAILURE(rc))
6026 return rc;
6027 rc = dbgcOpAddrFlat(pDbgc, pArg2, &Var);
6028 if (VBOX_FAILURE(rc))
6029 return rc;
6030 pResult->u.GCFlat -= pArg2->u.GCFlat;
6031 break;
6032 }
6033 break;
6034
6035 /*
6036 * GC Phys
6037 */
6038 case DBGCVAR_TYPE_GC_PHYS:
6039 switch (pArg2->enmType)
6040 {
6041 case DBGCVAR_TYPE_HC_FLAT:
6042 case DBGCVAR_TYPE_HC_FAR:
6043 case DBGCVAR_TYPE_HC_PHYS:
6044 return VERR_PARSE_INVALID_OPERATION;
6045 default:
6046 *pResult = *pArg1;
6047 rc = dbgcOpAddrPhys(pDbgc, pArg2, &Var);
6048 if (VBOX_FAILURE(rc))
6049 return rc;
6050 if (Var.enmType != DBGCVAR_TYPE_GC_PHYS)
6051 return VERR_PARSE_INVALID_OPERATION;
6052 pResult->u.GCPhys -= Var.u.GCPhys;
6053 break;
6054 }
6055 break;
6056
6057 /*
6058 * HC Flat
6059 */
6060 case DBGCVAR_TYPE_HC_FLAT:
6061 *pResult = *pArg1;
6062 rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
6063 if (VBOX_FAILURE(rc))
6064 return rc;
6065 rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
6066 if (VBOX_FAILURE(rc))
6067 return rc;
6068 pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat - (uintptr_t)Var.u.pvHCFlat;
6069 break;
6070
6071 /*
6072 * HC Far
6073 */
6074 case DBGCVAR_TYPE_HC_FAR:
6075 switch (pArg2->enmType)
6076 {
6077 case DBGCVAR_TYPE_NUMBER:
6078 *pResult = *pArg1;
6079 pResult->u.HCFar.off -= (uintptr_t)pArg2->u.u64Number;
6080 break;
6081
6082 default:
6083 rc = dbgcOpAddrFlat(pDbgc, pArg1, pResult);
6084 if (VBOX_FAILURE(rc))
6085 return rc;
6086 rc = dbgcOpAddrHost(pDbgc, pArg2, &Var2);
6087 if (VBOX_FAILURE(rc))
6088 return rc;
6089 rc = dbgcOpAddrFlat(pDbgc, &Var2, &Var);
6090 if (VBOX_FAILURE(rc))
6091 return rc;
6092 pResult->u.pvHCFlat = (char *)pResult->u.pvHCFlat - (uintptr_t)Var.u.pvHCFlat;
6093 break;
6094 }
6095 break;
6096
6097 /*
6098 * HC Phys
6099 */
6100 case DBGCVAR_TYPE_HC_PHYS:
6101 *pResult = *pArg1;
6102 rc = dbgcOpAddrHostPhys(pDbgc, pArg2, &Var);
6103 if (VBOX_FAILURE(rc))
6104 return rc;
6105 pResult->u.HCPhys -= Var.u.HCPhys;
6106 break;
6107
6108 /*
6109 * Numbers (see start of function)
6110 */
6111 case DBGCVAR_TYPE_NUMBER:
6112 *pResult = *pArg1;
6113 switch (pArg2->enmType)
6114 {
6115 case DBGCVAR_TYPE_SYMBOL:
6116 case DBGCVAR_TYPE_STRING:
6117 rc = dbgcSymbolGet(pDbgc, pArg2->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
6118 if (VBOX_FAILURE(rc))
6119 return rc;
6120 case DBGCVAR_TYPE_NUMBER:
6121 pResult->u.u64Number -= pArg2->u.u64Number;
6122 break;
6123 default:
6124 return VERR_PARSE_INVALID_OPERATION;
6125 }
6126 break;
6127
6128 default:
6129 return VERR_PARSE_INVALID_OPERATION;
6130
6131 }
6132 return 0;
6133}
6134
6135
6136/**
6137 * Bitwise shift left operator (binary).
6138 *
6139 * @returns 0 on success.
6140 * @returns VBox evaluation / parsing error code on failure.
6141 * The caller does the bitching.
6142 * @param pDbgc Debugger console instance data.
6143 * @param pArg1 The first argument.
6144 * @param pArg2 The 2nd argument.
6145 * @param pResult Where to store the result.
6146 */
6147static DECLCALLBACK(int) dbgcOpBitwiseShiftLeft(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6148{
6149 LogFlow(("dbgcOpBitwiseShiftLeft\n"));
6150 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6151 return -1;
6152}
6153
6154
6155/**
6156 * Bitwise shift right operator (binary).
6157 *
6158 * @returns 0 on success.
6159 * @returns VBox evaluation / parsing error code on failure.
6160 * The caller does the bitching.
6161 * @param pDbgc Debugger console instance data.
6162 * @param pArg1 The first argument.
6163 * @param pArg2 The 2nd argument.
6164 * @param pResult Where to store the result.
6165 */
6166static DECLCALLBACK(int) dbgcOpBitwiseShiftRight(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6167{
6168 LogFlow(("dbgcOpBitwiseShiftRight\n"));
6169 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6170 return -1;
6171}
6172
6173
6174/**
6175 * Bitwise and operator (binary).
6176 *
6177 * @returns 0 on success.
6178 * @returns VBox evaluation / parsing error code on failure.
6179 * The caller does the bitching.
6180 * @param pDbgc Debugger console instance data.
6181 * @param pArg1 The first argument.
6182 * @param pArg2 The 2nd argument.
6183 * @param pResult Where to store the result.
6184 */
6185static DECLCALLBACK(int) dbgcOpBitwiseAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6186{
6187 LogFlow(("dbgcOpBitwiseAnd\n"));
6188 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6189 return -1;
6190}
6191
6192
6193/**
6194 * Bitwise exclusive or operator (binary).
6195 *
6196 * @returns 0 on success.
6197 * @returns VBox evaluation / parsing error code on failure.
6198 * The caller does the bitching.
6199 * @param pDbgc Debugger console instance data.
6200 * @param pArg1 The first argument.
6201 * @param pArg2 The 2nd argument.
6202 * @param pResult Where to store the result.
6203 */
6204static DECLCALLBACK(int) dbgcOpBitwiseXor(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6205{
6206 LogFlow(("dbgcOpBitwiseXor\n"));
6207 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6208 return -1;
6209}
6210
6211
6212/**
6213 * Bitwise inclusive or operator (binary).
6214 *
6215 * @returns 0 on success.
6216 * @returns VBox evaluation / parsing error code on failure.
6217 * The caller does the bitching.
6218 * @param pDbgc Debugger console instance data.
6219 * @param pArg1 The first argument.
6220 * @param pArg2 The 2nd argument.
6221 * @param pResult Where to store the result.
6222 */
6223static DECLCALLBACK(int) dbgcOpBitwiseOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6224{
6225 LogFlow(("dbgcOpBitwiseOr\n"));
6226 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6227 return -1;
6228}
6229
6230
6231/**
6232 * Boolean and operator (binary).
6233 *
6234 * @returns 0 on success.
6235 * @returns VBox evaluation / parsing error code on failure.
6236 * The caller does the bitching.
6237 * @param pDbgc Debugger console instance data.
6238 * @param pArg1 The first argument.
6239 * @param pArg2 The 2nd argument.
6240 * @param pResult Where to store the result.
6241 */
6242static DECLCALLBACK(int) dbgcOpBooleanAnd(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6243{
6244 LogFlow(("dbgcOpBooleanAnd\n"));
6245 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6246 return -1;
6247}
6248
6249
6250/**
6251 * Boolean or operator (binary).
6252 *
6253 * @returns 0 on success.
6254 * @returns VBox evaluation / parsing error code on failure.
6255 * The caller does the bitching.
6256 * @param pDbgc Debugger console instance data.
6257 * @param pArg1 The first argument.
6258 * @param pArg2 The 2nd argument.
6259 * @param pResult Where to store the result.
6260 */
6261static DECLCALLBACK(int) dbgcOpBooleanOr(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6262{
6263 LogFlow(("dbgcOpBooleanOr\n"));
6264 NOREF(pDbgc); NOREF(pArg1); NOREF(pArg2); NOREF(pResult);
6265 return -1;
6266}
6267
6268
6269/**
6270 * Range to operator (binary).
6271 *
6272 * @returns 0 on success.
6273 * @returns VBox evaluation / parsing error code on failure.
6274 * The caller does the bitching.
6275 * @param pDbgc Debugger console instance data.
6276 * @param pArg1 The first argument.
6277 * @param pArg2 The 2nd argument.
6278 * @param pResult Where to store the result.
6279 */
6280static DECLCALLBACK(int) dbgcOpRangeLength(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6281{
6282// LogFlow(("dbgcOpRangeLength\n"));
6283 /*
6284 * Make result. Strings needs to be resolved into symbols.
6285 */
6286 if (pArg1->enmType == DBGCVAR_TYPE_STRING)
6287 {
6288 int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_ANY, pResult);
6289 if (VBOX_FAILURE(rc))
6290 return rc;
6291 }
6292 else
6293 *pResult = *pArg1;
6294
6295 /*
6296 * Convert 2nd argument to element count.
6297 */
6298 pResult->enmRangeType = DBGCVAR_RANGE_ELEMENTS;
6299 switch (pArg2->enmType)
6300 {
6301 case DBGCVAR_TYPE_NUMBER:
6302 pResult->u64Range = pArg2->u.u64Number;
6303 break;
6304
6305 case DBGCVAR_TYPE_STRING:
6306 {
6307 int rc = dbgcSymbolGet(pDbgc, pArg1->u.pszString, DBGCVAR_TYPE_NUMBER, pResult);
6308 if (VBOX_FAILURE(rc))
6309 return rc;
6310 pResult->u64Range = pArg2->u.u64Number;
6311 break;
6312 }
6313
6314 default:
6315 return VERR_PARSE_INVALID_OPERATION;
6316 }
6317
6318 return VINF_SUCCESS;
6319}
6320
6321
6322/**
6323 * Range to operator (binary).
6324 *
6325 * @returns 0 on success.
6326 * @returns VBox evaluation / parsing error code on failure.
6327 * The caller does the bitching.
6328 * @param pDbgc Debugger console instance data.
6329 * @param pArg1 The first argument.
6330 * @param pArg2 The 2nd argument.
6331 * @param pResult Where to store the result.
6332 */
6333static DECLCALLBACK(int) dbgcOpRangeLengthBytes(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6334{
6335// LogFlow(("dbgcOpRangeLengthBytes\n"));
6336 int rc = dbgcOpRangeLength(pDbgc, pArg1, pArg2, pResult);
6337 if (VBOX_SUCCESS(rc))
6338 pResult->enmRangeType = DBGCVAR_RANGE_BYTES;
6339 return rc;
6340}
6341
6342
6343/**
6344 * Range to operator (binary).
6345 *
6346 * @returns 0 on success.
6347 * @returns VBox evaluation / parsing error code on failure.
6348 * The caller does the bitching.
6349 * @param pDbgc Debugger console instance data.
6350 * @param pArg1 The first argument.
6351 * @param pArg2 The 2nd argument.
6352 * @param pResult Where to store the result.
6353 */
6354static DECLCALLBACK(int) dbgcOpRangeTo(PDBGC pDbgc, PCDBGCVAR pArg1, PCDBGCVAR pArg2, PDBGCVAR pResult)
6355{
6356// LogFlow(("dbgcOpRangeTo\n"));
6357 /*
6358 * Calc number of bytes between the two args.
6359 */
6360 DBGCVAR Diff;
6361 int rc = dbgcOpSub(pDbgc, pArg2, pArg1, &Diff);
6362 if (VBOX_FAILURE(rc))
6363 return rc;
6364
6365 /*
6366 * Use the diff as the range of Arg1.
6367 */
6368 *pResult = *pArg1;
6369 pResult->enmRangeType = DBGCVAR_RANGE_BYTES;
6370 switch (Diff.enmType)
6371 {
6372 case DBGCVAR_TYPE_GC_FLAT:
6373 pResult->u64Range = (RTGCUINTPTR)Diff.u.GCFlat;
6374 break;
6375 case DBGCVAR_TYPE_GC_PHYS:
6376 pResult->u64Range = Diff.u.GCPhys;
6377 break;
6378 case DBGCVAR_TYPE_HC_FLAT:
6379 pResult->u64Range = (uintptr_t)Diff.u.pvHCFlat;
6380 break;
6381 case DBGCVAR_TYPE_HC_PHYS:
6382 pResult->u64Range = Diff.u.HCPhys;
6383 break;
6384 case DBGCVAR_TYPE_NUMBER:
6385 pResult->u64Range = Diff.u.u64Number;
6386 break;
6387
6388 case DBGCVAR_TYPE_GC_FAR:
6389 case DBGCVAR_TYPE_STRING:
6390 case DBGCVAR_TYPE_HC_FAR:
6391 default:
6392 AssertMsgFailed(("Impossible!\n"));
6393 return VERR_PARSE_INVALID_OPERATION;
6394 }
6395
6396 return 0;
6397}
6398
6399
6400
6401
6402
6403/**
6404 * Output callback.
6405 *
6406 * @returns number of bytes written.
6407 * @param pvArg User argument.
6408 * @param pachChars Pointer to an array of utf-8 characters.
6409 * @param cbChars Number of bytes in the character array pointed to by pachChars.
6410 */
6411static DECLCALLBACK(size_t) dbgcFormatOutput(void *pvArg, const char *pachChars, size_t cbChars)
6412{
6413 PDBGC pDbgc = (PDBGC)pvArg;
6414 if (cbChars)
6415 {
6416 int rc = pDbgc->pBack->pfnWrite(pDbgc->pBack, pachChars, cbChars, NULL);
6417 if (VBOX_FAILURE(rc))
6418 {
6419 pDbgc->rcOutput = rc;
6420 cbChars = 0;
6421 }
6422 }
6423
6424 return cbChars;
6425}
6426
6427
6428
6429
6430
6431
6432
6433
6434
6435//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
6436//
6437//
6438// C a l l b a c k H e l p e r s
6439//
6440//
6441//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
6442
6443
6444
6445/**
6446 * Command helper for writing text to the debug console.
6447 *
6448 * @returns VBox status.
6449 * @param pCmdHlp Pointer to the command callback structure.
6450 * @param pvBuf What to write.
6451 * @param cbBuf Number of bytes to write.
6452 * @param pcbWritten Where to store the number of bytes actually written.
6453 * If NULL the entire buffer must be successfully written.
6454 */
6455static DECLCALLBACK(int) dbgcHlpWrite(PDBGCCMDHLP pCmdHlp, const void *pvBuf, size_t cbBuf, size_t *pcbWritten)
6456{
6457 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6458 return pDbgc->pBack->pfnWrite(pDbgc->pBack, pvBuf, cbBuf, pcbWritten);
6459}
6460
6461
6462/**
6463 * Command helper for writing formatted text to the debug console.
6464 *
6465 * @returns VBox status.
6466 * @param pCmdHlp Pointer to the command callback structure.
6467 * @param pcb Where to store the number of bytes written.
6468 * @param pszFormat The format string.
6469 * This is using the log formatter, so it's format extensions can be used.
6470 * @param ... Arguments specified in the format string.
6471 */
6472static DECLCALLBACK(int) dbgcHlpPrintf(PDBGCCMDHLP pCmdHlp, size_t *pcbWritten, const char *pszFormat, ...)
6473{
6474 /*
6475 * Do the formatting and output.
6476 */
6477 va_list args;
6478 va_start(args, pszFormat);
6479 int rc = pCmdHlp->pfnPrintfV(pCmdHlp, pcbWritten, pszFormat, args);
6480 va_end(args);
6481
6482 return rc;
6483}
6484
6485/**
6486 * Callback to format non-standard format specifiers.
6487 *
6488 * @returns The number of bytes formatted.
6489 * @param pvArg Formatter argument.
6490 * @param pfnOutput Pointer to output function.
6491 * @param pvArgOutput Argument for the output function.
6492 * @param ppszFormat Pointer to the format string pointer. Advance this till the char
6493 * after the format specifier.
6494 * @param pArgs Pointer to the argument list. Use this to fetch the arguments.
6495 * @param cchWidth Format Width. -1 if not specified.
6496 * @param cchPrecision Format Precision. -1 if not specified.
6497 * @param fFlags Flags (RTSTR_NTFS_*).
6498 * @param chArgSize The argument size specifier, 'l' or 'L'.
6499 */
6500static DECLCALLBACK(size_t) dbgcStringFormatter(void *pvArg, PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
6501 const char **ppszFormat, va_list *pArgs, int cchWidth,
6502 int cchPrecision, unsigned fFlags, char chArgSize)
6503{
6504 NOREF(cchWidth); NOREF(cchPrecision); NOREF(fFlags); NOREF(chArgSize); NOREF(pvArg);
6505 if (**ppszFormat != 'D')
6506 {
6507 (*ppszFormat)++;
6508 return 0;
6509 }
6510
6511 (*ppszFormat)++;
6512 switch (**ppszFormat)
6513 {
6514 /*
6515 * Print variable without range.
6516 * The argument is a const pointer to the variable.
6517 */
6518 case 'V':
6519 {
6520 (*ppszFormat)++;
6521 PCDBGCVAR pVar = va_arg(*pArgs, PCDBGCVAR);
6522 switch (pVar->enmType)
6523 {
6524 case DBGCVAR_TYPE_GC_FLAT:
6525 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%VGv", pVar->u.GCFlat);
6526 case DBGCVAR_TYPE_GC_FAR:
6527 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%04x:%08x", pVar->u.GCFar.sel, pVar->u.GCFar.off);
6528 case DBGCVAR_TYPE_GC_PHYS:
6529 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%%%VGp", pVar->u.GCPhys);
6530 case DBGCVAR_TYPE_HC_FLAT:
6531 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%#%VHv", (uintptr_t)pVar->u.pvHCFlat);
6532 case DBGCVAR_TYPE_HC_FAR:
6533 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%04x:%08x", pVar->u.HCFar.sel, pVar->u.HCFar.off);
6534 case DBGCVAR_TYPE_HC_PHYS:
6535 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%%%%%VHp", pVar->u.HCPhys);
6536 case DBGCVAR_TYPE_STRING:
6537 return pfnOutput(pvArgOutput, pVar->u.pszString, (size_t)pVar->u64Range);
6538 case DBGCVAR_TYPE_NUMBER:
6539 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%llx", pVar->u.u64Number);
6540
6541 case DBGCVAR_TYPE_UNKNOWN:
6542 default:
6543 return pfnOutput(pvArgOutput, "??", 2);
6544 }
6545 }
6546
6547 /*
6548 * Print variable with range.
6549 * The argument is a const pointer to the variable.
6550 */
6551 case 'v':
6552 {
6553 (*ppszFormat)++;
6554 PCDBGCVAR pVar = va_arg(*pArgs, PCDBGCVAR);
6555
6556 char szRange[32];
6557 switch (pVar->enmRangeType)
6558 {
6559 case DBGCVAR_RANGE_NONE:
6560 szRange[0] = '\0';
6561 break;
6562 case DBGCVAR_RANGE_ELEMENTS:
6563 RTStrPrintf(szRange, sizeof(szRange), " L %llx", pVar->u64Range);
6564 break;
6565 case DBGCVAR_RANGE_BYTES:
6566 RTStrPrintf(szRange, sizeof(szRange), " LB %llx", pVar->u64Range);
6567 break;
6568 }
6569
6570 switch (pVar->enmType)
6571 {
6572 case DBGCVAR_TYPE_GC_FLAT:
6573 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%VGv%s", pVar->u.GCFlat, szRange);
6574 case DBGCVAR_TYPE_GC_FAR:
6575 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%04x:%08x%s", pVar->u.GCFar.sel, pVar->u.GCFar.off, szRange);
6576 case DBGCVAR_TYPE_GC_PHYS:
6577 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%%%%VGp%s", pVar->u.GCPhys, szRange);
6578 case DBGCVAR_TYPE_HC_FLAT:
6579 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%%#%VHv%s", (uintptr_t)pVar->u.pvHCFlat, szRange);
6580 case DBGCVAR_TYPE_HC_FAR:
6581 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%04x:%08x%s", pVar->u.HCFar.sel, pVar->u.HCFar.off, szRange);
6582 case DBGCVAR_TYPE_HC_PHYS:
6583 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "#%%%%%VHp%s", pVar->u.HCPhys, szRange);
6584 case DBGCVAR_TYPE_STRING:
6585 return pfnOutput(pvArgOutput, pVar->u.pszString, (size_t)pVar->u64Range);
6586 case DBGCVAR_TYPE_NUMBER:
6587 return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "%llx%s", pVar->u.u64Number, szRange);
6588
6589 case DBGCVAR_TYPE_UNKNOWN:
6590 default:
6591 return pfnOutput(pvArgOutput, "??", 2);
6592 }
6593 }
6594
6595 default:
6596 AssertMsgFailed(("Invalid format type '%s'!\n", **ppszFormat));
6597 return 0;
6598 }
6599}
6600
6601
6602/**
6603 * Command helper for writing formatted text to the debug console.
6604 *
6605 * @returns VBox status.
6606 * @param pCmdHlp Pointer to the command callback structure.
6607 * @param pcb Where to store the number of bytes written.
6608 * @param pszFormat The format string.
6609 * This is using the log formatter, so it's format extensions can be used.
6610 * @param args Arguments specified in the format string.
6611 */
6612static DECLCALLBACK(int) dbgcHlpPrintfV(PDBGCCMDHLP pCmdHlp, size_t *pcbWritten, const char *pszFormat, va_list args)
6613{
6614 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6615
6616 /*
6617 * Do the formatting and output.
6618 */
6619 pDbgc->rcOutput = 0;
6620 size_t cb = RTStrFormatV(dbgcFormatOutput, pDbgc, dbgcStringFormatter, pDbgc, pszFormat, args);
6621
6622 if (pcbWritten)
6623 *pcbWritten = cb;
6624
6625 return pDbgc->rcOutput;
6626}
6627
6628
6629/**
6630 * Reports an error from a DBGF call.
6631 *
6632 * @returns VBox status code appropriate to return from a command.
6633 * @param pCmdHlp Pointer to command helpers.
6634 * @param rc The VBox status code returned by a DBGF call.
6635 * @param pszFormat Format string for additional messages. Can be NULL.
6636 * @param ... Format arguments, optional.
6637 */
6638static DECLCALLBACK(int) dbgcHlpVBoxErrorV(PDBGCCMDHLP pCmdHlp, int rc, const char *pszFormat, va_list args)
6639{
6640 switch (rc)
6641 {
6642 case VINF_SUCCESS:
6643 break;
6644
6645 default:
6646 rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %Vrc: %s", rc, pszFormat ? " " : "\n");
6647 if (VBOX_SUCCESS(rc) && pszFormat)
6648 rc = pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
6649 break;
6650 }
6651 return rc;
6652}
6653
6654
6655/**
6656 * Reports an error from a DBGF call.
6657 *
6658 * @returns VBox status code appropriate to return from a command.
6659 * @param pCmdHlp Pointer to command helpers.
6660 * @param rc The VBox status code returned by a DBGF call.
6661 * @param pszFormat Format string for additional messages. Can be NULL.
6662 * @param ... Format arguments, optional.
6663 */
6664static DECLCALLBACK(int) dbgcHlpVBoxError(PDBGCCMDHLP pCmdHlp, int rc, const char *pszFormat, ...)
6665{
6666 va_list args;
6667 va_start(args, pszFormat);
6668 int rcRet = pCmdHlp->pfnVBoxErrorV(pCmdHlp, rc, pszFormat, args);
6669 va_end(args);
6670 return rcRet;
6671}
6672
6673
6674/**
6675 * Command helper for reading memory specified by a DBGC variable.
6676 *
6677 * @returns VBox status code appropriate to return from a command.
6678 * @param pCmdHlp Pointer to the command callback structure.
6679 * @param pVM VM handle if GC or physical HC address.
6680 * @param pvBuffer Where to store the read data.
6681 * @param cbRead Number of bytes to read.
6682 * @param pVarPointer DBGC variable specifying where to start reading.
6683 * @param pcbRead Where to store the number of bytes actually read.
6684 * This optional, but it's useful when read GC virtual memory where a
6685 * page in the requested range might not be present.
6686 * If not specified not-present failure or end of a HC physical page
6687 * will cause failure.
6688 */
6689static DECLCALLBACK(int) dbgcHlpMemRead(PDBGCCMDHLP pCmdHlp, PVM pVM, void *pvBuffer, size_t cbRead, PCDBGCVAR pVarPointer, size_t *pcbRead)
6690{
6691 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6692
6693 /*
6694 * Dummy check.
6695 */
6696 if (cbRead == 0)
6697 {
6698 if (*pcbRead)
6699 *pcbRead = 0;
6700 return VINF_SUCCESS;
6701 }
6702
6703 /*
6704 * Convert Far addresses getting size and the correct base address.
6705 * Getting and checking the size is what makes this messy and slow.
6706 */
6707 DBGCVAR Var = *pVarPointer;
6708 switch (pVarPointer->enmType)
6709 {
6710 case DBGCVAR_TYPE_GC_FAR:
6711 {
6712 /* Use DBGFR3AddrFromSelOff for the conversion. */
6713 Assert(pDbgc->pVM);
6714 DBGFADDRESS Address;
6715 int rc = DBGFR3AddrFromSelOff(pDbgc->pVM, &Address, Var.u.GCFar.sel, Var.u.GCFar.off);
6716 if (VBOX_FAILURE(rc))
6717 return rc;
6718
6719 /* don't bother with flat selectors (for now). */
6720 if (!DBGFADDRESS_IS_FLAT(&Address))
6721 {
6722 SELMSELINFO SelInfo;
6723 rc = SELMR3GetSelectorInfo(pDbgc->pVM, Address.Sel, &SelInfo);
6724 if (VBOX_SUCCESS(rc))
6725 {
6726 RTGCUINTPTR cb; /* -1 byte */
6727 if (SELMSelInfoIsExpandDown(&SelInfo))
6728 {
6729 if ( !SelInfo.Raw.Gen.u1Granularity
6730 && Address.off > UINT16_C(0xffff))
6731 return VERR_OUT_OF_SELECTOR_BOUNDS;
6732 if (Address.off <= SelInfo.cbLimit)
6733 return VERR_OUT_OF_SELECTOR_BOUNDS;
6734 cb = (SelInfo.Raw.Gen.u1Granularity ? UINT32_C(0xffffffff) : UINT32_C(0xffff)) - Address.off;
6735 }
6736 else
6737 {
6738 if (Address.off > SelInfo.cbLimit)
6739 return VERR_OUT_OF_SELECTOR_BOUNDS;
6740 cb = SelInfo.cbLimit - Address.off;
6741 }
6742 if (cbRead - 1 > cb)
6743 {
6744 if (!pcbRead)
6745 return VERR_OUT_OF_SELECTOR_BOUNDS;
6746 cbRead = cb + 1;
6747 }
6748 }
6749
6750 Var.enmType = DBGCVAR_TYPE_GC_FLAT;
6751 Var.u.GCFlat = Address.FlatPtr;
6752 }
6753 break;
6754 }
6755
6756 case DBGCVAR_TYPE_GC_FLAT:
6757 case DBGCVAR_TYPE_GC_PHYS:
6758 case DBGCVAR_TYPE_HC_FLAT:
6759 case DBGCVAR_TYPE_HC_PHYS:
6760 break;
6761
6762 case DBGCVAR_TYPE_HC_FAR: /* not supported yet! */
6763 default:
6764 return VERR_NOT_IMPLEMENTED;
6765 }
6766
6767
6768
6769 /*
6770 * Copy page by page.
6771 */
6772 size_t cbLeft = cbRead;
6773 for (;;)
6774 {
6775 /*
6776 * Calc read size.
6777 */
6778 size_t cb = RT_MIN(PAGE_SIZE, cbLeft);
6779 switch (pVarPointer->enmType)
6780 {
6781 case DBGCVAR_TYPE_GC_FLAT: cb = RT_MIN(cb, PAGE_SIZE - (Var.u.GCFlat & PAGE_OFFSET_MASK)); break;
6782 case DBGCVAR_TYPE_GC_PHYS: cb = RT_MIN(cb, PAGE_SIZE - (Var.u.GCPhys & PAGE_OFFSET_MASK)); break;
6783 case DBGCVAR_TYPE_HC_FLAT: cb = RT_MIN(cb, PAGE_SIZE - ((uintptr_t)Var.u.pvHCFlat & PAGE_OFFSET_MASK)); break;
6784 case DBGCVAR_TYPE_HC_PHYS: cb = RT_MIN(cb, PAGE_SIZE - ((size_t)Var.u.HCPhys & PAGE_OFFSET_MASK)); break; /* size_t: MSC has braindead loss of data warnings! */
6785 default: break;
6786 }
6787
6788 /*
6789 * Perform read.
6790 */
6791 int rc;
6792 switch (Var.enmType)
6793 {
6794 case DBGCVAR_TYPE_GC_FLAT:
6795 rc = MMR3ReadGCVirt(pVM, pvBuffer, Var.u.GCFlat, cb);
6796 break;
6797 case DBGCVAR_TYPE_GC_PHYS:
6798 rc = PGMPhysReadGCPhys(pVM, pvBuffer, Var.u.GCPhys, cb);
6799 break;
6800
6801 case DBGCVAR_TYPE_HC_PHYS:
6802 case DBGCVAR_TYPE_HC_FLAT:
6803 case DBGCVAR_TYPE_HC_FAR:
6804 {
6805 DBGCVAR Var2;
6806 rc = dbgcOpAddrFlat(pDbgc, &Var, &Var2);
6807 if (VBOX_SUCCESS(rc))
6808 {
6809 /** @todo protect this!!! */
6810 memcpy(pvBuffer, Var2.u.pvHCFlat, cb);
6811 rc = 0;
6812 }
6813 else
6814 rc = VERR_INVALID_POINTER;
6815 break;
6816 }
6817
6818 default:
6819 rc = VERR_PARSE_INCORRECT_ARG_TYPE;
6820 }
6821
6822 /*
6823 * Check for failure.
6824 */
6825 if (VBOX_FAILURE(rc))
6826 {
6827 if (pcbRead && (*pcbRead = cbRead - cbLeft) > 0)
6828 return VINF_SUCCESS;
6829 return rc;
6830 }
6831
6832 /*
6833 * Next.
6834 */
6835 cbLeft -= cb;
6836 if (!cbLeft)
6837 break;
6838 pvBuffer = (char *)pvBuffer + cb;
6839 rc = pCmdHlp->pfnEval(pCmdHlp, &Var, "%DV + %d", &Var, cb);
6840 if (VBOX_FAILURE(rc))
6841 {
6842 if (pcbRead && (*pcbRead = cbRead - cbLeft) > 0)
6843 return VINF_SUCCESS;
6844 return rc;
6845 }
6846 }
6847
6848 /*
6849 * Done
6850 */
6851 if (pcbRead)
6852 *pcbRead = cbRead;
6853 return 0;
6854}
6855
6856/**
6857 * Command helper for writing memory specified by a DBGC variable.
6858 *
6859 * @returns VBox status code appropriate to return from a command.
6860 * @param pCmdHlp Pointer to the command callback structure.
6861 * @param pVM VM handle if GC or physical HC address.
6862 * @param pvBuffer What to write.
6863 * @param cbWrite Number of bytes to write.
6864 * @param pVarPointer DBGC variable specifying where to start reading.
6865 * @param pcbWritten Where to store the number of bytes written.
6866 * This is optional. If NULL be aware that some of the buffer
6867 * might have been written to the specified address.
6868 */
6869static DECLCALLBACK(int) dbgcHlpMemWrite(PDBGCCMDHLP pCmdHlp, PVM pVM, const void *pvBuffer, size_t cbWrite, PCDBGCVAR pVarPointer, size_t *pcbWritten)
6870{
6871 NOREF(pCmdHlp); NOREF(pVM); NOREF(pvBuffer); NOREF(cbWrite); NOREF(pVarPointer); NOREF(pcbWritten);
6872 return VERR_NOT_IMPLEMENTED;
6873}
6874
6875
6876/**
6877 * Evaluates an expression.
6878 * (Hopefully the parser and functions are fully reentrant.)
6879 *
6880 * @returns VBox status code appropriate to return from a command.
6881 * @param pCmdHlp Pointer to the command callback structure.
6882 * @param pResult Where to store the result.
6883 * @param pszExpr The expression. Format string with the format DBGC extensions.
6884 * @param ... Format arguments.
6885 */
6886static DECLCALLBACK(int) dbgcHlpEval(PDBGCCMDHLP pCmdHlp, PDBGCVAR pResult, const char *pszExpr, ...)
6887{
6888 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6889
6890 /*
6891 * Format the expression.
6892 */
6893 char szExprFormatted[2048];
6894 va_list args;
6895 va_start(args, pszExpr);
6896 size_t cb = RTStrPrintfExV(dbgcStringFormatter, pDbgc, szExprFormatted, sizeof(szExprFormatted), pszExpr, args);
6897 va_end(args);
6898 /* ignore overflows. */
6899
6900 return dbgcEvalSub(pDbgc, &szExprFormatted[0], cb, pResult);
6901}
6902
6903
6904/**
6905 * Executes one command expression.
6906 * (Hopefully the parser and functions are fully reentrant.)
6907 *
6908 * @returns VBox status code appropriate to return from a command.
6909 * @param pCmdHlp Pointer to the command callback structure.
6910 * @param pszExpr The expression. Format string with the format DBGC extensions.
6911 * @param ... Format arguments.
6912 */
6913static DECLCALLBACK(int) dbgcHlpExec(PDBGCCMDHLP pCmdHlp, const char *pszExpr, ...)
6914{
6915 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6916 /* Save the scratch state. */
6917 char *pszScratch = pDbgc->pszScratch;
6918 unsigned iArg = pDbgc->iArg;
6919
6920 /*
6921 * Format the expression.
6922 */
6923 va_list args;
6924 va_start(args, pszExpr);
6925 size_t cbScratch = sizeof(pDbgc->achScratch) - (pDbgc->pszScratch - &pDbgc->achScratch[0]);
6926 size_t cb = RTStrPrintfExV(dbgcStringFormatter, pDbgc, pDbgc->pszScratch, cbScratch, pszExpr, args);
6927 va_end(args);
6928 if (cb >= cbScratch)
6929 return VERR_BUFFER_OVERFLOW;
6930
6931 /*
6932 * Execute the command.
6933 * We save and restore the arg index and scratch buffer pointer.
6934 */
6935 pDbgc->pszScratch = pDbgc->pszScratch + cb + 1;
6936 int rc = dbgcProcessCommand(pDbgc, pszScratch, cb);
6937
6938 /* Restore the scratch state. */
6939 pDbgc->iArg = iArg;
6940 pDbgc->pszScratch = pszScratch;
6941
6942 return rc;
6943}
6944
6945
6946/**
6947 * Converts a DBGC variable to a DBGF address structure.
6948 *
6949 * @returns VBox status code.
6950 * @param pCmdHlp Pointer to the command callback structure.
6951 * @param pVar The variable to convert.
6952 * @param pAddress The target address.
6953 */
6954static DECLCALLBACK(int) dbgcHlpVarToDbgfAddr(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, PDBGFADDRESS pAddress)
6955{
6956 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6957 return dbgcVarToDbgfAddr(pDbgc, pVar, pAddress);
6958}
6959
6960
6961/**
6962 * Converts a DBGC variable to a boolean.
6963 *
6964 * @returns VBox status code.
6965 * @param pCmdHlp Pointer to the command callback structure.
6966 * @param pVar The variable to convert.
6967 * @param pf Where to store the boolean.
6968 */
6969static DECLCALLBACK(int) dbgcHlpVarToBool(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, bool *pf)
6970{
6971 PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
6972 NOREF(pDbgc);
6973
6974 switch (pVar->enmType)
6975 {
6976 case DBGCVAR_TYPE_STRING:
6977 /** @todo add strcasecmp / stricmp wrappers to iprt/string.h. */
6978 if ( !strcmp(pVar->u.pszString, "true")
6979 || !strcmp(pVar->u.pszString, "True")
6980 || !strcmp(pVar->u.pszString, "TRUE")
6981 || !strcmp(pVar->u.pszString, "on")
6982 || !strcmp(pVar->u.pszString, "On")
6983 || !strcmp(pVar->u.pszString, "oN")
6984 || !strcmp(pVar->u.pszString, "ON")
6985 || !strcmp(pVar->u.pszString, "enabled")
6986 || !strcmp(pVar->u.pszString, "Enabled")
6987 || !strcmp(pVar->u.pszString, "DISABLED"))
6988 {
6989 *pf = true;
6990 return VINF_SUCCESS;
6991 }
6992 if ( !strcmp(pVar->u.pszString, "false")
6993 || !strcmp(pVar->u.pszString, "False")
6994 || !strcmp(pVar->u.pszString, "FALSE")
6995 || !strcmp(pVar->u.pszString, "off")
6996 || !strcmp(pVar->u.pszString, "Off")
6997 || !strcmp(pVar->u.pszString, "OFF")
6998 || !strcmp(pVar->u.pszString, "disabled")
6999 || !strcmp(pVar->u.pszString, "Disabled")
7000 || !strcmp(pVar->u.pszString, "DISABLED"))
7001 {
7002 *pf = false;
7003 return VINF_SUCCESS;
7004 }
7005 return VERR_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
7006
7007 case DBGCVAR_TYPE_GC_FLAT:
7008 case DBGCVAR_TYPE_GC_PHYS:
7009 case DBGCVAR_TYPE_HC_FLAT:
7010 case DBGCVAR_TYPE_HC_PHYS:
7011 case DBGCVAR_TYPE_NUMBER:
7012 *pf = pVar->u.u64Number != 0;
7013 return VINF_SUCCESS;
7014
7015 case DBGCVAR_TYPE_HC_FAR:
7016 case DBGCVAR_TYPE_GC_FAR:
7017 case DBGCVAR_TYPE_SYMBOL:
7018 default:
7019 return VERR_PARSE_INCORRECT_ARG_TYPE;
7020 }
7021}
7022
7023
7024
7025
7026
7027//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7028//
7029//
7030// V a r i a b l e M a n i p u l a t i o n
7031//
7032//
7033//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7034
7035
7036
7037/** @todo move me!*/
7038static void dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat)
7039{
7040 if (pVar)
7041 {
7042 pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
7043 pVar->u.GCFlat = GCFlat;
7044 pVar->enmRangeType = DBGCVAR_RANGE_NONE;
7045 pVar->u64Range = 0;
7046 }
7047}
7048
7049
7050/** @todo move me!*/
7051static void dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb)
7052{
7053 if (pVar)
7054 {
7055 pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
7056 pVar->u.GCFlat = GCFlat;
7057 pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
7058 pVar->u64Range = cb;
7059 }
7060}
7061
7062
7063/** @todo move me!*/
7064static void dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2)
7065{
7066 if (pVar)
7067 {
7068 if (pVar2)
7069 *pVar = *pVar2;
7070 else
7071 {
7072 pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
7073 memset(&pVar->u, 0, sizeof(pVar->u));
7074 pVar->enmRangeType = DBGCVAR_RANGE_NONE;
7075 pVar->u64Range = 0;
7076 }
7077 }
7078}
7079
7080
7081/** @todo move me!*/
7082static void dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb)
7083{
7084 if (pVar)
7085 {
7086 pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
7087 pVar->u64Range = cb;
7088 }
7089}
7090
7091
7092/** @todo move me!*/
7093static void dbgcVarSetNoRange(PDBGCVAR pVar)
7094{
7095 if (pVar)
7096 {
7097 pVar->enmRangeType = DBGCVAR_RANGE_NONE;
7098 pVar->u64Range = 0;
7099 }
7100}
7101
7102
7103/**
7104 * Converts a DBGC variable to a DBGF address.
7105 *
7106 * @returns VBox status code.
7107 * @param pDbgc The DBGC instance.
7108 * @param pVar The variable.
7109 * @param pAddress Where to store the address.
7110 */
7111static int dbgcVarToDbgfAddr(PDBGC pDbgc, PCDBGCVAR pVar, PDBGFADDRESS pAddress)
7112{
7113 AssertReturn(pVar, VERR_INVALID_PARAMETER);
7114 switch (pVar->enmType)
7115 {
7116 case DBGCVAR_TYPE_GC_FLAT:
7117 DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, pVar->u.GCFlat);
7118 return VINF_SUCCESS;
7119
7120 case DBGCVAR_TYPE_NUMBER:
7121 DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, (RTGCUINTPTR)pVar->u.u64Number);
7122 return VINF_SUCCESS;
7123
7124 case DBGCVAR_TYPE_GC_FAR:
7125 return DBGFR3AddrFromSelOff(pDbgc->pVM, pAddress, pVar->u.GCFar.sel, pVar->u.GCFar.sel);
7126
7127 case DBGCVAR_TYPE_STRING:
7128 case DBGCVAR_TYPE_SYMBOL:
7129 {
7130 DBGCVAR Var;
7131 int rc = pDbgc->CmdHlp.pfnEval(&pDbgc->CmdHlp, &Var, "%%(%DV)", pVar);
7132 if (VBOX_FAILURE(rc))
7133 return rc;
7134 return dbgcVarToDbgfAddr(pDbgc, &Var, pAddress);
7135 }
7136
7137 case DBGCVAR_TYPE_GC_PHYS:
7138 case DBGCVAR_TYPE_HC_FLAT:
7139 case DBGCVAR_TYPE_HC_FAR:
7140 case DBGCVAR_TYPE_HC_PHYS:
7141 default:
7142 return VERR_PARSE_CONVERSION_FAILED;
7143 }
7144}
7145
7146
7147
7148//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7149//
7150//
7151// B r e a k p o i n t M a n a g e m e n t
7152//
7153//
7154//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7155
7156
7157/**
7158 * Adds a breakpoint to the DBGC breakpoint list.
7159 */
7160static int dbgcBpAdd(PDBGC pDbgc, RTUINT iBp, const char *pszCmd)
7161{
7162 /*
7163 * Check if it already exists.
7164 */
7165 PDBGCBP pBp = dbgcBpGet(pDbgc, iBp);
7166 if (pBp)
7167 return VERR_DBGC_BP_EXISTS;
7168
7169 /*
7170 * Add the breakpoint.
7171 */
7172 if (pszCmd)
7173 pszCmd = RTStrStripL(pszCmd);
7174 size_t cchCmd = pszCmd ? strlen(pszCmd) : 0;
7175 pBp = (PDBGCBP)RTMemAlloc(RT_OFFSETOF(DBGCBP, szCmd[cchCmd + 1]));
7176 if (!pBp)
7177 return VERR_NO_MEMORY;
7178 if (cchCmd)
7179 memcpy(pBp->szCmd, pszCmd, cchCmd + 1);
7180 else
7181 pBp->szCmd[0] = '\0';
7182 pBp->cchCmd = cchCmd;
7183 pBp->iBp = iBp;
7184 pBp->pNext = pDbgc->pFirstBp;
7185 pDbgc->pFirstBp = pBp;
7186
7187 return VINF_SUCCESS;
7188}
7189
7190/**
7191 * Updates the a breakpoint.
7192 *
7193 * @returns VBox status code.
7194 * @param pDbgc The DBGC instance.
7195 * @param iBp The breakpoint to update.
7196 * @param pszCmd The new command.
7197 */
7198static int dbgcBpUpdate(PDBGC pDbgc, RTUINT iBp, const char *pszCmd)
7199{
7200 /*
7201 * Find the breakpoint.
7202 */
7203 PDBGCBP pBp = dbgcBpGet(pDbgc, iBp);
7204 if (!pBp)
7205 return VERR_DBGC_BP_NOT_FOUND;
7206
7207 /*
7208 * Do we need to reallocate?
7209 */
7210 if (pszCmd)
7211 pszCmd = RTStrStripL(pszCmd);
7212 if (!pszCmd || !*pszCmd)
7213 pBp->szCmd[0] = '\0';
7214 else
7215 {
7216 size_t cchCmd = strlen(pszCmd);
7217 if (strlen(pBp->szCmd) >= cchCmd)
7218 {
7219 memcpy(pBp->szCmd, pszCmd, cchCmd + 1);
7220 pBp->cchCmd = cchCmd;
7221 }
7222 else
7223 {
7224 /*
7225 * Yes, let's do it the simple way...
7226 */
7227 int rc = dbgcBpDelete(pDbgc, iBp);
7228 AssertRC(rc);
7229 return dbgcBpAdd(pDbgc, iBp, pszCmd);
7230 }
7231 }
7232 return VINF_SUCCESS;
7233}
7234
7235
7236/**
7237 * Deletes a breakpoint.
7238 *
7239 * @returns VBox status code.
7240 * @param pDbgc The DBGC instance.
7241 * @param iBp The breakpoint to delete.
7242 */
7243static int dbgcBpDelete(PDBGC pDbgc, RTUINT iBp)
7244{
7245 /*
7246 * Search thru the list, when found unlink and free it.
7247 */
7248 PDBGCBP pBpPrev = NULL;
7249 PDBGCBP pBp = pDbgc->pFirstBp;
7250 for (; pBp; pBp = pBp->pNext)
7251 {
7252 if (pBp->iBp == iBp)
7253 {
7254 if (pBpPrev)
7255 pBpPrev->pNext = pBp->pNext;
7256 else
7257 pDbgc->pFirstBp = pBp->pNext;
7258 RTMemFree(pBp);
7259 return VINF_SUCCESS;
7260 }
7261 pBpPrev = pBp;
7262 }
7263
7264 return VERR_DBGC_BP_NOT_FOUND;
7265}
7266
7267
7268/**
7269 * Get a breakpoint.
7270 *
7271 * @returns Pointer to the breakpoint.
7272 * @returns NULL if the breakpoint wasn't found.
7273 * @param pDbgc The DBGC instance.
7274 * @param iBp The breakpoint to get.
7275 */
7276static PDBGCBP dbgcBpGet(PDBGC pDbgc, RTUINT iBp)
7277{
7278 /*
7279 * Enumerate the list.
7280 */
7281 PDBGCBP pBp = pDbgc->pFirstBp;
7282 for (; pBp; pBp = pBp->pNext)
7283 if (pBp->iBp == iBp)
7284 return pBp;
7285 return NULL;
7286}
7287
7288
7289/**
7290 * Executes the command of a breakpoint.
7291 *
7292 * @returns VINF_DBGC_BP_NO_COMMAND if there is no command associated with the breakpoint.
7293 * @returns VERR_DBGC_BP_NOT_FOUND if the breakpoint wasn't found.
7294 * @returns VERR_BUFFER_OVERFLOW if the is not enough space in the scratch buffer for the command.
7295 * @returns VBox status code from dbgcProcessCommand() other wise.
7296 * @param pDbgc The DBGC instance.
7297 * @param iBp The breakpoint to execute.
7298 */
7299static int dbgcBpExec(PDBGC pDbgc, RTUINT iBp)
7300{
7301 /*
7302 * Find the breakpoint.
7303 */
7304 PDBGCBP pBp = dbgcBpGet(pDbgc, iBp);
7305 if (!pBp)
7306 return VERR_DBGC_BP_NOT_FOUND;
7307
7308 /*
7309 * Anything to do?
7310 */
7311 if (!pBp->cchCmd)
7312 return VINF_DBGC_BP_NO_COMMAND;
7313
7314 /*
7315 * Execute the command.
7316 * This means copying it to the scratch buffer and process it as if it
7317 * were user input. We must save and restore the state of the scratch buffer.
7318 */
7319 /* Save the scratch state. */
7320 char *pszScratch = pDbgc->pszScratch;
7321 unsigned iArg = pDbgc->iArg;
7322
7323 /* Copy the command to the scratch buffer. */
7324 size_t cbScratch = sizeof(pDbgc->achScratch) - (pDbgc->pszScratch - &pDbgc->achScratch[0]);
7325 if (pBp->cchCmd >= cbScratch)
7326 return VERR_BUFFER_OVERFLOW;
7327 memcpy(pDbgc->pszScratch, pBp->szCmd, pBp->cchCmd + 1);
7328
7329 /* Execute the command. */
7330 pDbgc->pszScratch = pDbgc->pszScratch + pBp->cchCmd + 1;
7331 int rc = dbgcProcessCommand(pDbgc, pszScratch, pBp->cchCmd);
7332
7333 /* Restore the scratch state. */
7334 pDbgc->iArg = iArg;
7335 pDbgc->pszScratch = pszScratch;
7336
7337 return rc;
7338}
7339
7340
7341
7342
7343
7344//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7345//
7346//
7347// I n p u t , p a r s i n g a n d l o g g i n g
7348//
7349//
7350//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
7351
7352
7353
7354/**
7355 * Prints any log lines from the log buffer.
7356 *
7357 * The caller must not call function this unless pDbgc->fLog is set.
7358 *
7359 * @returns VBox status. (output related)
7360 * @param pDbgc Debugger console instance data.
7361 */
7362static int dbgcProcessLog(PDBGC pDbgc)
7363{
7364 /** @todo */
7365 NOREF(pDbgc);
7366 return 0;
7367}
7368
7369
7370
7371/**
7372 * Handle input buffer overflow.
7373 *
7374 * Will read any available input looking for a '\n' to reset the buffer on.
7375 *
7376 * @returns VBox status.
7377 * @param pDbgc Debugger console instance data.
7378 */
7379static int dbgcInputOverflow(PDBGC pDbgc)
7380{
7381 /*
7382 * Assert overflow status and reset the input buffer.
7383 */
7384 if (!pDbgc->fInputOverflow)
7385 {
7386 pDbgc->fInputOverflow = true;
7387 pDbgc->iRead = pDbgc->iWrite = 0;
7388 pDbgc->cInputLines = 0;
7389 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Input overflow!!\n");
7390 }
7391
7392 /*
7393 * Eat input till no more or there is a '\n'.
7394 * When finding a '\n' we'll continue normal processing.
7395 */
7396 while (pDbgc->pBack->pfnInput(pDbgc->pBack, 0))
7397 {
7398 size_t cbRead;
7399 int rc = pDbgc->pBack->pfnRead(pDbgc->pBack, &pDbgc->achInput[0], sizeof(pDbgc->achInput) - 1, &cbRead);
7400 if (VBOX_FAILURE(rc))
7401 return rc;
7402 char *psz = (char *)memchr(&pDbgc->achInput[0], '\n', cbRead);
7403 if (psz)
7404 {
7405 pDbgc->fInputOverflow = false;
7406 pDbgc->iRead = psz - &pDbgc->achInput[0] + 1;
7407 pDbgc->iWrite = (unsigned)cbRead;
7408 pDbgc->cInputLines = 0;
7409 break;
7410 }
7411 }
7412
7413 return 0;
7414}
7415
7416
7417
7418/**
7419 * Read input and do some preprocessing.
7420 *
7421 * @returns VBox status.
7422 * In addition to the iWrite and achInput, cInputLines is maintained.
7423 * In case of an input overflow the fInputOverflow flag will be set.
7424 * @param pDbgc Debugger console instance data.
7425 */
7426static int dbgcInputRead(PDBGC pDbgc)
7427{
7428 /*
7429 * We have ready input.
7430 * Read it till we don't have any or we have a full input buffer.
7431 */
7432 int rc = 0;
7433 do
7434 {
7435 /*
7436 * More available buffer space?
7437 */
7438 size_t cbLeft;
7439 if (pDbgc->iWrite > pDbgc->iRead)
7440 cbLeft = sizeof(pDbgc->achInput) - pDbgc->iWrite - (pDbgc->iRead == 0);
7441 else
7442 cbLeft = pDbgc->iRead - pDbgc->iWrite - 1;
7443 if (!cbLeft)
7444 {
7445 /* overflow? */
7446 if (!pDbgc->cInputLines)
7447 rc = dbgcInputOverflow(pDbgc);
7448 break;
7449 }
7450
7451 /*
7452 * Read one char and interpret it.
7453 */
7454 char achRead[128];
7455 size_t cbRead;
7456 rc = pDbgc->pBack->pfnRead(pDbgc->pBack, &achRead[0], RT_MIN(cbLeft, sizeof(achRead)), &cbRead);
7457 if (VBOX_FAILURE(rc))
7458 return rc;
7459 char *psz = &achRead[0];
7460 while (cbRead-- > 0)
7461 {
7462 char ch = *psz++;
7463 switch (ch)
7464 {
7465 /*
7466 * Ignore.
7467 */
7468 case '\0':
7469 case '\r':
7470 case '\a':
7471 break;
7472
7473 /*
7474 * Backspace.
7475 */
7476 case '\b':
7477 Log2(("DBGC: backspace\n"));
7478 if (pDbgc->iRead != pDbgc->iWrite)
7479 {
7480 unsigned iWriteUndo = pDbgc->iWrite;
7481 if (pDbgc->iWrite)
7482 pDbgc->iWrite--;
7483 else
7484 pDbgc->iWrite = sizeof(pDbgc->achInput) - 1;
7485
7486 if (pDbgc->achInput[pDbgc->iWrite] == '\n')
7487 pDbgc->iWrite = iWriteUndo;
7488 }
7489 break;
7490
7491 /*
7492 * Add char to buffer.
7493 */
7494 case '\t':
7495 case '\n':
7496 case ';':
7497 switch (ch)
7498 {
7499 case '\t': ch = ' '; break;
7500 case '\n': pDbgc->cInputLines++; break;
7501 }
7502 default:
7503 Log2(("DBGC: ch=%02x\n", (unsigned char)ch));
7504 pDbgc->achInput[pDbgc->iWrite] = ch;
7505 if (++pDbgc->iWrite >= sizeof(pDbgc->achInput))
7506 pDbgc->iWrite = 0;
7507 break;
7508 }
7509 }
7510
7511 /* Terminate it to make it easier to read in the debugger. */
7512 pDbgc->achInput[pDbgc->iWrite] = '\0';
7513 } while (pDbgc->pBack->pfnInput(pDbgc->pBack, 0));
7514
7515 return rc;
7516}
7517
7518
7519/**
7520 * Finds a builtin symbol.
7521 * @returns Pointer to symbol descriptor on success.
7522 * @returns NULL on failure.
7523 * @param pDbgc The debug console instance.
7524 * @param pszSymbol The symbol name.
7525 */
7526static PCDBGCSYM dbgcLookupRegisterSymbol(PDBGC pDbgc, const char *pszSymbol)
7527{
7528 for (unsigned iSym = 0; iSym < ELEMENTS(g_aSyms); iSym++)
7529 if (!strcmp(pszSymbol, g_aSyms[iSym].pszName))
7530 return &g_aSyms[iSym];
7531
7532 /** @todo externally registered symbols. */
7533 NOREF(pDbgc);
7534 return NULL;
7535}
7536
7537
7538/**
7539 * Resolves a symbol (or tries to do so at least).
7540 *
7541 * @returns 0 on success.
7542 * @returns VBox status on failure.
7543 * @param pDbgc The debug console instance.
7544 * @param pszSymbol The symbol name.
7545 * @param enmType The result type.
7546 * @param pResult Where to store the result.
7547 */
7548static int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult)
7549{
7550 /*
7551 * Builtin?
7552 */
7553 PCDBGCSYM pSymDesc = dbgcLookupRegisterSymbol(pDbgc, pszSymbol);
7554 if (pSymDesc)
7555 {
7556 if (!pSymDesc->pfnGet)
7557 return VERR_PARSE_WRITEONLY_SYMBOL;
7558 return pSymDesc->pfnGet(pSymDesc, &pDbgc->CmdHlp, enmType, pResult);
7559 }
7560
7561
7562 /*
7563 * Ask PDM.
7564 */
7565 /** @todo resolve symbols using PDM. */
7566
7567
7568 /*
7569 * Ask the debug info manager.
7570 */
7571 DBGFSYMBOL Symbol;
7572 int rc = DBGFR3SymbolByName(pDbgc->pVM, pszSymbol, &Symbol);
7573 if (VBOX_SUCCESS(rc))
7574 {
7575 /*
7576 * Default return is a flat gc address.
7577 */
7578 memset(pResult, 0, sizeof(*pResult));
7579 pResult->enmRangeType = Symbol.cb ? DBGCVAR_RANGE_BYTES : DBGCVAR_RANGE_NONE;
7580 pResult->u64Range = Symbol.cb;
7581 pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
7582 pResult->u.GCFlat = Symbol.Value;
7583 DBGCVAR VarTmp;
7584 switch (enmType)
7585 {
7586 /* nothing to do. */
7587 case DBGCVAR_TYPE_GC_FLAT:
7588 case DBGCVAR_TYPE_GC_FAR:
7589 case DBGCVAR_TYPE_ANY:
7590 return VINF_SUCCESS;
7591
7592 /* simply make it numeric. */
7593 case DBGCVAR_TYPE_NUMBER:
7594 pResult->enmType = DBGCVAR_TYPE_NUMBER;
7595 pResult->u.u64Number = Symbol.Value;
7596 return VINF_SUCCESS;
7597
7598 /* cast it. */
7599
7600 case DBGCVAR_TYPE_GC_PHYS:
7601 VarTmp = *pResult;
7602 return dbgcOpAddrPhys(pDbgc, &VarTmp, pResult);
7603
7604 case DBGCVAR_TYPE_HC_FAR:
7605 case DBGCVAR_TYPE_HC_FLAT:
7606 VarTmp = *pResult;
7607 return dbgcOpAddrHost(pDbgc, &VarTmp, pResult);
7608
7609 case DBGCVAR_TYPE_HC_PHYS:
7610 VarTmp = *pResult;
7611 return dbgcOpAddrHostPhys(pDbgc, &VarTmp, pResult);
7612
7613 default:
7614 AssertMsgFailed(("Internal error enmType=%d\n", enmType));
7615 return VERR_INVALID_PARAMETER;
7616 }
7617 }
7618
7619 return VERR_PARSE_NOT_IMPLEMENTED;
7620}
7621
7622
7623
7624/**
7625 * Finds a routine.
7626 *
7627 * @returns Pointer to the command descriptor.
7628 * If the request was for an external command, the caller is responsible for
7629 * unlocking the external command list.
7630 * @returns NULL if not found.
7631 * @param pDbgc The debug console instance.
7632 * @param pachName Pointer to the routine string (not terminated).
7633 * @param cchName Length of the routine name.
7634 * @param fExternal Whether or not the routine is external.
7635 */
7636static PCDBGCCMD dbgcRoutineLookup(PDBGC pDbgc, const char *pachName, size_t cchName, bool fExternal)
7637{
7638 if (!fExternal)
7639 {
7640 /* emulation first, so commands can be overloaded (info ++). */
7641 PCDBGCCMD pCmd = pDbgc->paEmulationCmds;
7642 unsigned cLeft = pDbgc->cEmulationCmds;
7643 while (cLeft-- > 0)
7644 {
7645 if ( !strncmp(pachName, pCmd->pszCmd, cchName)
7646 && !pCmd->pszCmd[cchName])
7647 return pCmd;
7648 pCmd++;
7649 }
7650
7651 for (unsigned iCmd = 0; iCmd < ELEMENTS(g_aCmds); iCmd++)
7652 {
7653 if ( !strncmp(pachName, g_aCmds[iCmd].pszCmd, cchName)
7654 && !g_aCmds[iCmd].pszCmd[cchName])
7655 return &g_aCmds[iCmd];
7656 }
7657 }
7658 else
7659 {
7660 DBGCEXTCMDS_LOCK_RD();
7661 for (PDBGCEXTCMDS pExtCmds = g_pExtCmdsHead; pExtCmds; pExtCmds = pExtCmds->pNext)
7662 {
7663 for (unsigned iCmd = 0; iCmd < pExtCmds->cCmds; iCmd++)
7664 {
7665 if ( !strncmp(pachName, pExtCmds->paCmds[iCmd].pszCmd, cchName)
7666 && !pExtCmds->paCmds[iCmd].pszCmd[cchName])
7667 return &pExtCmds->paCmds[iCmd];
7668 }
7669 }
7670 DBGCEXTCMDS_UNLOCK_RD();
7671 }
7672
7673 NOREF(pDbgc);
7674 return NULL;
7675}
7676
7677
7678/**
7679 * Searches for an operator descriptor which matches the start of
7680 * the expression given us.
7681 *
7682 * @returns Pointer to the operator on success.
7683 * @param pDbgc The debug console instance.
7684 * @param pszExpr Pointer to the expression string which might start with an operator.
7685 * @param fPreferBinary Whether to favour binary or unary operators.
7686 * Caller must assert that it's the disired type! Both types will still
7687 * be returned, this is only for resolving duplicates.
7688 * @param chPrev The previous char. Some operators requires a blank in front of it.
7689 */
7690static PCDBGCOP dbgcOperatorLookup(PDBGC pDbgc, const char *pszExpr, bool fPreferBinary, char chPrev)
7691{
7692 PCDBGCOP pOp = NULL;
7693 for (unsigned iOp = 0; iOp < ELEMENTS(g_aOps); iOp++)
7694 {
7695 if ( g_aOps[iOp].szName[0] == pszExpr[0]
7696 && (!g_aOps[iOp].szName[1] || g_aOps[iOp].szName[1] == pszExpr[1])
7697 && (!g_aOps[iOp].szName[2] || g_aOps[iOp].szName[2] == pszExpr[2]))
7698 {
7699 /*
7700 * Check that we don't mistake it for some other operator which have more chars.
7701 */
7702 unsigned j;
7703 for (j = iOp + 1; j < ELEMENTS(g_aOps); j++)
7704 if ( g_aOps[j].cchName > g_aOps[iOp].cchName
7705 && g_aOps[j].szName[0] == pszExpr[0]
7706 && (!g_aOps[j].szName[1] || g_aOps[j].szName[1] == pszExpr[1])
7707 && (!g_aOps[j].szName[2] || g_aOps[j].szName[2] == pszExpr[2]) )
7708 break;
7709 if (j < ELEMENTS(g_aOps))
7710 continue; /* we'll catch it later. (for theoretical +,++,+++ cases.) */
7711 pOp = &g_aOps[iOp];
7712
7713 /*
7714 * Prefered type?
7715 */
7716 if (g_aOps[iOp].fBinary == fPreferBinary)
7717 break;
7718 }
7719 }
7720
7721 if (pOp)
7722 Log2(("dbgcOperatorLookup: pOp=%p %s\n", pOp, pOp->szName));
7723 NOREF(pDbgc); NOREF(chPrev);
7724 return pOp;
7725}
7726
7727
7728/**
7729 * Initalizes g_bmOperatorChars.
7730 */
7731static void dbgcInitOpCharBitMap(void)
7732{
7733 memset(g_bmOperatorChars, 0, sizeof(g_bmOperatorChars));
7734 for (unsigned iOp = 0; iOp < RT_ELEMENTS(g_aOps); iOp++)
7735 ASMBitSet(&g_bmOperatorChars[0], (uint8_t)g_aOps[iOp].szName[0]);
7736}
7737
7738
7739/**
7740 * Checks whether the character may be the start of an operator.
7741 *
7742 * @returns true/false.
7743 * @param ch The character.
7744 */
7745DECLINLINE(bool) dbgcIsOpChar(char ch)
7746{
7747 return ASMBitTest(&g_bmOperatorChars[0], (uint8_t)ch);
7748}
7749
7750
7751static int dbgcEvalSubString(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pArg)
7752{
7753 Log2(("dbgcEvalSubString: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
7754
7755 /*
7756 * Removing any quoting and escapings.
7757 */
7758 char ch = *pszExpr;
7759 if (ch == '"' || ch == '\'' || ch == '`')
7760 {
7761 if (pszExpr[--cchExpr] != ch)
7762 return VERR_PARSE_UNBALANCED_QUOTE;
7763 cchExpr--;
7764 pszExpr++;
7765
7766 /** @todo string unescaping. */
7767 }
7768 pszExpr[cchExpr] = '\0';
7769
7770 /*
7771 * Make the argument.
7772 */
7773 pArg->pDesc = NULL;
7774 pArg->pNext = NULL;
7775 pArg->enmType = DBGCVAR_TYPE_STRING;
7776 pArg->u.pszString = pszExpr;
7777 pArg->enmRangeType = DBGCVAR_RANGE_BYTES;
7778 pArg->u64Range = cchExpr;
7779
7780 NOREF(pDbgc);
7781 return 0;
7782}
7783
7784
7785static int dbgcEvalSubNum(char *pszExpr, unsigned uBase, PDBGCVAR pArg)
7786{
7787 Log2(("dbgcEvalSubNum: uBase=%d pszExpr=%s\n", uBase, pszExpr));
7788 /*
7789 * Convert to number.
7790 */
7791 uint64_t u64 = 0;
7792 char ch;
7793 while ((ch = *pszExpr) != '\0')
7794 {
7795 uint64_t u64Prev = u64;
7796 unsigned u = ch - '0';
7797 if (u < 10 && u < uBase)
7798 u64 = u64 * uBase + u;
7799 else if (ch >= 'a' && (u = ch - ('a' - 10)) < uBase)
7800 u64 = u64 * uBase + u;
7801 else if (ch >= 'A' && (u = ch - ('A' - 10)) < uBase)
7802 u64 = u64 * uBase + u;
7803 else
7804 return VERR_PARSE_INVALID_NUMBER;
7805
7806 /* check for overflow - ARG!!! How to detect overflow correctly!?!?!? */
7807 if (u64Prev != u64 / uBase)
7808 return VERR_PARSE_NUMBER_TOO_BIG;
7809
7810 /* next */
7811 pszExpr++;
7812 }
7813
7814 /*
7815 * Initialize the argument.
7816 */
7817 pArg->pDesc = NULL;
7818 pArg->pNext = NULL;
7819 pArg->enmType = DBGCVAR_TYPE_NUMBER;
7820 pArg->u.u64Number = u64;
7821 pArg->enmRangeType = DBGCVAR_RANGE_NONE;
7822 pArg->u64Range = 0;
7823
7824 return 0;
7825}
7826
7827
7828/**
7829 * Match variable and variable descriptor, promoting the variable if necessary.
7830 *
7831 * @returns VBox status code.
7832 * @param pDbgc Debug console instanace.
7833 * @param pVar Variable.
7834 * @param pVarDesc Variable descriptor.
7835 */
7836static int dbgcEvalSubMatchVar(PDBGC pDbgc, PDBGCVAR pVar, PCDBGCVARDESC pVarDesc)
7837{
7838 /*
7839 * (If match or promoted to match, return, else break.)
7840 */
7841 switch (pVarDesc->enmCategory)
7842 {
7843 /*
7844 * Anything goes
7845 */
7846 case DBGCVAR_CAT_ANY:
7847 return VINF_SUCCESS;
7848
7849 /*
7850 * Pointer with and without range.
7851 * We can try resolve strings and symbols as symbols and
7852 * promote numbers to flat GC pointers.
7853 */
7854 case DBGCVAR_CAT_POINTER_NO_RANGE:
7855 if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7856 return VERR_PARSE_NO_RANGE_ALLOWED;
7857 /* fallthru */
7858 case DBGCVAR_CAT_POINTER:
7859 switch (pVar->enmType)
7860 {
7861 case DBGCVAR_TYPE_GC_FLAT:
7862 case DBGCVAR_TYPE_GC_FAR:
7863 case DBGCVAR_TYPE_GC_PHYS:
7864 case DBGCVAR_TYPE_HC_FLAT:
7865 case DBGCVAR_TYPE_HC_FAR:
7866 case DBGCVAR_TYPE_HC_PHYS:
7867 return VINF_SUCCESS;
7868
7869 case DBGCVAR_TYPE_SYMBOL:
7870 case DBGCVAR_TYPE_STRING:
7871 {
7872 DBGCVAR Var;
7873 int rc = dbgcSymbolGet(pDbgc, pVar->u.pszString, DBGCVAR_TYPE_GC_FLAT, &Var);
7874 if (VBOX_SUCCESS(rc))
7875 {
7876 /* deal with range */
7877 if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7878 {
7879 Var.enmRangeType = pVar->enmRangeType;
7880 Var.u64Range = pVar->u64Range;
7881 }
7882 else if (pVarDesc->enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
7883 Var.enmRangeType = DBGCVAR_RANGE_NONE;
7884 *pVar = Var;
7885 return rc;
7886 }
7887 break;
7888 }
7889
7890 case DBGCVAR_TYPE_NUMBER:
7891 {
7892 RTGCPTR GCPtr = (RTGCPTR)pVar->u.u64Number;
7893 pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
7894 pVar->u.GCFlat = GCPtr;
7895 return VINF_SUCCESS;
7896 }
7897
7898 default:
7899 break;
7900 }
7901 break;
7902
7903 /*
7904 * GC pointer with and without range.
7905 * We can try resolve strings and symbols as symbols and
7906 * promote numbers to flat GC pointers.
7907 */
7908 case DBGCVAR_CAT_GC_POINTER_NO_RANGE:
7909 if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7910 return VERR_PARSE_NO_RANGE_ALLOWED;
7911 /* fallthru */
7912 case DBGCVAR_CAT_GC_POINTER:
7913 switch (pVar->enmType)
7914 {
7915 case DBGCVAR_TYPE_GC_FLAT:
7916 case DBGCVAR_TYPE_GC_FAR:
7917 case DBGCVAR_TYPE_GC_PHYS:
7918 return VINF_SUCCESS;
7919
7920 case DBGCVAR_TYPE_HC_FLAT:
7921 case DBGCVAR_TYPE_HC_FAR:
7922 case DBGCVAR_TYPE_HC_PHYS:
7923 return VERR_PARSE_CONVERSION_FAILED;
7924
7925 case DBGCVAR_TYPE_SYMBOL:
7926 case DBGCVAR_TYPE_STRING:
7927 {
7928 DBGCVAR Var;
7929 int rc = dbgcSymbolGet(pDbgc, pVar->u.pszString, DBGCVAR_TYPE_GC_FLAT, &Var);
7930 if (VBOX_SUCCESS(rc))
7931 {
7932 /* deal with range */
7933 if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7934 {
7935 Var.enmRangeType = pVar->enmRangeType;
7936 Var.u64Range = pVar->u64Range;
7937 }
7938 else if (pVarDesc->enmCategory == DBGCVAR_CAT_POINTER_NO_RANGE)
7939 Var.enmRangeType = DBGCVAR_RANGE_NONE;
7940 *pVar = Var;
7941 return rc;
7942 }
7943 break;
7944 }
7945
7946 case DBGCVAR_TYPE_NUMBER:
7947 {
7948 RTGCPTR GCPtr = (RTGCPTR)pVar->u.u64Number;
7949 pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
7950 pVar->u.GCFlat = GCPtr;
7951 return VINF_SUCCESS;
7952 }
7953
7954 default:
7955 break;
7956 }
7957 break;
7958
7959 /*
7960 * Number with or without a range.
7961 * Numbers can be resolved from symbols, but we cannot demote a pointer
7962 * to a number.
7963 */
7964 case DBGCVAR_CAT_NUMBER_NO_RANGE:
7965 if (pVar->enmRangeType != DBGCVAR_RANGE_NONE)
7966 return VERR_PARSE_NO_RANGE_ALLOWED;
7967 /* fallthru */
7968 case DBGCVAR_CAT_NUMBER:
7969 switch (pVar->enmType)
7970 {
7971 case DBGCVAR_TYPE_NUMBER:
7972 return VINF_SUCCESS;
7973
7974 case DBGCVAR_TYPE_SYMBOL:
7975 case DBGCVAR_TYPE_STRING:
7976 {
7977 DBGCVAR Var;
7978 int rc = dbgcSymbolGet(pDbgc, pVar->u.pszString, DBGCVAR_TYPE_NUMBER, &Var);
7979 if (VBOX_SUCCESS(rc))
7980 {
7981 *pVar = Var;
7982 return rc;
7983 }
7984 break;
7985 }
7986 default:
7987 break;
7988 }
7989 break;
7990
7991 /*
7992 * Strings can easily be made from symbols (and of course strings).
7993 * We could consider reformatting the addresses and numbers into strings later...
7994 */
7995 case DBGCVAR_CAT_STRING:
7996 switch (pVar->enmType)
7997 {
7998 case DBGCVAR_TYPE_SYMBOL:
7999 pVar->enmType = DBGCVAR_TYPE_STRING;
8000 /* fallthru */
8001 case DBGCVAR_TYPE_STRING:
8002 return VINF_SUCCESS;
8003 default:
8004 break;
8005 }
8006 break;
8007
8008 /*
8009 * Symol is pretty much the same thing as a string (at least until we actually implement it).
8010 */
8011 case DBGCVAR_CAT_SYMBOL:
8012 switch (pVar->enmType)
8013 {
8014 case DBGCVAR_TYPE_STRING:
8015 pVar->enmType = DBGCVAR_TYPE_SYMBOL;
8016 /* fallthru */
8017 case DBGCVAR_TYPE_SYMBOL:
8018 return VINF_SUCCESS;
8019 default:
8020 break;
8021 }
8022 break;
8023
8024 /*
8025 * Anything else is illegal.
8026 */
8027 default:
8028 AssertMsgFailed(("enmCategory=%d\n", pVar->enmType));
8029 break;
8030 }
8031
8032 return VERR_PARSE_NO_ARGUMENT_MATCH;
8033}
8034
8035
8036/**
8037 * Matches a set of variables with a description set.
8038 *
8039 * This is typically used for routine arguments before a call. The effects in
8040 * addition to the validation, is that some variables might be propagated to
8041 * other types in order to match the description. The following transformations
8042 * are supported:
8043 * - String reinterpreted as a symbol and resolved to a number or pointer.
8044 * - Number to a pointer.
8045 * - Pointer to a number.
8046 * @returns 0 on success with paVars.
8047 * @returns VBox error code for match errors.
8048 */
8049static int dbgcEvalSubMatchVars(PDBGC pDbgc, unsigned cVarsMin, unsigned cVarsMax,
8050 PCDBGCVARDESC paVarDescs, unsigned cVarDescs,
8051 PDBGCVAR paVars, unsigned cVars)
8052{
8053 /*
8054 * Just do basic min / max checks first.
8055 */
8056 if (cVars < cVarsMin)
8057 return VERR_PARSE_TOO_FEW_ARGUMENTS;
8058 if (cVars > cVarsMax)
8059 return VERR_PARSE_TOO_MANY_ARGUMENTS;
8060
8061 /*
8062 * Match the descriptors and actual variables.
8063 */
8064 PCDBGCVARDESC pPrevDesc = NULL;
8065 unsigned cCurDesc = 0;
8066 unsigned iVar = 0;
8067 unsigned iVarDesc = 0;
8068 while (iVar < cVars)
8069 {
8070 /* walk the descriptors */
8071 if (iVarDesc >= cVarDescs)
8072 return VERR_PARSE_TOO_MANY_ARGUMENTS;
8073 if ( ( paVarDescs[iVarDesc].fFlags & DBGCVD_FLAGS_DEP_PREV
8074 && &paVarDescs[iVarDesc - 1] != pPrevDesc)
8075 || cCurDesc >= paVarDescs[iVarDesc].cTimesMax)
8076 {
8077 iVarDesc++;
8078 if (iVarDesc >= cVarDescs)
8079 return VERR_PARSE_TOO_MANY_ARGUMENTS;
8080 cCurDesc = 0;
8081 }
8082
8083 /*
8084 * Skip thru optional arguments until we find something which matches
8085 * or can easily be promoted to what the descriptor want.
8086 */
8087 for (;;)
8088 {
8089 int rc = dbgcEvalSubMatchVar(pDbgc, &paVars[iVar], &paVarDescs[iVarDesc]);
8090 if (VBOX_SUCCESS(rc))
8091 {
8092 paVars[iVar].pDesc = &paVarDescs[iVarDesc];
8093 cCurDesc++;
8094 break;
8095 }
8096
8097 /* can we advance? */
8098 if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
8099 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
8100 if (++iVarDesc >= cVarDescs)
8101 return VERR_PARSE_ARGUMENT_TYPE_MISMATCH;
8102 cCurDesc = 0;
8103 }
8104
8105 /* next var */
8106 iVar++;
8107 }
8108
8109 /*
8110 * Check that the rest of the descriptors are optional.
8111 */
8112 while (iVarDesc < cVarDescs)
8113 {
8114 if (paVarDescs[iVarDesc].cTimesMin > cCurDesc)
8115 return VERR_PARSE_TOO_FEW_ARGUMENTS;
8116 cCurDesc = 0;
8117
8118 /* next */
8119 iVarDesc++;
8120 }
8121
8122 return 0;
8123}
8124
8125
8126/**
8127 * Evaluates one argument with respect to unary operators.
8128 *
8129 * @returns 0 on success. pResult contains the result.
8130 * @returns VBox error code on parse or other evaluation error.
8131 *
8132 * @param pDbgc Debugger console instance data.
8133 * @param pszExpr The expression string.
8134 * @param pResult Where to store the result of the expression evaluation.
8135 */
8136static int dbgcEvalSubUnary(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult)
8137{
8138 Log2(("dbgcEvalSubUnary: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
8139
8140 /*
8141 * The state of the expression is now such that it will start by zero or more
8142 * unary operators and being followed by an expression of some kind.
8143 * The expression is either plain or in parenthesis.
8144 *
8145 * Being in a lazy, recursive mode today, the parsing is done as simple as possible. :-)
8146 * ASSUME: unary operators are all of equal precedence.
8147 */
8148 int rc = 0;
8149 PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, pszExpr, false, ' ');
8150 if (pOp)
8151 {
8152 /* binary operators means syntax error. */
8153 if (pOp->fBinary)
8154 return VERR_PARSE_UNEXPECTED_OPERATOR;
8155
8156 /*
8157 * If the next expression (the one following the unary operator) is in a
8158 * parenthesis a full eval is needed. If not the unary eval will suffice.
8159 */
8160 /* calc and strip next expr. */
8161 char *pszExpr2 = pszExpr + pOp->cchName;
8162 while (isblank(*pszExpr2))
8163 pszExpr2++;
8164
8165 if (!*pszExpr2)
8166 rc = VERR_PARSE_EMPTY_ARGUMENT;
8167 else
8168 {
8169 DBGCVAR Arg;
8170 if (*pszExpr2 == '(')
8171 rc = dbgcEvalSub(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), &Arg);
8172 else
8173 rc = dbgcEvalSubUnary(pDbgc, pszExpr2, cchExpr - (pszExpr2 - pszExpr), &Arg);
8174 if (VBOX_SUCCESS(rc))
8175 rc = pOp->pfnHandlerUnary(pDbgc, &Arg, pResult);
8176 }
8177 }
8178 else
8179 {
8180 /*
8181 * Didn't find any operators, so it we have to check if this can be an
8182 * function call before assuming numeric or string expression.
8183 *
8184 * (ASSUMPTIONS:)
8185 * A function name only contains alphanumerical chars and it can not start
8186 * with a numerical character.
8187 * Immediately following the name is a parenthesis which must over
8188 * the remaining part of the expression.
8189 */
8190 bool fExternal = *pszExpr == '.';
8191 char *pszFun = fExternal ? pszExpr + 1 : pszExpr;
8192 char *pszFunEnd = NULL;
8193 if (pszExpr[cchExpr - 1] == ')' && isalpha(*pszFun))
8194 {
8195 pszFunEnd = pszExpr + 1;
8196 while (*pszFunEnd != '(' && isalnum(*pszFunEnd))
8197 pszFunEnd++;
8198 if (*pszFunEnd != '(')
8199 pszFunEnd = NULL;
8200 }
8201
8202 if (pszFunEnd)
8203 {
8204 /*
8205 * Ok, it's a function call.
8206 */
8207 if (fExternal)
8208 pszExpr++, cchExpr--;
8209 PCDBGCCMD pFun = dbgcRoutineLookup(pDbgc, pszExpr, pszFunEnd - pszExpr, fExternal);
8210 if (!pFun)
8211 return VERR_PARSE_FUNCTION_NOT_FOUND;
8212 if (!pFun->pResultDesc)
8213 return VERR_PARSE_NOT_A_FUNCTION;
8214
8215 /*
8216 * Parse the expression in parenthesis.
8217 */
8218 cchExpr -= pszFunEnd - pszExpr;
8219 pszExpr = pszFunEnd;
8220 /** @todo implement multiple arguments. */
8221 DBGCVAR Arg;
8222 rc = dbgcEvalSub(pDbgc, pszExpr, cchExpr, &Arg);
8223 if (!rc)
8224 {
8225 rc = dbgcEvalSubMatchVars(pDbgc, pFun->cArgsMin, pFun->cArgsMax, pFun->paArgDescs, pFun->cArgDescs, &Arg, 1);
8226 if (!rc)
8227 rc = pFun->pfnHandler(pFun, &pDbgc->CmdHlp, pDbgc->pVM, &Arg, 1, pResult);
8228 }
8229 else if (rc == VERR_PARSE_EMPTY_ARGUMENT && pFun->cArgsMin == 0)
8230 rc = pFun->pfnHandler(pFun, &pDbgc->CmdHlp, pDbgc->pVM, NULL, 0, pResult);
8231 }
8232 else
8233 {
8234 /*
8235 * Didn't find any operators, so it must be a plain expression.
8236 * This might be numeric or a string expression.
8237 */
8238 char ch = pszExpr[0];
8239 char ch2 = pszExpr[1];
8240 if (ch == '0' && (ch2 == 'x' || ch2 == 'X'))
8241 rc = dbgcEvalSubNum(pszExpr + 2, 16, pResult);
8242 else if (ch == '0' && (ch2 == 'i' || ch2 == 'i'))
8243 rc = dbgcEvalSubNum(pszExpr + 2, 10, pResult);
8244 else if (ch == '0' && (ch2 == 't' || ch2 == 'T'))
8245 rc = dbgcEvalSubNum(pszExpr + 2, 8, pResult);
8246 /// @todo 0b doesn't work as a binary prefix, we confuse it with 0bf8:0123 and stuff.
8247 //else if (ch == '0' && (ch2 == 'b' || ch2 == 'b'))
8248 // rc = dbgcEvalSubNum(pszExpr + 2, 2, pResult);
8249 else
8250 {
8251 /*
8252 * Hexadecimal number or a string?
8253 */
8254 char *psz = pszExpr;
8255 while (isxdigit(*psz))
8256 psz++;
8257 if (!*psz)
8258 rc = dbgcEvalSubNum(pszExpr, 16, pResult);
8259 else if ((*psz == 'h' || *psz == 'H') && !psz[1])
8260 {
8261 *psz = '\0';
8262 rc = dbgcEvalSubNum(pszExpr, 16, pResult);
8263 }
8264 else
8265 rc = dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
8266 }
8267 }
8268 }
8269
8270 return rc;
8271}
8272
8273
8274/**
8275 * Evaluates one argument.
8276 *
8277 * @returns 0 on success. pResult contains the result.
8278 * @returns VBox error code on parse or other evaluation error.
8279 *
8280 * @param pDbgc Debugger console instance data.
8281 * @param pszExpr The expression string.
8282 * @param pResult Where to store the result of the expression evaluation.
8283 */
8284static int dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, PDBGCVAR pResult)
8285{
8286 Log2(("dbgcEvalSub: cchExpr=%d pszExpr=%s\n", cchExpr, pszExpr));
8287 /*
8288 * First we need to remove blanks in both ends.
8289 * ASSUMES: There is no quoting unless the entire expression is a string.
8290 */
8291
8292 /* stripping. */
8293 while (cchExpr > 0 && isblank(pszExpr[cchExpr - 1]))
8294 pszExpr[--cchExpr] = '\0';
8295 while (isblank(*pszExpr))
8296 pszExpr++, cchExpr--;
8297 if (!*pszExpr)
8298 return VERR_PARSE_EMPTY_ARGUMENT;
8299
8300 /* it there is any kind of quoting in the expression, it's string meat. */
8301 if (strpbrk(pszExpr, "\"'`"))
8302 return dbgcEvalSubString(pDbgc, pszExpr, cchExpr, pResult);
8303
8304 /*
8305 * Check if there are any parenthesis which needs removing.
8306 */
8307 if (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')')
8308 {
8309 do
8310 {
8311 unsigned cPar = 1;
8312 char *psz = pszExpr + 1;
8313 char ch;
8314 while ((ch = *psz) != '\0')
8315 {
8316 if (ch == '(')
8317 cPar++;
8318 else if (ch == ')')
8319 {
8320 if (cPar <= 0)
8321 return VERR_PARSE_UNBALANCED_PARENTHESIS;
8322 cPar--;
8323 if (cPar == 0 && psz[1]) /* If not at end, there's nothing to do. */
8324 break;
8325 }
8326 /* next */
8327 psz++;
8328 }
8329 if (ch)
8330 break;
8331
8332 /* remove the parenthesis. */
8333 pszExpr++;
8334 cchExpr -= 2;
8335 pszExpr[cchExpr] = '\0';
8336
8337 /* strip blanks. */
8338 while (cchExpr > 0 && isblank(pszExpr[cchExpr - 1]))
8339 pszExpr[--cchExpr] = '\0';
8340 while (isblank(*pszExpr))
8341 pszExpr++, cchExpr--;
8342 if (!*pszExpr)
8343 return VERR_PARSE_EMPTY_ARGUMENT;
8344 } while (pszExpr[0] == '(' && pszExpr[cchExpr - 1] == ')');
8345 }
8346
8347 /* tabs to spaces. */
8348 char *psz = pszExpr;
8349 while ((psz = strchr(psz, '\t')) != NULL)
8350 *psz = ' ';
8351
8352 /*
8353 * Now, we need to look for the binary operator with the lowest precedence.
8354 *
8355 * If there are no operators we're left with a simple expression which we
8356 * evaluate with respect to unary operators
8357 */
8358 char *pszOpSplit = NULL;
8359 PCDBGCOP pOpSplit = NULL;
8360 unsigned cBinaryOps = 0;
8361 unsigned cPar = 0;
8362 char ch;
8363 char chPrev = ' ';
8364 bool fBinary = false;
8365 psz = pszExpr;
8366
8367 while ((ch = *psz) != '\0')
8368 {
8369 //Log2(("ch=%c cPar=%d fBinary=%d\n", ch, cPar, fBinary));
8370 /*
8371 * Parenthesis.
8372 */
8373 if (ch == '(')
8374 {
8375 cPar++;
8376 fBinary = false;
8377 }
8378 else if (ch == ')')
8379 {
8380 if (cPar <= 0)
8381 return VERR_PARSE_UNBALANCED_PARENTHESIS;
8382 cPar--;
8383 fBinary = true;
8384 }
8385 /*
8386 * Potential operator.
8387 */
8388 else if (cPar == 0 && !isblank(ch))
8389 {
8390 PCDBGCOP pOp = dbgcIsOpChar(ch)
8391 ? dbgcOperatorLookup(pDbgc, psz, fBinary, chPrev)
8392 : NULL;
8393 if (pOp)
8394 {
8395 /* If not the right kind of operator we've got a syntax error. */
8396 if (pOp->fBinary != fBinary)
8397 return VERR_PARSE_UNEXPECTED_OPERATOR;
8398
8399 /*
8400 * Update the parse state and skip the operator.
8401 */
8402 if (!pOpSplit)
8403 {
8404 pOpSplit = pOp;
8405 pszOpSplit = psz;
8406 cBinaryOps = fBinary;
8407 }
8408 else if (fBinary)
8409 {
8410 cBinaryOps++;
8411 if (pOp->iPrecedence >= pOpSplit->iPrecedence)
8412 {
8413 pOpSplit = pOp;
8414 pszOpSplit = psz;
8415 }
8416 }
8417
8418 psz += pOp->cchName - 1;
8419 fBinary = false;
8420 }
8421 else
8422 fBinary = true;
8423 }
8424
8425 /* next */
8426 psz++;
8427 chPrev = ch;
8428 } /* parse loop. */
8429
8430
8431 /*
8432 * Either we found an operator to divide the expression by
8433 * or we didn't find any. In the first case it's divide and
8434 * conquer. In the latter it's a single expression which
8435 * needs dealing with its unary operators if any.
8436 */
8437 int rc;
8438 if ( cBinaryOps
8439 && pOpSplit->fBinary)
8440 {
8441 /* process 1st sub expression. */
8442 *pszOpSplit = '\0';
8443 DBGCVAR Arg1;
8444 rc = dbgcEvalSub(pDbgc, pszExpr, pszOpSplit - pszExpr, &Arg1);
8445 if (VBOX_SUCCESS(rc))
8446 {
8447 /* process 2nd sub expression. */
8448 char *psz2 = pszOpSplit + pOpSplit->cchName;
8449 DBGCVAR Arg2;
8450 rc = dbgcEvalSub(pDbgc, psz2, cchExpr - (psz2 - pszExpr), &Arg2);
8451 if (VBOX_SUCCESS(rc))
8452 /* apply the operator. */
8453 rc = pOpSplit->pfnHandlerBinary(pDbgc, &Arg1, &Arg2, pResult);
8454 }
8455 }
8456 else if (cBinaryOps)
8457 {
8458 /* process sub expression. */
8459 pszOpSplit += pOpSplit->cchName;
8460 DBGCVAR Arg;
8461 rc = dbgcEvalSub(pDbgc, pszOpSplit, cchExpr - (pszOpSplit - pszExpr), &Arg);
8462 if (VBOX_SUCCESS(rc))
8463 /* apply the operator. */
8464 rc = pOpSplit->pfnHandlerUnary(pDbgc, &Arg, pResult);
8465 }
8466 else
8467 /* plain expression or using unary operators perhaps with paratheses. */
8468 rc = dbgcEvalSubUnary(pDbgc, pszExpr, cchExpr, pResult);
8469
8470 return rc;
8471}
8472
8473
8474/**
8475 * Parses the arguments of one command.
8476 *
8477 * @returns 0 on success.
8478 * @returns VBox error code on parse error with *pcArg containing the argument causing trouble.
8479 * @param pDbgc Debugger console instance data.
8480 * @param pCmd Pointer to the command descriptor.
8481 * @param pszArg Pointer to the arguments to parse.
8482 * @param paArgs Where to store the parsed arguments.
8483 * @param cArgs Size of the paArgs array.
8484 * @param pcArgs Where to store the number of arguments.
8485 * In the event of an error this is used to store the index of the offending argument.
8486 */
8487static int dbgcProcessArguments(PDBGC pDbgc, PCDBGCCMD pCmd, char *pszArgs, PDBGCVAR paArgs, unsigned cArgs, unsigned *pcArgs)
8488{
8489 Log2(("dbgcProcessArguments: pCmd=%s pszArgs='%s'\n", pCmd->pszCmd, pszArgs));
8490 /*
8491 * Check if we have any argument and if the command takes any.
8492 */
8493 *pcArgs = 0;
8494 /* strip leading blanks. */
8495 while (*pszArgs && isblank(*pszArgs))
8496 pszArgs++;
8497 if (!*pszArgs)
8498 {
8499 if (!pCmd->cArgsMin)
8500 return 0;
8501 return VERR_PARSE_TOO_FEW_ARGUMENTS;
8502 }
8503 /** @todo fixme - foo() doesn't work. */
8504 if (!pCmd->cArgsMax)
8505 return VERR_PARSE_TOO_MANY_ARGUMENTS;
8506
8507 /*
8508 * This is a hack, it's "temporary" and should go away "when" the parser is
8509 * modified to match arguments while parsing.
8510 */
8511 if ( pCmd->cArgsMax == 1
8512 && pCmd->cArgsMin == 1
8513 && pCmd->cArgDescs == 1
8514 && pCmd->paArgDescs[0].enmCategory == DBGCVAR_CAT_STRING
8515 && cArgs >= 1)
8516 {
8517 *pcArgs = 1;
8518 RTStrStripR(pszArgs);
8519 return dbgcEvalSubString(pDbgc, pszArgs, strlen(pszArgs), &paArgs[0]);
8520 }
8521
8522
8523 /*
8524 * The parse loop.
8525 */
8526 PDBGCVAR pArg0 = &paArgs[0];
8527 PDBGCVAR pArg = pArg0;
8528 *pcArgs = 0;
8529 do
8530 {
8531 /*
8532 * Can we have another argument?
8533 */
8534 if (*pcArgs >= pCmd->cArgsMax)
8535 return VERR_PARSE_TOO_MANY_ARGUMENTS;
8536 if (pArg >= &paArgs[cArgs])
8537 return VERR_PARSE_ARGUMENT_OVERFLOW;
8538
8539 /*
8540 * Find the end of the argument.
8541 */
8542 int cPar = 0;
8543 char chQuote = '\0';
8544 char *pszEnd = NULL;
8545 char *psz = pszArgs;
8546 char ch;
8547 bool fBinary = false;
8548 for (;;)
8549 {
8550 /*
8551 * Check for the end.
8552 */
8553 if ((ch = *psz) == '\0')
8554 {
8555 if (chQuote)
8556 return VERR_PARSE_UNBALANCED_QUOTE;
8557 if (cPar)
8558 return VERR_PARSE_UNBALANCED_PARENTHESIS;
8559 pszEnd = psz;
8560 break;
8561 }
8562 /*
8563 * When quoted we ignore everything but the quotation char.
8564 * We use the REXX way of escaping the quotation char, i.e. double occurence.
8565 */
8566 else if (ch == '\'' || ch == '"' || ch == '`')
8567 {
8568 if (chQuote)
8569 {
8570 /* end quote? */
8571 if (ch == chQuote)
8572 {
8573 if (psz[1] == ch)
8574 psz++; /* skip the escaped quote char */
8575 else
8576 chQuote = '\0'; /* end of quoted string. */
8577 }
8578 }
8579 else
8580 chQuote = ch; /* open new quote */
8581 }
8582 /*
8583 * Parenthesis can of course be nested.
8584 */
8585 else if (ch == '(')
8586 {
8587 cPar++;
8588 fBinary = false;
8589 }
8590 else if (ch == ')')
8591 {
8592 if (!cPar)
8593 return VERR_PARSE_UNBALANCED_PARENTHESIS;
8594 cPar--;
8595 fBinary = true;
8596 }
8597 else if (!chQuote && !cPar)
8598 {
8599 /*
8600 * Encountering blanks may mean the end of it all. A binary operator
8601 * will force continued parsing.
8602 */
8603 if (isblank(*psz))
8604 {
8605 pszEnd = psz++; /* just in case. */
8606 while (isblank(*psz))
8607 psz++;
8608 PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, psz, fBinary, ' ');
8609 if (!pOp || pOp->fBinary != fBinary)
8610 break; /* the end. */
8611 psz += pOp->cchName;
8612 while (isblank(*psz)) /* skip blanks so we don't get here again */
8613 psz++;
8614 fBinary = false;
8615 continue;
8616 }
8617
8618 /*
8619 * Look for operators without a space up front.
8620 */
8621 if (dbgcIsOpChar(*psz))
8622 {
8623 PCDBGCOP pOp = dbgcOperatorLookup(pDbgc, psz, fBinary, ' ');
8624 if (pOp)
8625 {
8626 if (pOp->fBinary != fBinary)
8627 {
8628 pszEnd = psz;
8629 /** @todo this is a parsing error really. */
8630 break; /* the end. */
8631 }
8632 psz += pOp->cchName;
8633 while (isblank(*psz)) /* skip blanks so we don't get here again */
8634 psz++;
8635 fBinary = false;
8636 continue;
8637 }
8638 }
8639 fBinary = true;
8640 }
8641
8642 /* next char */
8643 psz++;
8644 }
8645 *pszEnd = '\0';
8646 /* (psz = next char to process) */
8647
8648 /*
8649 * Parse and evaluate the argument.
8650 */
8651 int rc = dbgcEvalSub(pDbgc, pszArgs, strlen(pszArgs), pArg);
8652 if (VBOX_FAILURE(rc))
8653 return rc;
8654
8655 /*
8656 * Next.
8657 */
8658 pArg++;
8659 (*pcArgs)++;
8660 pszArgs = psz;
8661 while (*pszArgs && isblank(*pszArgs))
8662 pszArgs++;
8663 } while (*pszArgs);
8664
8665 /*
8666 * Match the arguments.
8667 */
8668 return dbgcEvalSubMatchVars(pDbgc, pCmd->cArgsMin, pCmd->cArgsMax, pCmd->paArgDescs, pCmd->cArgDescs, pArg0, pArg - pArg0);
8669}
8670
8671
8672/**
8673 * Process one command.
8674 *
8675 * @returns VBox status code. Any error indicates the termination of the console session.
8676 * @param pDbgc Debugger console instance data.
8677 * @param pszCmd Pointer to the command.
8678 * @param cchCmd Length of the command.
8679 */
8680static int dbgcProcessCommand(PDBGC pDbgc, char *pszCmd, size_t cchCmd)
8681{
8682 char *pszCmdInput = pszCmd;
8683
8684 /*
8685 * Skip blanks.
8686 */
8687 while (isblank(*pszCmd))
8688 pszCmd++, cchCmd--;
8689
8690 /* external command? */
8691 bool fExternal = *pszCmd == '.';
8692 if (fExternal)
8693 pszCmd++, cchCmd--;
8694
8695 /*
8696 * Find arguments.
8697 */
8698 char *pszArgs = pszCmd;
8699 while (isalnum(*pszArgs))
8700 pszArgs++;
8701 if (*pszArgs && (!isblank(*pszArgs) || pszArgs == pszCmd))
8702 {
8703 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Syntax error in command '%s'!\n", pszCmdInput);
8704 return 0;
8705 }
8706
8707 /*
8708 * Find the command.
8709 */
8710 PCDBGCCMD pCmd = dbgcRoutineLookup(pDbgc, pszCmd, pszArgs - pszCmd, fExternal);
8711 if (!pCmd || (pCmd->fFlags & DBGCCMD_FLAGS_FUNCTION))
8712 return pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Unknown command '%s'!\n", pszCmdInput);
8713
8714 /*
8715 * Parse arguments (if any).
8716 */
8717 unsigned cArgs;
8718 int rc = dbgcProcessArguments(pDbgc, pCmd, pszArgs, &pDbgc->aArgs[pDbgc->iArg], ELEMENTS(pDbgc->aArgs) - pDbgc->iArg, &cArgs);
8719
8720 /*
8721 * Execute the command.
8722 */
8723 if (!rc)
8724 {
8725 rc = pCmd->pfnHandler(pCmd, &pDbgc->CmdHlp, pDbgc->pVM, &pDbgc->aArgs[0], cArgs, NULL);
8726 }
8727 else
8728 {
8729 /* report parse / eval error. */
8730 switch (rc)
8731 {
8732 case VERR_PARSE_TOO_FEW_ARGUMENTS:
8733 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8734 "Syntax error: Too few arguments. Minimum is %d for command '%s'.\n", pCmd->cArgsMin, pCmd->pszCmd);
8735 break;
8736 case VERR_PARSE_TOO_MANY_ARGUMENTS:
8737 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8738 "Syntax error: Too many arguments. Maximum is %d for command '%s'.\n", pCmd->cArgsMax, pCmd->pszCmd);
8739 break;
8740 case VERR_PARSE_ARGUMENT_OVERFLOW:
8741 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8742 "Syntax error: Too many arguments.\n");
8743 break;
8744 case VERR_PARSE_UNBALANCED_QUOTE:
8745 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8746 "Syntax error: Unbalanced quote (argument %d).\n", cArgs);
8747 break;
8748 case VERR_PARSE_UNBALANCED_PARENTHESIS:
8749 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8750 "Syntax error: Unbalanced parenthesis (argument %d).\n", cArgs);
8751 break;
8752 case VERR_PARSE_EMPTY_ARGUMENT:
8753 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8754 "Syntax error: An argument or subargument contains nothing useful (argument %d).\n", cArgs);
8755 break;
8756 case VERR_PARSE_UNEXPECTED_OPERATOR:
8757 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8758 "Syntax error: Invalid operator usage (argument %d).\n", cArgs);
8759 break;
8760 case VERR_PARSE_INVALID_NUMBER:
8761 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8762 "Syntax error: Ivalid numeric value (argument %d). If a string was the intention, then quote it.\n", cArgs);
8763 break;
8764 case VERR_PARSE_NUMBER_TOO_BIG:
8765 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8766 "Error: Numeric overflow (argument %d).\n", cArgs);
8767 break;
8768 case VERR_PARSE_INVALID_OPERATION:
8769 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8770 "Error: Invalid operation attempted (argument %d).\n", cArgs);
8771 break;
8772 case VERR_PARSE_FUNCTION_NOT_FOUND:
8773 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8774 "Error: Function not found (argument %d).\n", cArgs);
8775 break;
8776 case VERR_PARSE_NOT_A_FUNCTION:
8777 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8778 "Error: The function specified is not a function (argument %d).\n", cArgs);
8779 break;
8780 case VERR_PARSE_NO_MEMORY:
8781 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8782 "Error: Out memory in the regular heap! Expect odd stuff to happen...\n", cArgs);
8783 break;
8784 case VERR_PARSE_INCORRECT_ARG_TYPE:
8785 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8786 "Error: Incorrect argument type (argument %d?).\n", cArgs);
8787 break;
8788 case VERR_PARSE_VARIABLE_NOT_FOUND:
8789 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8790 "Error: An undefined variable was referenced (argument %d).\n", cArgs);
8791 break;
8792 case VERR_PARSE_CONVERSION_FAILED:
8793 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8794 "Error: A conversion between two types failed (argument %d).\n", cArgs);
8795 break;
8796 case VERR_PARSE_NOT_IMPLEMENTED:
8797 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8798 "Error: You hit a debugger feature which isn't implemented yet (argument %d).\n", cArgs);
8799 break;
8800 case VERR_PARSE_BAD_RESULT_TYPE:
8801 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8802 "Error: Couldn't satisfy a request for a specific result type (argument %d). (Usually applies to symbols)\n", cArgs);
8803 break;
8804 case VERR_PARSE_WRITEONLY_SYMBOL:
8805 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8806 "Error: Cannot get symbol, it's set only (argument %d).\n", cArgs);
8807 break;
8808
8809 default:
8810 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
8811 "Error: Unknown error %d!\n", rc);
8812 return rc;
8813 }
8814
8815 /*
8816 * Parse errors are non fatal.
8817 */
8818 if (rc >= VERR_PARSE_FIRST && rc < VERR_PARSE_LAST)
8819 rc = 0;
8820 }
8821
8822 return rc;
8823}
8824
8825
8826/**
8827 * Process all commands current in the buffer.
8828 *
8829 * @returns VBox status code. Any error indicates the termination of the console session.
8830 * @param pDbgc Debugger console instance data.
8831 */
8832static int dbgcProcessCommands(PDBGC pDbgc)
8833{
8834 int rc = 0;
8835 while (pDbgc->cInputLines)
8836 {
8837 /*
8838 * Empty the log buffer if we're hooking the log.
8839 */
8840 if (pDbgc->fLog)
8841 {
8842 rc = dbgcProcessLog(pDbgc);
8843 if (VBOX_FAILURE(rc))
8844 break;
8845 }
8846
8847 if (pDbgc->iRead == pDbgc->iWrite)
8848 {
8849 AssertMsgFailed(("The input buffer is empty while cInputLines=%d!\n", pDbgc->cInputLines));
8850 pDbgc->cInputLines = 0;
8851 return 0;
8852 }
8853
8854 /*
8855 * Copy the command to the parse buffer.
8856 */
8857 char ch;
8858 char *psz = &pDbgc->achInput[pDbgc->iRead];
8859 char *pszTrg = &pDbgc->achScratch[0];
8860 while ((*pszTrg = ch = *psz++) != ';' && ch != '\n' )
8861 {
8862 if (psz == &pDbgc->achInput[sizeof(pDbgc->achInput)])
8863 psz = &pDbgc->achInput[0];
8864
8865 if (psz == &pDbgc->achInput[pDbgc->iWrite])
8866 {
8867 AssertMsgFailed(("The buffer contains no commands while cInputLines=%d!\n", pDbgc->cInputLines));
8868 pDbgc->cInputLines = 0;
8869 return 0;
8870 }
8871
8872 pszTrg++;
8873 }
8874 *pszTrg = '\0';
8875
8876 /*
8877 * Advance the buffer.
8878 */
8879 pDbgc->iRead = psz - &pDbgc->achInput[0];
8880 if (ch == '\n')
8881 pDbgc->cInputLines--;
8882
8883 /*
8884 * Parse and execute this command.
8885 */
8886 pDbgc->pszScratch = psz;
8887 pDbgc->iArg = 0;
8888 rc = dbgcProcessCommand(pDbgc, &pDbgc->achScratch[0], psz - &pDbgc->achScratch[0] - 1);
8889 if (rc)
8890 break;
8891 }
8892
8893 return rc;
8894}
8895
8896
8897/**
8898 * Reads input, parses it and executes commands on '\n'.
8899 *
8900 * @returns VBox status.
8901 * @param pDbgc Debugger console instance data.
8902 */
8903static int dbgcProcessInput(PDBGC pDbgc)
8904{
8905 /*
8906 * We know there's input ready, so let's read it first.
8907 */
8908 int rc = dbgcInputRead(pDbgc);
8909 if (VBOX_FAILURE(rc))
8910 return rc;
8911
8912 /*
8913 * Now execute any ready commands.
8914 */
8915 if (pDbgc->cInputLines)
8916 {
8917 /** @todo this fReady stuff is broken. */
8918 pDbgc->fReady = false;
8919 rc = dbgcProcessCommands(pDbgc);
8920 if (VBOX_SUCCESS(rc) && rc != VWRN_DBGC_CMD_PENDING)
8921 pDbgc->fReady = true;
8922 if ( VBOX_SUCCESS(rc)
8923 && pDbgc->iRead == pDbgc->iWrite
8924 && pDbgc->fReady)
8925 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
8926 }
8927
8928 return rc;
8929}
8930
8931
8932/**
8933 * Gets the event context identifier string.
8934 * @returns Read only string.
8935 * @param enmCtx The context.
8936 */
8937static const char *dbgcGetEventCtx(DBGFEVENTCTX enmCtx)
8938{
8939 switch (enmCtx)
8940 {
8941 case DBGFEVENTCTX_RAW: return "raw";
8942 case DBGFEVENTCTX_REM: return "rem";
8943 case DBGFEVENTCTX_HWACCL: return "hwaccl";
8944 case DBGFEVENTCTX_HYPER: return "hyper";
8945 case DBGFEVENTCTX_OTHER: return "other";
8946
8947 case DBGFEVENTCTX_INVALID: return "!Invalid Event Ctx!";
8948 default:
8949 AssertMsgFailed(("enmCtx=%d\n", enmCtx));
8950 return "!Unknown Event Ctx!";
8951 }
8952}
8953
8954
8955/**
8956 * Processes debugger events.
8957 *
8958 * @returns VBox status.
8959 * @param pDbgc DBGC Instance data.
8960 * @param pEvent Pointer to event data.
8961 */
8962static int dbgcProcessEvent(PDBGC pDbgc, PCDBGFEVENT pEvent)
8963{
8964 /*
8965 * Flush log first.
8966 */
8967 if (pDbgc->fLog)
8968 {
8969 int rc = dbgcProcessLog(pDbgc);
8970 if (VBOX_FAILURE(rc))
8971 return rc;
8972 }
8973
8974 /*
8975 * Process the event.
8976 */
8977 pDbgc->pszScratch = &pDbgc->achInput[0];
8978 pDbgc->iArg = 0;
8979 bool fPrintPrompt = true;
8980 int rc = VINF_SUCCESS;
8981 switch (pEvent->enmType)
8982 {
8983 /*
8984 * The first part is events we have initiated with commands.
8985 */
8986 case DBGFEVENT_HALT_DONE:
8987 {
8988 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: VM %p is halted! (%s)\n",
8989 pDbgc->pVM, dbgcGetEventCtx(pEvent->enmCtx));
8990 pDbgc->fRegCtxGuest = true; /* we're always in guest context when halted. */
8991 if (VBOX_SUCCESS(rc))
8992 rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
8993 break;
8994 }
8995
8996
8997 /*
8998 * The second part is events which can occur at any time.
8999 */
9000 case DBGFEVENT_FATAL_ERROR:
9001 {
9002 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbf event: Fatal error! (%s)\n",
9003 dbgcGetEventCtx(pEvent->enmCtx));
9004 pDbgc->fRegCtxGuest = false; /* fatal errors are always in hypervisor. */
9005 if (VBOX_SUCCESS(rc))
9006 rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
9007 break;
9008 }
9009
9010 case DBGFEVENT_BREAKPOINT:
9011 case DBGFEVENT_BREAKPOINT_HYPER:
9012 {
9013 bool fRegCtxGuest = pDbgc->fRegCtxGuest;
9014 pDbgc->fRegCtxGuest = pEvent->enmType == DBGFEVENT_BREAKPOINT;
9015
9016 rc = dbgcBpExec(pDbgc, pEvent->u.Bp.iBp);
9017 switch (rc)
9018 {
9019 case VERR_DBGC_BP_NOT_FOUND:
9020 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Unknown breakpoint %u! (%s)\n",
9021 pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
9022 break;
9023
9024 case VINF_DBGC_BP_NO_COMMAND:
9025 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Breakpoint %u! (%s)\n",
9026 pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
9027 break;
9028
9029 case VINF_BUFFER_OVERFLOW:
9030 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Breakpoint %u! Command too long to execute! (%s)\n",
9031 pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
9032 break;
9033
9034 default:
9035 break;
9036 }
9037 if (VBOX_SUCCESS(rc) && DBGFR3IsHalted(pDbgc->pVM))
9038 rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
9039 else
9040 pDbgc->fRegCtxGuest = fRegCtxGuest;
9041 break;
9042 }
9043
9044 case DBGFEVENT_STEPPED:
9045 case DBGFEVENT_STEPPED_HYPER:
9046 {
9047 pDbgc->fRegCtxGuest = pEvent->enmType == DBGFEVENT_STEPPED;
9048
9049 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Single step! (%s)\n", dbgcGetEventCtx(pEvent->enmCtx));
9050 if (VBOX_SUCCESS(rc))
9051 rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
9052 break;
9053 }
9054
9055 case DBGFEVENT_ASSERTION_HYPER:
9056 {
9057 pDbgc->fRegCtxGuest = false;
9058
9059 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9060 "\ndbgf event: Hypervisor Assertion! (%s)\n"
9061 "%s"
9062 "%s"
9063 "\n",
9064 dbgcGetEventCtx(pEvent->enmCtx),
9065 pEvent->u.Assert.pszMsg1,
9066 pEvent->u.Assert.pszMsg2);
9067 if (VBOX_SUCCESS(rc))
9068 rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
9069 break;
9070 }
9071
9072 case DBGFEVENT_DEV_STOP:
9073 {
9074 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9075 "\n"
9076 "dbgf event: DBGFSTOP (%s)\n"
9077 "File: %s\n"
9078 "Line: %d\n"
9079 "Function: %s\n",
9080 dbgcGetEventCtx(pEvent->enmCtx),
9081 pEvent->u.Src.pszFile,
9082 pEvent->u.Src.uLine,
9083 pEvent->u.Src.pszFunction);
9084 if (VBOX_SUCCESS(rc) && pEvent->u.Src.pszMessage && *pEvent->u.Src.pszMessage)
9085 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9086 "Message: %s\n",
9087 pEvent->u.Src.pszMessage);
9088 if (VBOX_SUCCESS(rc))
9089 rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
9090 break;
9091 }
9092
9093
9094 case DBGFEVENT_INVALID_COMMAND:
9095 {
9096 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf/dbgc error: Invalid command event!\n");
9097 fPrintPrompt = !pDbgc->fReady;
9098 break;
9099 }
9100
9101 case DBGFEVENT_TERMINATING:
9102 {
9103 pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\nVM is terminating!\n");
9104 rc = VERR_GENERAL_FAILURE;
9105 break;
9106 }
9107
9108
9109 default:
9110 {
9111 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf/dbgc error: Unknown event %d!\n", pEvent->enmType);
9112 fPrintPrompt = !pDbgc->fReady;
9113 break;
9114 }
9115 }
9116
9117 /*
9118 * Prompt, anyone?
9119 */
9120 if (fPrintPrompt && VBOX_SUCCESS(rc))
9121 {
9122 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
9123 }
9124
9125 return rc;
9126}
9127
9128
9129
9130
9131
9132/**
9133 * Make a console instance.
9134 *
9135 * This will not return until either an 'exit' command is issued or a error code
9136 * indicating connection loss is encountered.
9137 *
9138 * @returns VINF_SUCCESS if console termination caused by the 'exit' command.
9139 * @returns The VBox status code causing the console termination.
9140 *
9141 * @param pVM VM Handle.
9142 * @param pBack Pointer to the backend structure. This must contain
9143 * a full set of function pointers to service the console.
9144 * @param fFlags Reserved, must be zero.
9145 * @remark A forced termination of the console is easiest done by forcing the
9146 * callbacks to return fatal failures.
9147 */
9148DBGDECL(int) DBGCCreate(PVM pVM, PDBGCBACK pBack, unsigned fFlags)
9149{
9150 /*
9151 * Validate input.
9152 */
9153 AssertReturn(VALID_PTR(pVM), VERR_INVALID_PARAMETER);
9154 AssertReturn(VALID_PTR(pBack), VERR_INVALID_PARAMETER);
9155 AssertMsgReturn(!fFlags, ("%#x", fFlags), VERR_INVALID_PARAMETER);
9156
9157 /*
9158 * Allocate and initialize instance data
9159 */
9160 PDBGC pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
9161 if (!pDbgc)
9162 return VERR_NO_MEMORY;
9163
9164 pDbgc->CmdHlp.pfnWrite = dbgcHlpWrite;
9165 pDbgc->CmdHlp.pfnPrintfV = dbgcHlpPrintfV;
9166 pDbgc->CmdHlp.pfnPrintf = dbgcHlpPrintf;
9167 pDbgc->CmdHlp.pfnVBoxErrorV = dbgcHlpVBoxErrorV;
9168 pDbgc->CmdHlp.pfnVBoxError = dbgcHlpVBoxError;
9169 pDbgc->CmdHlp.pfnMemRead = dbgcHlpMemRead;
9170 pDbgc->CmdHlp.pfnMemWrite = dbgcHlpMemWrite;
9171 pDbgc->CmdHlp.pfnEval = dbgcHlpEval;
9172 pDbgc->CmdHlp.pfnExec = dbgcHlpExec;
9173 pDbgc->CmdHlp.pfnVarToDbgfAddr = dbgcHlpVarToDbgfAddr;
9174 pDbgc->CmdHlp.pfnVarToBool = dbgcHlpVarToBool;
9175 pDbgc->pBack = pBack;
9176 pDbgc->pVM = NULL;
9177 pDbgc->pszEmulation = "CodeView/WinDbg";
9178 pDbgc->paEmulationCmds = &g_aCmdsCodeView[0];
9179 pDbgc->cEmulationCmds = RT_ELEMENTS(g_aCmdsCodeView);
9180 //pDbgc->fLog = false;
9181 pDbgc->fRegCtxGuest = true;
9182 pDbgc->fRegTerse = true;
9183 //pDbgc->DisasmPos = {0};
9184 //pDbgc->SourcePos = {0};
9185 //pDbgc->DumpPos = {0};
9186 //pDbgc->cbDumpElement = 0;
9187 //pDbgc->cVars = 0;
9188 //pDbgc->paVars = NULL;
9189 //pDbgc->pFirstBp = NULL;
9190 //pDbgc->uInputZero = 0;
9191 //pDbgc->iRead = 0;
9192 //pDbgc->iWrite = 0;
9193 //pDbgc->cInputLines = 0;
9194 //pDbgc->fInputOverflow = false;
9195 pDbgc->fReady = true;
9196 pDbgc->pszScratch = &pDbgc->achScratch[0];
9197 //pDbgc->iArg = 0;
9198 //pDbgc->rcOutput = 0;
9199
9200 dbgcInitOpCharBitMap();
9201
9202 /*
9203 * Print welcome message.
9204 */
9205 int rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9206 "Welcome to the VirtualBox Debugger!\n");
9207 if (VBOX_FAILURE(rc))
9208 goto l_failure;
9209
9210 /*
9211 * Attach to the VM.
9212 */
9213 rc = DBGFR3Attach(pVM);
9214 if (VBOX_FAILURE(rc))
9215 {
9216 rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
9217 goto l_failure;
9218 }
9219 pDbgc->pVM = pVM;
9220
9221 /*
9222 * Print commandline and auto select result.
9223 */
9224 rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
9225 "Current VM is %08x\n" /** @todo get and print the VM name! */
9226 "VBoxDbg> ",
9227 pDbgc->pVM);
9228 if (VBOX_FAILURE(rc))
9229 goto l_failure;
9230
9231 /*
9232 * Main Debugger Loop.
9233 *
9234 * This loop will either block on waiting for input or on waiting on
9235 * debug events. If we're forwarding the log we cannot wait for long
9236 * before we must flush the log.
9237 */
9238 for (rc = 0;;)
9239 {
9240 if (pDbgc->pVM && DBGFR3CanWait(pDbgc->pVM))
9241 {
9242 /*
9243 * Wait for a debug event.
9244 */
9245 PCDBGFEVENT pEvent;
9246 rc = DBGFR3EventWait(pDbgc->pVM, pDbgc->fLog ? 1 : 32, &pEvent);
9247 if (VBOX_SUCCESS(rc))
9248 {
9249 rc = dbgcProcessEvent(pDbgc, pEvent);
9250 if (VBOX_FAILURE(rc))
9251 break;
9252 }
9253 else if (rc != VERR_TIMEOUT)
9254 break;
9255
9256 /*
9257 * Check for input.
9258 */
9259 if (pBack->pfnInput(pDbgc->pBack, 0))
9260 {
9261 rc = dbgcProcessInput(pDbgc);
9262 if (VBOX_FAILURE(rc))
9263 break;
9264 }
9265 }
9266 else
9267 {
9268 /*
9269 * Wait for input. If Logging is enabled we'll only wait very briefly.
9270 */
9271 if (pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
9272 {
9273 rc = dbgcProcessInput(pDbgc);
9274 if (VBOX_FAILURE(rc))
9275 break;
9276 }
9277 }
9278
9279 /*
9280 * Forward log output.
9281 */
9282 if (pDbgc->fLog)
9283 {
9284 rc = dbgcProcessLog(pDbgc);
9285 if (VBOX_FAILURE(rc))
9286 break;
9287 }
9288 }
9289
9290
9291l_failure:
9292 /*
9293 * Cleanup console debugger session.
9294 */
9295 /* Disable log hook. */
9296 if (pDbgc->fLog)
9297 {
9298
9299 }
9300
9301 /* Detach from the VM. */
9302 if (pDbgc->pVM)
9303 DBGFR3Detach(pDbgc->pVM);
9304
9305 /* finally, free the instance memory. */
9306 RTMemFree(pDbgc);
9307
9308 return rc;
9309}
9310
9311
9312
9313/**
9314 * Register one or more external commands.
9315 *
9316 * @returns VBox status.
9317 * @param paCommands Pointer to an array of command descriptors.
9318 * The commands must be unique. It's not possible
9319 * to register the same commands more than once.
9320 * @param cCommands Number of commands.
9321 */
9322DBGDECL(int) DBGCRegisterCommands(PCDBGCCMD paCommands, unsigned cCommands)
9323{
9324 /*
9325 * Lock the list.
9326 */
9327 DBGCEXTCMDS_LOCK_WR();
9328 PDBGCEXTCMDS pCur = g_pExtCmdsHead;
9329 while (pCur)
9330 {
9331 if (paCommands == pCur->paCmds)
9332 {
9333 DBGCEXTCMDS_UNLOCK_WR();
9334 AssertMsgFailed(("Attempt at re-registering %d command(s)!\n", cCommands));
9335 return VWRN_DBGC_ALREADY_REGISTERED;
9336 }
9337 pCur = pCur->pNext;
9338 }
9339
9340 /*
9341 * Allocate new chunk.
9342 */
9343 int rc = 0;
9344 pCur = (PDBGCEXTCMDS)RTMemAlloc(sizeof(*pCur));
9345 if (pCur)
9346 {
9347 pCur->cCmds = cCommands;
9348 pCur->paCmds = paCommands;
9349 pCur->pNext = g_pExtCmdsHead;
9350 g_pExtCmdsHead = pCur;
9351 }
9352 else
9353 rc = VERR_NO_MEMORY;
9354 DBGCEXTCMDS_UNLOCK_WR();
9355
9356 return rc;
9357}
9358
9359
9360/**
9361 * Deregister one or more external commands previously registered by
9362 * DBGCRegisterCommands().
9363 *
9364 * @returns VBox status.
9365 * @param paCommands Pointer to an array of command descriptors
9366 * as given to DBGCRegisterCommands().
9367 * @param cCommands Number of commands.
9368 */
9369DBGDECL(int) DBGCDeregisterCommands(PCDBGCCMD paCommands, unsigned cCommands)
9370{
9371 /*
9372 * Lock the list.
9373 */
9374 DBGCEXTCMDS_LOCK_WR();
9375 PDBGCEXTCMDS pPrev = NULL;
9376 PDBGCEXTCMDS pCur = g_pExtCmdsHead;
9377 while (pCur)
9378 {
9379 if (paCommands == pCur->paCmds)
9380 {
9381 if (pPrev)
9382 pPrev->pNext = pCur->pNext;
9383 else
9384 g_pExtCmdsHead = pCur->pNext;
9385 DBGCEXTCMDS_UNLOCK_WR();
9386
9387 RTMemFree(pCur);
9388 return VINF_SUCCESS;
9389 }
9390 pPrev = pCur;
9391 pCur = pCur->pNext;
9392 }
9393 DBGCEXTCMDS_UNLOCK_WR();
9394
9395 NOREF(cCommands);
9396 return VERR_DBGC_COMMANDS_NOT_REGISTERED;
9397}
9398
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette