DBGF.cpp@ 73388

Last change on this file since 73388 was 73351, checked in by vboxsync, 6 years ago
VBoxGuest,VMMDev,DBGF,VM: Added bug check report to VBoxGuest/VMMDev and hooked it up to DBGF. Made DBGF remember the last reported bug check, adding an info handler for displaying it. Added VM reset counters w/ getters for use in bug check reporting.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 69.1 KB

Line
1	/* $Id: DBGF.cpp 73351 2018-07-25 13:02:11Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 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/vmm/dbgf.h>
74	#include <VBox/vmm/selm.h>
75	#ifdef VBOX_WITH_REM
76	# include <VBox/vmm/rem.h>
77	#endif
78	#include <VBox/vmm/em.h>
79	#include <VBox/vmm/hm.h>
80	#include "DBGFInternal.h"
81	#include <VBox/vmm/vm.h>
82	#include <VBox/vmm/uvm.h>
83	#include <VBox/err.h>
84
85	#include <VBox/log.h>
86	#include <iprt/semaphore.h>
87	#include <iprt/thread.h>
88	#include <iprt/asm.h>
89	#include <iprt/time.h>
90	#include <iprt/assert.h>
91	#include <iprt/stream.h>
92	#include <iprt/env.h>
93
94
95	/*********************************************************************************************************************************
96	* Structures and Typedefs *
97	*********************************************************************************************************************************/
98	/**
99	* Instruction type returned by dbgfStepGetCurInstrType.
100	*/
101	typedef enum DBGFSTEPINSTRTYPE
102	{
103	DBGFSTEPINSTRTYPE_INVALID = 0,
104	DBGFSTEPINSTRTYPE_OTHER,
105	DBGFSTEPINSTRTYPE_RET,
106	DBGFSTEPINSTRTYPE_CALL,
107	DBGFSTEPINSTRTYPE_END,
108	DBGFSTEPINSTRTYPE_32BIT_HACK = 0x7fffffff
109	} DBGFSTEPINSTRTYPE;
110
111
112	/*********************************************************************************************************************************
113	* Internal Functions *
114	*********************************************************************************************************************************/
115	static int dbgfR3VMMWait(PVM pVM);
116	static int dbgfR3VMMCmd(PVM pVM, DBGFCMD enmCmd, PDBGFCMDDATA pCmdData, bool *pfResumeExecution);
117	static DECLCALLBACK(int) dbgfR3Attach(PVM pVM);
118	static DBGFSTEPINSTRTYPE dbgfStepGetCurInstrType(PVM pVM, PVMCPU pVCpu);
119	static bool dbgfStepAreWeThereYet(PVM pVM, PVMCPU pVCpu);
120
121
122	/**
123	* Sets the VMM Debug Command variable.
124	*
125	* @returns Previous command.
126	* @param pVM The cross context VM structure.
127	* @param enmCmd The command.
128	*/
129	DECLINLINE(DBGFCMD) dbgfR3SetCmd(PVM pVM, DBGFCMD enmCmd)
130	{
131	DBGFCMD rc;
132	if (enmCmd == DBGFCMD_NO_COMMAND)
133	{
134	Log2(("DBGF: Setting command to %d (DBGFCMD_NO_COMMAND)\n", enmCmd));
135	rc = (DBGFCMD)ASMAtomicXchgU32((uint32_t volatile )(void )&pVM->dbgf.s.enmVMMCmd, enmCmd);
136	VM_FF_CLEAR(pVM, VM_FF_DBGF);
137	}
138	else
139	{
140	Log2(("DBGF: Setting command to %d\n", enmCmd));
141	AssertMsg(pVM->dbgf.s.enmVMMCmd == DBGFCMD_NO_COMMAND, ("enmCmd=%d enmVMMCmd=%d\n", enmCmd, pVM->dbgf.s.enmVMMCmd));
142	rc = (DBGFCMD)ASMAtomicXchgU32((uint32_t volatile )(void )&pVM->dbgf.s.enmVMMCmd, enmCmd);
143	VM_FF_SET(pVM, VM_FF_DBGF);
144	VMR3NotifyGlobalFFU(pVM->pUVM, 0 /* didn't notify REM */);
145	}
146	return rc;
147	}
148
149
150	/**
151	* Initializes the DBGF.
152	*
153	* @returns VBox status code.
154	* @param pVM The cross context VM structure.
155	*/
156	VMMR3_INT_DECL(int) DBGFR3Init(PVM pVM)
157	{
158	PUVM pUVM = pVM->pUVM;
159	AssertCompile(sizeof(pUVM->dbgf.s) <= sizeof(pUVM->dbgf.padding));
160	AssertCompile(sizeof(pUVM->aCpus[0].dbgf.s) <= sizeof(pUVM->aCpus[0].dbgf.padding));
161
162	pVM->dbgf.s.SteppingFilter.idCpu = NIL_VMCPUID;
163
164	/*
165	* The usual sideways mountain climbing style of init:
166	*/
167	int rc = dbgfR3InfoInit(pUVM); /* (First, initalizes the shared critical section.) */
168	if (RT_SUCCESS(rc))
169	{
170	rc = dbgfR3TraceInit(pVM);
171	if (RT_SUCCESS(rc))
172	{
173	rc = dbgfR3RegInit(pUVM);
174	if (RT_SUCCESS(rc))
175	{
176	rc = dbgfR3AsInit(pUVM);
177	if (RT_SUCCESS(rc))
178	{
179	rc = dbgfR3BpInit(pVM);
180	if (RT_SUCCESS(rc))
181	{
182	rc = dbgfR3OSInit(pUVM);
183	if (RT_SUCCESS(rc))
184	{
185	rc = dbgfR3PlugInInit(pUVM);
186	if (RT_SUCCESS(rc))
187	{
188	rc = dbgfR3BugCheckInit(pVM);
189	if (RT_SUCCESS(rc))
190	{
191	return VINF_SUCCESS;
192	}
193	dbgfR3PlugInTerm(pUVM);
194	}
195	dbgfR3OSTerm(pUVM);
196	}
197	}
198	dbgfR3AsTerm(pUVM);
199	}
200	dbgfR3RegTerm(pUVM);
201	}
202	dbgfR3TraceTerm(pVM);
203	}
204	dbgfR3InfoTerm(pUVM);
205	}
206	return rc;
207	}
208
209
210	/**
211	* Terminates and cleans up resources allocated by the DBGF.
212	*
213	* @returns VBox status code.
214	* @param pVM The cross context VM structure.
215	*/
216	VMMR3_INT_DECL(int) DBGFR3Term(PVM pVM)
217	{
218	PUVM pUVM = pVM->pUVM;
219
220	dbgfR3PlugInTerm(pUVM);
221	dbgfR3OSTerm(pUVM);
222	dbgfR3AsTerm(pUVM);
223	dbgfR3RegTerm(pUVM);
224	dbgfR3TraceTerm(pVM);
225	dbgfR3InfoTerm(pUVM);
226
227	return VINF_SUCCESS;
228	}
229
230
231	/**
232	* Called when the VM is powered off to detach debuggers.
233	*
234	* @param pVM The cross context VM structure.
235	*/
236	VMMR3_INT_DECL(void) DBGFR3PowerOff(PVM pVM)
237	{
238
239	/*
240	* Send a termination event to any attached debugger.
241	*/
242	/* wait to become the speaker (we should already be that). */
243	if ( pVM->dbgf.s.fAttached
244	&& RTSemPingShouldWait(&pVM->dbgf.s.PingPong))
245	RTSemPingWait(&pVM->dbgf.s.PingPong, 5000);
246
247	if (pVM->dbgf.s.fAttached)
248	{
249	/* Just mark it as detached if we're not in a position to send a power
250	off event. It should fail later on. */
251	if (!RTSemPingIsSpeaker(&pVM->dbgf.s.PingPong))
252	{
253	ASMAtomicWriteBool(&pVM->dbgf.s.fAttached, false);
254	if (RTSemPingIsSpeaker(&pVM->dbgf.s.PingPong))
255	ASMAtomicWriteBool(&pVM->dbgf.s.fAttached, true);
256	}
257
258	if (RTSemPingIsSpeaker(&pVM->dbgf.s.PingPong))
259	{
260	/* Try send the power off event. */
261	int rc;
262	DBGFCMD enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_NO_COMMAND);
263	if (enmCmd == DBGFCMD_DETACH_DEBUGGER)
264	/* the debugger beat us to initiating the detaching. */
265	rc = VINF_SUCCESS;
266	else
267	{
268	/* ignore the command (if any). */
269	enmCmd = DBGFCMD_NO_COMMAND;
270	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_POWERING_OFF;
271	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_OTHER;
272	rc = RTSemPing(&pVM->dbgf.s.PingPong);
273	}
274
275	/*
276	* Process commands and priority requests until we get a command
277	* indicating that the debugger has detached.
278	*/
279	uint32_t cPollHack = 1;
280	PVMCPU pVCpu = VMMGetCpu(pVM);
281	while (RT_SUCCESS(rc))
282	{
283	if (enmCmd != DBGFCMD_NO_COMMAND)
284	{
285	/* process command */
286	bool fResumeExecution;
287	DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
288	rc = dbgfR3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
289	if (enmCmd == DBGFCMD_DETACHED_DEBUGGER)
290	break;
291	enmCmd = DBGFCMD_NO_COMMAND;
292	}
293	else
294	{
295	/* Wait for new command, processing pending priority requests
296	first. The request processing is a bit crazy, but
297	unfortunately required by plugin unloading. */
298	if ( VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
299	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
300	{
301	LogFlow(("DBGFR3PowerOff: Processes priority requests...\n"));
302	rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, true /fPriorityOnly/);
303	if (rc == VINF_SUCCESS)
304	rc = VMR3ReqProcessU(pVM->pUVM, pVCpu->idCpu, true /fPriorityOnly/);
305	LogFlow(("DBGFR3PowerOff: VMR3ReqProcess -> %Rrc\n", rc));
306	cPollHack = 1;
307	}
308	/* Need to handle rendezvous too, for generic debug event management. */
309	else if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
310	{
311	rc = VMMR3EmtRendezvousFF(pVM, pVCpu);
312	AssertLogRel(rc == VINF_SUCCESS);
313	cPollHack = 1;
314	}
315	else if (cPollHack < 120)
316	cPollHack++;
317
318	rc = RTSemPingWait(&pVM->dbgf.s.PingPong, cPollHack);
319	if (RT_SUCCESS(rc))
320	enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_NO_COMMAND);
321	else if (rc == VERR_TIMEOUT)
322	rc = VINF_SUCCESS;
323	}
324	}
325
326	/*
327	* Clear the FF so we won't get confused later on.
328	*/
329	VM_FF_CLEAR(pVM, VM_FF_DBGF);
330	}
331	}
332	}
333
334
335	/**
336	* Applies relocations to data and code managed by this
337	* component. This function will be called at init and
338	* whenever the VMM need to relocate it self inside the GC.
339	*
340	* @param pVM The cross context VM structure.
341	* @param offDelta Relocation delta relative to old location.
342	*/
343	VMMR3_INT_DECL(void) DBGFR3Relocate(PVM pVM, RTGCINTPTR offDelta)
344	{
345	dbgfR3TraceRelocate(pVM);
346	dbgfR3AsRelocate(pVM->pUVM, offDelta);
347	}
348
349
350	/**
351	* Waits a little while for a debuggger to attach.
352	*
353	* @returns True is a debugger have attached.
354	* @param pVM The cross context VM structure.
355	* @param pVCpu The cross context per CPU structure.
356	* @param enmEvent Event.
357	*
358	* @thread EMT(pVCpu)
359	*/
360	bool dbgfR3WaitForAttach(PVM pVM, PVMCPU pVCpu, DBGFEVENTTYPE enmEvent)
361	{
362	/*
363	* First a message.
364	*/
365	#ifndef RT_OS_L4
366
367	# if !defined(DEBUG) \|\| defined(DEBUG_sandervl) \|\| defined(DEBUG_frank)
368	int cWait = 10;
369	# else
370	int cWait = !VM_IS_RAW_MODE_ENABLED(pVM)
371	&& ( enmEvent == DBGFEVENT_ASSERTION_HYPER
372	\|\| enmEvent == DBGFEVENT_FATAL_ERROR)
373	&& !RTEnvExist("VBOX_DBGF_WAIT_FOR_ATTACH")
374	? 10
375	: 150;
376	# endif
377	RTStrmPrintf(g_pStdErr, "DBGF: No debugger attached, waiting %d second%s for one to attach (event=%d)\n",
378	cWait / 10, cWait != 10 ? "s" : "", enmEvent);
379	RTStrmFlush(g_pStdErr);
380	while (cWait > 0)
381	{
382	RTThreadSleep(100);
383	if (pVM->dbgf.s.fAttached)
384	{
385	RTStrmPrintf(g_pStdErr, "Attached!\n");
386	RTStrmFlush(g_pStdErr);
387	return true;
388	}
389
390	/* Process priority stuff. */
391	if ( VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
392	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
393	{
394	int rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, true /fPriorityOnly/);
395	if (rc == VINF_SUCCESS)
396	rc = VMR3ReqProcessU(pVM->pUVM, pVCpu->idCpu, true /fPriorityOnly/);
397	if (rc != VINF_SUCCESS)
398	{
399	RTStrmPrintf(g_pStdErr, "[rcReq=%Rrc, ignored!]", rc);
400	RTStrmFlush(g_pStdErr);
401	}
402	}
403
404	/* next */
405	if (!(cWait % 10))
406	{
407	RTStrmPrintf(g_pStdErr, "%d.", cWait / 10);
408	RTStrmFlush(g_pStdErr);
409	}
410	cWait--;
411	}
412	#endif
413
414	RTStrmPrintf(g_pStdErr, "Stopping the VM!\n");
415	RTStrmFlush(g_pStdErr);
416	return false;
417	}
418
419
420	/**
421	* Forced action callback.
422	*
423	* The VMM will call this from it's main loop when either VM_FF_DBGF or
424	* VMCPU_FF_DBGF are set.
425	*
426	* The function checks for and executes pending commands from the debugger.
427	* Then it checks for pending debug events and serves these.
428	*
429	* @returns VINF_SUCCESS normally.
430	* @returns VERR_DBGF_RAISE_FATAL_ERROR to pretend a fatal error happened.
431	* @param pVM The cross context VM structure.
432	* @param pVCpu The cross context per CPU structure.
433	*/
434	VMMR3_INT_DECL(int) DBGFR3VMMForcedAction(PVM pVM, PVMCPU pVCpu)
435	{
436	VBOXSTRICTRC rcStrict = VINF_SUCCESS;
437
438	if (VM_FF_TEST_AND_CLEAR(pVM, VM_FF_DBGF))
439	{
440	/*
441	* Command pending? Process it.
442	*/
443	if (pVM->dbgf.s.enmVMMCmd != DBGFCMD_NO_COMMAND)
444	{
445	bool fResumeExecution;
446	DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
447	DBGFCMD enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_NO_COMMAND);
448	rcStrict = dbgfR3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
449	if (!fResumeExecution)
450	rcStrict = dbgfR3VMMWait(pVM);
451	}
452	}
453
454	/*
455	* Dispatch pending events.
456	*/
457	if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_DBGF))
458	{
459	if ( pVCpu->dbgf.s.cEvents > 0
460	&& pVCpu->dbgf.s.aEvents[pVCpu->dbgf.s.cEvents - 1].enmState == DBGFEVENTSTATE_CURRENT)
461	{
462	VBOXSTRICTRC rcStrict2 = DBGFR3EventHandlePending(pVM, pVCpu);
463	if ( rcStrict2 != VINF_SUCCESS
464	&& ( rcStrict == VINF_SUCCESS
465	\|\| RT_FAILURE(rcStrict2)
466	\|\| rcStrict2 < rcStrict) ) /** @todo oversimplified? */
467	rcStrict = rcStrict2;
468	}
469	}
470
471	return VBOXSTRICTRC_TODO(rcStrict);
472	}
473
474
475	/**
476	* Flag whether the event implies that we're stopped in the hypervisor code
477	* and have to block certain operations.
478	*
479	* @param pVM The cross context VM structure.
480	* @param enmEvent The event.
481	*/
482	static void dbgfR3EventSetStoppedInHyperFlag(PVM pVM, DBGFEVENTTYPE enmEvent)
483	{
484	switch (enmEvent)
485	{
486	case DBGFEVENT_STEPPED_HYPER:
487	case DBGFEVENT_ASSERTION_HYPER:
488	case DBGFEVENT_BREAKPOINT_HYPER:
489	pVM->dbgf.s.fStoppedInHyper = true;
490	break;
491	default:
492	pVM->dbgf.s.fStoppedInHyper = false;
493	break;
494	}
495	}
496
497
498	/**
499	* Try to determine the event context.
500	*
501	* @returns debug event context.
502	* @param pVM The cross context VM structure.
503	*/
504	static DBGFEVENTCTX dbgfR3FigureEventCtx(PVM pVM)
505	{
506	/** @todo SMP support! */
507	PVMCPU pVCpu = &pVM->aCpus[0];
508
509	switch (EMGetState(pVCpu))
510	{
511	case EMSTATE_RAW:
512	case EMSTATE_DEBUG_GUEST_RAW:
513	return DBGFEVENTCTX_RAW;
514
515	case EMSTATE_REM:
516	case EMSTATE_DEBUG_GUEST_REM:
517	return DBGFEVENTCTX_REM;
518
519	case EMSTATE_DEBUG_HYPER:
520	case EMSTATE_GURU_MEDITATION:
521	return DBGFEVENTCTX_HYPER;
522
523	default:
524	return DBGFEVENTCTX_OTHER;
525	}
526	}
527
528	/**
529	* The common event prologue code.
530	* It will set the 'stopped-in-hyper' flag, make sure someone is attached,
531	* and perhaps process any high priority pending actions (none yet).
532	*
533	* @returns VBox status code.
534	* @param pVM The cross context VM structure.
535	* @param enmEvent The event to be sent.
536	*/
537	static int dbgfR3EventPrologue(PVM pVM, DBGFEVENTTYPE enmEvent)
538	{
539	/** @todo SMP */
540	PVMCPU pVCpu = VMMGetCpu(pVM);
541
542	/*
543	* Check if a debugger is attached.
544	*/
545	if ( !pVM->dbgf.s.fAttached
546	&& !dbgfR3WaitForAttach(pVM, pVCpu, enmEvent))
547	{
548	Log(("DBGFR3VMMEventSrc: enmEvent=%d - debugger not attached\n", enmEvent));
549	return VERR_DBGF_NOT_ATTACHED;
550	}
551
552	/*
553	* Sync back the state from the REM.
554	*/
555	dbgfR3EventSetStoppedInHyperFlag(pVM, enmEvent);
556	#ifdef VBOX_WITH_REM
557	if (!pVM->dbgf.s.fStoppedInHyper)
558	REMR3StateUpdate(pVM, pVCpu);
559	#endif
560
561	/*
562	* Look thru pending commands and finish those which make sense now.
563	*/
564	/** @todo Process/purge pending commands. */
565	//int rc = DBGFR3VMMForcedAction(pVM);
566	return VINF_SUCCESS;
567	}
568
569
570	/**
571	* Sends the event in the event buffer.
572	*
573	* @returns VBox status code.
574	* @param pVM The cross context VM structure.
575	*/
576	static int dbgfR3SendEvent(PVM pVM)
577	{
578	pVM->dbgf.s.SteppingFilter.idCpu = NIL_VMCPUID;
579
580	int rc = RTSemPing(&pVM->dbgf.s.PingPong);
581	if (RT_SUCCESS(rc))
582	rc = dbgfR3VMMWait(pVM);
583
584	pVM->dbgf.s.fStoppedInHyper = false;
585	/** @todo sync VMM -> REM after exitting the debugger. everything may change while in the debugger! */
586	return rc;
587	}
588
589
590	/**
591	* Processes a pending event on the current CPU.
592	*
593	* This is called by EM in response to VINF_EM_DBG_EVENT.
594	*
595	* @returns Strict VBox status code.
596	* @param pVM The cross context VM structure.
597	* @param pVCpu The cross context per CPU structure.
598	*
599	* @thread EMT(pVCpu)
600	*/
601	VMMR3_INT_DECL(VBOXSTRICTRC) DBGFR3EventHandlePending(PVM pVM, PVMCPU pVCpu)
602	{
603	VMCPU_ASSERT_EMT(pVCpu);
604	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_DBGF);
605
606	/*
607	* Check that we've got an event first.
608	*/
609	AssertReturn(pVCpu->dbgf.s.cEvents > 0, VINF_SUCCESS);
610	AssertReturn(pVCpu->dbgf.s.aEvents[pVCpu->dbgf.s.cEvents - 1].enmState == DBGFEVENTSTATE_CURRENT, VINF_SUCCESS);
611	PDBGFEVENT pEvent = &pVCpu->dbgf.s.aEvents[pVCpu->dbgf.s.cEvents - 1].Event;
612
613	/*
614	* Make sure we've got a debugger and is allowed to speak to it.
615	*/
616	int rc = dbgfR3EventPrologue(pVM, pEvent->enmType);
617	if (RT_FAILURE(rc))
618	{
619	/** @todo drop them events? */
620	return rc;
621	}
622
623	/** @todo SMP + debugger speaker logic */
624	/*
625	* Copy the event over and mark it as ignore.
626	*/
627	pVM->dbgf.s.DbgEvent = *pEvent;
628	pVCpu->dbgf.s.aEvents[pVCpu->dbgf.s.cEvents - 1].enmState = DBGFEVENTSTATE_IGNORE;
629	return dbgfR3SendEvent(pVM);
630	}
631
632
633	/**
634	* Send a generic debugger event which takes no data.
635	*
636	* @returns VBox status code.
637	* @param pVM The cross context VM structure.
638	* @param enmEvent The event to send.
639	* @internal
640	*/
641	VMMR3DECL(int) DBGFR3Event(PVM pVM, DBGFEVENTTYPE enmEvent)
642	{
643	/*
644	* Do stepping filtering.
645	*/
646	/** @todo Would be better if we did some of this inside the execution
647	* engines. */
648	if ( enmEvent == DBGFEVENT_STEPPED
649	\|\| enmEvent == DBGFEVENT_STEPPED_HYPER)
650	{
651	if (!dbgfStepAreWeThereYet(pVM, VMMGetCpu(pVM)))
652	return VINF_EM_DBG_STEP;
653	}
654
655	int rc = dbgfR3EventPrologue(pVM, enmEvent);
656	if (RT_FAILURE(rc))
657	return rc;
658
659	/*
660	* Send the event and process the reply communication.
661	*/
662	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
663	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
664	return dbgfR3SendEvent(pVM);
665	}
666
667
668	/**
669	* Send a debugger event which takes the full source file location.
670	*
671	* @returns VBox status code.
672	* @param pVM The cross context VM structure.
673	* @param enmEvent The event to send.
674	* @param pszFile Source file.
675	* @param uLine Line number in source file.
676	* @param pszFunction Function name.
677	* @param pszFormat Message which accompanies the event.
678	* @param ... Message arguments.
679	* @internal
680	*/
681	VMMR3DECL(int) DBGFR3EventSrc(PVM pVM, DBGFEVENTTYPE enmEvent, const char pszFile, unsigned uLine, const char pszFunction, const char *pszFormat, ...)
682	{
683	va_list args;
684	va_start(args, pszFormat);
685	int rc = DBGFR3EventSrcV(pVM, enmEvent, pszFile, uLine, pszFunction, pszFormat, args);
686	va_end(args);
687	return rc;
688	}
689
690
691	/**
692	* Send a debugger event which takes the full source file location.
693	*
694	* @returns VBox status code.
695	* @param pVM The cross context VM structure.
696	* @param enmEvent The event to send.
697	* @param pszFile Source file.
698	* @param uLine Line number in source file.
699	* @param pszFunction Function name.
700	* @param pszFormat Message which accompanies the event.
701	* @param args Message arguments.
702	* @internal
703	*/
704	VMMR3DECL(int) DBGFR3EventSrcV(PVM pVM, DBGFEVENTTYPE enmEvent, const char pszFile, unsigned uLine, const char pszFunction, const char *pszFormat, va_list args)
705	{
706	int rc = dbgfR3EventPrologue(pVM, enmEvent);
707	if (RT_FAILURE(rc))
708	return rc;
709
710	/*
711	* Format the message.
712	*/
713	char *pszMessage = NULL;
714	char szMessage[8192];
715	if (pszFormat && *pszFormat)
716	{
717	pszMessage = &szMessage[0];
718	RTStrPrintfV(szMessage, sizeof(szMessage), pszFormat, args);
719	}
720
721	/*
722	* Send the event and process the reply communication.
723	*/
724	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
725	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
726	pVM->dbgf.s.DbgEvent.u.Src.pszFile = pszFile;
727	pVM->dbgf.s.DbgEvent.u.Src.uLine = uLine;
728	pVM->dbgf.s.DbgEvent.u.Src.pszFunction = pszFunction;
729	pVM->dbgf.s.DbgEvent.u.Src.pszMessage = pszMessage;
730	return dbgfR3SendEvent(pVM);
731	}
732
733
734	/**
735	* Send a debugger event which takes the two assertion messages.
736	*
737	* @returns VBox status code.
738	* @param pVM The cross context VM structure.
739	* @param enmEvent The event to send.
740	* @param pszMsg1 First assertion message.
741	* @param pszMsg2 Second assertion message.
742	*/
743	VMMR3_INT_DECL(int) DBGFR3EventAssertion(PVM pVM, DBGFEVENTTYPE enmEvent, const char pszMsg1, const char pszMsg2)
744	{
745	int rc = dbgfR3EventPrologue(pVM, enmEvent);
746	if (RT_FAILURE(rc))
747	return rc;
748
749	/*
750	* Send the event and process the reply communication.
751	*/
752	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
753	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
754	pVM->dbgf.s.DbgEvent.u.Assert.pszMsg1 = pszMsg1;
755	pVM->dbgf.s.DbgEvent.u.Assert.pszMsg2 = pszMsg2;
756	return dbgfR3SendEvent(pVM);
757	}
758
759
760	/**
761	* Breakpoint was hit somewhere.
762	* Figure out which breakpoint it is and notify the debugger.
763	*
764	* @returns VBox status code.
765	* @param pVM The cross context VM structure.
766	* @param enmEvent DBGFEVENT_BREAKPOINT_HYPER or DBGFEVENT_BREAKPOINT.
767	*/
768	VMMR3_INT_DECL(int) DBGFR3EventBreakpoint(PVM pVM, DBGFEVENTTYPE enmEvent)
769	{
770	int rc = dbgfR3EventPrologue(pVM, enmEvent);
771	if (RT_FAILURE(rc))
772	return rc;
773
774	/*
775	* Send the event and process the reply communication.
776	*/
777	/** @todo SMP */
778	PVMCPU pVCpu = VMMGetCpu0(pVM);
779
780	pVM->dbgf.s.DbgEvent.enmType = enmEvent;
781	RTUINT iBp = pVM->dbgf.s.DbgEvent.u.Bp.iBp = pVCpu->dbgf.s.iActiveBp;
782	pVCpu->dbgf.s.iActiveBp = ~0U;
783	if (iBp != ~0U)
784	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_RAW;
785	else
786	{
787	/* REM breakpoints has be been searched for. */
788	#if 0 /** @todo get flat PC api! */
789	uint32_t eip = CPUMGetGuestEIP(pVM);
790	#else
791	/** @todo SMP support!! */
792	PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(VMMGetCpu(pVM));
793	RTGCPTR eip = pCtx->rip + pCtx->cs.u64Base;
794	#endif
795	for (size_t i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); i++)
796	if ( pVM->dbgf.s.aBreakpoints[i].enmType == DBGFBPTYPE_REM
797	&& pVM->dbgf.s.aBreakpoints[i].u.Rem.GCPtr == eip)
798	{
799	pVM->dbgf.s.DbgEvent.u.Bp.iBp = pVM->dbgf.s.aBreakpoints[i].iBp;
800	break;
801	}
802	AssertMsg(pVM->dbgf.s.DbgEvent.u.Bp.iBp != ~0U, ("eip=%08x\n", eip));
803	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_REM;
804	}
805	return dbgfR3SendEvent(pVM);
806	}
807
808
809	/**
810	* Waits for the debugger to respond.
811	*
812	* @returns VBox status code. (clearify)
813	* @param pVM The cross context VM structure.
814	*/
815	static int dbgfR3VMMWait(PVM pVM)
816	{
817	PVMCPU pVCpu = VMMGetCpu(pVM);
818
819	LogFlow(("dbgfR3VMMWait:\n"));
820	int rcRet = VINF_SUCCESS;
821
822	/*
823	* Waits for the debugger to reply (i.e. issue an command).
824	*/
825	for (;;)
826	{
827	/*
828	* Wait.
829	*/
830	uint32_t cPollHack = 1; /** @todo this interface is horrible now that we're using lots of VMR3ReqCall stuff all over DBGF. */
831	for (;;)
832	{
833	int rc;
834	if ( !VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS \| VM_FF_REQUEST)
835	&& !VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
836	{
837	rc = RTSemPingWait(&pVM->dbgf.s.PingPong, cPollHack);
838	if (RT_SUCCESS(rc))
839	break;
840	if (rc != VERR_TIMEOUT)
841	{
842	LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rc));
843	return rc;
844	}
845	}
846
847	if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
848	{
849	rc = VMMR3EmtRendezvousFF(pVM, pVCpu);
850	cPollHack = 1;
851	}
852	else if ( VM_FF_IS_PENDING(pVM, VM_FF_REQUEST)
853	\|\| VMCPU_FF_IS_PENDING(pVCpu, VMCPU_FF_REQUEST))
854	{
855	LogFlow(("dbgfR3VMMWait: Processes requests...\n"));
856	rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY, false /fPriorityOnly/);
857	if (rc == VINF_SUCCESS)
858	rc = VMR3ReqProcessU(pVM->pUVM, pVCpu->idCpu, false /fPriorityOnly/);
859	LogFlow(("dbgfR3VMMWait: VMR3ReqProcess -> %Rrc rcRet=%Rrc\n", rc, rcRet));
860	cPollHack = 1;
861	}
862	else
863	{
864	rc = VINF_SUCCESS;
865	if (cPollHack < 120)
866	cPollHack++;
867	}
868
869	if (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST)
870	{
871	switch (rc)
872	{
873	case VINF_EM_DBG_BREAKPOINT:
874	case VINF_EM_DBG_STEPPED:
875	case VINF_EM_DBG_STEP:
876	case VINF_EM_DBG_STOP:
877	case VINF_EM_DBG_EVENT:
878	AssertMsgFailed(("rc=%Rrc\n", rc));
879	break;
880
881	/* return straight away */
882	case VINF_EM_TERMINATE:
883	case VINF_EM_OFF:
884	LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rc));
885	return rc;
886
887	/* remember return code. */
888	default:
889	AssertReleaseMsgFailed(("rc=%Rrc is not in the switch!\n", rc));
890	RT_FALL_THRU();
891	case VINF_EM_RESET:
892	case VINF_EM_SUSPEND:
893	case VINF_EM_HALT:
894	case VINF_EM_RESUME:
895	case VINF_EM_RESCHEDULE:
896	case VINF_EM_RESCHEDULE_REM:
897	case VINF_EM_RESCHEDULE_RAW:
898	if (rc < rcRet \|\| rcRet == VINF_SUCCESS)
899	rcRet = rc;
900	break;
901	}
902	}
903	else if (RT_FAILURE(rc))
904	{
905	LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rc));
906	return rc;
907	}
908	}
909
910	/*
911	* Process the command.
912	*/
913	bool fResumeExecution;
914	DBGFCMDDATA CmdData = pVM->dbgf.s.VMMCmdData;
915	DBGFCMD enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_NO_COMMAND);
916	int rc = dbgfR3VMMCmd(pVM, enmCmd, &CmdData, &fResumeExecution);
917	if (fResumeExecution)
918	{
919	if (RT_FAILURE(rc))
920	rcRet = rc;
921	else if ( rc >= VINF_EM_FIRST
922	&& rc <= VINF_EM_LAST
923	&& (rc < rcRet \|\| rcRet == VINF_SUCCESS))
924	rcRet = rc;
925	LogFlow(("dbgfR3VMMWait: returns %Rrc\n", rcRet));
926	return rcRet;
927	}
928	}
929	}
930
931
932	/**
933	* Executes command from debugger.
934	*
935	* The caller is responsible for waiting or resuming execution based on the
936	* value returned in the *pfResumeExecution indicator.
937	*
938	* @returns VBox status code. (clearify!)
939	* @param pVM The cross context VM structure.
940	* @param enmCmd The command in question.
941	* @param pCmdData Pointer to the command data.
942	* @param pfResumeExecution Where to store the resume execution / continue waiting indicator.
943	*/
944	static int dbgfR3VMMCmd(PVM pVM, DBGFCMD enmCmd, PDBGFCMDDATA pCmdData, bool *pfResumeExecution)
945	{
946	bool fSendEvent;
947	bool fResume;
948	int rc = VINF_SUCCESS;
949
950	NOREF(pCmdData); /* for later */
951
952	switch (enmCmd)
953	{
954	/*
955	* Halt is answered by an event say that we've halted.
956	*/
957	case DBGFCMD_HALT:
958	{
959	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_HALT_DONE;
960	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
961	fSendEvent = true;
962	fResume = false;
963	break;
964	}
965
966
967	/*
968	* Resume is not answered we'll just resume execution.
969	*/
970	case DBGFCMD_GO:
971	{
972	/** @todo SMP */
973	PVMCPU pVCpu = VMMGetCpu0(pVM);
974	pVCpu->dbgf.s.fSingleSteppingRaw = false;
975	fSendEvent = false;
976	fResume = true;
977	break;
978	}
979
980	/** @todo implement (and define) the rest of the commands. */
981
982	/*
983	* Disable breakpoints and stuff.
984	* Send an everythings cool event to the debugger thread and resume execution.
985	*/
986	case DBGFCMD_DETACH_DEBUGGER:
987	{
988	ASMAtomicWriteBool(&pVM->dbgf.s.fAttached, false);
989	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_DETACH_DONE;
990	pVM->dbgf.s.DbgEvent.enmCtx = DBGFEVENTCTX_OTHER;
991	pVM->dbgf.s.SteppingFilter.idCpu = NIL_VMCPUID;
992	fSendEvent = true;
993	fResume = true;
994	break;
995	}
996
997	/*
998	* The debugger has detached successfully.
999	* There is no reply to this event.
1000	*/
1001	case DBGFCMD_DETACHED_DEBUGGER:
1002	{
1003	fSendEvent = false;
1004	fResume = true;
1005	break;
1006	}
1007
1008	/*
1009	* Single step, with trace into.
1010	*/
1011	case DBGFCMD_SINGLE_STEP:
1012	{
1013	Log2(("Single step\n"));
1014	/** @todo SMP */
1015	PVMCPU pVCpu = VMMGetCpu0(pVM);
1016	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_OVER)
1017	{
1018	if (dbgfStepGetCurInstrType(pVM, pVCpu) == DBGFSTEPINSTRTYPE_CALL)
1019	pVM->dbgf.s.SteppingFilter.uCallDepth++;
1020	}
1021	if (pVM->dbgf.s.SteppingFilter.cMaxSteps > 0)
1022	{
1023	pVCpu->dbgf.s.fSingleSteppingRaw = true;
1024	fSendEvent = false;
1025	fResume = true;
1026	rc = VINF_EM_DBG_STEP;
1027	}
1028	else
1029	{
1030	/* Stop after zero steps. Nonsense, but whatever. */
1031	pVM->dbgf.s.SteppingFilter.idCpu = NIL_VMCPUID;
1032	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
1033	pVM->dbgf.s.DbgEvent.enmType = pVM->dbgf.s.DbgEvent.enmCtx != DBGFEVENTCTX_HYPER
1034	? DBGFEVENT_STEPPED : DBGFEVENT_STEPPED_HYPER;
1035	fSendEvent = false;
1036	fResume = false;
1037	}
1038	break;
1039	}
1040
1041	/*
1042	* Default is to send an invalid command event.
1043	*/
1044	default:
1045	{
1046	pVM->dbgf.s.DbgEvent.enmType = DBGFEVENT_INVALID_COMMAND;
1047	pVM->dbgf.s.DbgEvent.enmCtx = dbgfR3FigureEventCtx(pVM);
1048	fSendEvent = true;
1049	fResume = false;
1050	break;
1051	}
1052	}
1053
1054	/*
1055	* Send pending event.
1056	*/
1057	if (fSendEvent)
1058	{
1059	Log2(("DBGF: Emulation thread: sending event %d\n", pVM->dbgf.s.DbgEvent.enmType));
1060	int rc2 = RTSemPing(&pVM->dbgf.s.PingPong);
1061	if (RT_FAILURE(rc2))
1062	{
1063	AssertRC(rc2);
1064	*pfResumeExecution = true;
1065	return rc2;
1066	}
1067	}
1068
1069	/*
1070	* Return.
1071	*/
1072	*pfResumeExecution = fResume;
1073	return rc;
1074	}
1075
1076
1077	/**
1078	* Attaches a debugger to the specified VM.
1079	*
1080	* Only one debugger at a time.
1081	*
1082	* @returns VBox status code.
1083	* @param pUVM The user mode VM handle.
1084	*/
1085	VMMR3DECL(int) DBGFR3Attach(PUVM pUVM)
1086	{
1087	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1088	PVM pVM = pUVM->pVM;
1089	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1090
1091	/*
1092	* Call the VM, use EMT for serialization.
1093	*
1094	* Using a priority call here so we can actually attach a debugger during
1095	* the countdown in dbgfR3WaitForAttach.
1096	*/
1097	/** @todo SMP */
1098	return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)dbgfR3Attach, 1, pVM);
1099	}
1100
1101
1102	/**
1103	* EMT worker for DBGFR3Attach.
1104	*
1105	* @returns VBox status code.
1106	* @param pVM The cross context VM structure.
1107	*/
1108	static DECLCALLBACK(int) dbgfR3Attach(PVM pVM)
1109	{
1110	if (pVM->dbgf.s.fAttached)
1111	{
1112	Log(("dbgR3Attach: Debugger already attached\n"));
1113	return VERR_DBGF_ALREADY_ATTACHED;
1114	}
1115
1116	/*
1117	* Create the Ping-Pong structure.
1118	*/
1119	int rc = RTSemPingPongInit(&pVM->dbgf.s.PingPong);
1120	AssertRCReturn(rc, rc);
1121
1122	/*
1123	* Set the attached flag.
1124	*/
1125	ASMAtomicWriteBool(&pVM->dbgf.s.fAttached, true);
1126	return VINF_SUCCESS;
1127	}
1128
1129
1130	/**
1131	* Detaches a debugger from the specified VM.
1132	*
1133	* Caller must be attached to the VM.
1134	*
1135	* @returns VBox status code.
1136	* @param pUVM The user mode VM handle.
1137	*/
1138	VMMR3DECL(int) DBGFR3Detach(PUVM pUVM)
1139	{
1140	LogFlow(("DBGFR3Detach:\n"));
1141	int rc;
1142
1143	/*
1144	* Validate input. The UVM handle shall be valid, the VM handle might be
1145	* in the processes of being destroyed already, so deal quietly with that.
1146	*/
1147	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1148	PVM pVM = pUVM->pVM;
1149	if (!VM_IS_VALID_EXT(pVM))
1150	return VERR_INVALID_VM_HANDLE;
1151
1152	/*
1153	* Check if attached.
1154	*/
1155	if (!pVM->dbgf.s.fAttached)
1156	return VERR_DBGF_NOT_ATTACHED;
1157
1158	/*
1159	* Try send the detach command.
1160	* Keep in mind that we might be racing EMT, so, be extra careful.
1161	*/
1162	DBGFCMD enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_DETACH_DEBUGGER);
1163	if (RTSemPongIsSpeaker(&pVM->dbgf.s.PingPong))
1164	{
1165	rc = RTSemPong(&pVM->dbgf.s.PingPong);
1166	AssertMsgRCReturn(rc, ("Failed to signal emulation thread. rc=%Rrc\n", rc), rc);
1167	LogRel(("DBGFR3Detach: enmCmd=%d (pong -> ping)\n", enmCmd));
1168	}
1169
1170	/*
1171	* Wait for the OK event.
1172	*/
1173	rc = RTSemPongWait(&pVM->dbgf.s.PingPong, RT_INDEFINITE_WAIT);
1174	AssertLogRelMsgRCReturn(rc, ("Wait on detach command failed, rc=%Rrc\n", rc), rc);
1175
1176	/*
1177	* Send the notification command indicating that we're really done.
1178	*/
1179	enmCmd = dbgfR3SetCmd(pVM, DBGFCMD_DETACHED_DEBUGGER);
1180	rc = RTSemPong(&pVM->dbgf.s.PingPong);
1181	AssertMsgRCReturn(rc, ("Failed to signal emulation thread. rc=%Rrc\n", rc), rc);
1182
1183	LogFlowFunc(("returns VINF_SUCCESS\n"));
1184	return VINF_SUCCESS;
1185	}
1186
1187
1188	/**
1189	* Wait for a debug event.
1190	*
1191	* @returns VBox status code. Will not return VBOX_INTERRUPTED.
1192	* @param pUVM The user mode VM handle.
1193	* @param cMillies Number of millis to wait.
1194	* @param ppEvent Where to store the event pointer.
1195	*/
1196	VMMR3DECL(int) DBGFR3EventWait(PUVM pUVM, RTMSINTERVAL cMillies, PCDBGFEVENT *ppEvent)
1197	{
1198	/*
1199	* Check state.
1200	*/
1201	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1202	PVM pVM = pUVM->pVM;
1203	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1204	AssertReturn(pVM->dbgf.s.fAttached, VERR_DBGF_NOT_ATTACHED);
1205	*ppEvent = NULL;
1206
1207	/*
1208	* Wait.
1209	*/
1210	int rc = RTSemPongWait(&pVM->dbgf.s.PingPong, cMillies);
1211	if (RT_SUCCESS(rc))
1212	{
1213	*ppEvent = &pVM->dbgf.s.DbgEvent;
1214	Log2(("DBGF: Debugger thread: receiving event %d\n", (*ppEvent)->enmType));
1215	return VINF_SUCCESS;
1216	}
1217
1218	return rc;
1219	}
1220
1221
1222	/**
1223	* Halts VM execution.
1224	*
1225	* After calling this the VM isn't actually halted till an DBGFEVENT_HALT_DONE
1226	* arrives. Until that time it's not possible to issue any new commands.
1227	*
1228	* @returns VBox status code.
1229	* @param pUVM The user mode VM handle.
1230	*/
1231	VMMR3DECL(int) DBGFR3Halt(PUVM pUVM)
1232	{
1233	/*
1234	* Check state.
1235	*/
1236	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1237	PVM pVM = pUVM->pVM;
1238	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1239	AssertReturn(pVM->dbgf.s.fAttached, VERR_DBGF_NOT_ATTACHED);
1240	RTPINGPONGSPEAKER enmSpeaker = pVM->dbgf.s.PingPong.enmSpeaker;
1241	if ( enmSpeaker == RTPINGPONGSPEAKER_PONG
1242	\|\| enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED)
1243	return VWRN_DBGF_ALREADY_HALTED;
1244
1245	/*
1246	* Send command.
1247	*/
1248	dbgfR3SetCmd(pVM, DBGFCMD_HALT);
1249
1250	return VINF_SUCCESS;
1251	}
1252
1253
1254	/**
1255	* Checks if the VM is halted by the debugger.
1256	*
1257	* @returns True if halted.
1258	* @returns False if not halted.
1259	* @param pUVM The user mode VM handle.
1260	*/
1261	VMMR3DECL(bool) DBGFR3IsHalted(PUVM pUVM)
1262	{
1263	UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
1264	PVM pVM = pUVM->pVM;
1265	VM_ASSERT_VALID_EXT_RETURN(pVM, false);
1266	AssertReturn(pVM->dbgf.s.fAttached, false);
1267
1268	RTPINGPONGSPEAKER enmSpeaker = pVM->dbgf.s.PingPong.enmSpeaker;
1269	return enmSpeaker == RTPINGPONGSPEAKER_PONG_SIGNALED
1270	\|\| enmSpeaker == RTPINGPONGSPEAKER_PONG;
1271	}
1272
1273
1274	/**
1275	* Checks if the debugger can wait for events or not.
1276	*
1277	* This function is only used by lazy, multiplexing debuggers. :-)
1278	*
1279	* @returns VBox status code.
1280	* @retval VINF_SUCCESS if waitable.
1281	* @retval VERR_SEM_OUT_OF_TURN if not waitable.
1282	* @retval VERR_INVALID_VM_HANDLE if the VM is being (/ has been) destroyed
1283	* (not asserted) or if the handle is invalid (asserted).
1284	* @retval VERR_DBGF_NOT_ATTACHED if not attached.
1285	*
1286	* @param pUVM The user mode VM handle.
1287	*/
1288	VMMR3DECL(int) DBGFR3QueryWaitable(PUVM pUVM)
1289	{
1290	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1291
1292	/* Note! There is a slight race here, unfortunately. */
1293	PVM pVM = pUVM->pVM;
1294	if (!RT_VALID_PTR(pVM))
1295	return VERR_INVALID_VM_HANDLE;
1296	if (pVM->enmVMState >= VMSTATE_DESTROYING)
1297	return VERR_INVALID_VM_HANDLE;
1298	if (!pVM->dbgf.s.fAttached)
1299	return VERR_DBGF_NOT_ATTACHED;
1300
1301	if (!RTSemPongShouldWait(&pVM->dbgf.s.PingPong))
1302	return VERR_SEM_OUT_OF_TURN;
1303
1304	return VINF_SUCCESS;
1305	}
1306
1307
1308	/**
1309	* Resumes VM execution.
1310	*
1311	* There is no receipt event on this command.
1312	*
1313	* @returns VBox status code.
1314	* @param pUVM The user mode VM handle.
1315	*/
1316	VMMR3DECL(int) DBGFR3Resume(PUVM pUVM)
1317	{
1318	/*
1319	* Check state.
1320	*/
1321	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1322	PVM pVM = pUVM->pVM;
1323	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1324	AssertReturn(pVM->dbgf.s.fAttached, VERR_DBGF_NOT_ATTACHED);
1325	if (RT_LIKELY(RTSemPongIsSpeaker(&pVM->dbgf.s.PingPong)))
1326	{ /* likely */ }
1327	else
1328	return VERR_SEM_OUT_OF_TURN;
1329
1330	/*
1331	* Send the ping back to the emulation thread telling it to run.
1332	*/
1333	dbgfR3SetCmd(pVM, DBGFCMD_GO);
1334	int rc = RTSemPong(&pVM->dbgf.s.PingPong);
1335	AssertRC(rc);
1336
1337	return rc;
1338	}
1339
1340
1341	/**
1342	* Classifies the current instruction.
1343	*
1344	* @returns Type of instruction.
1345	* @param pVM The cross context VM structure.
1346	* @param pVCpu The current CPU.
1347	* @thread EMT(pVCpu)
1348	*/
1349	static DBGFSTEPINSTRTYPE dbgfStepGetCurInstrType(PVM pVM, PVMCPU pVCpu)
1350	{
1351	/*
1352	* Read the instruction.
1353	*/
1354	bool fIsHyper = dbgfR3FigureEventCtx(pVM) == DBGFEVENTCTX_HYPER;
1355	size_t cbRead = 0;
1356	uint8_t abOpcode[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1357	int rc = PGMR3DbgReadGCPtr(pVM, abOpcode, !fIsHyper ? CPUMGetGuestFlatPC(pVCpu) : CPUMGetHyperRIP(pVCpu),
1358	sizeof(abOpcode) - 1, 0 /fFlags/, &cbRead);
1359	if (RT_SUCCESS(rc))
1360	{
1361	/*
1362	* Do minimal parsing. No real need to involve the disassembler here.
1363	*/
1364	uint8_t *pb = abOpcode;
1365	for (;;)
1366	{
1367	switch (*pb++)
1368	{
1369	default:
1370	return DBGFSTEPINSTRTYPE_OTHER;
1371
1372	case 0xe8: /* call rel16/32 */
1373	case 0x9a: /* call farptr */
1374	case 0xcc: /* int3 */
1375	case 0xcd: /* int xx */
1376	// case 0xce: /* into */
1377	return DBGFSTEPINSTRTYPE_CALL;
1378
1379	case 0xc2: /* ret xx */
1380	case 0xc3: /* ret */
1381	case 0xca: /* retf xx */
1382	case 0xcb: /* retf */
1383	case 0xcf: /* iret */
1384	return DBGFSTEPINSTRTYPE_RET;
1385
1386	case 0xff:
1387	if ( ((pb >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) == 2 / call indir */
1388	\|\| ((pb >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) == 3) / call indir-farptr */
1389	return DBGFSTEPINSTRTYPE_CALL;
1390	return DBGFSTEPINSTRTYPE_OTHER;
1391
1392	case 0x0f:
1393	switch (*pb++)
1394	{
1395	case 0x05: /* syscall */
1396	case 0x34: /* sysenter */
1397	return DBGFSTEPINSTRTYPE_CALL;
1398	case 0x07: /* sysret */
1399	case 0x35: /* sysexit */
1400	return DBGFSTEPINSTRTYPE_RET;
1401	}
1402	break;
1403
1404	/* Must handle some REX prefixes. So we do all normal prefixes. */
1405	case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
1406	case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
1407	if (fIsHyper) /* ASSUMES 32-bit raw-mode! */
1408	return DBGFSTEPINSTRTYPE_OTHER;
1409	if (!CPUMIsGuestIn64BitCode(pVCpu))
1410	return DBGFSTEPINSTRTYPE_OTHER;
1411	break;
1412
1413	case 0x2e: /* CS */
1414	case 0x36: /* SS */
1415	case 0x3e: /* DS */
1416	case 0x26: /* ES */
1417	case 0x64: /* FS */
1418	case 0x65: /* GS */
1419	case 0x66: /* op size */
1420	case 0x67: /* addr size */
1421	case 0xf0: /* lock */
1422	case 0xf2: /* REPNZ */
1423	case 0xf3: /* REPZ */
1424	break;
1425	}
1426	}
1427	}
1428
1429	return DBGFSTEPINSTRTYPE_INVALID;
1430	}
1431
1432
1433	/**
1434	* Checks if the stepping has reached a stop point.
1435	*
1436	* Called when raising a stepped event.
1437	*
1438	* @returns true if the event should be raised, false if we should take one more
1439	* step first.
1440	* @param pVM The cross context VM structure.
1441	* @param pVCpu The cross context per CPU structure of the calling EMT.
1442	* @thread EMT(pVCpu)
1443	*/
1444	static bool dbgfStepAreWeThereYet(PVM pVM, PVMCPU pVCpu)
1445	{
1446	/*
1447	* Check valid pVCpu and that it matches the CPU one stepping.
1448	*/
1449	if (pVCpu)
1450	{
1451	if (pVCpu->idCpu == pVM->dbgf.s.SteppingFilter.idCpu)
1452	{
1453	/*
1454	* Increase the number of steps and see if we've reached the max.
1455	*/
1456	pVM->dbgf.s.SteppingFilter.cSteps++;
1457	if (pVM->dbgf.s.SteppingFilter.cSteps < pVM->dbgf.s.SteppingFilter.cMaxSteps)
1458	{
1459	/*
1460	* Check PC and SP address filtering.
1461	*/
1462	if (pVM->dbgf.s.SteppingFilter.fFlags & (DBGF_STEP_F_STOP_ON_ADDRESS \| DBGF_STEP_F_STOP_ON_STACK_POP))
1463	{
1464	bool fIsHyper = dbgfR3FigureEventCtx(pVM) == DBGFEVENTCTX_HYPER;
1465	if ( (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_ADDRESS)
1466	&& pVM->dbgf.s.SteppingFilter.AddrPc == (!fIsHyper ? CPUMGetGuestFlatPC(pVCpu) : CPUMGetHyperRIP(pVCpu)))
1467	return true;
1468	if ( (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_STACK_POP)
1469	&& (!fIsHyper ? CPUMGetGuestFlatSP(pVCpu) : (uint64_t)CPUMGetHyperESP(pVCpu))
1470	- pVM->dbgf.s.SteppingFilter.AddrStackPop
1471	< pVM->dbgf.s.SteppingFilter.cbStackPop)
1472	return true;
1473	}
1474
1475	/*
1476	* Do step-over filtering separate from the step-into one.
1477	*/
1478	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_OVER)
1479	{
1480	DBGFSTEPINSTRTYPE enmType = dbgfStepGetCurInstrType(pVM, pVCpu);
1481	switch (enmType)
1482	{
1483	default:
1484	if ( pVM->dbgf.s.SteppingFilter.uCallDepth != 0
1485	\|\| (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_FILTER_MASK))
1486	break;
1487	return true;
1488	case DBGFSTEPINSTRTYPE_CALL:
1489	if ( (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_CALL)
1490	&& pVM->dbgf.s.SteppingFilter.uCallDepth == 0)
1491	return true;
1492	pVM->dbgf.s.SteppingFilter.uCallDepth++;
1493	break;
1494	case DBGFSTEPINSTRTYPE_RET:
1495	if (pVM->dbgf.s.SteppingFilter.uCallDepth == 0)
1496	{
1497	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_RET)
1498	return true;
1499	/* If after return, we use the cMaxStep limit to stop the next time. */
1500	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_AFTER_RET)
1501	pVM->dbgf.s.SteppingFilter.cMaxSteps = pVM->dbgf.s.SteppingFilter.cSteps + 1;
1502	}
1503	else if (pVM->dbgf.s.SteppingFilter.uCallDepth > 0)
1504	pVM->dbgf.s.SteppingFilter.uCallDepth--;
1505	break;
1506	}
1507	return false;
1508	}
1509	/*
1510	* Filtered step-into.
1511	*/
1512	else if ( pVM->dbgf.s.SteppingFilter.fFlags
1513	& (DBGF_STEP_F_STOP_ON_CALL \| DBGF_STEP_F_STOP_ON_RET \| DBGF_STEP_F_STOP_AFTER_RET))
1514	{
1515	DBGFSTEPINSTRTYPE enmType = dbgfStepGetCurInstrType(pVM, pVCpu);
1516	switch (enmType)
1517	{
1518	default:
1519	break;
1520	case DBGFSTEPINSTRTYPE_CALL:
1521	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_CALL)
1522	return true;
1523	break;
1524	case DBGFSTEPINSTRTYPE_RET:
1525	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_ON_RET)
1526	return true;
1527	/* If after return, we use the cMaxStep limit to stop the next time. */
1528	if (pVM->dbgf.s.SteppingFilter.fFlags & DBGF_STEP_F_STOP_AFTER_RET)
1529	pVM->dbgf.s.SteppingFilter.cMaxSteps = pVM->dbgf.s.SteppingFilter.cSteps + 1;
1530	break;
1531	}
1532	return false;
1533	}
1534	}
1535	}
1536	}
1537
1538	return true;
1539	}
1540
1541
1542	/**
1543	* Step Into.
1544	*
1545	* A single step event is generated from this command.
1546	* The current implementation is not reliable, so don't rely on the event coming.
1547	*
1548	* @returns VBox status code.
1549	* @param pUVM The user mode VM handle.
1550	* @param idCpu The ID of the CPU to single step on.
1551	*/
1552	VMMR3DECL(int) DBGFR3Step(PUVM pUVM, VMCPUID idCpu)
1553	{
1554	return DBGFR3StepEx(pUVM, idCpu, DBGF_STEP_F_INTO, NULL, NULL, 0, 1);
1555	}
1556
1557
1558	/**
1559	* Full fleged step.
1560	*
1561	* This extended stepping API allows for doing multiple steps before raising an
1562	* event, helping implementing step over, step out and other more advanced
1563	* features.
1564	*
1565	* Like the DBGFR3Step() API, this will normally generate a DBGFEVENT_STEPPED or
1566	* DBGFEVENT_STEPPED_EVENT. However the stepping may be interrupted by other
1567	* events, which will abort the stepping.
1568	*
1569	* The stop on pop area feature is for safeguarding step out.
1570	*
1571	* Please note though, that it will always use stepping and never breakpoints.
1572	* While this allows for a much greater flexibility it can at times be rather
1573	* slow.
1574	*
1575	* @returns VBox status code.
1576	* @param pUVM The user mode VM handle.
1577	* @param idCpu The ID of the CPU to single step on.
1578	* @param fFlags Flags controlling the stepping, DBGF_STEP_F_XXX.
1579	* Either DBGF_STEP_F_INTO or DBGF_STEP_F_OVER must
1580	* always be specified.
1581	* @param pStopPcAddr Address to stop executing at. Completely ignored
1582	* unless DBGF_STEP_F_STOP_ON_ADDRESS is specified.
1583	* @param pStopPopAddr Stack address that SP must be lower than when
1584	* performing DBGF_STEP_F_STOP_ON_STACK_POP filtering.
1585	* @param cbStopPop The range starting at @a pStopPopAddr which is
1586	* considered to be within the same thread stack. Note
1587	* that the API allows @a pStopPopAddr and @a cbStopPop
1588	* to form an area that wraps around and it will
1589	* consider the part starting at 0 as included.
1590	* @param cMaxSteps The maximum number of steps to take. This is to
1591	* prevent stepping for ever, so passing UINT32_MAX is
1592	* not recommended.
1593	*
1594	* @remarks The two address arguments must be guest context virtual addresses,
1595	* or HMA. The code doesn't make much of a point of out HMA, though.
1596	*/
1597	VMMR3DECL(int) DBGFR3StepEx(PUVM pUVM, VMCPUID idCpu, uint32_t fFlags, PCDBGFADDRESS pStopPcAddr,
1598	PCDBGFADDRESS pStopPopAddr, RTGCUINTPTR cbStopPop, uint32_t cMaxSteps)
1599	{
1600	/*
1601	* Check state.
1602	*/
1603	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1604	PVM pVM = pUVM->pVM;
1605	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1606	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
1607	AssertReturn(!(fFlags & ~DBGF_STEP_F_VALID_MASK), VERR_INVALID_FLAGS);
1608	AssertReturn(RT_BOOL(fFlags & DBGF_STEP_F_INTO) != RT_BOOL(fFlags & DBGF_STEP_F_OVER), VERR_INVALID_FLAGS);
1609	if (fFlags & DBGF_STEP_F_STOP_ON_ADDRESS)
1610	{
1611	AssertReturn(RT_VALID_PTR(pStopPcAddr), VERR_INVALID_POINTER);
1612	AssertReturn(DBGFADDRESS_IS_VALID(pStopPcAddr), VERR_INVALID_PARAMETER);
1613	AssertReturn(DBGFADDRESS_IS_VIRT_GC(pStopPcAddr), VERR_INVALID_PARAMETER);
1614	}
1615	AssertReturn(!(fFlags & DBGF_STEP_F_STOP_ON_STACK_POP) \|\| RT_VALID_PTR(pStopPopAddr), VERR_INVALID_POINTER);
1616	if (fFlags & DBGF_STEP_F_STOP_ON_STACK_POP)
1617	{
1618	AssertReturn(RT_VALID_PTR(pStopPopAddr), VERR_INVALID_POINTER);
1619	AssertReturn(DBGFADDRESS_IS_VALID(pStopPopAddr), VERR_INVALID_PARAMETER);
1620	AssertReturn(DBGFADDRESS_IS_VIRT_GC(pStopPopAddr), VERR_INVALID_PARAMETER);
1621	AssertReturn(cbStopPop > 0, VERR_INVALID_PARAMETER);
1622	}
1623
1624	AssertReturn(pVM->dbgf.s.fAttached, VERR_DBGF_NOT_ATTACHED);
1625	if (RT_LIKELY(RTSemPongIsSpeaker(&pVM->dbgf.s.PingPong)))
1626	{ /* likely */ }
1627	else
1628	return VERR_SEM_OUT_OF_TURN;
1629	Assert(pVM->dbgf.s.SteppingFilter.idCpu == NIL_VMCPUID);
1630
1631	/*
1632	* Send the ping back to the emulation thread telling it to run.
1633	*/
1634	if (fFlags == DBGF_STEP_F_INTO)
1635	pVM->dbgf.s.SteppingFilter.idCpu = NIL_VMCPUID;
1636	else
1637	pVM->dbgf.s.SteppingFilter.idCpu = idCpu;
1638	pVM->dbgf.s.SteppingFilter.fFlags = fFlags;
1639	if (fFlags & DBGF_STEP_F_STOP_ON_ADDRESS)
1640	pVM->dbgf.s.SteppingFilter.AddrPc = pStopPcAddr->FlatPtr;
1641	else
1642	pVM->dbgf.s.SteppingFilter.AddrPc = 0;
1643	if (fFlags & DBGF_STEP_F_STOP_ON_STACK_POP)
1644	{
1645	pVM->dbgf.s.SteppingFilter.AddrStackPop = pStopPopAddr->FlatPtr;
1646	pVM->dbgf.s.SteppingFilter.cbStackPop = cbStopPop;
1647	}
1648	else
1649	{
1650	pVM->dbgf.s.SteppingFilter.AddrStackPop = 0;
1651	pVM->dbgf.s.SteppingFilter.cbStackPop = RTGCPTR_MAX;
1652	}
1653
1654	pVM->dbgf.s.SteppingFilter.cMaxSteps = cMaxSteps;
1655	pVM->dbgf.s.SteppingFilter.cSteps = 0;
1656	pVM->dbgf.s.SteppingFilter.uCallDepth = 0;
1657
1658	/** @todo SMP (idCpu) */
1659	dbgfR3SetCmd(pVM, DBGFCMD_SINGLE_STEP);
1660	int rc = RTSemPong(&pVM->dbgf.s.PingPong);
1661	AssertRC(rc);
1662	return rc;
1663	}
1664
1665
1666
1667	/**
1668	* dbgfR3EventConfigEx argument packet.
1669	*/
1670	typedef struct DBGFR3EVENTCONFIGEXARGS
1671	{
1672	PCDBGFEVENTCONFIG paConfigs;
1673	size_t cConfigs;
1674	int rc;
1675	} DBGFR3EVENTCONFIGEXARGS;
1676	/** Pointer to a dbgfR3EventConfigEx argument packet. */
1677	typedef DBGFR3EVENTCONFIGEXARGS *PDBGFR3EVENTCONFIGEXARGS;
1678
1679
1680	/**
1681	* @callback_method_impl{FNVMMEMTRENDEZVOUS, Worker for DBGFR3EventConfigEx.}
1682	*/
1683	static DECLCALLBACK(VBOXSTRICTRC) dbgfR3EventConfigEx(PVM pVM, PVMCPU pVCpu, void *pvUser)
1684	{
1685	if (pVCpu->idCpu == 0)
1686	{
1687	PDBGFR3EVENTCONFIGEXARGS pArgs = (PDBGFR3EVENTCONFIGEXARGS)pvUser;
1688	DBGFEVENTCONFIG volatile const *paConfigs = pArgs->paConfigs;
1689	size_t cConfigs = pArgs->cConfigs;
1690
1691	/*
1692	* Apply the changes.
1693	*/
1694	unsigned cChanges = 0;
1695	for (uint32_t i = 0; i < cConfigs; i++)
1696	{
1697	DBGFEVENTTYPE enmType = paConfigs[i].enmType;
1698	AssertReturn(enmType >= DBGFEVENT_FIRST_SELECTABLE && enmType < DBGFEVENT_END, VERR_INVALID_PARAMETER);
1699	if (paConfigs[i].fEnabled)
1700	cChanges += ASMAtomicBitTestAndSet(&pVM->dbgf.s.bmSelectedEvents, enmType) == false;
1701	else
1702	cChanges += ASMAtomicBitTestAndClear(&pVM->dbgf.s.bmSelectedEvents, enmType) == true;
1703	}
1704
1705	/*
1706	* Inform HM about changes.
1707	*/
1708	if (cChanges > 0 && HMIsEnabled(pVM))
1709	{
1710	HMR3NotifyDebugEventChanged(pVM);
1711	HMR3NotifyDebugEventChangedPerCpu(pVM, pVCpu);
1712	}
1713	}
1714	else if (HMIsEnabled(pVM))
1715	HMR3NotifyDebugEventChangedPerCpu(pVM, pVCpu);
1716
1717	return VINF_SUCCESS;
1718	}
1719
1720
1721	/**
1722	* Configures (enables/disables) multiple selectable debug events.
1723	*
1724	* @returns VBox status code.
1725	* @param pUVM The user mode VM handle.
1726	* @param paConfigs The event to configure and their new state.
1727	* @param cConfigs Number of entries in @a paConfigs.
1728	*/
1729	VMMR3DECL(int) DBGFR3EventConfigEx(PUVM pUVM, PCDBGFEVENTCONFIG paConfigs, size_t cConfigs)
1730	{
1731	/*
1732	* Validate input.
1733	*/
1734	size_t i = cConfigs;
1735	while (i-- > 0)
1736	{
1737	AssertReturn(paConfigs[i].enmType >= DBGFEVENT_FIRST_SELECTABLE, VERR_INVALID_PARAMETER);
1738	AssertReturn(paConfigs[i].enmType < DBGFEVENT_END, VERR_INVALID_PARAMETER);
1739	}
1740	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1741	PVM pVM = pUVM->pVM;
1742	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1743
1744	/*
1745	* Apply the changes in EMT(0) and rendezvous with the other CPUs so they
1746	* can sync their data and execution with new debug state.
1747	*/
1748	DBGFR3EVENTCONFIGEXARGS Args = { paConfigs, cConfigs, VINF_SUCCESS };
1749	int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ASCENDING \| VMMEMTRENDEZVOUS_FLAGS_PRIORITY,
1750	dbgfR3EventConfigEx, &Args);
1751	if (RT_SUCCESS(rc))
1752	rc = Args.rc;
1753	return rc;
1754	}
1755
1756
1757	/**
1758	* Enables or disables a selectable debug event.
1759	*
1760	* @returns VBox status code.
1761	* @param pUVM The user mode VM handle.
1762	* @param enmEvent The selectable debug event.
1763	* @param fEnabled The new state.
1764	*/
1765	VMMR3DECL(int) DBGFR3EventConfig(PUVM pUVM, DBGFEVENTTYPE enmEvent, bool fEnabled)
1766	{
1767	/*
1768	* Convert to an array call.
1769	*/
1770	DBGFEVENTCONFIG EvtCfg = { enmEvent, fEnabled };
1771	return DBGFR3EventConfigEx(pUVM, &EvtCfg, 1);
1772	}
1773
1774
1775	/**
1776	* Checks if the given selectable event is enabled.
1777	*
1778	* @returns true if enabled, false if not or invalid input.
1779	* @param pUVM The user mode VM handle.
1780	* @param enmEvent The selectable debug event.
1781	* @sa DBGFR3EventQuery
1782	*/
1783	VMMR3DECL(bool) DBGFR3EventIsEnabled(PUVM pUVM, DBGFEVENTTYPE enmEvent)
1784	{
1785	/*
1786	* Validate input.
1787	*/
1788	AssertReturn( enmEvent >= DBGFEVENT_HALT_DONE
1789	&& enmEvent < DBGFEVENT_END, false);
1790	Assert( enmEvent >= DBGFEVENT_FIRST_SELECTABLE
1791	\|\| enmEvent == DBGFEVENT_BREAKPOINT
1792	\|\| enmEvent == DBGFEVENT_BREAKPOINT_IO
1793	\|\| enmEvent == DBGFEVENT_BREAKPOINT_MMIO);
1794
1795	UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
1796	PVM pVM = pUVM->pVM;
1797	VM_ASSERT_VALID_EXT_RETURN(pVM, false);
1798
1799	/*
1800	* Check the event status.
1801	*/
1802	return ASMBitTest(&pVM->dbgf.s.bmSelectedEvents, enmEvent);
1803	}
1804
1805
1806	/**
1807	* Queries the status of a set of events.
1808	*
1809	* @returns VBox status code.
1810	* @param pUVM The user mode VM handle.
1811	* @param paConfigs The events to query and where to return the state.
1812	* @param cConfigs The number of elements in @a paConfigs.
1813	* @sa DBGFR3EventIsEnabled, DBGF_IS_EVENT_ENABLED
1814	*/
1815	VMMR3DECL(int) DBGFR3EventQuery(PUVM pUVM, PDBGFEVENTCONFIG paConfigs, size_t cConfigs)
1816	{
1817	/*
1818	* Validate input.
1819	*/
1820	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1821	PVM pVM = pUVM->pVM;
1822	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1823
1824	for (size_t i = 0; i < cConfigs; i++)
1825	{
1826	DBGFEVENTTYPE enmType = paConfigs[i].enmType;
1827	AssertReturn( enmType >= DBGFEVENT_HALT_DONE
1828	&& enmType < DBGFEVENT_END, VERR_INVALID_PARAMETER);
1829	Assert( enmType >= DBGFEVENT_FIRST_SELECTABLE
1830	\|\| enmType == DBGFEVENT_BREAKPOINT
1831	\|\| enmType == DBGFEVENT_BREAKPOINT_IO
1832	\|\| enmType == DBGFEVENT_BREAKPOINT_MMIO);
1833	paConfigs[i].fEnabled = ASMBitTest(&pVM->dbgf.s.bmSelectedEvents, paConfigs[i].enmType);
1834	}
1835
1836	return VINF_SUCCESS;
1837	}
1838
1839
1840	/**
1841	* dbgfR3InterruptConfigEx argument packet.
1842	*/
1843	typedef struct DBGFR3INTERRUPTCONFIGEXARGS
1844	{
1845	PCDBGFINTERRUPTCONFIG paConfigs;
1846	size_t cConfigs;
1847	int rc;
1848	} DBGFR3INTERRUPTCONFIGEXARGS;
1849	/** Pointer to a dbgfR3InterruptConfigEx argument packet. */
1850	typedef DBGFR3INTERRUPTCONFIGEXARGS *PDBGFR3INTERRUPTCONFIGEXARGS;
1851
1852	/**
1853	* @callback_method_impl{FNVMMEMTRENDEZVOUS,
1854	* Worker for DBGFR3InterruptConfigEx.}
1855	*/
1856	static DECLCALLBACK(VBOXSTRICTRC) dbgfR3InterruptConfigEx(PVM pVM, PVMCPU pVCpu, void *pvUser)
1857	{
1858	if (pVCpu->idCpu == 0)
1859	{
1860	PDBGFR3INTERRUPTCONFIGEXARGS pArgs = (PDBGFR3INTERRUPTCONFIGEXARGS)pvUser;
1861	PCDBGFINTERRUPTCONFIG paConfigs = pArgs->paConfigs;
1862	size_t cConfigs = pArgs->cConfigs;
1863
1864	/*
1865	* Apply the changes.
1866	*/
1867	bool fChanged = false;
1868	bool fThis;
1869	for (uint32_t i = 0; i < cConfigs; i++)
1870	{
1871	/*
1872	* Hardware interrupts.
1873	*/
1874	if (paConfigs[i].enmHardState == DBGFINTERRUPTSTATE_ENABLED)
1875	{
1876	fChanged \|= fThis = ASMAtomicBitTestAndSet(&pVM->dbgf.s.bmHardIntBreakpoints, paConfigs[i].iInterrupt) == false;
1877	if (fThis)
1878	{
1879	Assert(pVM->dbgf.s.cHardIntBreakpoints < 256);
1880	pVM->dbgf.s.cHardIntBreakpoints++;
1881	}
1882	}
1883	else if (paConfigs[i].enmHardState == DBGFINTERRUPTSTATE_DISABLED)
1884	{
1885	fChanged \|= fThis = ASMAtomicBitTestAndClear(&pVM->dbgf.s.bmHardIntBreakpoints, paConfigs[i].iInterrupt) == true;
1886	if (fThis)
1887	{
1888	Assert(pVM->dbgf.s.cHardIntBreakpoints > 0);
1889	pVM->dbgf.s.cHardIntBreakpoints--;
1890	}
1891	}
1892
1893	/*
1894	* Software interrupts.
1895	*/
1896	if (paConfigs[i].enmHardState == DBGFINTERRUPTSTATE_ENABLED)
1897	{
1898	fChanged \|= fThis = ASMAtomicBitTestAndSet(&pVM->dbgf.s.bmSoftIntBreakpoints, paConfigs[i].iInterrupt) == false;
1899	if (fThis)
1900	{
1901	Assert(pVM->dbgf.s.cSoftIntBreakpoints < 256);
1902	pVM->dbgf.s.cSoftIntBreakpoints++;
1903	}
1904	}
1905	else if (paConfigs[i].enmSoftState == DBGFINTERRUPTSTATE_DISABLED)
1906	{
1907	fChanged \|= fThis = ASMAtomicBitTestAndClear(&pVM->dbgf.s.bmSoftIntBreakpoints, paConfigs[i].iInterrupt) == true;
1908	if (fThis)
1909	{
1910	Assert(pVM->dbgf.s.cSoftIntBreakpoints > 0);
1911	pVM->dbgf.s.cSoftIntBreakpoints--;
1912	}
1913	}
1914	}
1915
1916	/*
1917	* Update the event bitmap entries.
1918	*/
1919	if (pVM->dbgf.s.cHardIntBreakpoints > 0)
1920	fChanged \|= ASMAtomicBitTestAndSet(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_INTERRUPT_HARDWARE) == false;
1921	else
1922	fChanged \|= ASMAtomicBitTestAndClear(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_INTERRUPT_HARDWARE) == true;
1923
1924	if (pVM->dbgf.s.cSoftIntBreakpoints > 0)
1925	fChanged \|= ASMAtomicBitTestAndSet(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_INTERRUPT_SOFTWARE) == false;
1926	else
1927	fChanged \|= ASMAtomicBitTestAndClear(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_INTERRUPT_SOFTWARE) == true;
1928
1929	/*
1930	* Inform HM about changes.
1931	*/
1932	if (fChanged && HMIsEnabled(pVM))
1933	{
1934	HMR3NotifyDebugEventChanged(pVM);
1935	HMR3NotifyDebugEventChangedPerCpu(pVM, pVCpu);
1936	}
1937	}
1938	else if (HMIsEnabled(pVM))
1939	HMR3NotifyDebugEventChangedPerCpu(pVM, pVCpu);
1940
1941	return VINF_SUCCESS;
1942	}
1943
1944
1945	/**
1946	* Changes
1947	*
1948	* @returns VBox status code.
1949	* @param pUVM The user mode VM handle.
1950	* @param paConfigs The events to query and where to return the state.
1951	* @param cConfigs The number of elements in @a paConfigs.
1952	* @sa DBGFR3InterruptConfigHardware, DBGFR3InterruptConfigSoftware
1953	*/
1954	VMMR3DECL(int) DBGFR3InterruptConfigEx(PUVM pUVM, PCDBGFINTERRUPTCONFIG paConfigs, size_t cConfigs)
1955	{
1956	/*
1957	* Validate input.
1958	*/
1959	size_t i = cConfigs;
1960	while (i-- > 0)
1961	{
1962	AssertReturn(paConfigs[i].enmHardState <= DBGFINTERRUPTSTATE_DONT_TOUCH, VERR_INVALID_PARAMETER);
1963	AssertReturn(paConfigs[i].enmSoftState <= DBGFINTERRUPTSTATE_DONT_TOUCH, VERR_INVALID_PARAMETER);
1964	}
1965
1966	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
1967	PVM pVM = pUVM->pVM;
1968	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1969
1970	/*
1971	* Apply the changes in EMT(0) and rendezvous with the other CPUs so they
1972	* can sync their data and execution with new debug state.
1973	*/
1974	DBGFR3INTERRUPTCONFIGEXARGS Args = { paConfigs, cConfigs, VINF_SUCCESS };
1975	int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ASCENDING \| VMMEMTRENDEZVOUS_FLAGS_PRIORITY,
1976	dbgfR3InterruptConfigEx, &Args);
1977	if (RT_SUCCESS(rc))
1978	rc = Args.rc;
1979	return rc;
1980	}
1981
1982
1983	/**
1984	* Configures interception of a hardware interrupt.
1985	*
1986	* @returns VBox status code.
1987	* @param pUVM The user mode VM handle.
1988	* @param iInterrupt The interrupt number.
1989	* @param fEnabled Whether interception is enabled or not.
1990	* @sa DBGFR3InterruptSoftwareConfig, DBGFR3InterruptConfigEx
1991	*/
1992	VMMR3DECL(int) DBGFR3InterruptHardwareConfig(PUVM pUVM, uint8_t iInterrupt, bool fEnabled)
1993	{
1994	/*
1995	* Convert to DBGFR3InterruptConfigEx call.
1996	*/
1997	DBGFINTERRUPTCONFIG IntCfg = { iInterrupt, (uint8_t)fEnabled, DBGFINTERRUPTSTATE_DONT_TOUCH };
1998	return DBGFR3InterruptConfigEx(pUVM, &IntCfg, 1);
1999	}
2000
2001
2002	/**
2003	* Configures interception of a software interrupt.
2004	*
2005	* @returns VBox status code.
2006	* @param pUVM The user mode VM handle.
2007	* @param iInterrupt The interrupt number.
2008	* @param fEnabled Whether interception is enabled or not.
2009	* @sa DBGFR3InterruptHardwareConfig, DBGFR3InterruptConfigEx
2010	*/
2011	VMMR3DECL(int) DBGFR3InterruptSoftwareConfig(PUVM pUVM, uint8_t iInterrupt, bool fEnabled)
2012	{
2013	/*
2014	* Convert to DBGFR3InterruptConfigEx call.
2015	*/
2016	DBGFINTERRUPTCONFIG IntCfg = { iInterrupt, DBGFINTERRUPTSTATE_DONT_TOUCH, (uint8_t)fEnabled };
2017	return DBGFR3InterruptConfigEx(pUVM, &IntCfg, 1);
2018	}
2019
2020
2021	/**
2022	* Checks whether interception is enabled for a hardware interrupt.
2023	*
2024	* @returns true if enabled, false if not or invalid input.
2025	* @param pUVM The user mode VM handle.
2026	* @param iInterrupt The interrupt number.
2027	* @sa DBGFR3InterruptSoftwareIsEnabled, DBGF_IS_HARDWARE_INT_ENABLED,
2028	* DBGF_IS_SOFTWARE_INT_ENABLED
2029	*/
2030	VMMR3DECL(int) DBGFR3InterruptHardwareIsEnabled(PUVM pUVM, uint8_t iInterrupt)
2031	{
2032	/*
2033	* Validate input.
2034	*/
2035	UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
2036	PVM pVM = pUVM->pVM;
2037	VM_ASSERT_VALID_EXT_RETURN(pVM, false);
2038
2039	/*
2040	* Check it.
2041	*/
2042	return ASMBitTest(&pVM->dbgf.s.bmHardIntBreakpoints, iInterrupt);
2043	}
2044
2045
2046	/**
2047	* Checks whether interception is enabled for a software interrupt.
2048	*
2049	* @returns true if enabled, false if not or invalid input.
2050	* @param pUVM The user mode VM handle.
2051	* @param iInterrupt The interrupt number.
2052	* @sa DBGFR3InterruptHardwareIsEnabled, DBGF_IS_SOFTWARE_INT_ENABLED,
2053	* DBGF_IS_HARDWARE_INT_ENABLED,
2054	*/
2055	VMMR3DECL(int) DBGFR3InterruptSoftwareIsEnabled(PUVM pUVM, uint8_t iInterrupt)
2056	{
2057	/*
2058	* Validate input.
2059	*/
2060	UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
2061	PVM pVM = pUVM->pVM;
2062	VM_ASSERT_VALID_EXT_RETURN(pVM, false);
2063
2064	/*
2065	* Check it.
2066	*/
2067	return ASMBitTest(&pVM->dbgf.s.bmSoftIntBreakpoints, iInterrupt);
2068	}
2069
2070
2071
2072	/**
2073	* Call this to single step programmatically.
2074	*
2075	* You must pass down the return code to the EM loop! That's
2076	* where the actual single stepping take place (at least in the
2077	* current implementation).
2078	*
2079	* @returns VINF_EM_DBG_STEP
2080	*
2081	* @param pVCpu The cross context virtual CPU structure.
2082	*
2083	* @thread VCpu EMT
2084	* @internal
2085	*/
2086	VMMR3_INT_DECL(int) DBGFR3PrgStep(PVMCPU pVCpu)
2087	{
2088	VMCPU_ASSERT_EMT(pVCpu);
2089
2090	pVCpu->dbgf.s.fSingleSteppingRaw = true;
2091	return VINF_EM_DBG_STEP;
2092	}
2093
2094
2095	/**
2096	* Inject an NMI into a running VM (only VCPU 0!)
2097	*
2098	* @returns VBox status code.
2099	* @param pUVM The user mode VM structure.
2100	* @param idCpu The ID of the CPU to inject the NMI on.
2101	*/
2102	VMMR3DECL(int) DBGFR3InjectNMI(PUVM pUVM, VMCPUID idCpu)
2103	{
2104	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
2105	PVM pVM = pUVM->pVM;
2106	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
2107	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
2108
2109	/** @todo Implement generic NMI injection. */
2110	/** @todo NEM: NMI injection */
2111	if (!HMIsEnabled(pVM))
2112	return VERR_NOT_SUP_IN_RAW_MODE;
2113
2114	VMCPU_FF_SET(&pVM->aCpus[idCpu], VMCPU_FF_INTERRUPT_NMI);
2115	return VINF_SUCCESS;
2116	}
2117

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

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

Download in other formats: