DBGF.cpp@ 8155

Last change on this file since 8155 was 8155, checked in by vboxsync, 17 years ago
The Big Sun Rebranding Header Change
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 29.3 KB

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

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

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

Download in other formats: