DBGFAllTracer.cpp@ 87626

Last change on this file since 87626 was 84823, checked in by vboxsync, 4 years ago
VMM/DBGFTracer: Windows build fixes, bugref:9210
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.7 KB

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

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

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

Download in other formats: