DBGF.cpp@ 25062

Last change on this file since 25062 was 24999, checked in by vboxsync, 15 years ago
VMM: Fixed a few of -Wshadow warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.7 KB

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

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

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

Download in other formats: