DBGF.cpp@ 33935

Last change on this file since 33935 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.6 KB

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

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

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

Download in other formats: