DBGF.cpp@ 11964

Last change on this file since 11964 was 11820, checked in by vboxsync, 16 years ago
made Qt4 the default GUI; VBOX_VRDP => VBOX_WITH_VRDP; VBOX_HGCM => VBOX_WITH_HGCM; Makefile cleanup
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 29.8 KB

Line
1	/* $Id: DBGF.cpp 11820 2008-08-29 14:09:39Z vboxsync $ */
2	/** @file
3	* VMM DBGF - Debugger Facility.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/** @page pg_dbgf DBGC - The Debugger Facility
24	*
25	* The purpose of the DBGC is to provide an interface for debuggers to manipulate
26	* the VMM without having to mess up the source code for each of them. The DBGF
27	* is always built in and will always work when a debugger attaches to the VM.
28	* The DBGF provides the basic debugger features, such as halting execution,
29	* handling breakpoints and single step execution.
30	*
31	* The interface is working in a manner similar to the win32, linux and os2
32	* debugger interfaces. It interface has an asynchronous nature. This comes from
33	* the fact that the VMM and the Debugger are running in different threads.
34	* They are refered to as the "emulation thread" and the "debugger thread",
35	* or as the "ping thread" and the "pong thread, respectivly. (The last set
36	* of names comes from the use of the Ping-Pong synchronization construct from
37	* the RTSem API.)
38	*
39	*
40	*
41	* @section sec_dbgf_scenario Debugger Scenario
42	*
43	* The debugger starts by attaching to the VM. For pratical reasons we limit the
44	* number of concurrently attached debuggers to 1 per VM. The action of attaching
45	* to the VM causes the VM to check and generate debug events.
46	*
47	* The debugger then will wait/poll for debug events and issue commands.
48	*
49	* The waiting and polling is done by the DBGFEventWait() function. It will wait
50	* for the emulation thread to send a ping, thus indicating that there is an
51	* event waiting to be processed.
52	*
53	* An event can be a respons to an command issued previously, the hitting of a
54	* breakpoint, or running into a bad/fatal VMM condition. The debugger now have
55	* the ping and must respond to the event at hand - the VMM is waiting. This
56	* usually means that the user of the debugger must do something, but it doesn't
57	* have to. The debugger is free to call any DBGF function (nearly at least)
58	* while processing the event.
59	*
60	* Typically the user will issue a request for the execution to be resumed, so
61	* the debugger calls DBGFResume() and goes back to waiting/polling for events.
62	*
63	* When the user eventually terminates the debugging session or selects another
64	* VM, the debugger detaches from the VM. This means that breakpoints are disabled
65	* and that the emulation thread no longer polls for debugger commands.
66	*
67	*/
68
69
70
71	/*******************************************************************************
72	* Header Files *
73	*******************************************************************************/
74	#define LOG_GROUP LOG_GROUP_DBGF
75	#include <VBox/dbgf.h>
76	#include <VBox/selm.h>
77	#include <VBox/rem.h>
78	#include <VBox/em.h>
79	#include "DBGFInternal.h"
80	#include <VBox/vm.h>
81	#include <VBox/err.h>
82
83	#include <VBox/log.h>
84	#include <iprt/semaphore.h>
85	#include <iprt/thread.h>
86	#include <iprt/asm.h>
87	#include <iprt/time.h>
88	#include <iprt/assert.h>
89	#include <iprt/stream.h>
90
91
92	/*******************************************************************************
93	* Internal Functions *
94	*******************************************************************************/
95	static int dbgfr3VMMWait(PVM pVM);
96	static int dbgfr3VMMCmd(PVM pVM, DBGFCMD enmCmd, PDBGFCMDDATA pCmdData, bool *pfResumeExecution);
97
98
99	/**
100	* Sets the VMM Debug Command variable.
101	*
102	* @returns Previous command.
103	* @param pVM VM Handle.
104	* @param enmCmd The command.
105	*/
106	DECLINLINE(DBGFCMD) dbgfr3SetCmd(PVM pVM, DBGFCMD enmCmd)
107	{
108	DBGFCMD rc;
109	if (enmCmd == DBGFCMD_NO_COMMAND)
110	{
111	Log2(("DBGF: Setting command to %d (DBGFCMD_NO_COMMAND)\n", enmCmd));
112	rc = (DBGFCMD)ASMAtomicXchgU32((uint32_t volatile )(void )&pVM->dbgf.s.enmVMMCmd, enmCmd);
113	VM_FF_CLEAR(pVM, VM_FF_DBGF);
114	}
115	else
116	{
117	Log2(("DBGF: Setting command to %d\n", enmCmd));
118	AssertMsg(pVM->dbgf.s.enmVMMCmd == DBGFCMD_NO_COMMAND, ("enmCmd=%d enmVMMCmd=%d\n", enmCmd, pVM->dbgf.s.enmVMMCmd));
119	rc = (DBGFCMD)ASMAtomicXchgU32((uint32_t volatile )(void )&pVM->dbgf.s.enmVMMCmd, enmCmd);
120	VM_FF_SET(pVM, VM_FF_DBGF);
121	VMR3NotifyFF(pVM, false /* didn't notify REM */);
122	}
123	return rc;
124	}
125
126
127	/**
128	* Initializes the DBGF.
129	*
130	* @returns VBox status code.
131	* @param pVM VM handle.
132	*/
133	DBGFR3DECL(int) DBGFR3Init(PVM pVM)
134	{
135	int rc = dbgfR3InfoInit(pVM);
136	if (VBOX_SUCCESS(rc))
137	rc = dbgfR3SymInit(pVM);
138	if (VBOX_SUCCESS(rc))
139	rc = dbgfR3BpInit(pVM);
140	return rc;
141	}
142
143
144	/**
145	* Termiantes and cleans up resources allocated by the DBGF.
146	*
147	* @returns VBox status code.
148	* @param pVM VM Handle.
149	*/
150	DBGFR3DECL(int) DBGFR3Term(PVM pVM)
151	{
152	int rc;
153
154	/*
155	* Send a termination event to any attached debuggers.
156	*/
157	/* wait for any pending events or whatever */
158	if ( pVM->dbgf.s.fAttached
159	&& pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG)
160	{
161	RTThreadSleep(32); /* Don't want that assertion if we can help it. */
162	while ( pVM->dbgf.s.fAttached
163	&& pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG)
164	if (RTSemPingWait(&pVM->dbgf.s.PingPong, 5000) != VERR_TIMEOUT)
165	break;
166	}
167
168	/* now, send the event */
169	if ( pVM->dbgf.s.fAttached
170	&& pVM->dbgf.s.PingPong.enmSpeaker != RTPINGPONGSPEAKER_PONG)
171	{
172	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_TERMINATING;
173	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_OTHER;
174	rc = RTSemPing(&pVM->dbgf.s.PingPong);
175	if (VBOX_SUCCESS(rc))
176	{
177	/*
178	* Waits for the debugger to detach.
179	*/
180	while (pVM->dbgf.s.fAttached)
181	{
182	/*
183	* Wait.
184	*/
185	rc = RTSemPingWait(&pVM->dbgf.s.PingPong, 1000);
186
187	/*
188	* Process the command.
189	*/
190	DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
191	DBGFCMD enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_NO_COMMAND);
192	if (enmCmd != DBGFCMD_NO_COMMAND)
193	{
194	bool fResumeExecution = false;
195	rc = dbgfr3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
196	if (enmCmd == DBGFCMD_DETACH_DEBUGGER)
197	break;
198	}
199	else if (VBOX_FAILURE(rc))
200	break;
201	}
202	}
203	}
204
205	/*
206	* Terminate the other bits.
207	*/
208	dbgfR3OSTerm(pVM);
209	dbgfR3InfoTerm(pVM);
210	return VINF_SUCCESS;
211	}
212
213
214	/**
215	* Applies relocations to data and code managed by this
216	* component. This function will be called at init and
217	* whenever the VMM need to relocate it self inside the GC.
218	*
219	* @param pVM VM handle.
220	* @param offDelta Relocation delta relative to old location.
221	*/
222	DBGFR3DECL(void) DBGFR3Relocate(PVM pVM, RTGCINTPTR offDelta)
223	{
224	}
225
226
227	/**
228	* Waits a little while for a debuggger to attach.
229	*
230	* @returns True is a debugger have attached.
231	* @param pVM VM handle.
232	* @param enmEvent Event.
233	*/
234	bool dbgfR3WaitForAttach(PVM pVM, DBGFEVENTTYPE enmEvent)
235	{
236	/*
237	* First a message.
238	*/
239	#ifndef RT_OS_L4
240
241	RTStrmPrintf(g_pStdErr, "DBGF: No debugger attached, waiting 15 seconds for one to attach (event=%d)\n", enmEvent);
242	RTStrmFlush(g_pStdErr);
243	# if defined (DEBUG_sandervl) \|\| defined (DEBUG_frank)
244	int cWait = 10;
245	# else
246	int cWait = 150;
247	# endif
248	while (cWait > 0)
249	{
250	RTThreadSleep(100);
251	if (pVM->dbgf.s.fAttached)
252	{
253	RTStrmPrintf(g_pStdErr, "Attached!\n");
254	RTStrmFlush(g_pStdErr);
255	return true;
256	}
257
258	/* next */
259	if (!(cWait % 10))
260	{
261	RTStrmPrintf(g_pStdErr, "%d.", cWait / 10);
262	RTStrmFlush(g_pStdErr);
263	}
264	cWait--;
265	}
266	#endif
267
268	RTStrmPrintf(g_pStdErr, "Stopping the VM!\n");
269	RTStrmFlush(g_pStdErr);
270	return false;
271	}
272
273
274	/**
275	* Forced action callback.
276	* The VMM will call this from it's main loop when VM_FF_DBGF is set.
277	*
278	* The function checks and executes pending commands from the debugger.
279	*
280	* @returns VINF_SUCCESS normally.
281	* @returns VERR_DBGF_RAISE_FATAL_ERROR to pretend a fatal error happend.
282	* @param pVM VM Handle.
283	*/
284	DBGFR3DECL(int) DBGFR3VMMForcedAction(PVM pVM)
285	{
286	/*
287	* Clear the FF DBGF request flag.
288	*/
289	Assert(pVM->fForcedActions & VM_FF_DBGF);
290	VM_FF_CLEAR(pVM, VM_FF_DBGF);
291
292	/*
293	* Commands?
294	*/
295	int rc = VINF_SUCCESS;
296	if (pVM->dbgf.s.enmVMMCmd != DBGFCMD_NO_COMMAND)
297	{
298	/** @todo stupid GDT/LDT sync hack. go away! */
299	SELMR3UpdateFromCPUM(pVM);
300
301	/*
302	* Process the command.
303	*/
304	bool fResumeExecution;
305	DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
306	DBGFCMD enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_NO_COMMAND);
307	rc = dbgfr3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
308	if (!fResumeExecution)
309	rc = dbgfr3VMMWait(pVM);
310	}
311	return rc;
312	}
313
314
315	/**
316	* Flag whether the event implies that we're stopped in the hypervisor code
317	* and have to block certain operations.
318	*
319	* @param pVM The VM handle.
320	* @param enmEvent The event.
321	*/
322	static void dbgfR3EventSetStoppedInHyperFlag(PVM pVM, DBGFEVENTTYPE enmEvent)
323	{
324	switch (enmEvent)
325	{
326	case DBGFEVENT_STEPPED_HYPER:
327	case DBGFEVENT_ASSERTION_HYPER:
328	case DBGFEVENT_BREAKPOINT_HYPER:
329	pVM->dbgf.s.fStoppedInHyper = true;
330	break;
331	default:
332	pVM->dbgf.s.fStoppedInHyper = false;
333	break;
334	}
335	}
336
337
338	/**
339	* Try determin the event context.
340	*
341	* @returns debug event context.
342	* @param pVM The VM handle.
343	*/
344	static DBGFEVENTCTX dbgfR3FigureEventCtx(PVM pVM)
345	{
346	switch (EMGetState(pVM))
347	{
348	case EMSTATE_RAW:
349	case EMSTATE_DEBUG_GUEST_RAW:
350	return DBGFEVENTCTX_RAW;
351
352	case EMSTATE_REM:
353	case EMSTATE_DEBUG_GUEST_REM:
354	return DBGFEVENTCTX_REM;
355
356	case EMSTATE_DEBUG_HYPER:
357	case EMSTATE_GURU_MEDITATION:
358	return DBGFEVENTCTX_HYPER;
359
360	default:
361	return DBGFEVENTCTX_OTHER;
362	}
363	}
364
365	/**
366	* The common event prologue code.
367	* It will set the 'stopped-in-hyper' flag, make sure someone's attach,
368	* and perhaps process any high priority pending actions (none yet).
369	*
370	* @returns VBox status.
371	* @param pVM The VM handle.
372	* @param enmEvent The event to be sent.
373	*/
374	static int dbgfR3EventPrologue(PVM pVM, DBGFEVENTTYPE enmEvent)
375	{
376	/*
377	* Check if a debugger is attached.
378	*/
379	if ( !pVM->dbgf.s.fAttached
380	&& !dbgfR3WaitForAttach(pVM, enmEvent))
381	{
382	Log(("DBGFR3VMMEventSrc: enmEvent=%d - debugger not attached\n", enmEvent));
383	return VERR_DBGF_NOT_ATTACHED;
384	}
385
386	/*
387	* Sync back the state from the REM.
388	*/
389	dbgfR3EventSetStoppedInHyperFlag(pVM, enmEvent);
390	if (!pVM->dbgf.s.fStoppedInHyper)
391	REMR3StateUpdate(pVM);
392
393	/*
394	* Look thru pending commands and finish those which make sense now.
395	*/
396	/** @todo Process/purge pending commands. */
397	//int rc = DBGFR3VMMForcedAction(pVM);
398	return VINF_SUCCESS;
399	}
400
401
402	/**
403	* Sends the event in the event buffer.
404	*
405	* @returns VBox status code.
406	* @param pVM The VM handle.
407	*/
408	static int dbgfR3SendEvent(PVM pVM)
409	{
410	int rc = RTSemPing(&pVM->dbgf.s.PingPong);
411	if (VBOX_SUCCESS(rc))
412	rc = dbgfr3VMMWait(pVM);
413
414	pVM->dbgf.s.fStoppedInHyper = false;
415	/** @todo sync VMM -> REM after exitting the debugger. everything may change while in the debugger! */
416	return rc;
417	}
418
419
420	/**
421	* Send a generic debugger event which takes no data.
422	*
423	* @returns VBox status.
424	* @param pVM The VM handle.
425	* @param enmEvent The event to send.
426	*/
427	DBGFR3DECL(int) DBGFR3Event(PVM pVM, DBGFEVENTTYPE enmEvent)
428	{
429	int rc = dbgfR3EventPrologue(pVM, enmEvent);
430	if (VBOX_FAILURE(rc))
431	return rc;
432
433	/*
434	* Send the event and process the reply communication.
435	*/
436	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
437	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
438	return dbgfR3SendEvent(pVM);
439	}
440
441
442	/**
443	* Send a debugger event which takes the full source file location.
444	*
445	* @returns VBox status.
446	* @param pVM The VM handle.
447	* @param enmEvent The event to send.
448	* @param pszFile Source file.
449	* @param uLine Line number in source file.
450	* @param pszFunction Function name.
451	* @param pszFormat Message which accompanies the event.
452	* @param ... Message arguments.
453	*/
454	DBGFR3DECL(int) DBGFR3EventSrc(PVM pVM, DBGFEVENTTYPE enmEvent, const char pszFile, unsigned uLine, const char pszFunction, const char *pszFormat, ...)
455	{
456	va_list args;
457	va_start(args, pszFormat);
458	int rc = DBGFR3EventSrcV(pVM, enmEvent, pszFile, uLine, pszFunction, pszFormat, args);
459	va_end(args);
460	return rc;
461	}
462
463
464	/**
465	* Send a debugger event which takes the full source file location.
466	*
467	* @returns VBox status.
468	* @param pVM The VM handle.
469	* @param enmEvent The event to send.
470	* @param pszFile Source file.
471	* @param uLine Line number in source file.
472	* @param pszFunction Function name.
473	* @param pszFormat Message which accompanies the event.
474	* @param args Message arguments.
475	*/
476	DBGFR3DECL(int) DBGFR3EventSrcV(PVM pVM, DBGFEVENTTYPE enmEvent, const char pszFile, unsigned uLine, const char pszFunction, const char *pszFormat, va_list args)
477	{
478	int rc = dbgfR3EventPrologue(pVM, enmEvent);
479	if (VBOX_FAILURE(rc))
480	return rc;
481
482	/*
483	* Format the message.
484	*/
485	char *pszMessage = NULL;
486	char szMessage[8192];
487	if (pszFormat && *pszFormat)
488	{
489	pszMessage = &szMessage[0];
490	RTStrPrintfV(szMessage, sizeof(szMessage), pszFormat, args);
491	}
492
493	/*
494	* Send the event and process the reply communication.
495	*/
496	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
497	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
498	pVM->dbgf.s.DbgEvent.u.Src.pszFile = pszFile;
499	pVM->dbgf.s.DbgEvent.u.Src.uLine = uLine;
500	pVM->dbgf.s.DbgEvent.u.Src.pszFunction = pszFunction;
501	pVM->dbgf.s.DbgEvent.u.Src.pszMessage = pszMessage;
502	return dbgfR3SendEvent(pVM);
503	}
504
505
506	/**
507	* Send a debugger event which takes the two assertion messages.
508	*
509	* @returns VBox status.
510	* @param pVM The VM handle.
511	* @param enmEvent The event to send.
512	* @param pszMsg1 First assertion message.
513	* @param pszMsg2 Second assertion message.
514	*/
515	DBGFR3DECL(int) DBGFR3EventAssertion(PVM pVM, DBGFEVENTTYPE enmEvent, const char pszMsg1, const char pszMsg2)
516	{
517	int rc = dbgfR3EventPrologue(pVM, enmEvent);
518	if (VBOX_FAILURE(rc))
519	return rc;
520
521	/*
522	* Send the event and process the reply communication.
523	*/
524	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
525	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
526	pVM->dbgf.s.DbgEvent.u.Assert.pszMsg1 = pszMsg1;
527	pVM->dbgf.s.DbgEvent.u.Assert.pszMsg2 = pszMsg2;
528	return dbgfR3SendEvent(pVM);
529	}
530
531
532	/**
533	* Breakpoint was hit somewhere.
534	* Figure out which breakpoint it is and notify the debugger.
535	*
536	* @returns VBox status.
537	* @param pVM The VM handle.
538	* @param enmEvent DBGFEVENT_BREAKPOINT_HYPER or DBGFEVENT_BREAKPOINT.
539	*/
540	DBGFR3DECL(int) DBGFR3EventBreakpoint(PVM pVM, DBGFEVENTTYPE enmEvent)
541	{
542	int rc = dbgfR3EventPrologue(pVM, enmEvent);
543	if (VBOX_FAILURE(rc))
544	return rc;
545
546	/*
547	* Send the event and process the reply communication.
548	*/
549	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
550	RTUINT iBp = pVM->dbgf.s.DbgEvent.u.Bp.iBp = pVM->dbgf.s.iActiveBp;
551	pVM->dbgf.s.iActiveBp = ~0U;
552	if (iBp != ~0U)
553	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_RAW;
554	else
555	{
556	/* REM breakpoints has be been searched for. */
557	#if 0 /** @todo get flat PC api! */
558	uint32_t eip = CPUMGetGuestEIP(pVM);
559	#else
560	PCPUMCTX pCtx;
561	CPUMQueryGuestCtxPtr(pVM, &pCtx);
562	RTGCPTR eip = pCtx->rip + pCtx->csHid.u64Base;
563	#endif
564	for (iBp = 0; iBp < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); iBp++)
565	if ( pVM->dbgf.s.aBreakpoints[iBp].enmType == DBGFBPTYPE_REM
566	&& pVM->dbgf.s.aBreakpoints[iBp].GCPtr == eip)
567	{
568	pVM->dbgf.s.DbgEvent.u.Bp.iBp = iBp;
569	break;
570	}
571	AssertMsg(pVM->dbgf.s.DbgEvent.u.Bp.iBp != ~0U, ("eip=%08x\n", eip));
572	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_REM;
573	}
574	return dbgfR3SendEvent(pVM);
575	}
576
577
578	/**
579	* Waits for the debugger to respond.
580	*
581	* @returns VBox status. (clearify)
582	* @param pVM VM handle.
583	*/
584	static int dbgfr3VMMWait(PVM pVM)
585	{
586	LogFlow(("dbgfr3VMMWait:\n"));
587
588	/** @todo stupid GDT/LDT sync hack. go away! */
589	SELMR3UpdateFromCPUM(pVM);
590	int rcRet = VINF_SUCCESS;
591
592	/*
593	* Waits for the debugger to reply (i.e. issue an command).
594	*/
595	for (;;)
596	{
597	/*
598	* Wait.
599	*/
600	for (;;)
601	{
602	int rc = RTSemPingWait(&pVM->dbgf.s.PingPong, 250);
603	if (VBOX_SUCCESS(rc))
604	break;
605	if (rc != VERR_TIMEOUT)
606	{
607	LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rc));
608	return rc;
609	}
610
611	if (VM_FF_ISSET(pVM, VM_FF_REQUEST))
612	{
613	LogFlow(("dbgfr3VMMWait: Processes requests...\n"));
614	rc = VMR3ReqProcessU(pVM->pUVM);
615	LogFlow(("dbgfr3VMMWait: VMR3ReqProcess -> %Vrc rcRet=%Vrc\n", rc, rcRet));
616	if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
617	{
618	switch (rc)
619	{
620	case VINF_EM_DBG_BREAKPOINT:
621	case VINF_EM_DBG_STEPPED:
622	case VINF_EM_DBG_STEP:
623	case VINF_EM_DBG_STOP:
624	AssertMsgFailed(("rc=%Vrc\n", rc));
625	break;
626
627	/* return straight away */
628	case VINF_EM_TERMINATE:
629	case VINF_EM_OFF:
630	LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rc));
631	return rc;
632
633	/* remember return code. */
634	default:
635	AssertReleaseMsgFailed(("rc=%Vrc is not in the switch!\n", rc));
636	case VINF_EM_RESET:
637	case VINF_EM_SUSPEND:
638	case VINF_EM_HALT:
639	case VINF_EM_RESUME:
640	case VINF_EM_RESCHEDULE:
641	case VINF_EM_RESCHEDULE_REM:
642	case VINF_EM_RESCHEDULE_RAW:
643	if (rc < rcRet \|\| rcRet == VINF_SUCCESS)
644	rcRet = rc;
645	break;
646	}
647	}
648	else if (VBOX_FAILURE(rc))
649	{
650	LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rc));
651	return rc;
652	}
653	}
654	}
655
656	/*
657	* Process the command.
658	*/
659	bool fResumeExecution;
660	DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
661	DBGFCMD enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_NO_COMMAND);
662	int rc = dbgfr3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
663	if (fResumeExecution)
664	{
665	if (VBOX_FAILURE(rc))
666	rcRet = rc;
667	else if ( rc >= VINF_EM_FIRST
668	&& rc <= VINF_EM_LAST
669	&& (rc < rcRet \|\| rcRet == VINF_SUCCESS))
670	rcRet = rc;
671	LogFlow(("dbgfr3VMMWait: returns %Vrc\n", rcRet));
672	return rcRet;
673	}
674	}
675	}
676
677
678	/**
679	* Executes command from debugger.
680	* The caller is responsible for waiting or resuming execution based on the
681	* value returned in the *pfResumeExecution indicator.
682	*
683	* @returns VBox status. (clearify!)
684	* @param pVM VM Handle.
685	* @param enmCmd The command in question.
686	* @param pCmdData Pointer to the command data.
687	* @param pfResumeExecution Where to store the resume execution / continue waiting indicator.
688	*/
689	static int dbgfr3VMMCmd(PVM pVM, DBGFCMD enmCmd, PDBGFCMDDATA pCmdData, bool *pfResumeExecution)
690	{
691	bool fSendEvent;
692	bool fResume;
693	int rc = VINF_SUCCESS;
694
695	switch (enmCmd)
696	{
697	/*
698	* Halt is answered by an event say that we've halted.
699	*/
700	case DBGFCMD_HALT:
701	{
702	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_HALT_DONE;
703	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
704	fSendEvent = true;
705	fResume = false;
706	break;
707	}
708
709
710	/*
711	* Resume is not answered we'll just resume execution.
712	*/
713	case DBGFCMD_GO:
714	{
715	fSendEvent = false;
716	fResume = true;
717	break;
718	}
719
720	/** @todo implement (and define) the rest of the commands. */
721
722	/*
723	* Disable breakpoints and stuff.
724	* Send an everythings cool event to the debugger thread and resume execution.
725	*/
726	case DBGFCMD_DETACH_DEBUGGER:
727	{
728	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_DETACH_DONE;
729	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_OTHER;
730	VM_FF_CLEAR(pVM, VM_FF_DBGF);
731	pVM->dbgf.s.fAttached = false;
732	fSendEvent = true;
733	fResume = true;
734	break;
735	}
736
737	/*
738	* Single step, with trace into.
739	*/
740	case DBGFCMD_SINGLE_STEP:
741	{
742	Log2(("Single step\n"));
743	rc = VINF_EM_DBG_STEP;
744	pVM->dbgf.s.fSingleSteppingRaw = true;
745	fSendEvent = false;
746	fResume = true;
747	break;
748	}
749
750	/*
751	* Default is to send an invalid command event.
752	*/
753	default:
754	{
755	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_INVALID_COMMAND;
756	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
757	fSendEvent = true;
758	fResume = false;
759	break;
760	}
761	}
762
763	/*
764	* Send pending event.
765	*/
766	if (fSendEvent)
767	{
768	Log2(("DBGF: Emulation thread: sending event %d\n", pVM->dbgf.s.DbgEvent.enmType));
769	int rc2 = RTSemPing(&pVM->dbgf.s.PingPong);
770	if (VBOX_FAILURE(rc2))
771	{
772	AssertRC(rc2);
773	*pfResumeExecution = true;
774	return rc2;
775	}
776	}
777
778	/*
779	* Return.
780	*/
781	*pfResumeExecution = fResume;
782	return rc;
783	}
784
785
786
787
788	/**
789	* Attaches a debugger to the specified VM.
790	*
791	* Only one debugger at a time.
792	*
793	* @returns VBox status code.
794	* @param pVM VM Handle.
795	*/
796	DBGFR3DECL(int) DBGFR3Attach(PVM pVM)
797	{
798	/*
799	* Check if already attached.
800	*/
801	if (pVM->dbgf.s.fAttached)
802	{
803	AssertMsgFailed(("Already attached\n"));
804	return VERR_DBGF_ALREADY_ATTACHED;
805	}
806
807	/*
808	* Create the Ping-Pong structure.
809	*/
810	int rc = RTSemPingPongInit(&pVM->dbgf.s.PingPong);
811	if (rc)
812	return rc;
813
814	/*
815	* Set the attached flag.
816	*/
817	pVM->dbgf.s.fAttached = true;
818	return VINF_SUCCESS;
819	}
820
821
822	/**
823	* Detaches a debugger from the specified VM.
824	*
825	* Caller must be attached to the VM.
826	*
827	* @returns VBox status code.
828	* @param pVM VM Handle.
829	*/
830	DBGFR3DECL(int) DBGFR3Detach(PVM pVM)
831	{
832	LogFlowFunc(("\n"));
833
834	/*
835	* Check if attached.
836	*/
837	if (!pVM->dbgf.s.fAttached)
838	{
839	AssertMsgFailed(("Not attached to VM!\n"));
840	return VERR_DBGF_NOT_ATTACHED;
841	}
842
843	/*
844	* Send detach command.
845	*/
846	DBGFCMD enmCmd;
847	if (pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG)
848	{
849	enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_DETACH_DEBUGGER);
850	int rc = RTSemPong(&pVM->dbgf.s.PingPong);
851	if (VBOX_FAILURE(rc))
852	{
853	AssertMsgFailed(("Failed to signal emulation thread. rc=%d\n", rc));
854	return rc;
855	}
856	LogFunc(("enmCmd=%d (pong -> ping)\n", enmCmd));
857	}
858	else
859	{
860	enmCmd = dbgfr3SetCmd(pVM, DBGFCMD_DETACH_DEBUGGER);
861	LogFunc(("enmCmd=%d (ping)\n", enmCmd));
862	}
863
864	/*
865	* Wait for the ok event.
866	*/
867	PCDBGFEVENT pEvent;
868	int rc = DBGFR3EventWait(pVM, RT_INDEFINITE_WAIT, &pEvent);
869	if (VBOX_FAILURE(rc))
870	{
871	AssertMsgFailed(("Wait on detach command failed, rc=%d\n", rc));
872	return rc;
873	}
874
875	/*
876	* Destroy the ping-pong construct and return.
877	*/
878	ASMAtomicWriteBool(&pVM->dbgf.s.fAttached, false);
879	RTThreadSleep(10);
880	rc = RTSemPingPongDestroy(&pVM->dbgf.s.PingPong);
881	AssertRC(rc);
882
883	LogFlowFunc(("returns VINF_SUCCESS\n"));
884	return VINF_SUCCESS;
885	}
886
887
888
889	/**
890	* Wait for a debug event.
891	*
892	* @returns VBox status. Will not return VBOX_INTERRUPTED.
893	* @param pVM VM handle.
894	* @param cMillies Number of millies to wait.
895	* @param ppEvent Where to store the event pointer.
896	*/
897	DBGFR3DECL(int) DBGFR3EventWait(PVM pVM, unsigned cMillies, PCDBGFEVENT *ppEvent)
898	{
899	/*
900	* Check state.
901	*/
902	if (!pVM->dbgf.s.fAttached)
903	{
904	AssertMsgFailed(("Not attached to VM!\n"));
905	return VERR_DBGF_NOT_ATTACHED;
906	}
907	*ppEvent = NULL;
908
909	/*
910	* Wait.
911	*/
912	int rc = RTSemPongWait(&pVM->dbgf.s.PingPong, cMillies);
913	if (VBOX_SUCCESS(rc))
914	{
915	*ppEvent = &pVM->dbgf.s.DbgEvent;
916	Log2(("DBGF: Debugger thread: receiving event %d\n", (*ppEvent)->enmType));
917	return VINF_SUCCESS;
918	}
919
920	return rc;
921	}
922
923
924	/**
925	* Halts VM execution.
926	*
927	* After calling this the VM isn't actually halted till an DBGFEVENT_HALT_DONE
928	* arrives. Until that time it's not possible to issue any new commands.
929	*
930	* @returns VBox status.
931	* @param pVM VM handle.
932	*/
933	DBGFR3DECL(int) DBGFR3Halt(PVM pVM)
934	{
935	/*
936	* Check state.
937	*/
938	if (!pVM->dbgf.s.fAttached)
939	{
940	AssertMsgFailed(("Not attached to VM!\n"));
941	return VERR_DBGF_NOT_ATTACHED;
942	}
943	if ( pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG
944	\|\| pVM->dbgf.s.PingPong.enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED)
945	return VWRN_DBGF_ALREADY_HALTED;
946
947	/*
948	* Send command.
949	*/
950	dbgfr3SetCmd(pVM, DBGFCMD_HALT);
951
952	return VINF_SUCCESS;
953	}
954
955
956	/**
957	* Checks if the VM is halted by the debugger.
958	*
959	* @returns True if halted.
960	* @returns False if not halted.
961	* @param pVM VM handle.
962	*/
963	DBGFR3DECL(bool) DBGFR3IsHalted(PVM pVM)
964	{
965	AssertMsg(pVM->dbgf.s.fAttached, ("Not attached to VM!\n"));
966
967	RTPINGPONGSPEAKER enmSpeaker = pVM->dbgf.s.PingPong.enmSpeaker;
968	return pVM->dbgf.s.fAttached
969	&& ( enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED
970	\|\| enmSpeaker == RTPINGPONGSPEAKER_PONG);
971	}
972
973
974	/**
975	* Checks if the the debugger can wait for events or not.
976	*
977	* This function is only used by lazy, multiplexing debuggers. :-)
978	*
979	* @returns True if waitable.
980	* @returns False if not waitable.
981	* @param pVM VM handle.
982	*/
983	DBGFR3DECL(bool) DBGFR3CanWait(PVM pVM)
984	{
985	AssertMsg(pVM->dbgf.s.fAttached, ("Not attached to VM!\n"));
986
987	RTPINGPONGSPEAKER enmSpeaker = pVM->dbgf.s.PingPong.enmSpeaker;
988	return pVM->dbgf.s.fAttached
989	&& ( enmSpeaker == RTPINGPONGSPEAKER_PING
990	\|\| enmSpeaker == RTPINGPONGSPEAKER_PING_SIGNALED
991	\|\| enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED);
992	}
993
994
995	/**
996	* Resumes VM execution.
997	*
998	* There is no receipt event on this command.
999	*
1000	* @returns VBox status.
1001	* @param pVM VM handle.
1002	*/
1003	DBGFR3DECL(int) DBGFR3Resume(PVM pVM)
1004	{
1005	/*
1006	* Check state.
1007	*/
1008	if (!pVM->dbgf.s.fAttached)
1009	{
1010	AssertMsgFailed(("Not attached to VM!\n"));
1011	return VERR_DBGF_NOT_ATTACHED;
1012	}
1013	if (pVM->dbgf.s.PingPong.enmSpeaker != RTPINGPONGSPEAKER_PONG)
1014	{
1015	AssertMsgFailed(("Speaking out of turn!\n"));
1016	return VERR_SEM_OUT_OF_TURN;
1017	}
1018
1019	/*
1020	* Send the ping back to the emulation thread telling it to run.
1021	*/
1022	dbgfr3SetCmd(pVM, DBGFCMD_GO);
1023	int rc = RTSemPong(&pVM->dbgf.s.PingPong);
1024	AssertRC(rc);
1025
1026	return rc;
1027	}
1028
1029
1030	/**
1031	* Step Into.
1032	*
1033	* A single step event is generated from this command.
1034	* The current implementation is not reliable, so don't rely on the event comming.
1035	*
1036	* @returns VBox status.
1037	* @param pVM VM handle.
1038	*/
1039	DBGFR3DECL(int) DBGFR3Step(PVM pVM)
1040	{
1041	/*
1042	* Check state.
1043	*/
1044	if (!pVM->dbgf.s.fAttached)
1045	{
1046	AssertMsgFailed(("Not attached to VM!\n"));
1047	return VERR_DBGF_NOT_ATTACHED;
1048	}
1049	if (pVM->dbgf.s.PingPong.enmSpeaker != RTPINGPONGSPEAKER_PONG)
1050	{
1051	AssertMsgFailed(("Speaking out of turn!\n"));
1052	return VERR_SEM_OUT_OF_TURN;
1053	}
1054
1055	/*
1056	* Send the ping back to the emulation thread telling it to run.
1057	*/
1058	dbgfr3SetCmd(pVM, DBGFCMD_SINGLE_STEP);
1059	int rc = RTSemPong(&pVM->dbgf.s.PingPong);
1060	AssertRC(rc);
1061	return rc;
1062	}
1063
1064
1065	/**
1066	* Call this to single step rawmode or recompiled mode.
1067	*
1068	* You must pass down the return code to the EM loop! That's
1069	* where the actual single stepping take place (at least in the
1070	* current implementation).
1071	*
1072	* @returns VINF_EM_DBG_STEP
1073	* @thread EMT
1074	*/
1075	DBGFR3DECL(int) DBGFR3PrgStep(PVM pVM)
1076	{
1077	VM_ASSERT_EMT(pVM);
1078
1079	pVM->dbgf.s.fSingleSteppingRaw = true;
1080	return VINF_EM_DBG_STEP;
1081	}
1082

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

source: vbox/trunk/src/VBox/VMM/DBGF.cpp@ 11964

Download in other formats: