DBGConsole.cpp@ 45012

Last change on this file since 45012 was 45006, checked in by vboxsync, 12 years ago
DBGF/DBGC: Fixing power off problems.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.1 KB

Line
1	/* $Id: DBGConsole.cpp 45006 2013-03-12 14:58:51Z vboxsync $ */
2	/** @file
3	* DBGC - Debugger Console.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/** @page pg_dbgc DBGC - The Debug Console
20	*
21	* The debugger console is an early attempt to make some interactive
22	* debugging facilities for the VirtualBox VMM. It was initially only
23	* accessible thru a telnet session in debug builds. Later it was hastily built
24	* into the VBoxDbg module with a very simple Qt wrapper around it.
25	*
26	* The current state is that it's by default shipped with all standard
27	* VirtualBox builds. The GUI component is by default accessible in all
28	* non-release builds, while release builds require extra data, environment or
29	* command line options to make it visible.
30	*
31	* Now, even if we ship it with all standard builds we would like it to remain
32	* an optional feature that can be omitted when building VirtualBox. Therefore,
33	* all external code interfacing DBGC need to be enclosed in
34	* \#ifdef VBOX_WITH_DEBUGGER blocks. This is mandatory for components that
35	* register external commands.
36	*
37	*
38	* @section sec_dbgc_op Operation
39	*
40	* The console will process commands in a manner similar to the OS/2 and Windows
41	* kernel debuggers. This means ';' is a command separator and that when
42	* possible we'll use the same command names as these two uses. As an
43	* alternative we intent to provide a set of gdb-like commands as well and let
44	* the user decide which should take precedence.
45	*
46	*
47	* @subsection sec_dbg_op_numbers Numbers
48	*
49	* Numbers are hexadecimal unless specified with a prefix indicating
50	* elsewise. Prefixes:
51	* - '0x' - hexadecimal.
52	* - '0n' - decimal
53	* - '0t' - octal.
54	* - '0y' - binary.
55	*
56	* Some of the prefixes are a bit uncommon, the reason for this that the
57	* typical binary prefix '0b' can also be a hexadecimal value since no prefix or
58	* suffix is required for such values. Ditto for '0n' and '0' for decimal and
59	* octal.
60	*
61	* The '`' can be used in the numeric value to separate parts as the user
62	* wishes. Generally, though the debugger may use it in output as thousand
63	* separator in decimal numbers and 32-bit separator in hex numbers.
64	*
65	* For historical reasons, a 'h' suffix is suffered on hex numbers. Unlike most
66	* assemblers, a leading 0 before a-f is not required with the 'h' suffix.
67	*
68	* The prefix '0i' can be used instead of '0n', as it was the early decimal
69	* prefix employed by DBGC. It's being deprecated and may be removed later.
70	*
71	*
72	* @subsection sec_dbg_op_strings Strings and Symbols
73	*
74	* The debugger will try to guess, convert or promote what the type of an
75	* argument to a command, function or operator based on the input description of
76	* the receiver. If the user wants to make it clear to the debugger that
77	* something is a string, put it inside double quotes. Symbols should use
78	* single quotes, though we're current still a bit flexible on this point.
79	*
80	* If you need to put a quote character inside the quoted text, you escape it by
81	* repating it once: echo "printf(""hello world"");"
82	*
83	*
84	* @subsection sec_dbg_op_address Addressing modes
85	*
86	* - Default is flat. For compatibility '%' also means flat.
87	* - Segmented addresses are specified selector:offset.
88	* - Physical addresses are specified using '%%'.
89	* - The default target for the addressing is the guest context, the '#'
90	* will override this and set it to the host.
91	* Note that several operations won't work on host addresses.
92	*
93	* The '%', '%%' and '#' prefixes is implemented as unary operators, while ':'
94	* is a binary operator. Operator precedence takes care of evaluation order.
95	*
96	*
97	* @subsection sec_dbg_op_c_operators C/C++ Operators
98	*
99	* Most unary and binary arithmetic, comparison, logical and bitwise C/C++
100	* operators are supported by the debugger, with the same precedence rules of
101	* course. There is one notable change made due to the unary '%' and '%%'
102	* operators, and that is that the modulo (remainder) operator is called 'mod'
103	* instead of '%'. This saves a lot of trouble separating argument.
104	*
105	* There are no assignment operators. Instead some simple global variable space
106	* is provided thru the 'set' and 'unset' commands and the unary '$' operator.
107	*
108	*
109	* @subsection sec_dbg_op_registers Registers
110	*
111	* All registers and their sub-fields exposed by the DBGF API are accessible via
112	* the '\@' operator. A few CPU register are accessible directly (as symbols)
113	* without using the '\@' operator. Hypervisor registers are accessible by
114	* prefixing the register name with a dot ('.').
115	*
116	*
117	* @subsection sec_dbg_op_commands Commands
118	*
119	* Commands names are case sensitive. By convention they are lower cased, starts
120	* with a letter but may contain digits and underscores afterwards. Operators
121	* are not allowed in the name (not even part of it), as we would risk
122	* misunderstanding it otherwise.
123	*
124	* Commands returns a status code.
125	*
126	* The '.' prefix indicates the set of external commands. External commands are
127	* command registered by VMM components.
128	*
129	*
130	* @subsection sec_dbg_op_functions Functions
131	*
132	* Functions are similar to commands, but return a variable and can only be used
133	* as part of an expression making up the argument of a command, function,
134	* operator or language statement (if we get around to implement that).
135	*
136	*
137	* @section sec_dbgc_logging Logging
138	*
139	* The idea is to be able to pass thru debug and release logs to the console
140	* if the user so wishes. This feature requires some kind of hook into the
141	* logger instance and while this was sketched it hasn't yet been implemented
142	* (dbgcProcessLog and DBGC::fLog).
143	*
144	* This feature has not materialized and probably never will.
145	*
146	*
147	* @section sec_dbgc_linking Linking and API
148	*
149	* The DBGC code is linked into the VBoxVMM module.
150	*
151	* IMachineDebugger may one day be extended with a DBGC interface so we can work
152	* with DBGC remotely without requiring TCP. Some questions about callbacks
153	* (for output) and security (you may wish to restrict users from debugging a
154	* VM) needs to be answered first though.
155	*/
156
157
158	/*******************************************************************************
159	* Header Files *
160	*******************************************************************************/
161	#define LOG_GROUP LOG_GROUP_DBGC
162	#include <VBox/dbg.h>
163	#include <VBox/vmm/dbgf.h>
164	#include <VBox/vmm/vmapi.h> /* VMR3GetVM() */
165	#include <VBox/err.h>
166	#include <VBox/log.h>
167
168	#include <iprt/asm.h>
169	#include <iprt/assert.h>
170	#include <iprt/mem.h>
171	#include <iprt/string.h>
172
173	#include "DBGCInternal.h"
174	#include "DBGPlugIns.h"
175
176
177	/*******************************************************************************
178	* Internal Functions *
179	*******************************************************************************/
180	static int dbgcProcessLog(PDBGC pDbgc);
181
182
183	/**
184	* Resolves a symbol (or tries to do so at least).
185	*
186	* @returns 0 on success.
187	* @returns VBox status on failure.
188	* @param pDbgc The debug console instance.
189	* @param pszSymbol The symbol name.
190	* @param enmType The result type. Specifying DBGCVAR_TYPE_GC_FAR may
191	* cause failure, avoid it.
192	* @param pResult Where to store the result.
193	*/
194	int dbgcSymbolGet(PDBGC pDbgc, const char *pszSymbol, DBGCVARTYPE enmType, PDBGCVAR pResult)
195	{
196	int rc;
197
198	/*
199	* Builtin?
200	*/
201	PCDBGCSYM pSymDesc = dbgcLookupRegisterSymbol(pDbgc, pszSymbol);
202	if (pSymDesc)
203	{
204	if (!pSymDesc->pfnGet)
205	return VERR_DBGC_PARSE_WRITEONLY_SYMBOL;
206	return pSymDesc->pfnGet(pSymDesc, &pDbgc->CmdHlp, enmType, pResult);
207	}
208
209	/*
210	* A typical register? (Guest only)
211	*/
212	static const char s_szSixLetterRegisters[] =
213	"rflags;eflags;"
214	;
215	static const char s_szThreeLetterRegisters[] =
216	"eax;rax;" "r10;" "r8d;r8w;r8b;" "cr0;" "dr0;"
217	"ebx;rbx;" "r11;" "r9d;r9w;r8b;" "dr1;"
218	"ecx;rcx;" "r12;" "cr2;" "dr2;"
219	"edx;rdx;" "r13;" "cr3;" "dr3;"
220	"edi;rdi;dil;" "r14;" "cr4;" "dr4;"
221	"esi;rsi;sil;" "r15;" "cr8;"
222	"ebp;rbp;"
223	"esp;rsp;" "dr6;"
224	"rip;eip;" "dr7;"
225	"efl;"
226	;
227	static const char s_szTwoLetterRegisters[] =
228	"ax;al;ah;" "r8;"
229	"bx;bl;bh;" "r9;"
230	"cx;cl;ch;" "cs;"
231	"dx;dl;dh;" "ds;"
232	"di;" "es;"
233	"si;" "fs;"
234	"bp;" "gs;"
235	"sp;" "ss;"
236	"ip;"
237	;
238	size_t const cchSymbol = strlen(pszSymbol);
239	if ( (cchSymbol == 2 && strstr(s_szTwoLetterRegisters, pszSymbol))
240	\|\| (cchSymbol == 3 && strstr(s_szThreeLetterRegisters, pszSymbol))
241	\|\| (cchSymbol == 6 && strstr(s_szSixLetterRegisters, pszSymbol)))
242	{
243	if (!strchr(pszSymbol, ';'))
244	{
245	DBGCVAR Var;
246	DBGCVAR_INIT_SYMBOL(&Var, pszSymbol);
247	rc = dbgcOpRegister(pDbgc, &Var, DBGCVAR_CAT_ANY, pResult);
248	if (RT_SUCCESS(rc))
249	return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pResult, enmType, false /fConvSyms/, pResult);
250	}
251	}
252
253	/*
254	* Ask PDM.
255	*/
256	/** @todo resolve symbols using PDM. */
257
258	/*
259	* Ask the debug info manager.
260	*/
261	RTDBGSYMBOL Symbol;
262	rc = DBGFR3AsSymbolByName(pDbgc->pUVM, pDbgc->hDbgAs, pszSymbol, &Symbol, NULL);
263	if (RT_SUCCESS(rc))
264	{
265	/*
266	* Default return is a flat gc address.
267	*/
268	DBGCVAR_INIT_GC_FLAT(pResult, Symbol.Value);
269	if (Symbol.cb)
270	DBGCVAR_SET_RANGE(pResult, DBGCVAR_RANGE_BYTES, Symbol.cb);
271
272	switch (enmType)
273	{
274	/* nothing to do. */
275	case DBGCVAR_TYPE_GC_FLAT:
276	case DBGCVAR_TYPE_ANY:
277	return VINF_SUCCESS;
278
279	/* impossible at the moment. */
280	case DBGCVAR_TYPE_GC_FAR:
281	return VERR_DBGC_PARSE_CONVERSION_FAILED;
282
283	/* simply make it numeric. */
284	case DBGCVAR_TYPE_NUMBER:
285	pResult->enmType = DBGCVAR_TYPE_NUMBER;
286	pResult->u.u64Number = Symbol.Value;
287	return VINF_SUCCESS;
288
289	/* cast it. */
290	case DBGCVAR_TYPE_GC_PHYS:
291	case DBGCVAR_TYPE_HC_FLAT:
292	case DBGCVAR_TYPE_HC_PHYS:
293	return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pResult, enmType, false /fConvSyms/, pResult);
294
295	default:
296	AssertMsgFailed(("Internal error enmType=%d\n", enmType));
297	return VERR_INVALID_PARAMETER;
298	}
299	}
300
301	return VERR_DBGC_PARSE_NOT_IMPLEMENTED;
302	}
303
304
305	/**
306	* Process all commands currently in the buffer.
307	*
308	* @returns VBox status code. Any error indicates the termination of the console session.
309	* @param pDbgc Debugger console instance data.
310	* @param fNoExecute Indicates that no commands should actually be executed.
311	*/
312	static int dbgcProcessCommands(PDBGC pDbgc, bool fNoExecute)
313	{
314	/** @todo Replace this with a sh/ksh/csh/rexx like toplevel language that
315	* allows doing function, loops, if, cases, and such. */
316	int rc = VINF_SUCCESS;
317	while (pDbgc->cInputLines)
318	{
319	/*
320	* Empty the log buffer if we're hooking the log.
321	*/
322	if (pDbgc->fLog)
323	{
324	rc = dbgcProcessLog(pDbgc);
325	if (RT_FAILURE(rc))
326	break;
327	}
328
329	if (pDbgc->iRead == pDbgc->iWrite)
330	{
331	AssertMsgFailed(("The input buffer is empty while cInputLines=%d!\n", pDbgc->cInputLines));
332	pDbgc->cInputLines = 0;
333	return 0;
334	}
335
336	/*
337	* Copy the command to the parse buffer.
338	*/
339	char ch;
340	char *psz = &pDbgc->achInput[pDbgc->iRead];
341	char *pszTrg = &pDbgc->achScratch[0];
342	while ((pszTrg = ch = psz++) != ';' && ch != '\n' )
343	{
344	if (psz == &pDbgc->achInput[sizeof(pDbgc->achInput)])
345	psz = &pDbgc->achInput[0];
346
347	if (psz == &pDbgc->achInput[pDbgc->iWrite])
348	{
349	AssertMsgFailed(("The buffer contains no commands while cInputLines=%d!\n", pDbgc->cInputLines));
350	pDbgc->cInputLines = 0;
351	return 0;
352	}
353
354	pszTrg++;
355	}
356	*pszTrg = '\0';
357
358	/*
359	* Advance the buffer.
360	*/
361	pDbgc->iRead = psz - &pDbgc->achInput[0];
362	if (ch == '\n')
363	pDbgc->cInputLines--;
364
365	/*
366	* Parse and execute this command.
367	*/
368	pDbgc->pszScratch = pszTrg + 1;
369	pDbgc->iArg = 0;
370	rc = dbgcEvalCommand(pDbgc, &pDbgc->achScratch[0], pszTrg - &pDbgc->achScratch[0] - 1, fNoExecute);
371	if ( rc == VERR_DBGC_QUIT
372	\|\| rc == VWRN_DBGC_CMD_PENDING)
373	break;
374	rc = VINF_SUCCESS; /* ignore other statuses */
375	}
376
377	return rc;
378	}
379
380
381	/**
382	* Handle input buffer overflow.
383	*
384	* Will read any available input looking for a '\n' to reset the buffer on.
385	*
386	* @returns VBox status.
387	* @param pDbgc Debugger console instance data.
388	*/
389	static int dbgcInputOverflow(PDBGC pDbgc)
390	{
391	/*
392	* Assert overflow status and reset the input buffer.
393	*/
394	if (!pDbgc->fInputOverflow)
395	{
396	pDbgc->fInputOverflow = true;
397	pDbgc->iRead = pDbgc->iWrite = 0;
398	pDbgc->cInputLines = 0;
399	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "Input overflow!!\n");
400	}
401
402	/*
403	* Eat input till no more or there is a '\n'.
404	* When finding a '\n' we'll continue normal processing.
405	*/
406	while (pDbgc->pBack->pfnInput(pDbgc->pBack, 0))
407	{
408	size_t cbRead;
409	int rc = pDbgc->pBack->pfnRead(pDbgc->pBack, &pDbgc->achInput[0], sizeof(pDbgc->achInput) - 1, &cbRead);
410	if (RT_FAILURE(rc))
411	return rc;
412	char psz = (char )memchr(&pDbgc->achInput[0], '\n', cbRead);
413	if (psz)
414	{
415	pDbgc->fInputOverflow = false;
416	pDbgc->iRead = psz - &pDbgc->achInput[0] + 1;
417	pDbgc->iWrite = (unsigned)cbRead;
418	pDbgc->cInputLines = 0;
419	break;
420	}
421	}
422
423	return 0;
424	}
425
426
427	/**
428	* Read input and do some preprocessing.
429	*
430	* @returns VBox status.
431	* In addition to the iWrite and achInput, cInputLines is maintained.
432	* In case of an input overflow the fInputOverflow flag will be set.
433	* @param pDbgc Debugger console instance data.
434	*/
435	static int dbgcInputRead(PDBGC pDbgc)
436	{
437	/*
438	* We have ready input.
439	* Read it till we don't have any or we have a full input buffer.
440	*/
441	int rc = 0;
442	do
443	{
444	/*
445	* More available buffer space?
446	*/
447	size_t cbLeft;
448	if (pDbgc->iWrite > pDbgc->iRead)
449	cbLeft = sizeof(pDbgc->achInput) - pDbgc->iWrite - (pDbgc->iRead == 0);
450	else
451	cbLeft = pDbgc->iRead - pDbgc->iWrite - 1;
452	if (!cbLeft)
453	{
454	/* overflow? */
455	if (!pDbgc->cInputLines)
456	rc = dbgcInputOverflow(pDbgc);
457	break;
458	}
459
460	/*
461	* Read one char and interpret it.
462	*/
463	char achRead[128];
464	size_t cbRead;
465	rc = pDbgc->pBack->pfnRead(pDbgc->pBack, &achRead[0], RT_MIN(cbLeft, sizeof(achRead)), &cbRead);
466	if (RT_FAILURE(rc))
467	return rc;
468	char *psz = &achRead[0];
469	while (cbRead-- > 0)
470	{
471	char ch = *psz++;
472	switch (ch)
473	{
474	/*
475	* Ignore.
476	*/
477	case '\0':
478	case '\r':
479	case '\a':
480	break;
481
482	/*
483	* Backspace.
484	*/
485	case '\b':
486	Log2(("DBGC: backspace\n"));
487	if (pDbgc->iRead != pDbgc->iWrite)
488	{
489	unsigned iWriteUndo = pDbgc->iWrite;
490	if (pDbgc->iWrite)
491	pDbgc->iWrite--;
492	else
493	pDbgc->iWrite = sizeof(pDbgc->achInput) - 1;
494
495	if (pDbgc->achInput[pDbgc->iWrite] == '\n')
496	pDbgc->iWrite = iWriteUndo;
497	}
498	break;
499
500	/*
501	* Add char to buffer.
502	*/
503	case '\t':
504	case '\n':
505	case ';':
506	switch (ch)
507	{
508	case '\t': ch = ' '; break;
509	case '\n': pDbgc->cInputLines++; break;
510	}
511	default:
512	Log2(("DBGC: ch=%02x\n", (unsigned char)ch));
513	pDbgc->achInput[pDbgc->iWrite] = ch;
514	if (++pDbgc->iWrite >= sizeof(pDbgc->achInput))
515	pDbgc->iWrite = 0;
516	break;
517	}
518	}
519
520	/* Terminate it to make it easier to read in the debugger. */
521	pDbgc->achInput[pDbgc->iWrite] = '\0';
522	} while (pDbgc->pBack->pfnInput(pDbgc->pBack, 0));
523
524	return rc;
525	}
526
527
528	/**
529	* Reads input, parses it and executes commands on '\n'.
530	*
531	* @returns VBox status.
532	* @param pDbgc Debugger console instance data.
533	* @param fNoExecute Indicates that no commands should actually be executed.
534	*/
535	int dbgcProcessInput(PDBGC pDbgc, bool fNoExecute)
536	{
537	/*
538	* We know there's input ready, so let's read it first.
539	*/
540	int rc = dbgcInputRead(pDbgc);
541	if (RT_FAILURE(rc))
542	return rc;
543
544	/*
545	* Now execute any ready commands.
546	*/
547	if (pDbgc->cInputLines)
548	{
549	pDbgc->pBack->pfnSetReady(pDbgc->pBack, false);
550	pDbgc->fReady = false;
551	rc = dbgcProcessCommands(pDbgc, fNoExecute);
552	if (RT_SUCCESS(rc) && rc != VWRN_DBGC_CMD_PENDING)
553	pDbgc->fReady = true;
554
555	if ( RT_SUCCESS(rc)
556	&& pDbgc->iRead == pDbgc->iWrite
557	&& pDbgc->fReady)
558	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
559
560	if ( RT_SUCCESS(rc)
561	&& pDbgc->fReady)
562	pDbgc->pBack->pfnSetReady(pDbgc->pBack, true);
563	}
564	else
565	/* Received nonsense; just skip it. */
566	pDbgc->iRead = pDbgc->iWrite;
567
568	return rc;
569	}
570
571
572	/**
573	* Gets the event context identifier string.
574	* @returns Read only string.
575	* @param enmCtx The context.
576	*/
577	static const char *dbgcGetEventCtx(DBGFEVENTCTX enmCtx)
578	{
579	switch (enmCtx)
580	{
581	case DBGFEVENTCTX_RAW: return "raw";
582	case DBGFEVENTCTX_REM: return "rem";
583	case DBGFEVENTCTX_HM: return "hwaccl";
584	case DBGFEVENTCTX_HYPER: return "hyper";
585	case DBGFEVENTCTX_OTHER: return "other";
586
587	case DBGFEVENTCTX_INVALID: return "!Invalid Event Ctx!";
588	default:
589	AssertMsgFailed(("enmCtx=%d\n", enmCtx));
590	return "!Unknown Event Ctx!";
591	}
592	}
593
594
595	/**
596	* Processes debugger events.
597	*
598	* @returns VBox status.
599	* @param pDbgc DBGC Instance data.
600	* @param pEvent Pointer to event data.
601	*/
602	static int dbgcProcessEvent(PDBGC pDbgc, PCDBGFEVENT pEvent)
603	{
604	/*
605	* Flush log first.
606	*/
607	if (pDbgc->fLog)
608	{
609	int rc = dbgcProcessLog(pDbgc);
610	if (RT_FAILURE(rc))
611	return rc;
612	}
613
614	/*
615	* Process the event.
616	*/
617	pDbgc->pszScratch = &pDbgc->achInput[0];
618	pDbgc->iArg = 0;
619	bool fPrintPrompt = true;
620	int rc = VINF_SUCCESS;
621	switch (pEvent->enmType)
622	{
623	/*
624	* The first part is events we have initiated with commands.
625	*/
626	case DBGFEVENT_HALT_DONE:
627	{
628	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: VM %p is halted! (%s)\n",
629	pDbgc->pVM, dbgcGetEventCtx(pEvent->enmCtx));
630	pDbgc->fRegCtxGuest = true; /* we're always in guest context when halted. */
631	if (RT_SUCCESS(rc))
632	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
633	break;
634	}
635
636
637	/*
638	* The second part is events which can occur at any time.
639	*/
640	case DBGFEVENT_FATAL_ERROR:
641	{
642	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbf event: Fatal error! (%s)\n",
643	dbgcGetEventCtx(pEvent->enmCtx));
644	pDbgc->fRegCtxGuest = false; /* fatal errors are always in hypervisor. */
645	if (RT_SUCCESS(rc))
646	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
647	break;
648	}
649
650	case DBGFEVENT_BREAKPOINT:
651	case DBGFEVENT_BREAKPOINT_HYPER:
652	{
653	bool fRegCtxGuest = pDbgc->fRegCtxGuest;
654	pDbgc->fRegCtxGuest = pEvent->enmType == DBGFEVENT_BREAKPOINT;
655
656	rc = dbgcBpExec(pDbgc, pEvent->u.Bp.iBp);
657	switch (rc)
658	{
659	case VERR_DBGC_BP_NOT_FOUND:
660	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Unknown breakpoint %u! (%s)\n",
661	pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
662	break;
663
664	case VINF_DBGC_BP_NO_COMMAND:
665	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Breakpoint %u! (%s)\n",
666	pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
667	break;
668
669	case VINF_BUFFER_OVERFLOW:
670	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Breakpoint %u! Command too long to execute! (%s)\n",
671	pEvent->u.Bp.iBp, dbgcGetEventCtx(pEvent->enmCtx));
672	break;
673
674	default:
675	break;
676	}
677	if (RT_SUCCESS(rc) && DBGFR3IsHalted(pDbgc->pUVM))
678	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
679	else
680	pDbgc->fRegCtxGuest = fRegCtxGuest;
681	break;
682	}
683
684	case DBGFEVENT_STEPPED:
685	case DBGFEVENT_STEPPED_HYPER:
686	{
687	pDbgc->fRegCtxGuest = pEvent->enmType == DBGFEVENT_STEPPED;
688
689	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf event: Single step! (%s)\n", dbgcGetEventCtx(pEvent->enmCtx));
690	if (RT_SUCCESS(rc))
691	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
692	break;
693	}
694
695	case DBGFEVENT_ASSERTION_HYPER:
696	{
697	pDbgc->fRegCtxGuest = false;
698
699	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
700	"\ndbgf event: Hypervisor Assertion! (%s)\n"
701	"%s"
702	"%s"
703	"\n",
704	dbgcGetEventCtx(pEvent->enmCtx),
705	pEvent->u.Assert.pszMsg1,
706	pEvent->u.Assert.pszMsg2);
707	if (RT_SUCCESS(rc))
708	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
709	break;
710	}
711
712	case DBGFEVENT_DEV_STOP:
713	{
714	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
715	"\n"
716	"dbgf event: DBGFSTOP (%s)\n"
717	"File: %s\n"
718	"Line: %d\n"
719	"Function: %s\n",
720	dbgcGetEventCtx(pEvent->enmCtx),
721	pEvent->u.Src.pszFile,
722	pEvent->u.Src.uLine,
723	pEvent->u.Src.pszFunction);
724	if (RT_SUCCESS(rc) && pEvent->u.Src.pszMessage && *pEvent->u.Src.pszMessage)
725	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
726	"Message: %s\n",
727	pEvent->u.Src.pszMessage);
728	if (RT_SUCCESS(rc))
729	rc = pDbgc->CmdHlp.pfnExec(&pDbgc->CmdHlp, "r");
730	break;
731	}
732
733
734	case DBGFEVENT_INVALID_COMMAND:
735	{
736	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf/dbgc error: Invalid command event!\n");
737	break;
738	}
739
740	case DBGFEVENT_POWERING_OFF:
741	{
742	pDbgc->fReady = false;
743	pDbgc->pBack->pfnSetReady(pDbgc->pBack, false);
744	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\nVM is powering off!\n");
745	fPrintPrompt = false;
746	rc = VERR_GENERAL_FAILURE;
747	break;
748	}
749
750
751	default:
752	{
753	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\ndbgf/dbgc error: Unknown event %d!\n", pEvent->enmType);
754	break;
755	}
756	}
757
758	/*
759	* Prompt, anyone?
760	*/
761	if (fPrintPrompt && RT_SUCCESS(rc))
762	{
763	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
764	pDbgc->fReady = true;
765	if (RT_SUCCESS(rc))
766	pDbgc->pBack->pfnSetReady(pDbgc->pBack, true);
767	}
768
769	return rc;
770	}
771
772
773	/**
774	* Prints any log lines from the log buffer.
775	*
776	* The caller must not call function this unless pDbgc->fLog is set.
777	*
778	* @returns VBox status. (output related)
779	* @param pDbgc Debugger console instance data.
780	*/
781	static int dbgcProcessLog(PDBGC pDbgc)
782	{
783	/** @todo */
784	NOREF(pDbgc);
785	return 0;
786	}
787
788
789	/**
790	* Run the debugger console.
791	*
792	* @returns VBox status.
793	* @param pDbgc Pointer to the debugger console instance data.
794	*/
795	int dbgcRun(PDBGC pDbgc)
796	{
797	/*
798	* We're ready for commands now.
799	*/
800	pDbgc->fReady = true;
801	pDbgc->pBack->pfnSetReady(pDbgc->pBack, true);
802
803	/*
804	* Main Debugger Loop.
805	*
806	* This loop will either block on waiting for input or on waiting on
807	* debug events. If we're forwarding the log we cannot wait for long
808	* before we must flush the log.
809	*/
810	int rc;
811	for (;;)
812	{
813	rc = VERR_SEM_OUT_OF_TURN;
814	if (pDbgc->pUVM)
815	rc = DBGFR3QueryWaitable(pDbgc->pUVM);
816
817	if (RT_SUCCESS(rc))
818	{
819	/*
820	* Wait for a debug event.
821	*/
822	PCDBGFEVENT pEvent;
823	rc = DBGFR3EventWait(pDbgc->pUVM, pDbgc->fLog ? 1 : 32, &pEvent);
824	if (RT_SUCCESS(rc))
825	{
826	rc = dbgcProcessEvent(pDbgc, pEvent);
827	if (RT_FAILURE(rc))
828	break;
829	}
830	else if (rc != VERR_TIMEOUT)
831	break;
832
833	/*
834	* Check for input.
835	*/
836	if (pDbgc->pBack->pfnInput(pDbgc->pBack, 0))
837	{
838	rc = dbgcProcessInput(pDbgc, false /* fNoExecute */);
839	if (RT_FAILURE(rc))
840	break;
841	}
842	}
843	else if (rc == VERR_SEM_OUT_OF_TURN)
844	{
845	/*
846	* Wait for input. If Logging is enabled we'll only wait very briefly.
847	*/
848	if (pDbgc->pBack->pfnInput(pDbgc->pBack, pDbgc->fLog ? 1 : 1000))
849	{
850	rc = dbgcProcessInput(pDbgc, false /* fNoExecute */);
851	if (RT_FAILURE(rc))
852	break;
853	}
854	}
855	else
856	break;
857
858	/*
859	* Forward log output.
860	*/
861	if (pDbgc->fLog)
862	{
863	rc = dbgcProcessLog(pDbgc);
864	if (RT_FAILURE(rc))
865	break;
866	}
867	}
868
869	return rc;
870	}
871
872
873	/**
874	* Creates a a new instance.
875	*
876	* @returns VBox status code.
877	* @param ppDbgc Where to store the pointer to the instance data.
878	* @param pBack Pointer to the backend.
879	* @param fFlags The flags.
880	*/
881	int dbgcCreate(PDBGC *ppDbgc, PDBGCBACK pBack, unsigned fFlags)
882	{
883	/*
884	* Validate input.
885	*/
886	AssertPtrReturn(pBack, VERR_INVALID_POINTER);
887	AssertMsgReturn(!fFlags, ("%#x", fFlags), VERR_INVALID_PARAMETER);
888
889	/*
890	* Allocate and initialize.
891	*/
892	PDBGC pDbgc = (PDBGC)RTMemAllocZ(sizeof(*pDbgc));
893	if (!pDbgc)
894	return VERR_NO_MEMORY;
895
896	dbgcInitCmdHlp(pDbgc);
897	pDbgc->pBack = pBack;
898	pDbgc->pVM = NULL;
899	pDbgc->pUVM = NULL;
900	pDbgc->idCpu = 0;
901	pDbgc->hDbgAs = DBGF_AS_GLOBAL;
902	pDbgc->pszEmulation = "CodeView/WinDbg";
903	pDbgc->paEmulationCmds = &g_aCmdsCodeView[0];
904	pDbgc->cEmulationCmds = g_cCmdsCodeView;
905	pDbgc->paEmulationFuncs = &g_aFuncsCodeView[0];
906	pDbgc->cEmulationFuncs = g_cFuncsCodeView;
907	//pDbgc->fLog = false;
908	pDbgc->fRegCtxGuest = true;
909	pDbgc->fRegTerse = true;
910	//pDbgc->cPagingHierarchyDumps = 0;
911	//pDbgc->DisasmPos = {0};
912	//pDbgc->SourcePos = {0};
913	//pDbgc->DumpPos = {0};
914	pDbgc->pLastPos = &pDbgc->DisasmPos;
915	//pDbgc->cbDumpElement = 0;
916	//pDbgc->cVars = 0;
917	//pDbgc->paVars = NULL;
918	//pDbgc->pPlugInHead = NULL;
919	//pDbgc->pFirstBp = NULL;
920	//pDbgc->abSearch = {0};
921	//pDbgc->cbSearch = 0;
922	pDbgc->cbSearchUnit = 1;
923	pDbgc->cMaxSearchHits = 1;
924	//pDbgc->SearchAddr = {0};
925	//pDbgc->cbSearchRange = 0;
926
927	//pDbgc->uInputZero = 0;
928	//pDbgc->iRead = 0;
929	//pDbgc->iWrite = 0;
930	//pDbgc->cInputLines = 0;
931	//pDbgc->fInputOverflow = false;
932	pDbgc->fReady = true;
933	pDbgc->pszScratch = &pDbgc->achScratch[0];
934	//pDbgc->iArg = 0;
935	//pDbgc->rcOutput = 0;
936	//pDbgc->rcCmd = 0;
937
938	dbgcEvalInit();
939
940	*ppDbgc = pDbgc;
941	return VINF_SUCCESS;
942	}
943
944	/**
945	* Destroys a DBGC instance created by dbgcCreate.
946	*
947	* @param pDbgc Pointer to the debugger console instance data.
948	*/
949	void dbgcDestroy(PDBGC pDbgc)
950	{
951	AssertPtr(pDbgc);
952
953	/* Disable log hook. */
954	if (pDbgc->fLog)
955	{
956
957	}
958
959	/* Unload all plug-ins. */
960	dbgcPlugInUnloadAll(pDbgc);
961
962	/* Detach from the VM. */
963	if (pDbgc->pUVM)
964	DBGFR3Detach(pDbgc->pUVM);
965
966	/* finally, free the instance memory. */
967	RTMemFree(pDbgc);
968	}
969
970
971	/**
972	* Make a console instance.
973	*
974	* This will not return until either an 'exit' command is issued or a error code
975	* indicating connection loss is encountered.
976	*
977	* @returns VINF_SUCCESS if console termination caused by the 'exit' command.
978	* @returns The VBox status code causing the console termination.
979	*
980	* @param pUVM The user mode VM handle.
981	* @param pBack Pointer to the backend structure. This must contain
982	* a full set of function pointers to service the console.
983	* @param fFlags Reserved, must be zero.
984	* @remark A forced termination of the console is easiest done by forcing the
985	* callbacks to return fatal failures.
986	*/
987	DBGDECL(int) DBGCCreate(PUVM pUVM, PDBGCBACK pBack, unsigned fFlags)
988	{
989	/*
990	* Validate input.
991	*/
992	AssertPtrNullReturn(pUVM, VERR_INVALID_VM_HANDLE);
993	PVM pVM = NULL;
994	if (pUVM)
995	{
996	pVM = VMR3GetVM(pUVM);
997	AssertPtrReturn(pVM, VERR_INVALID_VM_HANDLE);
998	}
999
1000	/*
1001	* Allocate and initialize instance data
1002	*/
1003	PDBGC pDbgc;
1004	int rc = dbgcCreate(&pDbgc, pBack, fFlags);
1005	if (RT_FAILURE(rc))
1006	return rc;
1007
1008	/*
1009	* Print welcome message.
1010	*/
1011	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
1012	"Welcome to the VirtualBox Debugger!\n");
1013
1014	/*
1015	* Attach to the specified VM.
1016	*/
1017	if (RT_SUCCESS(rc) && pUVM)
1018	{
1019	rc = DBGFR3Attach(pUVM);
1020	if (RT_SUCCESS(rc))
1021	{
1022	pDbgc->pVM = pVM;
1023	pDbgc->pUVM = pUVM;
1024	pDbgc->idCpu = 0;
1025	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
1026	"Current VM is %08x, CPU #%u\n" /** @todo get and print the VM name! */
1027	, pDbgc->pVM, pDbgc->idCpu);
1028	}
1029	else
1030	rc = pDbgc->CmdHlp.pfnVBoxError(&pDbgc->CmdHlp, rc, "When trying to attach to VM %p\n", pDbgc->pVM);
1031	}
1032
1033	/*
1034	* Load plugins.
1035	*/
1036	if (RT_SUCCESS(rc))
1037	{
1038	if (pVM)
1039	dbgcPlugInAutoLoad(pDbgc);
1040	rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "VBoxDbg> ");
1041	}
1042	else
1043	pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL, "\nDBGCCreate error: %Rrc\n", rc);
1044
1045	/*
1046	* Run the debugger main loop.
1047	*/
1048	if (RT_SUCCESS(rc))
1049	rc = dbgcRun(pDbgc);
1050
1051	/*
1052	* Cleanup console debugger session.
1053	*/
1054	dbgcDestroy(pDbgc);
1055	return rc == VERR_DBGC_QUIT ? VINF_SUCCESS : rc;
1056	}
1057

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

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

Download in other formats: