DBGFAllTracer.cpp@ 104188

Last change on this file since 104188 was 99739, checked in by vboxsync, 19 months ago
*: doxygen corrections (mostly about removing @returns from functions returning void).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.9 KB

Line
1	/* $Id: DBGFAllTracer.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, All Context Code tracing part.
4	*/
5
6	/*
7	* Copyright (C) 2020-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DBGF
33	#include "DBGFInternal.h"
34	#include <VBox/types.h>
35	#include <VBox/err.h>
36	#include <VBox/vmm/dbgf.h>
37	#if defined(IN_RING3)
38	# include <VBox/vmm/uvm.h>
39	# include <VBox/vmm/vm.h>
40	#elif defined(IN_RING0)
41	# include <VBox/vmm/gvm.h>
42	#else
43	# error "Invalid environment"
44	#endif
45
46
47	/*********************************************************************************************************************************
48	* Internal Functions *
49	*********************************************************************************************************************************/
50
51	/**
52	* Returns the current context tracer instance of the given VM instance.
53	*
54	* @returns Current context pointer to the DBGF tracer instance.
55	*/
56	DECLINLINE(PDBGFTRACERINSCC) dbgfTracerGetInstance(PVMCC pVM)
57	{
58	#if defined(IN_RING0)
59	return pVM->dbgfr0.s.pTracerR0;
60	#elif defined(IN_RING3)
61	PUVM pUVM = pVM->pUVM;
62	return pUVM->dbgf.s.pTracerR3;
63	#elif defined(IN_RC)
64	# error "Not implemented"
65	#else
66	# error "No/Invalid context specified"
67	#endif
68	}
69
70
71	/**
72	* Returns the size of the tracing ring buffer.
73	*
74	* @returns Size of the ring buffer in bytes.
75	* @param pThisCC The event tracer instance current context data.
76	*/
77	DECLINLINE(size_t) dbgfTracerGetRingBufSz(PDBGFTRACERINSCC pThisCC)
78	{
79	#if defined(IN_RING0) /* For R0 we are extra cautious and use the ring buffer size stored in R0 memory so R3 can't corrupt it. */
80	return pThisCC->cbRingBuf;
81	#else
82	return pThisCC->CTX_SUFF(pShared)->cbRingBuf;
83	#endif
84	}
85
86
87	/**
88	* Posts a single event descriptor to the ring buffer of the given tracer instance - extended version.
89	*
90	* @returns VBox status code.
91	* @param pVM The current context VM instance data.
92	* @param pThisCC The event tracer instance current context data.
93	* @param hEvtSrc The event source for the posted event.
94	* @param enmTraceEvt The trace event type posted.
95	* @param idEvtPrev The previous event ID the posted event links to.
96	* @param pvEvtDesc The event descriptor to copy after the header.
97	* @param cbEvtDesc Size of the event descriptor.
98	* @param pidEvt Where to store the assigned event ID, optional.
99	*/
100	static int dbgfTracerEvtPostEx(PVMCC pVM, PDBGFTRACERINSCC pThisCC, DBGFTRACEREVTSRC hEvtSrc,
101	DBGFTRACEREVT enmTraceEvt, uint64_t idEvtPrev, const void *pvEvtDesc,
102	size_t cbEvtDesc, uint64_t *pidEvt)
103	{
104	LogFlowFunc(("pVM=%p pThisCC=%p hEvtSrc=%llu enmTraceEvt=%u idEvtPrev=%llu pvEvtDesc=%p cbEvtDesc=%zu pidEvt=%p\n",
105	pVM, pThisCC, hEvtSrc, enmTraceEvt, idEvtPrev, pvEvtDesc, cbEvtDesc, pidEvt));
106
107	PDBGFTRACERSHARED pSharedCC = pThisCC->CTX_SUFF(pShared);
108	size_t cRingBufEvts = dbgfTracerGetRingBufSz(pThisCC) / DBGF_TRACER_EVT_SZ;
109	AssertReturn(cRingBufEvts, VERR_DBGF_TRACER_IPE_1);
110	AssertReturn(cbEvtDesc <= DBGF_TRACER_EVT_PAYLOAD_SZ, VERR_DBGF_TRACER_IPE_1);
111
112	/* Grab a new event ID first. */
113	uint64_t idEvt = ASMAtomicIncU64(&pSharedCC->idEvt) - 1;
114	uint64_t idxRingBuf = idEvt % cRingBufEvts; /* This gives the index in the ring buffer for the event. */
115	PDBGFTRACEREVTHDR pEvtHdr = (PDBGFTRACEREVTHDR)(pThisCC->CTX_SUFF(pbRingBuf) + idxRingBuf * DBGF_TRACER_EVT_SZ);
116
117	if (RT_UNLIKELY(ASMAtomicReadU64(&pEvtHdr->idEvt) != DBGF_TRACER_EVT_HDR_ID_INVALID))
118	{
119	/** @todo The event ring buffer is full and we need to go back (from R0 to R3) and wait for the flusher thread to
120	* get its act together.
121	*/
122	AssertMsgFailed(("Flush thread can't keep up with event amount!\n"));
123	}
124
125	/* Write the event and kick the flush thread if necessary. */
126	if (cbEvtDesc)
127	memcpy(pEvtHdr + 1, pvEvtDesc, cbEvtDesc);
128	pEvtHdr->idEvtPrev = idEvtPrev;
129	pEvtHdr->hEvtSrc = hEvtSrc;
130	pEvtHdr->enmEvt = enmTraceEvt;
131	pEvtHdr->fFlags = DBGF_TRACER_EVT_HDR_F_DEFAULT;
132	ASMAtomicWriteU64(&pEvtHdr->idEvt, idEvt);
133
134	int rc = VINF_SUCCESS;
135	if (!ASMAtomicXchgBool(&pSharedCC->fEvtsWaiting, true))
136	{
137	if (!ASMAtomicXchgBool(&pSharedCC->fFlushThrdActive, true))
138	rc = SUPSemEventSignal(pVM->pSession, pSharedCC->hSupSemEvtFlush);
139	}
140
141	if (pidEvt)
142	*pidEvt = idEvt;
143	return rc;
144	}
145
146
147	/**
148	* Posts a single event descriptor to the ring buffer of the given tracer instance.
149	*
150	* @returns VBox status code.
151	* @param pVM The current context VM instance data.
152	* @param pThisCC The event tracer instance current context data.
153	* @param hEvtSrc The event source for the posted event.
154	* @param enmTraceEvt The trace event type posted.
155	* @param pvEvtDesc The event descriptor to copy after the header.
156	* @param pidEvt Where to store the assigned event ID, optional.
157	*/
158	DECLINLINE(int) dbgfTracerEvtPostSingle(PVMCC pVM, PDBGFTRACERINSCC pThisCC, DBGFTRACEREVTSRC hEvtSrc,
159	DBGFTRACEREVT enmTraceEvt, const void pvEvtDesc, uint64_t pidEvt)
160	{
161	return dbgfTracerEvtPostEx(pVM, pThisCC, hEvtSrc, enmTraceEvt, DBGF_TRACER_EVT_HDR_ID_INVALID,
162	pvEvtDesc, DBGF_TRACER_EVT_PAYLOAD_SZ, pidEvt);
163	}
164
165
166	#ifdef IN_RING3
167	/**
168	* Posts a single event descriptor to the ring buffer of the given tracer instance - R3 only variant
169	* (used for the register/deregister event source events currently).
170	*
171	* @returns VBox status code.
172	* @param pVM The current context VM instance data.
173	* @param pThisCC The event tracer instance current context data.
174	* @param hEvtSrc The event source for the posted event.
175	* @param enmTraceEvt The trace event type posted.
176	* @param pvEvtDesc The event descriptor to copy after the header.
177	* @param cbEvtDesc Event descriptor size in bytes.
178	* @param pidEvt Where to store the assigned event ID, optional.
179	*/
180	DECLHIDDEN(int) dbgfTracerR3EvtPostSingle(PVMCC pVM, PDBGFTRACERINSCC pThisCC, DBGFTRACEREVTSRC hEvtSrc,
181	DBGFTRACEREVT enmTraceEvt, const void *pvEvtDesc, size_t cbEvtDesc,
182	uint64_t *pidEvt)
183	{
184	return dbgfTracerEvtPostEx(pVM, pThisCC, hEvtSrc, enmTraceEvt, DBGF_TRACER_EVT_HDR_ID_INVALID,
185	pvEvtDesc, cbEvtDesc, pidEvt);
186	}
187	#endif
188
189	/**
190	* Copies the given MMIO value into the event descriptor based on the given size.
191	*
192	* @param pEvtMmio Pointer to the MMIO event descriptor to fill.
193	* @param pvVal The value to copy.
194	* @param cbVal Size of the value in bytes.
195	*/
196	static void dbgfTracerEvtMmioCopyVal(PDBGFTRACEREVTMMIO pEvtMmio, const void *pvVal, size_t cbVal)
197	{
198	switch (cbVal)
199	{
200	case 1:
201	pEvtMmio->u64Val = (uint8_t )pvVal;
202	break;
203	case 2:
204	pEvtMmio->u64Val = (uint16_t )pvVal;
205	break;
206	case 4:
207	pEvtMmio->u64Val = (uint32_t )pvVal;
208	break;
209	case 8:
210	pEvtMmio->u64Val = (uint64_t )pvVal;
211	break;
212	default:
213	AssertMsgFailed(("The value size %zu is not supported!\n", cbVal));
214	}
215	}
216
217
218	/**
219	* Copies the given I/O port value into the event descriptor based on the given size.
220	*
221	* @param pEvtIoPort Pointer to the I/O port read/write event descriptor to fill.
222	* @param pvVal The value to copy.
223	* @param cbVal Size of the value in bytes.
224	*/
225	static void dbgfTracerEvtIoPortCopyVal(PDBGFTRACEREVTIOPORT pEvtIoPort, const void *pvVal, size_t cbVal)
226	{
227	switch (cbVal)
228	{
229	case 1:
230	pEvtIoPort->u32Val = (uint8_t )pvVal;
231	break;
232	case 2:
233	pEvtIoPort->u32Val = (uint16_t )pvVal;
234	break;
235	case 4:
236	pEvtIoPort->u32Val = (uint32_t )pvVal;
237	break;
238	default:
239	AssertMsgFailed(("The value size %zu is not supported!\n", cbVal));
240	}
241	}
242
243
244	/**
245	* Handles a guest memory transfer event.
246	*
247	* @returns VBox status code.
248	* @param pVM The current context VM instance data.
249	* @param pThisCC The event tracer instance current context data.
250	* @param enmTraceEvt The trace event type posted.
251	* @param hEvtSrc The event source for the posted event.
252	* @param GCPhys The guest physical address the transfer starts at.
253	* @param pvBuf The data being transfered.
254	* @param cbXfer Number of bytes being transfered.
255	*/
256	static int dbgfTracerEvtGCPhys(PVMCC pVM, PDBGFTRACERINSCC pThisCC, DBGFTRACEREVT enmTraceEvt, DBGFTRACEREVTSRC hEvtSrc,
257	RTGCPHYS GCPhys, const void *pvBuf, size_t cbXfer)
258	{
259	/* Fast path for really small transfers where everything fits into the descriptor. */
260	DBGFTRACEREVTGCPHYS EvtGCPhys;
261	EvtGCPhys.GCPhys = GCPhys;
262	EvtGCPhys.cbXfer = cbXfer;
263	if (cbXfer <= sizeof(EvtGCPhys.abData))
264	{
265	memcpy(&EvtGCPhys.abData[0], pvBuf, cbXfer);
266	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, enmTraceEvt, &EvtGCPhys, NULL /pidEvt/);
267	}
268
269	/*
270	* Slow path where we have to split the data into multiple entries.
271	* Each one is linked to the previous one by the previous event ID.
272	*/
273	const uint8_t pbBuf = (const uint8_t )pvBuf;
274	size_t cbLeft = cbXfer;
275	uint64_t idEvtPrev = 0;
276	memcpy(&EvtGCPhys.abData[0], pbBuf, sizeof(EvtGCPhys.abData));
277	pbBuf += sizeof(EvtGCPhys.abData);
278	cbLeft -= sizeof(EvtGCPhys.abData);
279
280	int rc = dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, enmTraceEvt, &EvtGCPhys, &idEvtPrev);
281	while ( RT_SUCCESS(rc)
282	&& cbLeft)
283	{
284	size_t cbThisXfer = RT_MIN(cbLeft, DBGF_TRACER_EVT_PAYLOAD_SZ);
285	rc = dbgfTracerEvtPostEx(pVM, pThisCC, hEvtSrc, enmTraceEvt, idEvtPrev,
286	pbBuf, cbThisXfer, &idEvtPrev);
287
288	pbBuf += cbThisXfer;
289	cbLeft -= cbThisXfer;
290	}
291
292	return rc;
293	}
294
295
296	/**
297	* Handles a I/O port string transfer event.
298	*
299	* @returns VBox status code.
300	* @param pVM The current context VM instance data.
301	* @param pThisCC The event tracer instance current context data.
302	* @param enmTraceEvt The trace event type posted.
303	* @param hEvtSrc The event source for the posted event.
304	* @param hIoPorts The I/O port region handle for the transfer.
305	* @param offPort The offset into the region where the transfer happened.
306	* @param pv The data being transfered.
307	* @param cb Number of bytes of valid data in the buffer.
308	* @param cbItem Item size in bytes.
309	* @param cTransfersReq Number of transfers requested.
310	* @param cTransfersRet Number of transfers done.
311	*/
312	static int dbgfTracerEvtIoPortStr(PVMCC pVM, PDBGFTRACERINSCC pThisCC, DBGFTRACEREVT enmTraceEvt, DBGFTRACEREVTSRC hEvtSrc,
313	uint64_t hIoPorts, RTIOPORT offPort, const void *pv, size_t cb, size_t cbItem, uint32_t cTransfersReq,
314	uint32_t cTransfersRet)
315	{
316	/* Fast path for really small transfers where everything fits into the descriptor. */
317	DBGFTRACEREVTIOPORTSTR EvtIoPortStr;
318	EvtIoPortStr.hIoPorts = hIoPorts;
319	EvtIoPortStr.cbItem = (uint32_t)cbItem;
320	EvtIoPortStr.cTransfersReq = cTransfersReq;
321	EvtIoPortStr.cTransfersRet = cTransfersRet;
322	EvtIoPortStr.offPort = offPort;
323	if (cb <= sizeof(EvtIoPortStr.abData))
324	{
325	memcpy(&EvtIoPortStr.abData[0], pv, cb);
326	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, enmTraceEvt, &EvtIoPortStr, NULL /pidEvt/);
327	}
328
329	/*
330	* Slow path where we have to split the data into multiple entries.
331	* Each one is linked to the previous one by the previous event ID.
332	*/
333	const uint8_t pbBuf = (const uint8_t )pv;
334	size_t cbLeft = cb;
335	uint64_t idEvtPrev = 0;
336	memcpy(&EvtIoPortStr.abData[0], pbBuf, sizeof(EvtIoPortStr.abData));
337	pbBuf += sizeof(EvtIoPortStr.abData);
338	cbLeft -= sizeof(EvtIoPortStr.abData);
339
340	int rc = dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, enmTraceEvt, &EvtIoPortStr, &idEvtPrev);
341	while ( RT_SUCCESS(rc)
342	&& cbLeft)
343	{
344	size_t cbThisXfer = RT_MIN(cbLeft, DBGF_TRACER_EVT_PAYLOAD_SZ);
345	rc = dbgfTracerEvtPostEx(pVM, pThisCC, hEvtSrc, enmTraceEvt, idEvtPrev,
346	pbBuf, cbThisXfer, &idEvtPrev);
347
348	pbBuf += cbThisXfer;
349	cbLeft -= cbThisXfer;
350	}
351
352	return rc;
353	}
354
355
356	/**
357	* Registers an MMIO region mapping event for the given event source.
358	*
359	* @returns VBox status code.
360	* @param pVM The current context VM instance data.
361	* @param hEvtSrc The event source for the posted event.
362	* @param hRegion The MMIO region handle being mapped.
363	* @param GCPhysMmio The guest physical address where the region is mapped.
364	*/
365	VMM_INT_DECL(int) DBGFTracerEvtMmioMap(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hRegion, RTGCPHYS GCPhysMmio)
366	{
367	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
368	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
369
370	DBGFTRACEREVTMMIOMAP EvtMmioMap;
371	EvtMmioMap.hMmioRegion = hRegion;
372	EvtMmioMap.GCPhysMmioBase = GCPhysMmio;
373	EvtMmioMap.au64Pad0[0] = 0;
374	EvtMmioMap.au64Pad0[1] = 0;
375
376	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_MMIO_MAP, &EvtMmioMap, NULL /pidEvt/);
377	}
378
379
380	/**
381	* Registers an MMIO region unmap event for the given event source.
382	*
383	* @returns VBox status code.
384	* @param pVM The current context VM instance data.
385	* @param hEvtSrc The event source for the posted event.
386	* @param hRegion The MMIO region handle being unmapped.
387	*/
388	VMM_INT_DECL(int) DBGFTracerEvtMmioUnmap(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hRegion)
389	{
390	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
391	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
392
393	DBGFTRACEREVTMMIOUNMAP EvtMmioUnmap;
394	EvtMmioUnmap.hMmioRegion = hRegion;
395	EvtMmioUnmap.au64Pad0[0] = 0;
396	EvtMmioUnmap.au64Pad0[1] = 0;
397	EvtMmioUnmap.au64Pad0[2] = 0;
398
399	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_MMIO_UNMAP, &EvtMmioUnmap, NULL /pidEvt/);
400	}
401
402
403	/**
404	* Registers an MMIO region read event for the given event source.
405	*
406	* @returns VBox status code.
407	* @param pVM The current context VM instance data.
408	* @param hEvtSrc The event source for the posted event.
409	* @param hRegion The MMIO region handle being read.
410	* @param offMmio The MMIO offset into the region where the read happened.
411	* @param pvVal The value being read.
412	* @param cbVal Value size in bytes.
413	*/
414	VMM_INT_DECL(int) DBGFTracerEvtMmioRead(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hRegion, RTGCPHYS offMmio, const void *pvVal, size_t cbVal)
415	{
416	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
417	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
418
419	DBGFTRACEREVTMMIO EvtMmio;
420	EvtMmio.hMmioRegion = hRegion;
421	EvtMmio.offMmio = offMmio;
422	EvtMmio.cbXfer = cbVal;
423	dbgfTracerEvtMmioCopyVal(&EvtMmio, pvVal, cbVal);
424
425	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_MMIO_READ, &EvtMmio, NULL /pidEvt/);
426	}
427
428
429	/**
430	* Registers an MMIO region write event for the given event source.
431	*
432	* @returns VBox status code.
433	* @param pVM The current context VM instance data.
434	* @param hEvtSrc The event source for the posted event.
435	* @param hRegion The MMIO region handle being written to.
436	* @param offMmio The MMIO offset into the region where the write happened.
437	* @param pvVal The value being written.
438	* @param cbVal Value size in bytes.
439	*/
440	VMM_INT_DECL(int) DBGFTracerEvtMmioWrite(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hRegion, RTGCPHYS offMmio, const void *pvVal, size_t cbVal)
441	{
442	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
443	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
444
445	DBGFTRACEREVTMMIO EvtMmio;
446	EvtMmio.hMmioRegion = hRegion;
447	EvtMmio.offMmio = offMmio;
448	EvtMmio.cbXfer = cbVal;
449	dbgfTracerEvtMmioCopyVal(&EvtMmio, pvVal, cbVal);
450
451	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_MMIO_WRITE, &EvtMmio, NULL /pidEvt/);
452	}
453
454
455	/**
456	* Registers an MMIO region fill event for the given event source.
457	*
458	* @returns VBox status code.
459	* @param pVM The current context VM instance data.
460	* @param hEvtSrc The event source for the posted event.
461	* @param hRegion The MMIO region handle being filled.
462	* @param offMmio The MMIO offset into the region where the fill starts.
463	* @param u32Item The value being used for filling.
464	* @param cbItem Item size in bytes.
465	* @param cItems Number of items being written.
466	*/
467	VMM_INT_DECL(int) DBGFTracerEvtMmioFill(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hRegion, RTGCPHYS offMmio,
468	uint32_t u32Item, uint32_t cbItem, uint32_t cItems)
469	{
470	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
471	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
472
473	DBGFTRACEREVTMMIOFILL EvtMmioFill;
474	EvtMmioFill.hMmioRegion = hRegion;
475	EvtMmioFill.offMmio = offMmio;
476	EvtMmioFill.cbItem = cbItem;
477	EvtMmioFill.cItems = cItems;
478	EvtMmioFill.u32Item = u32Item;
479	EvtMmioFill.u32Pad0 = 0;
480
481	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_MMIO_FILL, &EvtMmioFill, NULL /pidEvt/);
482	}
483
484
485	/**
486	* Registers an I/O region mapping event for the given event source.
487	*
488	* @returns VBox status code.
489	* @param pVM The current context VM instance data.
490	* @param hEvtSrc The event source for the posted event.
491	* @param hIoPorts The I/O port region handle being mapped.
492	* @param IoPortBase The I/O port base where the region is mapped.
493	*/
494	VMM_INT_DECL(int) DBGFTracerEvtIoPortMap(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hIoPorts, RTIOPORT IoPortBase)
495	{
496	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
497	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
498
499	DBGFTRACEREVTIOPORTMAP EvtIoPortMap;
500	RT_ZERO(EvtIoPortMap);
501	EvtIoPortMap.hIoPorts = hIoPorts;
502	EvtIoPortMap.IoPortBase = IoPortBase;
503
504	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_IOPORT_MAP, &EvtIoPortMap, NULL /pidEvt/);
505	}
506
507
508	/**
509	* Registers an I/O region unmap event for the given event source.
510	*
511	* @returns VBox status code.
512	* @param pVM The current context VM instance data.
513	* @param hEvtSrc The event source for the posted event.
514	* @param hIoPorts The I/O port region handle being unmapped.
515	*/
516	VMM_INT_DECL(int) DBGFTracerEvtIoPortUnmap(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hIoPorts)
517	{
518	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
519	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
520
521	DBGFTRACEREVTIOPORTUNMAP EvtIoPortUnmap;
522	EvtIoPortUnmap.hIoPorts = hIoPorts;
523	EvtIoPortUnmap.au64Pad0[0] = 0;
524	EvtIoPortUnmap.au64Pad0[1] = 0;
525	EvtIoPortUnmap.au64Pad0[2] = 0;
526
527	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_IOPORT_UNMAP, &EvtIoPortUnmap, NULL /pidEvt/);
528	}
529
530
531	/**
532	* Registers an I/O region read event for the given event source.
533	*
534	* @returns VBox status code.
535	* @param pVM The current context VM instance data.
536	* @param hEvtSrc The event source for the posted event.
537	* @param hIoPorts The I/O port region handle being read from.
538	* @param offPort The offset into the region where the read happened.
539	* @param pvVal The value being read.
540	* @param cbVal Value size in bytes.
541	*/
542	VMM_INT_DECL(int) DBGFTracerEvtIoPortRead(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hIoPorts, RTIOPORT offPort, const void *pvVal, size_t cbVal)
543	{
544	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
545	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
546
547	DBGFTRACEREVTIOPORT EvtIoPort;
548	RT_ZERO(EvtIoPort);
549	EvtIoPort.hIoPorts = hIoPorts;
550	EvtIoPort.offPort = offPort;
551	EvtIoPort.cbXfer = cbVal;
552	dbgfTracerEvtIoPortCopyVal(&EvtIoPort, pvVal, cbVal);
553
554	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_IOPORT_READ, &EvtIoPort, NULL /pidEvt/);
555	}
556
557
558	/**
559	* Registers an I/O region string read event for the given event source.
560	*
561	* @returns VBox status code.
562	* @param pVM The current context VM instance data.
563	* @param hEvtSrc The event source for the posted event.
564	* @param hIoPorts The I/O port region handle being read from.
565	* @param offPort The offset into the region where the read happened.
566	* @param pv The data being read.
567	* @param cb Item size in bytes.
568	* @param cTransfersReq Number of transfers requested.
569	* @param cTransfersRet Number of transfers done.
570	*/
571	VMM_INT_DECL(int) DBGFTracerEvtIoPortReadStr(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hIoPorts, RTIOPORT offPort, const void *pv, size_t cb,
572	uint32_t cTransfersReq, uint32_t cTransfersRet)
573	{
574	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
575	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
576
577	return dbgfTracerEvtIoPortStr(pVM, pThisCC, DBGFTRACEREVT_IOPORT_READ_STR, hEvtSrc, hIoPorts, offPort, pv, cTransfersRet * cb,
578	cb, cTransfersReq, cTransfersRet);
579	}
580
581
582	/**
583	* Registers an I/O region write event for the given event source.
584	*
585	* @returns VBox status code.
586	* @param pVM The current context VM instance data.
587	* @param hEvtSrc The event source for the posted event.
588	* @param hIoPorts The I/O port region handle being written to.
589	* @param offPort The offset into the region where the write happened.
590	* @param pvVal The value being written.
591	* @param cbVal Value size in bytes.
592	*/
593	VMM_INT_DECL(int) DBGFTracerEvtIoPortWrite(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hIoPorts, RTIOPORT offPort, const void *pvVal, size_t cbVal)
594	{
595	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
596	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
597
598	DBGFTRACEREVTIOPORT EvtIoPort;
599	RT_ZERO(EvtIoPort);
600	EvtIoPort.hIoPorts = hIoPorts;
601	EvtIoPort.offPort = offPort;
602	EvtIoPort.cbXfer = cbVal;
603	dbgfTracerEvtIoPortCopyVal(&EvtIoPort, pvVal, cbVal);
604
605	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_IOPORT_WRITE, &EvtIoPort, NULL /pidEvt/);
606	}
607
608
609	/**
610	* Registers an I/O region string write event for the given event source.
611	*
612	* @returns VBox status code.
613	* @param pVM The current context VM instance data.
614	* @param hEvtSrc The event source for the posted event.
615	* @param hIoPorts The I/O port region handle being written to.
616	* @param offPort The offset into the region where the write happened.
617	* @param pv The data being written.
618	* @param cb Item size in bytes.
619	* @param cTransfersReq Number of transfers requested.
620	* @param cTransfersRet Number of transfers done.
621	*/
622	VMM_INT_DECL(int) DBGFTracerEvtIoPortWriteStr(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, uint64_t hIoPorts, RTIOPORT offPort, const void *pv, size_t cb,
623	uint32_t cTransfersReq, uint32_t cTransfersRet)
624	{
625	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
626	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
627
628	return dbgfTracerEvtIoPortStr(pVM, pThisCC, DBGFTRACEREVT_IOPORT_WRITE_STR, hEvtSrc, hIoPorts, offPort, pv, cTransfersReq * cb,
629	cb, cTransfersReq, cTransfersRet);
630	}
631
632
633	/**
634	* Registers an IRQ change event for the given event source.
635	*
636	* @returns VBox status code.
637	* @param pVM The current context VM instance data.
638	* @param hEvtSrc The event source for the posted event.
639	* @param iIrq The IRQ line changed.
640	* @param fIrqLvl The new IRQ level mask.
641	*/
642	VMM_INT_DECL(int) DBGFTracerEvtIrq(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, int32_t iIrq, int32_t fIrqLvl)
643	{
644	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
645	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
646
647	DBGFTRACEREVTIRQ EvtIrq;
648	RT_ZERO(EvtIrq);
649	EvtIrq.iIrq = iIrq;
650	EvtIrq.fIrqLvl = fIrqLvl;
651
652	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_IRQ, &EvtIrq, NULL /pidEvt/);
653	}
654
655
656	/**
657	* Registers an I/O APIC MSI event for the given event source.
658	*
659	* @returns VBox status code.
660	* @param pVM The current context VM instance data.
661	* @param hEvtSrc The event source for the posted event.
662	* @param GCPhys Guest physical address where the value is written to.
663	* @param u32Val The MSI event value being written.
664	*/
665	VMM_INT_DECL(int) DBGFTracerEvtIoApicMsi(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, RTGCPHYS GCPhys, uint32_t u32Val)
666	{
667	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
668	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
669
670	DBGFTRACEREVTIOAPICMSI EvtMsi;
671	RT_ZERO(EvtMsi);
672	EvtMsi.GCPhys = GCPhys;
673	EvtMsi.u32Val = u32Val;
674
675	return dbgfTracerEvtPostSingle(pVM, pThisCC, hEvtSrc, DBGFTRACEREVT_IOAPIC_MSI, &EvtMsi, NULL /pidEvt/);
676	}
677
678
679	/**
680	* Registers an guest physical memory read event for the given event source.
681	*
682	* @returns VBox status code.
683	* @param pVM The current context VM instance data.
684	* @param hEvtSrc The event source for the posted event.
685	* @param GCPhys Guest physical address the read started at.
686	* @param pvBuf The read data.
687	* @param cbRead Number of bytes read.
688	*/
689	VMM_INT_DECL(int) DBGFTracerEvtGCPhysRead(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, RTGCPHYS GCPhys, const void *pvBuf, size_t cbRead)
690	{
691	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
692	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
693
694	return dbgfTracerEvtGCPhys(pVM, pThisCC, DBGFTRACEREVT_GCPHYS_READ, hEvtSrc, GCPhys, pvBuf, cbRead);
695	}
696
697
698	/**
699	* Registers an guest physical memory write event for the given event source.
700	*
701	* @returns VBox status code.
702	* @param pVM The current context VM instance data.
703	* @param hEvtSrc The event source for the posted event.
704	* @param GCPhys Guest physical address the write started at.
705	* @param pvBuf The written data.
706	* @param cbWrite Number of bytes written.
707	*/
708	VMM_INT_DECL(int) DBGFTracerEvtGCPhysWrite(PVMCC pVM, DBGFTRACEREVTSRC hEvtSrc, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
709	{
710	PDBGFTRACERINSCC pThisCC = dbgfTracerGetInstance(pVM);
711	AssertReturn(pThisCC, VERR_DBGF_TRACER_IPE_1);
712
713	return dbgfTracerEvtGCPhys(pVM, pThisCC, DBGFTRACEREVT_GCPHYS_WRITE, hEvtSrc, GCPhys, pvBuf, cbWrite);
714	}
715

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

source: vbox/trunk/src/VBox/VMM/VMMAll/DBGFAllTracer.cpp@ 104188

Download in other formats: