VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFR3Tracer.cpp@ 84756

Last change on this file since 84756 was 84756, checked in by vboxsync, 5 years ago

VMM/DBGFTracer: Missing file, bugref:9210
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 39.6 KB
Line 
1/* $Id: DBGFR3Tracer.cpp 84756 2020-06-10 12:45:09Z vboxsync $ */
2/** @file
3 * DBGF - Debugger Facility, tracing parts.
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/vmm/pdm.h>
25#include <VBox/vmm/cfgm.h>
26#include <VBox/vmm/uvm.h>
27#include <VBox/vmm/vm.h>
28#include <VBox/vmm/vmm.h>
29#include <VBox/sup.h>
30
31#include <VBox/version.h>
32#include <VBox/log.h>
33#include <VBox/err.h>
34#include <iprt/buildconfig.h>
35#include <iprt/alloc.h>
36#include <iprt/alloca.h>
37#include <iprt/asm.h>
38#include <iprt/assert.h>
39#include <iprt/path.h>
40#include <iprt/semaphore.h>
41#include <iprt/string.h>
42#include <iprt/thread.h>
43#include <iprt/tracelog.h>
44
45
46/*********************************************************************************************************************************
47* Structures and Typedefs *
48*********************************************************************************************************************************/
49
50
51
52/*********************************************************************************************************************************
53* Global Variables *
54*********************************************************************************************************************************/
55/** The event descriptors written to the trace log. */
56
57static const RTTRACELOGEVTDESC g_EvtSrcRegisterEvtDesc =
58{
59 "EvtSrc.Register",
60 "An event soruce was registered",
61 RTTRACELOGEVTSEVERITY_DEBUG,
62 0,
63 NULL
64};
65
66
67static const RTTRACELOGEVTDESC g_EvtSrcDeregisterEvtDesc =
68{
69 "EvtSrc.Deregister",
70 "An event soruce was de-registered",
71 RTTRACELOGEVTSEVERITY_DEBUG,
72 0,
73 NULL
74};
75
76
77static const RTTRACELOGEVTITEMDESC g_DevMmioMapEvtItems[] =
78{
79 {"hMmioRegion", "The MMIO region handle being mapped", RTTRACELOGTYPE_UINT64, 0},
80 {"GCPhysMmioBase", "The guest physical address where the region is mapped", RTTRACELOGTYPE_UINT64, 0}
81};
82
83static const RTTRACELOGEVTDESC g_DevMmioMapEvtDesc =
84{
85 "Dev.MmioMap",
86 "MMIO region of a device is being mapped",
87 RTTRACELOGEVTSEVERITY_DEBUG,
88 RT_ELEMENTS(g_DevMmioMapEvtItems),
89 &g_DevMmioMapEvtItems[0]
90};
91
92
93static const RTTRACELOGEVTITEMDESC g_DevMmioUnmapEvtItems[] =
94{
95 {"hMmioRegion", "The MMIO region handle being unmapped", RTTRACELOGTYPE_UINT64, 0}
96};
97
98static const RTTRACELOGEVTDESC g_DevMmioUnmapEvtDesc =
99{
100 "Dev.MmioUnmap",
101 "MMIO region of a device is being unmapped",
102 RTTRACELOGEVTSEVERITY_DEBUG,
103 RT_ELEMENTS(g_DevMmioUnmapEvtItems),
104 &g_DevMmioUnmapEvtItems[0]
105};
106
107
108static const RTTRACELOGEVTITEMDESC g_DevMmioRwEvtItems[] =
109{
110 {"hMmioRegion", "The MMIO region handle being unmapped", RTTRACELOGTYPE_UINT64, 0},
111 {"offMmio", "The offset in the MMIO region being accessed", RTTRACELOGTYPE_UINT64, 0},
112 {"cbXfer", "Number of bytes being transfered", RTTRACELOGTYPE_UINT64, 0},
113 {"u64Val", "The value read or written", RTTRACELOGTYPE_UINT64, 0},
114};
115
116static const RTTRACELOGEVTDESC g_DevMmioReadEvtDesc =
117{
118 "Dev.MmioRead",
119 "MMIO region of a device is being read",
120 RTTRACELOGEVTSEVERITY_DEBUG,
121 RT_ELEMENTS(g_DevMmioRwEvtItems),
122 &g_DevMmioRwEvtItems[0]
123};
124
125static const RTTRACELOGEVTDESC g_DevMmioWriteEvtDesc =
126{
127 "Dev.MmioWrite",
128 "MMIO region of a device is being written",
129 RTTRACELOGEVTSEVERITY_DEBUG,
130 RT_ELEMENTS(g_DevMmioRwEvtItems),
131 &g_DevMmioRwEvtItems[0]
132};
133
134
135static const RTTRACELOGEVTITEMDESC g_DevMmioFillEvtItems[] =
136{
137 {"hMmioRegion", "The MMIO region handle being unmapped", RTTRACELOGTYPE_UINT64, 0},
138 {"offMmio", "The offset in the MMIO region being accessed", RTTRACELOGTYPE_UINT64, 0},
139 {"cbItem", "Item size in bytes", RTTRACELOGTYPE_UINT32, 0},
140 {"cItems", "Number of items being written", RTTRACELOGTYPE_UINT32, 0},
141 {"u32Val", "The value used for filling", RTTRACELOGTYPE_UINT32, 0},
142};
143
144static const RTTRACELOGEVTDESC g_DevMmioFillEvtDesc =
145{
146 "Dev.MmioFill",
147 "MMIO region of a device is being filled",
148 RTTRACELOGEVTSEVERITY_DEBUG,
149 RT_ELEMENTS(g_DevMmioFillEvtItems),
150 &g_DevMmioFillEvtItems[0]
151};
152
153
154static const RTTRACELOGEVTITEMDESC g_DevIoPortMapEvtItems[] =
155{
156 {"hIoPorts", "The I/O port region handle being mapped", RTTRACELOGTYPE_UINT64, 0},
157 {"IoPortBase", "The I/O port base address where the region is mapped", RTTRACELOGTYPE_UINT16, 0}
158};
159
160static const RTTRACELOGEVTDESC g_DevIoPortMapEvtDesc =
161{
162 "Dev.IoPortMap",
163 "I/O port region of a device is being mapped",
164 RTTRACELOGEVTSEVERITY_DEBUG,
165 RT_ELEMENTS(g_DevIoPortMapEvtItems),
166 &g_DevIoPortMapEvtItems[0]
167};
168
169
170static const RTTRACELOGEVTITEMDESC g_DevIoPortUnmapEvtItems[] =
171{
172 {"hIoPorts", "The I/O port region handle being unmapped", RTTRACELOGTYPE_UINT64, 0}
173};
174
175static const RTTRACELOGEVTDESC g_DevIoPortUnmapEvtDesc =
176{
177 "Dev.IoPortUnmap",
178 "I/O port region of a device is being unmapped",
179 RTTRACELOGEVTSEVERITY_DEBUG,
180 RT_ELEMENTS(g_DevIoPortUnmapEvtItems),
181 &g_DevIoPortUnmapEvtItems[0]
182};
183
184
185static const RTTRACELOGEVTITEMDESC g_DevIoPortRwEvtItems[] =
186{
187 {"hIoPorts", "The I/O region handle being accessed", RTTRACELOGTYPE_UINT64, 0},
188 {"offPort", "The offset in the I/O port region being accessed", RTTRACELOGTYPE_UINT16, 0},
189 {"cbXfer", "Number of bytes being transfered", RTTRACELOGTYPE_UINT64, 0},
190 {"u32Val", "The value read or written", RTTRACELOGTYPE_UINT32, 0},
191};
192
193static const RTTRACELOGEVTDESC g_DevIoPortReadEvtDesc =
194{
195 "Dev.IoPortRead",
196 "I/O port region of a device is being read",
197 RTTRACELOGEVTSEVERITY_DEBUG,
198 RT_ELEMENTS(g_DevIoPortRwEvtItems),
199 &g_DevIoPortRwEvtItems[0]
200};
201
202static const RTTRACELOGEVTDESC g_DevIoPortWriteEvtDesc =
203{
204 "Dev.IoPortWrite",
205 "I/O port region of a device is being written",
206 RTTRACELOGEVTSEVERITY_DEBUG,
207 RT_ELEMENTS(g_DevIoPortRwEvtItems),
208 &g_DevIoPortRwEvtItems[0]
209};
210
211
212static const RTTRACELOGEVTITEMDESC g_DevIoPortRwStrEvtItems[] =
213{
214 {"hIoPorts", "The I/O region handle being accesses", RTTRACELOGTYPE_UINT64, 0},
215 {"offPort", "The offset in the I/O port region being accessed", RTTRACELOGTYPE_UINT16, 0},
216 {"cbItem", "Item size for the access", RTTRACELOGTYPE_UINT32, 0},
217 {"cTransfersReq", "Number of transfers requested by the guest", RTTRACELOGTYPE_UINT32, 0},
218 {"cTransfersRet", "Number of transfers executed by the device", RTTRACELOGTYPE_UINT32, 0}
219};
220
221static const RTTRACELOGEVTDESC g_DevIoPortReadStrEvtDesc =
222{
223 "Dev.IoPortReadStr",
224 "I/O port region of a device is being read using REP INS",
225 RTTRACELOGEVTSEVERITY_DEBUG,
226 RT_ELEMENTS(g_DevIoPortRwStrEvtItems),
227 &g_DevIoPortRwStrEvtItems[0]
228};
229
230static const RTTRACELOGEVTDESC g_DevIoPortWriteStrEvtDesc =
231{
232 "Dev.IoPortWriteStr",
233 "I/O port region of a device is being written using REP OUTS",
234 RTTRACELOGEVTSEVERITY_DEBUG,
235 RT_ELEMENTS(g_DevIoPortRwStrEvtItems),
236 &g_DevIoPortRwStrEvtItems[0]
237};
238
239
240static const RTTRACELOGEVTITEMDESC g_DevIrqEvtItems[] =
241{
242 {"iIrq", "The IRQ line", RTTRACELOGTYPE_INT32, 0},
243 {"fIrqLvl", "The IRQ level", RTTRACELOGTYPE_INT32, 0}
244};
245
246static const RTTRACELOGEVTDESC g_DevIrqEvtDesc =
247{
248 "Dev.Irq",
249 "Device raised or lowered an IRQ line",
250 RTTRACELOGEVTSEVERITY_DEBUG,
251 RT_ELEMENTS(g_DevIrqEvtItems),
252 &g_DevIrqEvtItems[0]
253};
254
255
256static const RTTRACELOGEVTITEMDESC g_DevIoApicMsiEvtItems[] =
257{
258 {"GCPhys", "Physical guest address being written", RTTRACELOGTYPE_UINT64, 0},
259 {"u32Val", "value being written", RTTRACELOGTYPE_UINT32, 0}
260};
261
262static const RTTRACELOGEVTDESC g_DevIoApicMsiEvtDesc =
263{
264 "Dev.IoApicMsi",
265 "Device sent a MSI event through the I/O APIC",
266 RTTRACELOGEVTSEVERITY_DEBUG,
267 RT_ELEMENTS(g_DevIoApicMsiEvtItems),
268 &g_DevIoApicMsiEvtItems[0]
269};
270
271
272static const RTTRACELOGEVTITEMDESC g_DevGCPhysRwStartEvtItems[] =
273{
274 {"GCPhys", "Physical guest address being accessed", RTTRACELOGTYPE_UINT64, 0},
275 {"cbXfer", "Number of bytes being transfered", RTTRACELOGTYPE_UINT64, 0},
276};
277
278
279static const RTTRACELOGEVTDESC g_DevGCPhysReadEvtDesc =
280{
281 "Dev.GCPhysRead",
282 "Device read data from guest physical memory",
283 RTTRACELOGEVTSEVERITY_DEBUG,
284 RT_ELEMENTS(g_DevGCPhysRwStartEvtItems),
285 &g_DevGCPhysRwStartEvtItems[0]
286};
287
288
289static const RTTRACELOGEVTDESC g_DevGCPhysWriteEvtDesc =
290{
291 "Dev.GCPhysWrite",
292 "Device wrote data to guest physical memory",
293 RTTRACELOGEVTSEVERITY_DEBUG,
294 RT_ELEMENTS(g_DevGCPhysRwStartEvtItems),
295 &g_DevGCPhysRwStartEvtItems[0]
296};
297
298
299static const RTTRACELOGEVTITEMDESC g_DevRwDataEvtItems[] =
300{
301 {"abData", "The data being read/written", RTTRACELOGTYPE_RAWDATA, 0}
302};
303
304static const RTTRACELOGEVTDESC g_DevRwDataEvtDesc =
305{
306 "Dev.RwData",
307 "The data being read or written",
308 RTTRACELOGEVTSEVERITY_DEBUG,
309 RT_ELEMENTS(g_DevRwDataEvtItems),
310 &g_DevRwDataEvtItems[0]
311};
312
313
314/*********************************************************************************************************************************
315* Internal Functions *
316*********************************************************************************************************************************/
317
318
319/**
320 * Returns an unused guest memory read/write data aggregation structure.
321 *
322 * @returns Pointer to a new aggregation structure or NULL if out of memory.
323 * @param pThis The DBGF tracer instance.
324 */
325static PDBGFTRACERGCPHYSRWAGG dbgfTracerR3EvtRwAggNew(PDBGFTRACERINSR3 pThis)
326{
327 for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aGstMemRwData); i++)
328 {
329 if (pThis->aGstMemRwData[i].idEvtStart == DBGF_TRACER_EVT_HDR_ID_INVALID)
330 return &pThis->aGstMemRwData[i];
331 }
332
333 return NULL;
334}
335
336
337/**
338 * Find the guest memory read/write data aggregation structure for the given event ID.
339 *
340 * @returns Pointer to a new aggregation structure or NULL if not found.
341 * @param pThis The DBGF tracer instance.
342 * @param idEvtPrev The event ID to look for.
343 */
344static PDBGFTRACERGCPHYSRWAGG dbgfTracerR3EvtRwAggFind(PDBGFTRACERINSR3 pThis, uint64_t idEvtPrev)
345{
346 for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aGstMemRwData); i++)
347 {
348 if ( pThis->aGstMemRwData[i].idEvtStart != DBGF_TRACER_EVT_HDR_ID_INVALID
349 && pThis->aGstMemRwData[i].idEvtPrev == idEvtPrev)
350 return &pThis->aGstMemRwData[i];
351 }
352
353 return NULL;
354}
355
356
357/**
358 * Common code for the guest memory and string I/O port read/write events.
359 *
360 * @returns VBox status code.
361 * @param pThis The DBGF tracer instance.
362 * @param pEvtHdr The event header.
363 * @param cbXfer Overall number of bytes of data for this event.
364 * @param pvData Initial data supplied in the event starting the aggregation.
365 * @param cbData Number of initial bytes of data.
366 */
367static int dbgfTracerR3EvtRwStartCommon(PDBGFTRACERINSR3 pThis, PCDBGFTRACEREVTHDR pEvtHdr, size_t cbXfer, const void *pvData, size_t cbData)
368{
369 /* Slow path, find an empty aggregation structure. */
370 int rc = VINF_SUCCESS;
371 PDBGFTRACERGCPHYSRWAGG pDataAgg = dbgfTracerR3EvtRwAggNew(pThis);
372 if (RT_LIKELY(pDataAgg))
373 {
374 /* Initialize it. */
375 pDataAgg->idEvtStart = pEvtHdr->idEvt;
376 pDataAgg->idEvtPrev = pEvtHdr->idEvt;
377 pDataAgg->cbXfer = cbXfer;
378 pDataAgg->cbLeft = pDataAgg->cbXfer;
379 pDataAgg->offBuf = 0;
380
381 /* Need to reallocate the buffer to hold the complete data? */
382 if (RT_UNLIKELY(pDataAgg->cbBufMax < pDataAgg->cbXfer))
383 {
384 uint8_t *pbBufNew = (uint8_t *)RTMemRealloc(pDataAgg->pbBuf, pDataAgg->cbXfer);
385 if (RT_LIKELY(pbBufNew))
386 {
387 pDataAgg->pbBuf = pbBufNew;
388 pDataAgg->cbBufMax = pDataAgg->cbXfer;
389 }
390 else
391 rc = VERR_NO_MEMORY;
392 }
393
394 if (RT_SUCCESS(rc))
395 {
396 memcpy(pDataAgg->pbBuf, pvData, cbData);
397 pDataAgg->offBuf += cbData;
398 pDataAgg->cbLeft -= cbData;
399 }
400 }
401 else
402 rc = VERR_NO_MEMORY;
403
404 if (RT_FAILURE(rc))
405 {
406 LogRelMax(10, ("DBGF: Creating new data aggregation structure for memory read/write failed with %Rrc, trace log will not contain data for this event!\n", rc));
407
408 /* Write out the finish event without any data. */
409 size_t cbEvtData = 0;
410 rc = RTTraceLogWrEvtAdd(pThis->hTraceLog, &g_DevRwDataEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_FINISH,
411 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, NULL, &cbEvtData);
412 if (pDataAgg) /* Reset the aggregation event. */
413 pDataAgg->idEvtStart = DBGF_TRACER_EVT_HDR_ID_INVALID;
414 }
415
416 return rc;
417}
418
419
420/**
421 * Starts a new guest memory read/write event.
422 *
423 * @returns VBox status code.
424 * @param pThis The DBGF tracer instance.
425 * @param pEvtHdr The event header.
426 * @param pEvtGCPhysRw The guest memory read/write event descriptor.
427 * @param pEvtDesc The event descriptor written to the trace log.
428 */
429static int dbgfTracerR3EvtGCPhysRwStart(PDBGFTRACERINSR3 pThis, PCDBGFTRACEREVTHDR pEvtHdr,
430 PCDBGFTRACEREVTGCPHYS pEvtGCPhysRw, PCRTTRACELOGEVTDESC pEvtDesc)
431{
432 /* Write out the event header first in any case. */
433 int rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, pEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_START,
434 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtGCPhysRw->GCPhys, pEvtGCPhysRw->cbXfer);
435 if (RT_SUCCESS(rc))
436 {
437 /*
438 * If the amount of data is small enough to fit into the single event descriptor we can skip allocating
439 * an aggregation tracking structure and write the event containing the complete data out immediately.
440 */
441 if (pEvtGCPhysRw->cbXfer <= sizeof(pEvtGCPhysRw->abData))
442 {
443 size_t cbEvtData = pEvtGCPhysRw->cbXfer;
444
445 rc = RTTraceLogWrEvtAdd(pThis->hTraceLog, &g_DevRwDataEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_FINISH,
446 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, &pEvtGCPhysRw->abData[0], &cbEvtData);
447 }
448 else
449 rc = dbgfTracerR3EvtRwStartCommon(pThis, pEvtHdr, pEvtGCPhysRw->cbXfer, &pEvtGCPhysRw->abData[0], sizeof(pEvtGCPhysRw->abData));
450 }
451
452 return rc;
453}
454
455
456/**
457 * Starts a new I/O port string read/write event.
458 *
459 * @returns VBox status code.
460 * @param pThis The DBGF tracer instance.
461 * @param pEvtHdr The event header.
462 * @param pEvtIoPortStrRw The I/O port string read/write event descriptor.
463 * @param cbXfer Number of bytes of valid data for this event.
464 * @param pEvtDesc The event descriptor written to the trace log.
465 */
466static int dbgfTracerR3EvtIoPortStrRwStart(PDBGFTRACERINSR3 pThis, PCDBGFTRACEREVTHDR pEvtHdr,
467 PCDBGFTRACEREVTIOPORTSTR pEvtIoPortStrRw, size_t cbXfer,
468 PCRTTRACELOGEVTDESC pEvtDesc)
469{
470 /* Write out the event header first in any case. */
471 int rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, pEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_START,
472 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtIoPortStrRw->hIoPorts, pEvtIoPortStrRw->offPort,
473 pEvtIoPortStrRw->cbItem, pEvtIoPortStrRw->cTransfersReq, pEvtIoPortStrRw->cTransfersRet);
474 if (RT_SUCCESS(rc))
475 {
476 /*
477 * If the amount of data is small enough to fit into the single event descriptor we can skip allocating
478 * an aggregation tracking structure and write the event containing the complete data out immediately.
479 */
480 if (cbXfer <= sizeof(pEvtIoPortStrRw->abData))
481 {
482 size_t cbEvtData = cbXfer;
483
484 rc = RTTraceLogWrEvtAdd(pThis->hTraceLog, &g_DevRwDataEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_FINISH,
485 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, &pEvtIoPortStrRw->abData[0], &cbEvtData);
486 }
487 else
488 rc = dbgfTracerR3EvtRwStartCommon(pThis, pEvtHdr, cbXfer, &pEvtIoPortStrRw->abData[0], sizeof(pEvtIoPortStrRw->abData));
489 }
490
491 return rc;
492}
493
494
495/**
496 * Continues a previously started guest memory or string I/O port read/write event.
497 *
498 * @returns VBox status code.
499 * @param pThis The DBGF tracer instance.
500 * @param pEvtHdr The event header.
501 * @param pvData The data to log.
502 */
503static int dbgfTracerR3EvtRwContinue(PDBGFTRACERINSR3 pThis, PCDBGFTRACEREVTHDR pEvtHdr, void *pvData)
504{
505 int rc = VINF_SUCCESS;
506 PDBGFTRACERGCPHYSRWAGG pDataAgg = dbgfTracerR3EvtRwAggFind(pThis, pEvtHdr->idEvtPrev);
507
508 if (RT_LIKELY(pDataAgg))
509 {
510 size_t cbThisXfer = RT_MIN(pDataAgg->cbLeft, DBGF_TRACER_EVT_PAYLOAD_SZ);
511
512 memcpy(pDataAgg->pbBuf + pDataAgg->offBuf, pvData, cbThisXfer);
513 pDataAgg->offBuf += cbThisXfer;
514 pDataAgg->cbLeft -= cbThisXfer;
515
516 if (!pDataAgg->cbLeft)
517 {
518 /* All data aggregated, write it out and reset the structure. */
519 rc = RTTraceLogWrEvtAdd(pThis->hTraceLog, &g_DevRwDataEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_FINISH,
520 pDataAgg->idEvtStart, pEvtHdr->hEvtSrc, pDataAgg->pbBuf, &pDataAgg->cbXfer);
521 pDataAgg->offBuf = 0;
522 pDataAgg->idEvtStart = DBGF_TRACER_EVT_HDR_ID_INVALID;
523 }
524 else
525 pDataAgg->idEvtPrev = pEvtHdr->idEvt; /* So the next event containing more data can find the aggregation structure. */
526 }
527 else /* This can only happen if creating a new structure failed before. */
528 rc = VERR_DBGF_TRACER_IPE_1;
529
530 return rc;
531}
532
533
534/**
535 * Processes the given event.
536 *
537 * @returns VBox status code.
538 * @param pThis The DBGF tracer instance.
539 * @param pEvtHdr The event to process.
540 */
541static int dbgfR3TracerEvtProcess(PDBGFTRACERINSR3 pThis, PDBGFTRACEREVTHDR pEvtHdr)
542{
543 int rc = VINF_SUCCESS;
544
545 LogFlowFunc(("pThis=%p pEvtHdr=%p{idEvt=%llu,enmEvt=%u}\n",
546 pThis, pEvtHdr, pEvtHdr->idEvt, pEvtHdr->enmEvt));
547
548 switch (pEvtHdr->enmEvt)
549 {
550 case DBGFTRACEREVT_SRC_REGISTER:
551 {
552 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_EvtSrcRegisterEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_START,
553 pEvtHdr->hEvtSrc, 0 /*uParentGrpId*/);
554 break;
555 }
556 case DBGFTRACEREVT_SRC_DEREGISTER:
557 {
558 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_EvtSrcDeregisterEvtDesc, RTTRACELOG_WR_ADD_EVT_F_GRP_FINISH,
559 pEvtHdr->hEvtSrc, 0 /*uParentGrpId*/);
560 break;
561 }
562 case DBGFTRACEREVT_MMIO_MAP:
563 {
564 PCDBGFTRACEREVTMMIOMAP pEvtMmioMap = (PCDBGFTRACEREVTMMIOMAP)(pEvtHdr + 1);
565
566 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevMmioMapEvtDesc, 0 /*fFlags*/,
567 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtMmioMap->hMmioRegion, pEvtMmioMap->GCPhysMmioBase);
568 break;
569 }
570 case DBGFTRACEREVT_MMIO_UNMAP:
571 {
572 PCDBGFTRACEREVTMMIOUNMAP pEvtMmioUnmap = (PCDBGFTRACEREVTMMIOUNMAP)(pEvtHdr + 1);
573
574 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevMmioUnmapEvtDesc, 0 /*fFlags*/,
575 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtMmioUnmap->hMmioRegion);
576 break;
577 }
578 case DBGFTRACEREVT_MMIO_READ:
579 case DBGFTRACEREVT_MMIO_WRITE:
580 {
581 PCDBGFTRACEREVTMMIO pEvtMmioRw = (PCDBGFTRACEREVTMMIO)(pEvtHdr + 1);
582
583 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog,
584 pEvtHdr->enmEvt == DBGFTRACEREVT_MMIO_READ
585 ? &g_DevMmioReadEvtDesc
586 : &g_DevMmioWriteEvtDesc,
587 0 /*fFlags*/,
588 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtMmioRw->hMmioRegion, pEvtMmioRw->offMmio,
589 pEvtMmioRw->cbXfer, pEvtMmioRw->u64Val);
590 break;
591 }
592 case DBGFTRACEREVT_MMIO_FILL:
593 {
594 PCDBGFTRACEREVTMMIOFILL pEvtMmioFill = (PCDBGFTRACEREVTMMIOFILL)(pEvtHdr + 1);
595
596 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevMmioFillEvtDesc, 0 /*fFlags*/,
597 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtMmioFill->hMmioRegion, pEvtMmioFill->offMmio,
598 pEvtMmioFill->cbItem, pEvtMmioFill->cItems, pEvtMmioFill->u32Item);
599 break;
600 }
601 case DBGFTRACEREVT_IOPORT_MAP:
602 {
603 PCDBGFTRACEREVTIOPORTMAP pEvtIoPortMap = (PCDBGFTRACEREVTIOPORTMAP)(pEvtHdr + 1);
604
605 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevIoPortMapEvtDesc, 0 /*fFlags*/,
606 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtIoPortMap->hIoPorts, pEvtIoPortMap->IoPortBase);
607 break;
608 }
609 case DBGFTRACEREVT_IOPORT_UNMAP:
610 {
611 PCDBGFTRACEREVTIOPORTUNMAP pEvtIoPortUnmap = (PCDBGFTRACEREVTIOPORTUNMAP)(pEvtHdr + 1);
612
613 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevIoPortUnmapEvtDesc, 0 /*fFlags*/,
614 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtIoPortUnmap->hIoPorts);
615 break;
616 }
617 case DBGFTRACEREVT_IOPORT_READ:
618 case DBGFTRACEREVT_IOPORT_WRITE:
619 {
620 PCDBGFTRACEREVTIOPORT pEvtIoPortRw = (PCDBGFTRACEREVTIOPORT)(pEvtHdr + 1);
621
622 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog,
623 pEvtHdr->enmEvt == DBGFTRACEREVT_IOPORT_READ
624 ? &g_DevIoPortReadEvtDesc
625 : &g_DevIoPortWriteEvtDesc,
626 0 /*fFlags*/,
627 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtIoPortRw->hIoPorts, pEvtIoPortRw->offPort,
628 pEvtIoPortRw->cbXfer, pEvtIoPortRw->u32Val);
629 break;
630 }
631 case DBGFTRACEREVT_IOPORT_READ_STR:
632 case DBGFTRACEREVT_IOPORT_WRITE_STR:
633 {
634 PCRTTRACELOGEVTDESC pEvtDesc = pEvtHdr->enmEvt == DBGFTRACEREVT_IOPORT_WRITE_STR
635 ? &g_DevIoPortWriteStrEvtDesc
636 : &g_DevIoPortReadStrEvtDesc;
637
638 /* If the previous event ID is invalid this starts a new read/write we have to aggregate all the data for. */
639 if (pEvtHdr->idEvtPrev == DBGF_TRACER_EVT_HDR_ID_INVALID)
640 {
641 PCDBGFTRACEREVTIOPORTSTR pEvtIoPortStrRw = (PCDBGFTRACEREVTIOPORTSTR)(pEvtHdr + 1);
642 size_t cbXfer = pEvtHdr->enmEvt == DBGFTRACEREVT_IOPORT_WRITE_STR
643 ? pEvtIoPortStrRw->cTransfersReq * pEvtIoPortStrRw->cbItem
644 : pEvtIoPortStrRw->cTransfersRet * pEvtIoPortStrRw->cbItem;
645
646 rc = dbgfTracerR3EvtIoPortStrRwStart(pThis, pEvtHdr, pEvtIoPortStrRw, cbXfer, pEvtDesc);
647 }
648 else
649 {
650 /* Continuation of a started read or write, look up the right tracking structure and process the new data. */
651 void *pvData = pEvtHdr + 1;
652 rc = dbgfTracerR3EvtRwContinue(pThis, pEvtHdr, pvData);
653 }
654 break;
655 }
656 case DBGFTRACEREVT_IRQ:
657 {
658 PCDBGFTRACEREVTIRQ pEvtIrq = (PCDBGFTRACEREVTIRQ)(pEvtHdr + 1);
659
660 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevIrqEvtDesc, 0 /*fFlags*/,
661 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtIrq->iIrq, pEvtIrq->fIrqLvl);
662 break;
663 }
664 case DBGFTRACEREVT_IOAPIC_MSI:
665 {
666 PCDBGFTRACEREVTIOAPICMSI pEvtIoApicMsi = (PCDBGFTRACEREVTIOAPICMSI)(pEvtHdr + 1);
667
668 rc = RTTraceLogWrEvtAddL(pThis->hTraceLog, &g_DevIrqEvtDesc, 0 /*fFlags*/,
669 pEvtHdr->idEvt, pEvtHdr->hEvtSrc, pEvtIoApicMsi->GCPhys, pEvtIoApicMsi->u32Val);
670 break;
671 }
672 case DBGFTRACEREVT_GCPHYS_READ:
673 case DBGFTRACEREVT_GCPHYS_WRITE:
674 {
675 PCRTTRACELOGEVTDESC pEvtDesc = pEvtHdr->enmEvt == DBGFTRACEREVT_GCPHYS_WRITE
676 ? &g_DevGCPhysWriteEvtDesc
677 : &g_DevGCPhysReadEvtDesc;
678
679 /* If the previous event ID is invalid this starts a new read/write we have to aggregate all the data for. */
680 if (pEvtHdr->idEvtPrev == DBGF_TRACER_EVT_HDR_ID_INVALID)
681 {
682 PCDBGFTRACEREVTGCPHYS pEvtGCPhysRw = (PCDBGFTRACEREVTGCPHYS)(pEvtHdr + 1);
683 rc = dbgfTracerR3EvtGCPhysRwStart(pThis, pEvtHdr, pEvtGCPhysRw, pEvtDesc);
684 }
685 else
686 {
687 /* Continuation of a started read or write, look up the right tracking structure and process the new data. */
688 void *pvData = pEvtHdr + 1;
689 rc = dbgfTracerR3EvtRwContinue(pThis, pEvtHdr, pvData);
690 }
691 break;
692 }
693 default:
694 AssertLogRelMsgFailed(("Invalid or unsupported event: %u!\n", pEvtHdr->enmEvt));
695 break;
696 }
697
698 return rc;
699}
700
701
702/**
703 * @callback_method_impl{FNRTTHREAD,
704 * DBGF Tracer flush thread}
705 */
706static DECLCALLBACK(int) dbgfR3TracerThreadFlush(RTTHREAD ThreadSelf, void *pvUser)
707{
708 PDBGFTRACERINSR3 pThis = (PDBGFTRACERINSR3)pvUser;
709 PDBGFTRACERSHARED pShared = pThis->pSharedR3;
710 PSUPDRVSESSION pSession = pThis->pVMR3->pSession;
711
712 /* Release the waiter. */
713 RTThreadUserSignal(ThreadSelf);
714
715 /*
716 * Process stuff until we're told to terminate.
717 */
718 for (;;)
719 {
720 ASMAtomicXchgBool(&pShared->fFlushThrdActive, false);
721 if (!ASMAtomicXchgBool(&pShared->fEvtsWaiting, false))
722 {
723 int rc = SUPSemEventWaitNoResume(pSession, pShared->hSupSemEvtFlush, RT_INDEFINITE_WAIT);
724 Assert(RT_SUCCESS(rc) || rc == VERR_INTERRUPTED);
725
726 if (RT_UNLIKELY(ASMAtomicReadBool(&pThis->fShutdown)))
727 break;
728 }
729
730 ASMAtomicXchgBool(&pShared->fFlushThrdActive, true);
731
732 uint64_t idEvtNow = ASMAtomicReadU64(&pShared->idEvt);
733 uint64_t idEvt = pThis->idEvtLast;
734 size_t cRingBufEvts = pShared->cbRingBuf / DBGF_TRACER_EVT_SZ;
735 while (idEvt < idEvtNow)
736 {
737 uint64_t idxRingBuf = idEvt % cRingBufEvts; /* This gives the index in the ring buffer for the event. */
738 PDBGFTRACEREVTHDR pEvtHdr = (PDBGFTRACEREVTHDR)(pThis->CTX_SUFF(pbRingBuf) + idxRingBuf * DBGF_TRACER_EVT_SZ);
739
740 /*
741 * If the event header contains the invalid ID the producer was interrupted or didn't get that far yet, spin a bit
742 * and wait for the ID to become valid.
743 */
744 while (ASMAtomicReadU64(&pEvtHdr->idEvt) == DBGF_TRACER_EVT_HDR_ID_INVALID)
745 RTThreadYield();
746
747 int rc = dbgfR3TracerEvtProcess(pThis, pEvtHdr);
748 if (RT_FAILURE(rc))
749 LogRelMax(10, ("DBGF: Writing event failed with %Rrc, tracing log will be incomplete!\n", rc));
750
751 ASMAtomicWriteU64(&pEvtHdr->idEvt, DBGF_TRACER_EVT_HDR_ID_INVALID);
752 idEvt++;
753 }
754
755 pThis->idEvtLast = idEvt;
756 ASMAtomicXchgBool(&pShared->fEvtsWaiting, false);
757 }
758
759 return VINF_SUCCESS;
760}
761
762
763/**
764 * Registers a possible event descriptors with the created trace log for faster subsequent operations.
765 *
766 * @returns VBox status code.
767 * @param pThis The DBGF tracer instance.
768 */
769static int dbgfR3TracerTraceLogEvtDescRegister(PDBGFTRACERINSR3 pThis)
770{
771 int rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevMmioMapEvtDesc);
772 if (RT_SUCCESS(rc))
773 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevMmioUnmapEvtDesc);
774 if (RT_SUCCESS(rc))
775 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevMmioReadEvtDesc);
776 if (RT_SUCCESS(rc))
777 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevMmioWriteEvtDesc);
778 if (RT_SUCCESS(rc))
779 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevIoPortMapEvtDesc);
780 if (RT_SUCCESS(rc))
781 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevIoPortUnmapEvtDesc);
782 if (RT_SUCCESS(rc))
783 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevIoPortReadEvtDesc);
784 if (RT_SUCCESS(rc))
785 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevIoPortWriteEvtDesc);
786 if (RT_SUCCESS(rc))
787 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevIrqEvtDesc);
788 if (RT_SUCCESS(rc))
789 rc = RTTraceLogWrAddEvtDesc(pThis->hTraceLog, &g_DevIoApicMsiEvtDesc);
790
791 return rc;
792}
793
794
795/**
796 * Initializes the R3 and shared tarcer instance data and spins up the flush thread.
797 *
798 * @returns VBox status code.
799 * @param pThis The DBGF tracer instance.
800 * @param pszTraceFilePath The path of the trace file to create.
801 */
802static int dbgfR3TracerInitR3(PDBGFTRACERINSR3 pThis, const char *pszTraceFilePath)
803{
804 PVM pVM = pThis->pVMR3;
805 PDBGFTRACERSHARED pShared = pThis->pSharedR3;
806
807 pThis->fShutdown = false;
808
809 for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aGstMemRwData); i++)
810 pThis->aGstMemRwData[i].idEvtStart = DBGF_TRACER_EVT_HDR_ID_INVALID;
811
812 /* Try to create a file based trace log. */
813 int rc = RTTraceLogWrCreateFile(&pThis->hTraceLog, RTBldCfgVersion(), pszTraceFilePath);
814 AssertLogRelRCReturn(rc, rc);
815
816 rc = dbgfR3TracerTraceLogEvtDescRegister(pThis);
817 AssertLogRelRCReturn(rc, rc);
818
819 /*
820 * Go through the whole ring buffer and initialize the event IDs of all entries
821 * to invalid values.
822 */
823 uint64_t cEvtEntries = pShared->cbRingBuf / DBGF_TRACER_EVT_SZ;
824 PDBGFTRACEREVTHDR pEvtHdr = (PDBGFTRACEREVTHDR)pThis->pbRingBufR3;
825 for (uint32_t i = 0; i < cEvtEntries; i++)
826 {
827 pEvtHdr->idEvt = DBGF_TRACER_EVT_HDR_ID_INVALID;
828 pEvtHdr++;
829 }
830
831 rc = SUPSemEventCreate(pVM->pSession, &pShared->hSupSemEvtFlush);
832 if (RT_SUCCESS(rc))
833 {
834 rc = RTThreadCreate(&pThis->hThrdFlush, dbgfR3TracerThreadFlush, pThis, 0 /*cbStack*/, RTTHREADTYPE_IO,
835 RTTHREADFLAGS_WAITABLE, "DBGFTracer");
836 if (RT_SUCCESS(rc))
837 {
838 rc = RTThreadUserWait(pThis->hThrdFlush, 10 * 1000);
839 if (RT_SUCCESS(rc))
840 {
841 return VINF_SUCCESS;
842 }
843 }
844
845 SUPSemEventClose(pVM->pSession, pShared->hSupSemEvtFlush);
846 }
847
848 return rc;
849}
850
851
852/**
853 * Creates a DBGF tracer based on the given config and returns it.
854 *
855 * @returns VBox status code.
856 * @param pVM The cross context VM structure.
857 * @param fR0Enabled Flag whether the tracer should have R0 support enabled.
858 * @param pszTraceFilePath The path of the trace file to create.
859 * @param cbRingBuf Size of the ring buffer in bytes.
860 * @param ppDbgfTracerR3 Where to store the pointer to the tracer on success.
861 */
862DECLHIDDEN(int) dbgfR3TracerCreate(PVM pVM, bool fR0Enabled, const char *pszTraceFilePath,
863 size_t cbRingBuf, PDBGFTRACERINSR3 *ppDbgfTracerR3)
864{
865 PDBGFTRACERINSR3 pThis = NULL;
866
867 /*
868 * Allocate the tracer instance.
869 */
870 if (fR0Enabled /*|| fRCEnabled*/)
871 {
872 AssertLogRel(fR0Enabled /* not possible to just enabled raw-mode atm. */);
873
874 DBGFTRACERCREATEREQ Req;
875 Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
876 Req.Hdr.cbReq = sizeof(Req);
877 Req.pTracerInsR3 = NULL;
878 Req.cbRingBuf = cbRingBuf;
879 Req.fRCEnabled = false; /*fRCEnabled;*/
880 Req.afReserved[0] = false;
881 Req.afReserved[1] = false;
882 Req.afReserved[2] = false;
883 int rc = VMMR3CallR0Emt(pVM, pVM->apCpusR3[0], VMMR0_DO_DBGF_TRACER_CREATE, 0, &Req.Hdr);
884 AssertLogRelMsgRCReturn(rc, ("VMMR0_DO_DBGF_TRACER_CREATE failed: %Rrc\n", rc), rc);
885 pThis = Req.pTracerInsR3;
886 }
887 else
888 {
889 /* The code in this else branch works by the same rules as the DBGFR0Tracer.cpp
890 code, except there is only the ring-3 components of the tracer instance.
891 Changes here may need to be reflected in DBGFR0Tracer.cpp and vice versa! */
892 uint32_t cb = sizeof(DBGFTRACERINSR3);
893 cb = RT_ALIGN_32(cb, 64);
894 const uint32_t offShared = cb;
895 cb += sizeof(DBGFTRACERSHARED) + cbRingBuf;
896 AssertLogRelMsgReturn(cb <= DBGF_MAX_TRACER_INSTANCE_SIZE_R3,
897 ("Tracer total instance size is to big: %u, max %u\n",
898 cb, DBGF_MAX_TRACER_INSTANCE_SIZE_R3),
899 VERR_ALLOCATION_TOO_BIG);
900
901 int rc = MMR3HeapAllocZEx(pVM, MM_TAG_DBGF_TRACER, cb, (void **)&pThis);
902 AssertLogRelMsgRCReturn(rc, ("Failed to allocate %zu bytes of instance data for tracer. rc=%Rrc\n",
903 cb, rc), rc);
904
905 /* Initialize it: */
906 pThis->pNextR3 = NULL;
907 pThis->pVMR3 = pVM;
908 pThis->fR0Enabled = false;
909 pThis->pSharedR3 = (PDBGFTRACERSHARED)((uint8_t *)pThis + offShared);
910 pThis->pbRingBufR3 = (uint8_t *)(pThis->pSharedR3 + 1);
911
912 pThis->pSharedR3->idEvt = 0;
913 pThis->pSharedR3->cbRingBuf = cbRingBuf;
914 pThis->pSharedR3->fEvtsWaiting = false;
915 pThis->pSharedR3->fFlushThrdActive = false;
916 }
917
918 /* Initialize the rest of the R3 tracer instance and spin up the flush thread. */
919 int rc = dbgfR3TracerInitR3(pThis, pszTraceFilePath);
920 if (RT_SUCCESS(rc))
921 {
922 *ppDbgfTracerR3 = pThis;
923 return rc;
924 }
925
926 /** @todo Cleanup. */
927 LogFlow(("dbgfR3TracerCreate: returns %Rrc\n", rc));
928 return rc;
929}
930
931
932/**
933 * Initializes and configures the tracer if configured.
934 *
935 * @returns VBox status code.
936 * @param pVM The cross context VM pointer.
937 */
938DECLHIDDEN(int) dbgfR3TracerInit(PVM pVM)
939{
940 PUVM pUVM = pVM->pUVM;
941
942 pUVM->dbgf.s.pTracerR3 = NULL;
943
944 /*
945 * Check the config and enable tracing if requested.
946 */
947 PCFGMNODE pDbgfNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "DBGF");
948 bool fTracerEnabled;
949 int rc = CFGMR3QueryBoolDef(pDbgfNode, "TracerEnabled", &fTracerEnabled, false);
950 AssertRCReturn(rc, rc);
951 if (fTracerEnabled)
952 {
953 bool fR0Enabled;
954 uint64_t cbRingBuf = 0;
955 char *pszTraceFilePath = NULL;
956 rc = CFGMR3QueryBoolDef(pDbgfNode, "TracerR0Enabled", &fR0Enabled, false);
957 if (RT_SUCCESS(rc))
958 rc = CFGMR3QueryU64Def(pDbgfNode, "TracerRingBufSz", &cbRingBuf, _4M);
959 if (RT_SUCCESS(rc))
960 rc = CFGMR3QueryStringAlloc(pDbgfNode, "TracerFilePath", &pszTraceFilePath);
961 if (RT_SUCCESS(rc))
962 {
963 AssertLogRelMsgReturn(cbRingBuf && cbRingBuf == (size_t)cbRingBuf,
964 ("Tracing ringbuffer size %#RX64 is invalid\n", cbRingBuf),
965 VERR_INVALID_PARAMETER);
966
967 rc = dbgfR3TracerCreate(pVM, fR0Enabled, pszTraceFilePath, cbRingBuf, &pUVM->dbgf.s.pTracerR3);
968 }
969
970 if (pszTraceFilePath)
971 {
972 MMR3HeapFree(pszTraceFilePath);
973 pszTraceFilePath = NULL;
974 }
975 }
976
977 return rc;
978}
979
980
981/**
982 * Terminates any configured tracer for the given VM instance.
983 *
984 * @returns nothing.
985 * @param pVM The cross context VM structure.
986 */
987DECLHIDDEN(void) dbgfR3TracerTerm(PVM pVM)
988{
989 PUVM pUVM = pVM->pUVM;
990
991 if (pUVM->dbgf.s.pTracerR3)
992 {
993 PDBGFTRACERINSR3 pThis = pUVM->dbgf.s.pTracerR3;
994 PDBGFTRACERSHARED pSharedR3 = pThis->CTX_SUFF(pShared);
995
996 /* Tear down the flush thread. */
997 ASMAtomicXchgBool(&pThis->fShutdown, true);
998 SUPSemEventSignal(pVM->pSession, pSharedR3->hSupSemEvtFlush);
999
1000 int rc = RTThreadWait(pThis->hThrdFlush, RT_MS_30SEC, NULL);
1001 AssertLogRelMsgRC(rc, ("DBGF: Waiting for the tracer flush thread to terminate failed with %Rrc\n", rc));
1002
1003 /* Close the trace log. */
1004 rc = RTTraceLogWrDestroy(pThis->hTraceLog);
1005 AssertLogRelMsgRC(rc, ("DBGF: Closing the trace log file failed with %Rrc\n", rc));
1006
1007 SUPSemEventClose(pVM->pSession, pSharedR3->hSupSemEvtFlush);
1008 /* The instance memory is freed by MM or when the R0 component terminates. */
1009 pUVM->dbgf.s.pTracerR3 = NULL;
1010 }
1011}
1012
1013
1014/**
1015 * Registers a new event source with the given name and returns a tracer event source handle.
1016 *
1017 * @returns VBox status code.
1018 * @param pVM The cross context VM structure.
1019 * @param pszName The event source name.
1020 * @param phEvtSrc Where to return the handle to the event source on success.
1021 */
1022VMMR3_INT_DECL(int) DBGFR3TracerRegisterEvtSrc(PVM pVM, const char *pszName, PDBGFTRACEREVTSRC phEvtSrc)
1023{
1024 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
1025 AssertReturn(pszName && *pszName != '\0', VERR_INVALID_PARAMETER);
1026 AssertPtrReturn(phEvtSrc, VERR_INVALID_POINTER);
1027
1028 PUVM pUVM = pVM->pUVM;
1029 PDBGFTRACERINSR3 pThis = pUVM->dbgf.s.pTracerR3;
1030
1031 DBGFTRACEREVTSRC hEvtSrc = ASMAtomicIncU64((volatile uint64_t *)&pThis->hEvtSrcNext) - 1;
1032
1033 int rc = dbgfTracerR3EvtPostSingle(pVM, pThis, hEvtSrc, DBGFTRACEREVT_SRC_REGISTER,
1034 NULL /*pvEvtDesc*/, 0 /*cbEvtDesc*/, NULL /*pidEvt*/);
1035 if (RT_SUCCESS(rc))
1036 *phEvtSrc = hEvtSrc;
1037
1038 return rc;
1039}
1040
1041
1042/**
1043 * Deregisters the given event source handle.
1044 *
1045 * @returns VBox status code.
1046 * @param pVM The cross context VM structure.
1047 * @param hEvtSrc The event source handle to deregister.
1048 */
1049VMMR3_INT_DECL(int) DBGFR3TracerDeregisterEvtSrc(PVM pVM, DBGFTRACEREVTSRC hEvtSrc)
1050{
1051 VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
1052 AssertReturn(hEvtSrc != NIL_DBGFTRACEREVTSRC, VERR_INVALID_HANDLE);
1053
1054 PUVM pUVM = pVM->pUVM;
1055 PDBGFTRACERINSR3 pThis = pUVM->dbgf.s.pTracerR3;
1056 return dbgfTracerR3EvtPostSingle(pVM, pThis, hEvtSrc, DBGFTRACEREVT_SRC_DEREGISTER,
1057 NULL /*pvEvtDesc*/, 0 /*cbEvtDesc*/, NULL /*pidEvt*/);
1058}
1059
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette