DBGFBp.cpp@ 62637

Last change on this file since 62637 was 62637, checked in by vboxsync, 8 years ago
VMMR3: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 39.7 KB

Line
1	/* $Id: DBGFBp.cpp 62637 2016-07-28 17:12:17Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Breakpoint Management.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 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	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGF
23	#include <VBox/vmm/dbgf.h>
24	#include <VBox/vmm/selm.h>
25	#ifdef VBOX_WITH_REM
26	# include <VBox/vmm/rem.h>
27	#else
28	# include <VBox/vmm/iem.h>
29	#endif
30	#include <VBox/vmm/mm.h>
31	#include <VBox/vmm/iom.h>
32	#include <VBox/vmm/hm.h>
33	#include "DBGFInternal.h"
34	#include <VBox/vmm/vm.h>
35	#include <VBox/vmm/uvm.h>
36
37	#include <VBox/err.h>
38	#include <VBox/log.h>
39	#include <iprt/assert.h>
40	#include <iprt/string.h>
41
42
43	/*********************************************************************************************************************************
44	* Internal Functions *
45	*********************************************************************************************************************************/
46	RT_C_DECLS_BEGIN
47	static int dbgfR3BpRegArm(PVM pVM, PDBGFBP pBp);
48	static int dbgfR3BpInt3Arm(PUVM pUVM, PDBGFBP pBp);
49	RT_C_DECLS_END
50
51
52
53	/**
54	* Initialize the breakpoint stuff.
55	*
56	* @returns VINF_SUCCESS
57	* @param pVM The cross context VM structure.
58	*/
59	int dbgfR3BpInit(PVM pVM)
60	{
61	/*
62	* Init structures.
63	*/
64	unsigned i;
65	for (i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); i++)
66	{
67	pVM->dbgf.s.aHwBreakpoints[i].iBp = i;
68	pVM->dbgf.s.aHwBreakpoints[i].enmType = DBGFBPTYPE_FREE;
69	pVM->dbgf.s.aHwBreakpoints[i].u.Reg.iReg = i;
70	}
71
72	for (i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); i++)
73	{
74	pVM->dbgf.s.aBreakpoints[i].iBp = i + RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints);
75	pVM->dbgf.s.aBreakpoints[i].enmType = DBGFBPTYPE_FREE;
76	}
77
78	for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
79	{
80	PVMCPU pVCpu = &pVM->aCpus[idCpu];
81	pVCpu->dbgf.s.iActiveBp = ~0U;
82	}
83
84	/*
85	* Register saved state.
86	*/
87	/** @todo */
88
89	return VINF_SUCCESS;
90	}
91
92
93
94	/**
95	* Allocate a breakpoint.
96	*
97	* @returns Pointer to the allocated breakpoint.
98	* @returns NULL if we're out of breakpoints.
99	* @param pVM The cross context VM structure.
100	* @param enmType The type to allocate.
101	*/
102	static PDBGFBP dbgfR3BpAlloc(PVM pVM, DBGFBPTYPE enmType)
103	{
104	/*
105	* Determine which array to search and where in the array to start
106	* searching (latter for grouping similar BPs, reducing runtime overhead).
107	*/
108	unsigned iStart;
109	unsigned cBps;
110	PDBGFBP paBps;
111	switch (enmType)
112	{
113	case DBGFBPTYPE_REG:
114	cBps = RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints);
115	paBps = &pVM->dbgf.s.aHwBreakpoints[0];
116	iStart = 0;
117	break;
118
119	case DBGFBPTYPE_INT3:
120	case DBGFBPTYPE_REM:
121	case DBGFBPTYPE_PORT_IO:
122	case DBGFBPTYPE_MMIO:
123	cBps = RT_ELEMENTS(pVM->dbgf.s.aBreakpoints);
124	paBps = &pVM->dbgf.s.aBreakpoints[0];
125	if (enmType == DBGFBPTYPE_PORT_IO)
126	iStart = cBps / 4 * 2;
127	else if (enmType == DBGFBPTYPE_MMIO)
128	iStart = cBps / 4 * 1;
129	else if (enmType == DBGFBPTYPE_REM)
130	iStart = cBps / 4 * 3;
131	else
132	iStart = 0;
133	break;
134
135	default:
136	AssertMsgFailed(("enmType=%d\n", enmType));
137	return NULL;
138	}
139
140	/*
141	* Search for a free breakpoint entry.
142	*/
143	unsigned iBp;
144	for (iBp = iStart; iBp < cBps; iBp++)
145	if (paBps[iBp].enmType == DBGFBPTYPE_FREE)
146	break;
147	if (iBp >= cBps && iStart != 0)
148	for (iBp = 0; iBp < cBps; iBp++)
149	if (paBps[iBp].enmType == DBGFBPTYPE_FREE)
150	break;
151	if (iBp < cBps)
152	{
153	/*
154	* Return what we found.
155	*/
156	paBps[iBp].fEnabled = false;
157	paBps[iBp].cHits = 0;
158	paBps[iBp].enmType = enmType;
159	return &paBps[iBp];
160	}
161
162	LogFlow(("dbgfR3BpAlloc: returns NULL - we're out of breakpoint slots! cBps=%u\n", cBps));
163	return NULL;
164	}
165
166
167	/**
168	* Updates IOM on whether we've got any armed I/O port or MMIO breakpoints.
169	*
170	* @returns VINF_SUCCESS
171	* @param pVM The cross context VM structure.
172	* @param enmType The breakpoint type.
173	* @param pOpt The breakpoint optimization structure to update.
174	*/
175	static int dbgfR3BpUpdateSearchOptimizations(PVM pVM, DBGFBPTYPE enmType, PDBGFBPSEARCHOPT pOpt)
176	{
177	DBGFBPSEARCHOPT Opt = { UINT32_MAX, 0 };
178
179	for (uint32_t iBp = 0; iBp < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); iBp++)
180	if ( pVM->dbgf.s.aBreakpoints[iBp].enmType == enmType
181	&& pVM->dbgf.s.aBreakpoints[iBp].fEnabled)
182	{
183	if (Opt.iStartSearch > iBp)
184	Opt.iStartSearch = iBp;
185	Opt.cToSearch = iBp - Opt.iStartSearch + 1;
186	}
187
188	*pOpt = Opt;
189	return VINF_SUCCESS;
190	}
191
192
193	/**
194	* Get a breakpoint give by breakpoint id.
195	*
196	* @returns Pointer to the allocated breakpoint.
197	* @returns NULL if the breakpoint is invalid.
198	* @param pVM The cross context VM structure.
199	* @param iBp The breakpoint id.
200	*/
201	static PDBGFBP dbgfR3BpGet(PVM pVM, uint32_t iBp)
202	{
203	/* Find it. */
204	PDBGFBP pBp;
205	if (iBp < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints))
206	pBp = &pVM->dbgf.s.aHwBreakpoints[iBp];
207	else
208	{
209	iBp -= RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints);
210	if (iBp >= RT_ELEMENTS(pVM->dbgf.s.aBreakpoints))
211	return NULL;
212	pBp = &pVM->dbgf.s.aBreakpoints[iBp];
213	}
214
215	/* check if it's valid. */
216	switch (pBp->enmType)
217	{
218	case DBGFBPTYPE_FREE:
219	return NULL;
220
221	case DBGFBPTYPE_REG:
222	case DBGFBPTYPE_INT3:
223	case DBGFBPTYPE_REM:
224	case DBGFBPTYPE_PORT_IO:
225	case DBGFBPTYPE_MMIO:
226	break;
227
228	default:
229	AssertMsgFailed(("Invalid enmType=%d!\n", pBp->enmType));
230	return NULL;
231	}
232
233	return pBp;
234	}
235
236
237	/**
238	* Get a breakpoint give by address.
239	*
240	* @returns Pointer to the allocated breakpoint.
241	* @returns NULL if the breakpoint is invalid.
242	* @param pVM The cross context VM structure.
243	* @param enmType The breakpoint type.
244	* @param GCPtr The breakpoint address.
245	*/
246	static PDBGFBP dbgfR3BpGetByAddr(PVM pVM, DBGFBPTYPE enmType, RTGCUINTPTR GCPtr)
247	{
248	/*
249	* Determine which array to search.
250	*/
251	unsigned cBps;
252	PDBGFBP paBps;
253	switch (enmType)
254	{
255	case DBGFBPTYPE_REG:
256	cBps = RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints);
257	paBps = &pVM->dbgf.s.aHwBreakpoints[0];
258	break;
259
260	case DBGFBPTYPE_INT3:
261	case DBGFBPTYPE_REM:
262	cBps = RT_ELEMENTS(pVM->dbgf.s.aBreakpoints);
263	paBps = &pVM->dbgf.s.aBreakpoints[0];
264	break;
265
266	default:
267	AssertMsgFailed(("enmType=%d\n", enmType));
268	return NULL;
269	}
270
271	/*
272	* Search.
273	*/
274	for (unsigned iBp = 0; iBp < cBps; iBp++)
275	if ( paBps[iBp].enmType == enmType
276	&& paBps[iBp].u.GCPtr == GCPtr)
277	return &paBps[iBp];
278
279	return NULL;
280	}
281
282
283	/**
284	* Frees a breakpoint.
285	*
286	* @param pVM The cross context VM structure.
287	* @param pBp The breakpoint to free.
288	*/
289	static void dbgfR3BpFree(PVM pVM, PDBGFBP pBp)
290	{
291	switch (pBp->enmType)
292	{
293	case DBGFBPTYPE_FREE:
294	AssertMsgFailed(("Already freed!\n"));
295	return;
296
297	case DBGFBPTYPE_REG:
298	Assert((uintptr_t)(pBp - &pVM->dbgf.s.aHwBreakpoints[0]) < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints));
299	break;
300
301	case DBGFBPTYPE_INT3:
302	case DBGFBPTYPE_REM:
303	case DBGFBPTYPE_PORT_IO:
304	case DBGFBPTYPE_MMIO:
305	Assert((uintptr_t)(pBp - &pVM->dbgf.s.aBreakpoints[0]) < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints));
306	break;
307
308	default:
309	AssertMsgFailed(("Invalid enmType=%d!\n", pBp->enmType));
310	return;
311
312	}
313	pBp->enmType = DBGFBPTYPE_FREE;
314	NOREF(pVM);
315	}
316
317
318	/**
319	* Sets a breakpoint (int 3 based).
320	*
321	* @returns VBox status code.
322	* @param pUVM The user mode VM handle.
323	* @param pAddress The address of the breakpoint.
324	* @param piHitTrigger The hit count at which the breakpoint start triggering.
325	* Use 0 (or 1) if it's gonna trigger at once.
326	* @param piHitDisable The hit count which disables the breakpoint.
327	* Use ~(uint64_t) if it's never gonna be disabled.
328	* @param piBp Where to store the breakpoint id. (optional)
329	* @thread Any thread.
330	*/
331	static DECLCALLBACK(int) dbgfR3BpSetInt3(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t *piHitTrigger,
332	uint64_t piHitDisable, uint32_t piBp)
333	{
334	/*
335	* Validate input.
336	*/
337	PVM pVM = pUVM->pVM;
338	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
339	if (!DBGFR3AddrIsValid(pUVM, pAddress))
340	return VERR_INVALID_PARAMETER;
341	if (piHitTrigger > piHitDisable)
342	return VERR_INVALID_PARAMETER;
343	AssertMsgReturn(!piBp \|\| VALID_PTR(piBp), ("piBp=%p\n", piBp), VERR_INVALID_POINTER);
344	if (piBp)
345	*piBp = UINT32_MAX;
346
347	/*
348	* Check if the breakpoint already exists.
349	*/
350	PDBGFBP pBp = dbgfR3BpGetByAddr(pVM, DBGFBPTYPE_INT3, pAddress->FlatPtr);
351	if (pBp)
352	{
353	int rc = VINF_SUCCESS;
354	if (!pBp->fEnabled)
355	rc = dbgfR3BpInt3Arm(pUVM, pBp);
356	if (RT_SUCCESS(rc))
357	{
358	rc = VINF_DBGF_BP_ALREADY_EXIST;
359	if (piBp)
360	*piBp = pBp->iBp;
361	}
362	return rc;
363	}
364
365	/*
366	* Allocate and initialize the bp.
367	*/
368	pBp = dbgfR3BpAlloc(pVM, DBGFBPTYPE_INT3);
369	if (!pBp)
370	return VERR_DBGF_NO_MORE_BP_SLOTS;
371	pBp->u.Int3.GCPtr = pAddress->FlatPtr;
372	pBp->iHitTrigger = *piHitTrigger;
373	pBp->iHitDisable = *piHitDisable;
374	ASMCompilerBarrier();
375	pBp->fEnabled = true;
376	dbgfR3BpUpdateSearchOptimizations(pVM, DBGFBPTYPE_INT3, &pVM->dbgf.s.Int3);
377
378	/*
379	* Now ask REM to set the breakpoint.
380	*/
381	int rc = dbgfR3BpInt3Arm(pUVM, pBp);
382	if (RT_SUCCESS(rc))
383	{
384	if (piBp)
385	*piBp = pBp->iBp;
386	}
387	else
388	dbgfR3BpFree(pVM, pBp);
389
390	return rc;
391	}
392
393
394	/**
395	* Sets a breakpoint (int 3 based).
396	*
397	* @returns VBox status code.
398	* @param pUVM The user mode VM handle.
399	* @param pAddress The address of the breakpoint.
400	* @param iHitTrigger The hit count at which the breakpoint start triggering.
401	* Use 0 (or 1) if it's gonna trigger at once.
402	* @param iHitDisable The hit count which disables the breakpoint.
403	* Use ~(uint64_t) if it's never gonna be disabled.
404	* @param piBp Where to store the breakpoint id. (optional)
405	* @thread Any thread.
406	*/
407	VMMR3DECL(int) DBGFR3BpSet(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable, uint32_t *piBp)
408	{
409	/*
410	* This must be done on EMT.
411	*/
412	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpSetInt3, 5,
413	pUVM, pAddress, &iHitTrigger, &iHitDisable, piBp);
414	LogFlow(("DBGFR3BpSet: returns %Rrc\n", rc));
415	return rc;
416	}
417
418
419	/**
420	* Arms an int 3 breakpoint.
421	* This is used to implement both DBGFR3BpSetReg() and DBGFR3BpEnable().
422	*
423	* @returns VBox status code.
424	* @param pUVM The user mode VM handle.
425	* @param pBp The breakpoint.
426	*/
427	static int dbgfR3BpInt3Arm(PUVM pUVM, PDBGFBP pBp)
428	{
429	/** @todo should actually use physical address here! */
430
431	/** @todo SMP support! */
432	VMCPUID idCpu = 0;
433
434	/*
435	* Save current byte and write int3 instruction.
436	*/
437	DBGFADDRESS Addr;
438	DBGFR3AddrFromFlat(pUVM, &Addr, pBp->u.Int3.GCPtr);
439	int rc = DBGFR3MemRead(pUVM, idCpu, &Addr, &pBp->u.Int3.bOrg, 1);
440	if (RT_SUCCESS(rc))
441	{
442	static const uint8_t s_bInt3 = 0xcc;
443	rc = DBGFR3MemWrite(pUVM, idCpu, &Addr, &s_bInt3, 1);
444	}
445	return rc;
446	}
447
448
449	/**
450	* Disarms an int 3 breakpoint.
451	* This is used to implement both DBGFR3BpClear() and DBGFR3BpDisable().
452	*
453	* @returns VBox status code.
454	* @param pUVM The user mode VM handle.
455	* @param pBp The breakpoint.
456	*/
457	static int dbgfR3BpInt3Disarm(PUVM pUVM, PDBGFBP pBp)
458	{
459	/* @todo SMP support! */
460	VMCPUID idCpu = 0;
461
462	/*
463	* Check that the current byte is the int3 instruction, and restore the original one.
464	* We currently ignore invalid bytes.
465	*/
466	DBGFADDRESS Addr;
467	DBGFR3AddrFromFlat(pUVM, &Addr, pBp->u.Int3.GCPtr);
468	uint8_t bCurrent;
469	int rc = DBGFR3MemRead(pUVM, idCpu, &Addr, &bCurrent, 1);
470	if (bCurrent == 0xcc)
471	rc = DBGFR3MemWrite(pUVM, idCpu, &Addr, &pBp->u.Int3.bOrg, 1);
472	return rc;
473	}
474
475
476	/**
477	* Sets a register breakpoint.
478	*
479	* @returns VBox status code.
480	* @param pUVM The user mode VM handle.
481	* @param pAddress The address of the breakpoint.
482	* @param piHitTrigger The hit count at which the breakpoint start triggering.
483	* Use 0 (or 1) if it's gonna trigger at once.
484	* @param piHitDisable The hit count which disables the breakpoint.
485	* Use ~(uint64_t) if it's never gonna be disabled.
486	* @param fType The access type (one of the X86_DR7_RW_* defines).
487	* @param cb The access size - 1,2,4 or 8 (the latter is AMD64 long mode only.
488	* Must be 1 if fType is X86_DR7_RW_EO.
489	* @param piBp Where to store the breakpoint id. (optional)
490	* @thread EMT
491	* @internal
492	*/
493	static DECLCALLBACK(int) dbgfR3BpSetReg(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t piHitTrigger, uint64_t piHitDisable,
494	uint8_t fType, uint8_t cb, uint32_t *piBp)
495	{
496	/*
497	* Validate input.
498	*/
499	PVM pVM = pUVM->pVM;
500	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
501	if (!DBGFR3AddrIsValid(pUVM, pAddress))
502	return VERR_INVALID_PARAMETER;
503	if (piHitTrigger > piHitDisable)
504	return VERR_INVALID_PARAMETER;
505	AssertMsgReturn(!piBp \|\| VALID_PTR(piBp), ("piBp=%p\n", piBp), VERR_INVALID_POINTER);
506	if (piBp)
507	*piBp = UINT32_MAX;
508	switch (fType)
509	{
510	case X86_DR7_RW_EO:
511	if (cb == 1)
512	break;
513	AssertMsgFailed(("fType=%#x cb=%d != 1\n", fType, cb));
514	return VERR_INVALID_PARAMETER;
515	case X86_DR7_RW_IO:
516	case X86_DR7_RW_RW:
517	case X86_DR7_RW_WO:
518	break;
519	default:
520	AssertMsgFailed(("fType=%#x\n", fType));
521	return VERR_INVALID_PARAMETER;
522	}
523	switch (cb)
524	{
525	case 1:
526	case 2:
527	case 4:
528	break;
529	default:
530	AssertMsgFailed(("cb=%#x\n", cb));
531	return VERR_INVALID_PARAMETER;
532	}
533
534	/*
535	* Check if the breakpoint already exists.
536	*/
537	PDBGFBP pBp = dbgfR3BpGetByAddr(pVM, DBGFBPTYPE_REG, pAddress->FlatPtr);
538	if ( pBp
539	&& pBp->u.Reg.cb == cb
540	&& pBp->u.Reg.fType == fType)
541	{
542	int rc = VINF_SUCCESS;
543	if (!pBp->fEnabled)
544	rc = dbgfR3BpRegArm(pVM, pBp);
545	if (RT_SUCCESS(rc))
546	{
547	rc = VINF_DBGF_BP_ALREADY_EXIST;
548	if (piBp)
549	*piBp = pBp->iBp;
550	}
551	return rc;
552	}
553
554	/*
555	* Allocate and initialize the bp.
556	*/
557	pBp = dbgfR3BpAlloc(pVM, DBGFBPTYPE_REG);
558	if (!pBp)
559	return VERR_DBGF_NO_MORE_BP_SLOTS;
560	pBp->iHitTrigger = *piHitTrigger;
561	pBp->iHitDisable = *piHitDisable;
562	Assert(pBp->iBp == pBp->u.Reg.iReg);
563	pBp->u.Reg.GCPtr = pAddress->FlatPtr;
564	pBp->u.Reg.fType = fType;
565	pBp->u.Reg.cb = cb;
566	ASMCompilerBarrier();
567	pBp->fEnabled = true;
568
569	/*
570	* Arm the breakpoint.
571	*/
572	int rc = dbgfR3BpRegArm(pVM, pBp);
573	if (RT_SUCCESS(rc))
574	{
575	if (piBp)
576	*piBp = pBp->iBp;
577	}
578	else
579	dbgfR3BpFree(pVM, pBp);
580
581	return rc;
582	}
583
584
585	/**
586	* Sets a register breakpoint.
587	*
588	* @returns VBox status code.
589	* @param pUVM The user mode VM handle.
590	* @param pAddress The address of the breakpoint.
591	* @param iHitTrigger The hit count at which the breakpoint start triggering.
592	* Use 0 (or 1) if it's gonna trigger at once.
593	* @param iHitDisable The hit count which disables the breakpoint.
594	* Use ~(uint64_t) if it's never gonna be disabled.
595	* @param fType The access type (one of the X86_DR7_RW_* defines).
596	* @param cb The access size - 1,2,4 or 8 (the latter is AMD64 long mode only.
597	* Must be 1 if fType is X86_DR7_RW_EO.
598	* @param piBp Where to store the breakpoint id. (optional)
599	* @thread Any thread.
600	*/
601	VMMR3DECL(int) DBGFR3BpSetReg(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable,
602	uint8_t fType, uint8_t cb, uint32_t *piBp)
603	{
604	/*
605	* This must be done on EMT.
606	*/
607	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpSetReg, 7,
608	pUVM, pAddress, &iHitTrigger, &iHitDisable, fType, cb, piBp);
609	LogFlow(("DBGFR3BpSetReg: returns %Rrc\n", rc));
610	return rc;
611
612	}
613
614
615	/**
616	* @callback_method_impl{FNVMMEMTRENDEZVOUS}
617	*/
618	static DECLCALLBACK(VBOXSTRICTRC) dbgfR3BpRegRecalcOnCpu(PVM pVM, PVMCPU pVCpu, void *pvUser)
619	{
620	NOREF(pVM); NOREF(pvUser);
621
622	/*
623	* CPU 0 updates the enabled hardware breakpoint counts.
624	*/
625	if (pVCpu->idCpu == 0)
626	{
627	pVM->dbgf.s.cEnabledHwBreakpoints = 0;
628	pVM->dbgf.s.cEnabledHwIoBreakpoints = 0;
629
630	for (uint32_t iBp = 0; iBp < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); iBp++)
631	if ( pVM->dbgf.s.aHwBreakpoints[iBp].fEnabled
632	&& pVM->dbgf.s.aHwBreakpoints[iBp].enmType == DBGFBPTYPE_REG)
633	{
634	pVM->dbgf.s.cEnabledHwBreakpoints += 1;
635	pVM->dbgf.s.cEnabledHwIoBreakpoints += pVM->dbgf.s.aHwBreakpoints[iBp].u.Reg.fType == X86_DR7_RW_IO;
636	}
637	}
638
639	return CPUMRecalcHyperDRx(pVCpu, UINT8_MAX, false);
640	}
641
642
643	/**
644	* Arms a debug register breakpoint.
645	*
646	* This is used to implement both DBGFR3BpSetReg() and DBGFR3BpEnable().
647	*
648	* @returns VBox status code.
649	* @param pVM The cross context VM structure.
650	* @param pBp The breakpoint.
651	* @thread EMT(0)
652	*/
653	static int dbgfR3BpRegArm(PVM pVM, PDBGFBP pBp)
654	{
655	RT_NOREF_PV(pBp);
656	Assert(pBp->fEnabled);
657	return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, dbgfR3BpRegRecalcOnCpu, NULL);
658	}
659
660
661	/**
662	* Disarms a debug register breakpoint.
663	*
664	* This is used to implement both DBGFR3BpClear() and DBGFR3BpDisable().
665	*
666	* @returns VBox status code.
667	* @param pVM The cross context VM structure.
668	* @param pBp The breakpoint.
669	* @thread EMT(0)
670	*/
671	static int dbgfR3BpRegDisarm(PVM pVM, PDBGFBP pBp)
672	{
673	RT_NOREF_PV(pBp);
674	Assert(!pBp->fEnabled);
675	return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, dbgfR3BpRegRecalcOnCpu, NULL);
676	}
677
678
679	/**
680	* EMT worker for DBGFR3BpSetREM().
681	*
682	* @returns VBox status code.
683	* @param pUVM The user mode VM handle.
684	* @param pAddress The address of the breakpoint.
685	* @param piHitTrigger The hit count at which the breakpoint start triggering.
686	* Use 0 (or 1) if it's gonna trigger at once.
687	* @param piHitDisable The hit count which disables the breakpoint.
688	* Use ~(uint64_t) if it's never gonna be disabled.
689	* @param piBp Where to store the breakpoint id. (optional)
690	* @thread EMT(0)
691	* @internal
692	*/
693	static DECLCALLBACK(int) dbgfR3BpSetREM(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t *piHitTrigger,
694	uint64_t piHitDisable, uint32_t piBp)
695	{
696	/*
697	* Validate input.
698	*/
699	PVM pVM = pUVM->pVM;
700	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
701	if (!DBGFR3AddrIsValid(pUVM, pAddress))
702	return VERR_INVALID_PARAMETER;
703	if (piHitTrigger > piHitDisable)
704	return VERR_INVALID_PARAMETER;
705	AssertMsgReturn(!piBp \|\| VALID_PTR(piBp), ("piBp=%p\n", piBp), VERR_INVALID_POINTER);
706	if (piBp)
707	*piBp = UINT32_MAX;
708
709	/*
710	* Check if the breakpoint already exists.
711	*/
712	PDBGFBP pBp = dbgfR3BpGetByAddr(pVM, DBGFBPTYPE_REM, pAddress->FlatPtr);
713	if (pBp)
714	{
715	int rc = VINF_SUCCESS;
716	if (!pBp->fEnabled)
717	#ifdef VBOX_WITH_REM
718	rc = REMR3BreakpointSet(pVM, pBp->u.Rem.GCPtr);
719	#else
720	rc = IEMBreakpointSet(pVM, pBp->u.Rem.GCPtr);
721	#endif
722	if (RT_SUCCESS(rc))
723	{
724	rc = VINF_DBGF_BP_ALREADY_EXIST;
725	if (piBp)
726	*piBp = pBp->iBp;
727	}
728	return rc;
729	}
730
731	/*
732	* Allocate and initialize the bp.
733	*/
734	pBp = dbgfR3BpAlloc(pVM, DBGFBPTYPE_REM);
735	if (!pBp)
736	return VERR_DBGF_NO_MORE_BP_SLOTS;
737	pBp->u.Rem.GCPtr = pAddress->FlatPtr;
738	pBp->iHitTrigger = *piHitTrigger;
739	pBp->iHitDisable = *piHitDisable;
740	ASMCompilerBarrier();
741	pBp->fEnabled = true;
742
743	/*
744	* Now ask REM to set the breakpoint.
745	*/
746	#ifdef VBOX_WITH_REM
747	int rc = REMR3BreakpointSet(pVM, pAddress->FlatPtr);
748	#else
749	int rc = IEMBreakpointSet(pVM, pAddress->FlatPtr);
750	#endif
751	if (RT_SUCCESS(rc))
752	{
753	if (piBp)
754	*piBp = pBp->iBp;
755	}
756	else
757	dbgfR3BpFree(pVM, pBp);
758
759	return rc;
760	}
761
762
763	/**
764	* Sets a recompiler breakpoint.
765	*
766	* @returns VBox status code.
767	* @param pUVM The user mode VM handle.
768	* @param pAddress The address of the breakpoint.
769	* @param iHitTrigger The hit count at which the breakpoint start triggering.
770	* Use 0 (or 1) if it's gonna trigger at once.
771	* @param iHitDisable The hit count which disables the breakpoint.
772	* Use ~(uint64_t) if it's never gonna be disabled.
773	* @param piBp Where to store the breakpoint id. (optional)
774	* @thread Any thread.
775	*/
776	VMMR3DECL(int) DBGFR3BpSetREM(PUVM pUVM, PCDBGFADDRESS pAddress, uint64_t iHitTrigger, uint64_t iHitDisable, uint32_t *piBp)
777	{
778	/*
779	* This must be done on EMT.
780	*/
781	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpSetREM, 5,
782	pUVM, pAddress, &iHitTrigger, &iHitDisable, piBp);
783	LogFlow(("DBGFR3BpSetREM: returns %Rrc\n", rc));
784	return rc;
785	}
786
787
788	/**
789	* Updates IOM on whether we've got any armed I/O port or MMIO breakpoints.
790	*
791	* @returns VINF_SUCCESS
792	* @param pVM The cross context VM structure.
793	* @thread EMT(0)
794	*/
795	static int dbgfR3BpUpdateIom(PVM pVM)
796	{
797	dbgfR3BpUpdateSearchOptimizations(pVM, DBGFBPTYPE_PORT_IO, &pVM->dbgf.s.PortIo);
798	if (pVM->dbgf.s.PortIo.cToSearch)
799	ASMAtomicBitSet(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_BREAKPOINT_IO);
800	else
801	ASMAtomicBitClear(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_BREAKPOINT_IO);
802
803	dbgfR3BpUpdateSearchOptimizations(pVM, DBGFBPTYPE_MMIO, &pVM->dbgf.s.Mmio);
804	if (pVM->dbgf.s.Mmio.cToSearch)
805	ASMAtomicBitSet(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_BREAKPOINT_MMIO);
806	else
807	ASMAtomicBitClear(&pVM->dbgf.s.bmSelectedEvents, DBGFEVENT_BREAKPOINT_MMIO);
808
809	IOMR3NotifyBreakpointCountChange(pVM, pVM->dbgf.s.PortIo.cToSearch != 0, pVM->dbgf.s.Mmio.cToSearch != 0);
810	return VINF_SUCCESS;
811	}
812
813
814	/**
815	* EMT worker for DBGFR3BpSetPortIo.
816	*
817	* @returns VBox status code.
818	* @param pUVM The user mode VM handle.
819	* @param uPort The first I/O port.
820	* @param cPorts The number of I/O ports.
821	* @param fAccess The access we want to break on.
822	* @param piHitTrigger The hit count at which the breakpoint start triggering.
823	* Use 0 (or 1) if it's gonna trigger at once.
824	* @param piHitDisable The hit count which disables the breakpoint.
825	* Use ~(uint64_t) if it's never gonna be disabled.
826	* @param piBp Where to store the breakpoint ID.
827	* @thread EMT(0)
828	*/
829	static DECLCALLBACK(int) dbgfR3BpSetPortIo(PUVM pUVM, RTIOPORT uPort, RTIOPORT cPorts, uint32_t fAccess,
830	uint64_t const piHitTrigger, uint64_t const piHitDisable, uint32_t *piBp)
831	{
832	/*
833	* Validate input.
834	*/
835	PVM pVM = pUVM->pVM;
836	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
837	*piBp = UINT32_MAX;
838
839	/*
840	* Check if the breakpoint already exists.
841	*/
842	for (uint32_t i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); i++)
843	if ( pVM->dbgf.s.aBreakpoints[i].enmType == DBGFBPTYPE_PORT_IO
844	&& pVM->dbgf.s.aBreakpoints[i].u.PortIo.uPort == uPort
845	&& pVM->dbgf.s.aBreakpoints[i].u.PortIo.cPorts == cPorts
846	&& pVM->dbgf.s.aBreakpoints[i].u.PortIo.fAccess == fAccess)
847	{
848	if (!pVM->dbgf.s.aBreakpoints[i].fEnabled)
849	{
850	pVM->dbgf.s.aBreakpoints[i].fEnabled = true;
851	dbgfR3BpUpdateIom(pVM);
852	}
853	*piBp = pVM->dbgf.s.aBreakpoints[i].iBp;
854	return VINF_DBGF_BP_ALREADY_EXIST;
855	}
856
857	/*
858	* Allocate and initialize the breakpoint.
859	*/
860	PDBGFBP pBp = dbgfR3BpAlloc(pVM, DBGFBPTYPE_PORT_IO);
861	if (!pBp)
862	return VERR_DBGF_NO_MORE_BP_SLOTS;
863	pBp->iHitTrigger = *piHitTrigger;
864	pBp->iHitDisable = *piHitDisable;
865	pBp->u.PortIo.uPort = uPort;
866	pBp->u.PortIo.cPorts = cPorts;
867	pBp->u.PortIo.fAccess = fAccess;
868	ASMCompilerBarrier();
869	pBp->fEnabled = true;
870
871	/*
872	* Tell IOM.
873	*/
874	dbgfR3BpUpdateIom(pVM);
875	*piBp = pBp->iBp;
876	return VINF_SUCCESS;
877	}
878
879
880	/**
881	* Sets an I/O port breakpoint.
882	*
883	* @returns VBox status code.
884	* @param pUVM The user mode VM handle.
885	* @param uPort The first I/O port.
886	* @param cPorts The number of I/O ports, see DBGFBPIOACCESS_XXX.
887	* @param fAccess The access we want to break on.
888	* @param iHitTrigger The hit count at which the breakpoint start
889	* triggering. Use 0 (or 1) if it's gonna trigger at
890	* once.
891	* @param iHitDisable The hit count which disables the breakpoint.
892	* Use ~(uint64_t) if it's never gonna be disabled.
893	* @param piBp Where to store the breakpoint ID. Optional.
894	* @thread Any thread.
895	*/
896	VMMR3DECL(int) DBGFR3BpSetPortIo(PUVM pUVM, RTIOPORT uPort, RTIOPORT cPorts, uint32_t fAccess,
897	uint64_t iHitTrigger, uint64_t iHitDisable, uint32_t *piBp)
898	{
899	AssertReturn(!(fAccess & ~DBGFBPIOACCESS_VALID_MASK_PORT_IO), VERR_INVALID_FLAGS);
900	AssertReturn(fAccess, VERR_INVALID_FLAGS);
901	if (iHitTrigger > iHitDisable)
902	return VERR_INVALID_PARAMETER;
903	AssertPtrNullReturn(piBp, VERR_INVALID_POINTER);
904	AssertReturn(cPorts > 0, VERR_OUT_OF_RANGE);
905	AssertReturn((RTIOPORT)(uPort + cPorts) < uPort, VERR_OUT_OF_RANGE);
906
907	/*
908	* This must be done on EMT.
909	*/
910	uint32_t iBp = UINT32_MAX;
911	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpSetPortIo, 7,
912	pUVM, uPort, cPorts, fAccess, &iHitTrigger, &iHitDisable, piBp);
913	if (piBp)
914	*piBp = iBp;
915	LogFlow(("DBGFR3BpSetPortIo: returns %Rrc iBp=%d\n", rc, iBp));
916	return rc;
917	}
918
919
920	/**
921	* EMT worker for DBGFR3BpSetMmio.
922	*
923	* @returns VBox status code.
924	* @param pUVM The user mode VM handle.
925	* @param pGCPhys The start of the MMIO range to break on.
926	* @param cb The the size of the MMIO range.
927	* @param fAccess The access we want to break on.
928	* @param piHitTrigger The hit count at which the breakpoint start triggering.
929	* Use 0 (or 1) if it's gonna trigger at once.
930	* @param piHitDisable The hit count which disables the breakpoint.
931	* Use ~(uint64_t) if it's never gonna be disabled.
932	* @param piBp Where to store the breakpoint ID.
933	* @thread EMT(0)
934	*/
935	static DECLCALLBACK(int) dbgfR3BpSetMmio(PUVM pUVM, PCRTGCPHYS pGCPhys, uint32_t cb, uint32_t fAccess,
936	uint64_t const piHitTrigger, uint64_t const piHitDisable, uint32_t *piBp)
937	{
938	RTGCPHYS const GCPhys = *pGCPhys;
939
940	/*
941	* Validate input.
942	*/
943	PVM pVM = pUVM->pVM;
944	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
945	*piBp = UINT32_MAX;
946
947	/*
948	* Check if the breakpoint already exists.
949	*/
950	for (uint32_t i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); i++)
951	if ( pVM->dbgf.s.aBreakpoints[i].enmType == DBGFBPTYPE_MMIO
952	&& pVM->dbgf.s.aBreakpoints[i].u.Mmio.PhysAddr == GCPhys
953	&& pVM->dbgf.s.aBreakpoints[i].u.Mmio.cb == cb
954	&& pVM->dbgf.s.aBreakpoints[i].u.Mmio.fAccess == fAccess)
955	{
956	if (!pVM->dbgf.s.aBreakpoints[i].fEnabled)
957	{
958	pVM->dbgf.s.aBreakpoints[i].fEnabled = true;
959	dbgfR3BpUpdateIom(pVM);
960	}
961	*piBp = pVM->dbgf.s.aBreakpoints[i].iBp;
962	return VINF_DBGF_BP_ALREADY_EXIST;
963	}
964
965	/*
966	* Allocate and initialize the breakpoint.
967	*/
968	PDBGFBP pBp = dbgfR3BpAlloc(pVM, DBGFBPTYPE_PORT_IO);
969	if (!pBp)
970	return VERR_DBGF_NO_MORE_BP_SLOTS;
971	pBp->iHitTrigger = *piHitTrigger;
972	pBp->iHitDisable = *piHitDisable;
973	pBp->u.Mmio.PhysAddr = GCPhys;
974	pBp->u.Mmio.cb = cb;
975	pBp->u.Mmio.fAccess = fAccess;
976	ASMCompilerBarrier();
977	pBp->fEnabled = true;
978
979	/*
980	* Tell IOM.
981	*/
982	dbgfR3BpUpdateIom(pVM);
983	*piBp = pBp->iBp;
984	return VINF_SUCCESS;
985	}
986
987
988	/**
989	* Sets a memory mapped I/O breakpoint.
990	*
991	* @returns VBox status code.
992	* @param pUVM The user mode VM handle.
993	* @param GCPhys The first MMIO address.
994	* @param cb The size of the MMIO range to break on.
995	* @param fAccess The access we want to break on.
996	* @param iHitTrigger The hit count at which the breakpoint start
997	* triggering. Use 0 (or 1) if it's gonna trigger at
998	* once.
999	* @param iHitDisable The hit count which disables the breakpoint.
1000	* Use ~(uint64_t) if it's never gonna be disabled.
1001	* @param piBp Where to store the breakpoint ID. Optional.
1002	* @thread Any thread.
1003	*/
1004	VMMR3DECL(int) DBGFR3BpSetMmio(PUVM pUVM, RTGCPHYS GCPhys, uint32_t cb, uint32_t fAccess,
1005	uint64_t iHitTrigger, uint64_t iHitDisable, uint32_t *piBp)
1006	{
1007	AssertReturn(!(fAccess & ~DBGFBPIOACCESS_VALID_MASK_MMIO), VERR_INVALID_FLAGS);
1008	AssertReturn(fAccess, VERR_INVALID_FLAGS);
1009	if (iHitTrigger > iHitDisable)
1010	return VERR_INVALID_PARAMETER;
1011	AssertPtrNullReturn(piBp, VERR_INVALID_POINTER);
1012	AssertReturn(cb, VERR_OUT_OF_RANGE);
1013	AssertReturn(GCPhys + cb < GCPhys, VERR_OUT_OF_RANGE);
1014
1015	/*
1016	* This must be done on EMT.
1017	*/
1018	uint32_t iBp = UINT32_MAX;
1019	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpSetMmio, 7,
1020	pUVM, &GCPhys, cb, fAccess, &iHitTrigger, &iHitDisable, piBp);
1021	if (piBp)
1022	*piBp = iBp;
1023	LogFlow(("DBGFR3BpSetMmio: returns %Rrc iBp=%d\n", rc, iBp));
1024	return rc;
1025	}
1026
1027
1028	/**
1029	* EMT worker for DBGFR3BpClear().
1030	*
1031	* @returns VBox status code.
1032	* @param pUVM The user mode VM handle.
1033	* @param iBp The id of the breakpoint which should be removed (cleared).
1034	* @thread EMT(0)
1035	* @internal
1036	*/
1037	static DECLCALLBACK(int) dbgfR3BpClear(PUVM pUVM, uint32_t iBp)
1038	{
1039	/*
1040	* Validate input.
1041	*/
1042	PVM pVM = pUVM->pVM;
1043	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1044	PDBGFBP pBp = dbgfR3BpGet(pVM, iBp);
1045	if (!pBp)
1046	return VERR_DBGF_BP_NOT_FOUND;
1047
1048	/*
1049	* Disarm the breakpoint if it's enabled.
1050	*/
1051	if (pBp->fEnabled)
1052	{
1053	pBp->fEnabled = false;
1054	int rc;
1055	switch (pBp->enmType)
1056	{
1057	case DBGFBPTYPE_REG:
1058	rc = dbgfR3BpRegDisarm(pVM, pBp);
1059	break;
1060
1061	case DBGFBPTYPE_INT3:
1062	rc = dbgfR3BpInt3Disarm(pUVM, pBp);
1063	dbgfR3BpUpdateSearchOptimizations(pVM, DBGFBPTYPE_INT3, &pVM->dbgf.s.Int3);
1064	break;
1065
1066	case DBGFBPTYPE_REM:
1067	#ifdef VBOX_WITH_REM
1068	rc = REMR3BreakpointClear(pVM, pBp->u.Rem.GCPtr);
1069	#else
1070	rc = IEMBreakpointClear(pVM, pBp->u.Rem.GCPtr);
1071	#endif
1072	break;
1073
1074	case DBGFBPTYPE_PORT_IO:
1075	case DBGFBPTYPE_MMIO:
1076	rc = dbgfR3BpUpdateIom(pVM);
1077	break;
1078
1079	default:
1080	AssertMsgFailedReturn(("Invalid enmType=%d!\n", pBp->enmType), VERR_IPE_NOT_REACHED_DEFAULT_CASE);
1081	}
1082	AssertRCReturn(rc, rc);
1083	}
1084
1085	/*
1086	* Free the breakpoint.
1087	*/
1088	dbgfR3BpFree(pVM, pBp);
1089	return VINF_SUCCESS;
1090	}
1091
1092
1093	/**
1094	* Clears a breakpoint.
1095	*
1096	* @returns VBox status code.
1097	* @param pUVM The user mode VM handle.
1098	* @param iBp The id of the breakpoint which should be removed (cleared).
1099	* @thread Any thread.
1100	*/
1101	VMMR3DECL(int) DBGFR3BpClear(PUVM pUVM, uint32_t iBp)
1102	{
1103	/*
1104	* This must be done on EMT.
1105	*/
1106	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpClear, 2, pUVM, iBp);
1107	LogFlow(("DBGFR3BpClear: returns %Rrc\n", rc));
1108	return rc;
1109	}
1110
1111
1112	/**
1113	* EMT worker for DBGFR3BpEnable().
1114	*
1115	* @returns VBox status code.
1116	* @param pUVM The user mode VM handle.
1117	* @param iBp The id of the breakpoint which should be enabled.
1118	* @thread EMT(0)
1119	* @internal
1120	*/
1121	static DECLCALLBACK(int) dbgfR3BpEnable(PUVM pUVM, uint32_t iBp)
1122	{
1123	/*
1124	* Validate input.
1125	*/
1126	PVM pVM = pUVM->pVM;
1127	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1128	PDBGFBP pBp = dbgfR3BpGet(pVM, iBp);
1129	if (!pBp)
1130	return VERR_DBGF_BP_NOT_FOUND;
1131
1132	/*
1133	* Already enabled?
1134	*/
1135	if (pBp->fEnabled)
1136	return VINF_DBGF_BP_ALREADY_ENABLED;
1137
1138	/*
1139	* Remove the breakpoint.
1140	*/
1141	int rc;
1142	pBp->fEnabled = true;
1143	switch (pBp->enmType)
1144	{
1145	case DBGFBPTYPE_REG:
1146	rc = dbgfR3BpRegArm(pVM, pBp);
1147	break;
1148
1149	case DBGFBPTYPE_INT3:
1150	dbgfR3BpUpdateSearchOptimizations(pVM, DBGFBPTYPE_INT3, &pVM->dbgf.s.Int3);
1151	rc = dbgfR3BpInt3Arm(pUVM, pBp);
1152	break;
1153
1154	case DBGFBPTYPE_REM:
1155	#ifdef VBOX_WITH_REM
1156	rc = REMR3BreakpointSet(pVM, pBp->u.Rem.GCPtr);
1157	#else
1158	rc = IEMBreakpointSet(pVM, pBp->u.Rem.GCPtr);
1159	#endif
1160	break;
1161
1162	case DBGFBPTYPE_PORT_IO:
1163	case DBGFBPTYPE_MMIO:
1164	rc = dbgfR3BpUpdateIom(pVM);
1165	break;
1166
1167	default:
1168	AssertMsgFailedReturn(("Invalid enmType=%d!\n", pBp->enmType), VERR_IPE_NOT_REACHED_DEFAULT_CASE);
1169	}
1170	if (RT_FAILURE(rc))
1171	pBp->fEnabled = false;
1172
1173	return rc;
1174	}
1175
1176
1177	/**
1178	* Enables a breakpoint.
1179	*
1180	* @returns VBox status code.
1181	* @param pUVM The user mode VM handle.
1182	* @param iBp The id of the breakpoint which should be enabled.
1183	* @thread Any thread.
1184	*/
1185	VMMR3DECL(int) DBGFR3BpEnable(PUVM pUVM, uint32_t iBp)
1186	{
1187	/*
1188	* This must be done on EMT.
1189	*/
1190	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpEnable, 2, pUVM, iBp);
1191	LogFlow(("DBGFR3BpEnable: returns %Rrc\n", rc));
1192	return rc;
1193	}
1194
1195
1196	/**
1197	* EMT worker for DBGFR3BpDisable().
1198	*
1199	* @returns VBox status code.
1200	* @param pUVM The user mode VM handle.
1201	* @param iBp The id of the breakpoint which should be disabled.
1202	* @thread EMT(0)
1203	* @internal
1204	*/
1205	static DECLCALLBACK(int) dbgfR3BpDisable(PUVM pUVM, uint32_t iBp)
1206	{
1207	/*
1208	* Validate input.
1209	*/
1210	PVM pVM = pUVM->pVM;
1211	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1212	PDBGFBP pBp = dbgfR3BpGet(pVM, iBp);
1213	if (!pBp)
1214	return VERR_DBGF_BP_NOT_FOUND;
1215
1216	/*
1217	* Already enabled?
1218	*/
1219	if (!pBp->fEnabled)
1220	return VINF_DBGF_BP_ALREADY_DISABLED;
1221
1222	/*
1223	* Remove the breakpoint.
1224	*/
1225	pBp->fEnabled = false;
1226	int rc;
1227	switch (pBp->enmType)
1228	{
1229	case DBGFBPTYPE_REG:
1230	rc = dbgfR3BpRegDisarm(pVM, pBp);
1231	break;
1232
1233	case DBGFBPTYPE_INT3:
1234	rc = dbgfR3BpInt3Disarm(pUVM, pBp);
1235	dbgfR3BpUpdateSearchOptimizations(pVM, DBGFBPTYPE_INT3, &pVM->dbgf.s.Int3);
1236	break;
1237
1238	case DBGFBPTYPE_REM:
1239	#ifdef VBOX_WITH_REM
1240	rc = REMR3BreakpointClear(pVM, pBp->u.Rem.GCPtr);
1241	#else
1242	rc = IEMBreakpointClear(pVM, pBp->u.Rem.GCPtr);
1243	#endif
1244	break;
1245
1246	case DBGFBPTYPE_PORT_IO:
1247	case DBGFBPTYPE_MMIO:
1248	rc = dbgfR3BpUpdateIom(pVM);
1249	break;
1250
1251	default:
1252	AssertMsgFailedReturn(("Invalid enmType=%d!\n", pBp->enmType), VERR_IPE_NOT_REACHED_DEFAULT_CASE);
1253	}
1254
1255	return rc;
1256	}
1257
1258
1259	/**
1260	* Disables a breakpoint.
1261	*
1262	* @returns VBox status code.
1263	* @param pUVM The user mode VM handle.
1264	* @param iBp The id of the breakpoint which should be disabled.
1265	* @thread Any thread.
1266	*/
1267	VMMR3DECL(int) DBGFR3BpDisable(PUVM pUVM, uint32_t iBp)
1268	{
1269	/*
1270	* This must be done on EMT.
1271	*/
1272	int rc = VMR3ReqCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpDisable, 2, pUVM, iBp);
1273	LogFlow(("DBGFR3BpDisable: returns %Rrc\n", rc));
1274	return rc;
1275	}
1276
1277
1278	/**
1279	* EMT worker for DBGFR3BpEnum().
1280	*
1281	* @returns VBox status code.
1282	* @param pUVM The user mode VM handle.
1283	* @param pfnCallback The callback function.
1284	* @param pvUser The user argument to pass to the callback.
1285	* @thread EMT
1286	* @internal
1287	*/
1288	static DECLCALLBACK(int) dbgfR3BpEnum(PUVM pUVM, PFNDBGFBPENUM pfnCallback, void *pvUser)
1289	{
1290	/*
1291	* Validate input.
1292	*/
1293	PVM pVM = pUVM->pVM;
1294	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
1295	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
1296
1297	/*
1298	* Enumerate the hardware breakpoints.
1299	*/
1300	unsigned i;
1301	for (i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aHwBreakpoints); i++)
1302	if (pVM->dbgf.s.aHwBreakpoints[i].enmType != DBGFBPTYPE_FREE)
1303	{
1304	int rc = pfnCallback(pUVM, pvUser, &pVM->dbgf.s.aHwBreakpoints[i]);
1305	if (RT_FAILURE(rc) \|\| rc == VINF_CALLBACK_RETURN)
1306	return rc;
1307	}
1308
1309	/*
1310	* Enumerate the other breakpoints.
1311	*/
1312	for (i = 0; i < RT_ELEMENTS(pVM->dbgf.s.aBreakpoints); i++)
1313	if (pVM->dbgf.s.aBreakpoints[i].enmType != DBGFBPTYPE_FREE)
1314	{
1315	int rc = pfnCallback(pUVM, pvUser, &pVM->dbgf.s.aBreakpoints[i]);
1316	if (RT_FAILURE(rc) \|\| rc == VINF_CALLBACK_RETURN)
1317	return rc;
1318	}
1319
1320	return VINF_SUCCESS;
1321	}
1322
1323
1324	/**
1325	* Enumerate the breakpoints.
1326	*
1327	* @returns VBox status code.
1328	* @param pUVM The user mode VM handle.
1329	* @param pfnCallback The callback function.
1330	* @param pvUser The user argument to pass to the callback.
1331	* @thread Any thread but the callback will be called from EMT.
1332	*/
1333	VMMR3DECL(int) DBGFR3BpEnum(PUVM pUVM, PFNDBGFBPENUM pfnCallback, void *pvUser)
1334	{
1335	/*
1336	* This must be done on EMT.
1337	*/
1338	int rc = VMR3ReqPriorityCallWaitU(pUVM, 0 /idDstCpu/, (PFNRT)dbgfR3BpEnum, 3, pUVM, pfnCallback, pvUser);
1339	LogFlow(("DBGFR3BpClear: returns %Rrc\n", rc));
1340	return rc;
1341	}
1342

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFBp.cpp@ 62637

Download in other formats: