DBGF.cpp@ 9176

Last change on this file since 9176 was 8823, checked in by vboxsync, 17 years ago
Don't loop forever in DBGFR3Term if the debugger and EMT race each other.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 29.8 KB

Line
1	/* $Id: DBGF.cpp 8823 2008-05-14 21:51:07Z 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	# ifdef DEBUG_sandervl
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	uint32_t eip = pCtx->eip + pCtx->csHid.u32Base;
563	#endif
564	for (iBp = 0; iBp < 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@ 9176

Download in other formats: