DBGF.cpp@ 6796

Last change on this file since 6796 was 6796, checked in by vboxsync, 17 years ago
Fixed init problems wrt. VM ownership by implementing the UVM structure (U = user mode) and moving problematic ring-3 stuff over there (emt+reqs, r3heap, stam, loader[VMMR0.r0]). Big change, but it works fine here... :-)
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 29.2 KB

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

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

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

Download in other formats: