1 | /* $Id: DBGFR3FlowTrace.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * DBGF - Debugger Facility, Guest Execution Flow Tracing.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2016-2024 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 | /** @page pg_dbgf_flow DBGFR3FlowTrace - Flow Trace Interface
|
---|
30 | *
|
---|
31 | * @todo
|
---|
32 | */
|
---|
33 |
|
---|
34 |
|
---|
35 | /*********************************************************************************************************************************
|
---|
36 | * Header Files *
|
---|
37 | *********************************************************************************************************************************/
|
---|
38 | #define LOG_GROUP LOG_GROUP_DBGF
|
---|
39 | #include <VBox/vmm/dbgfflowtrace.h>
|
---|
40 | #include "DBGFInternal.h"
|
---|
41 | #include <VBox/vmm/mm.h>
|
---|
42 | #include <VBox/vmm/uvm.h>
|
---|
43 | #include <VBox/vmm/vm.h>
|
---|
44 | #include <VBox/err.h>
|
---|
45 | #include <VBox/log.h>
|
---|
46 |
|
---|
47 | #include <iprt/assert.h>
|
---|
48 | #include <iprt/semaphore.h>
|
---|
49 | #include <iprt/list.h>
|
---|
50 | #include <iprt/time.h>
|
---|
51 |
|
---|
52 |
|
---|
53 | /*********************************************************************************************************************************
|
---|
54 | * Defined Constants And Macros *
|
---|
55 | *********************************************************************************************************************************/
|
---|
56 |
|
---|
57 |
|
---|
58 |
|
---|
59 | /*********************************************************************************************************************************
|
---|
60 | * Structures and Typedefs *
|
---|
61 | *********************************************************************************************************************************/
|
---|
62 |
|
---|
63 | /** Pointer to the internal trace module instance data. */
|
---|
64 | typedef struct DBGFFLOWTRACEMODINT *PDBGFFLOWTRACEMODINT;
|
---|
65 | /** Pointer to a trace module probe location. */
|
---|
66 | typedef struct DBGFFLOWTRACEMODPROBELOC *PDBGFFLOWTRACEMODPROBELOC;
|
---|
67 |
|
---|
68 | /**
|
---|
69 | * Internal probe instance data.
|
---|
70 | */
|
---|
71 | typedef struct DBGFFLOWTRACEPROBEINT
|
---|
72 | {
|
---|
73 | /** External and internal references hold. */
|
---|
74 | volatile uint32_t cRefs;
|
---|
75 | /** Trace modules referencing this probe. */
|
---|
76 | volatile uint32_t cRefsMod;
|
---|
77 | /** The user mode VM handle. */
|
---|
78 | PUVM pUVM;
|
---|
79 | /** Description of this probe. */
|
---|
80 | char *pszDescr;
|
---|
81 | /** Overall memory consumed for this probe for each invocation. */
|
---|
82 | size_t cbProbe;
|
---|
83 | /** Number of entries for this probe. */
|
---|
84 | uint32_t cEntries;
|
---|
85 | /** Maximum number of entries the array can hold. */
|
---|
86 | uint32_t cEntriesMax;
|
---|
87 | /** Pointer to the probe entry array. */
|
---|
88 | PDBGFFLOWTRACEPROBEENTRY paEntries;
|
---|
89 | } DBGFFLOWTRACEPROBEINT;
|
---|
90 | /** Pointer to the internal probe instance data. */
|
---|
91 | typedef DBGFFLOWTRACEPROBEINT *PDBGFFLOWTRACEPROBEINT;
|
---|
92 | /** Pointer to a constant internal probe instance data. */
|
---|
93 | typedef const DBGFFLOWTRACEPROBEINT *PCDBGFFLOWTRACEPROBEINT;
|
---|
94 |
|
---|
95 | /**
|
---|
96 | * Record collected for one probe hit.
|
---|
97 | */
|
---|
98 | typedef struct DBGFFLOWTRACERECORDINT
|
---|
99 | {
|
---|
100 | /** Data list node. */
|
---|
101 | RTLISTNODE NdRecord;
|
---|
102 | /** The probe instance the record was created for. */
|
---|
103 | PDBGFFLOWTRACEPROBEINT pProbe;
|
---|
104 | /** The common probe instance data was collected for. */
|
---|
105 | PDBGFFLOWTRACEPROBEINT pProbeCmn;
|
---|
106 | /** Address of the probe location. */
|
---|
107 | DBGFADDRESS AddrProbe;
|
---|
108 | /** Reference counter. */
|
---|
109 | volatile uint32_t cRefs;
|
---|
110 | /** CPU ID this data was collected on. */
|
---|
111 | VMCPUID idCpu;
|
---|
112 | /** Sequence number for this data. */
|
---|
113 | uint64_t u64SeqNo;
|
---|
114 | /** Timestamp in nanoseconds when the data was collected. */
|
---|
115 | uint64_t u64TsCollected;
|
---|
116 | /** Pointer to the values for the common probe if available. */
|
---|
117 | PDBGFFLOWTRACEPROBEVAL paValCmn;
|
---|
118 | /** The probe values collected - size defined
|
---|
119 | * by the number of entries in the probe. */
|
---|
120 | DBGFFLOWTRACEPROBEVAL aVal[1];
|
---|
121 | } DBGFFLOWTRACERECORDINT;
|
---|
122 | /** Pointer to one collected probe data. */
|
---|
123 | typedef DBGFFLOWTRACERECORDINT *PDBGFFLOWTRACERECORDINT;
|
---|
124 |
|
---|
125 | /**
|
---|
126 | * Trace module state.
|
---|
127 | */
|
---|
128 | typedef enum DBGFFLOWTRACEMODSTATE
|
---|
129 | {
|
---|
130 | /** Invalid state. */
|
---|
131 | DBGFFLOWTRACEMODSTATE_INVALID = 0,
|
---|
132 | /** The module was created. */
|
---|
133 | DBGFFLOWTRACEMODSTATE_CREATED,
|
---|
134 | /** The module is active, no probes can be added. */
|
---|
135 | DBGFFLOWTRACEMODSTATE_ENABLED,
|
---|
136 | /** The VM is destroyed but there are still references to the module,
|
---|
137 | * functionality is limited (query records only). */
|
---|
138 | DBGFFLOWTRACEMODSTATE_VM_DESTROYED,
|
---|
139 | /** The trace module is destroyed. */
|
---|
140 | DBGFFLOWTRACEMODSTATE_DESTROYED,
|
---|
141 | /** 32bit hack. */
|
---|
142 | DBGFFLOWTRACEMODSTATE_32BIT_HACK = 0x7fffffff
|
---|
143 | } DBGFFLOWTRACEMODSTATE;
|
---|
144 |
|
---|
145 | /**
|
---|
146 | * Internal trace module instance data.
|
---|
147 | */
|
---|
148 | typedef struct DBGFFLOWTRACEMODINT
|
---|
149 | {
|
---|
150 | /** References hold for this trace module. */
|
---|
151 | volatile uint32_t cRefs;
|
---|
152 | /** The user mode VM handle. */
|
---|
153 | PUVM pUVM;
|
---|
154 | /** CPU ID the module is for. */
|
---|
155 | VMCPUID idCpu;
|
---|
156 | /** The DBGF owner handle. */
|
---|
157 | DBGFBPOWNER hBpOwner;
|
---|
158 | /** State of the trace module. */
|
---|
159 | volatile DBGFFLOWTRACEMODSTATE enmState;
|
---|
160 | /** Next free sequence number. */
|
---|
161 | volatile uint64_t u64SeqNoNext;
|
---|
162 | /** Optional ocmmon probe describing data to collect. */
|
---|
163 | PDBGFFLOWTRACEPROBEINT pProbeCmn;
|
---|
164 | /** Flags whether to record only a limited amount of data as indicated
|
---|
165 | * by cHitsLeft. */
|
---|
166 | bool fLimit;
|
---|
167 | /** Number of hits left until the module is disabled automatically. */
|
---|
168 | volatile uint32_t cHitsLeft;
|
---|
169 | /** Number of records to keep before evicting the oldest one. */
|
---|
170 | uint32_t cRecordsMax;
|
---|
171 | /** Number of records collected in this module. */
|
---|
172 | volatile uint32_t cRecords;
|
---|
173 | /** Number of probes in this trace module. */
|
---|
174 | uint32_t cProbes;
|
---|
175 | /** List of probes active for this module - DBGFFLOWTRACEMODPROBELOC. */
|
---|
176 | RTLISTANCHOR LstProbes;
|
---|
177 | /** List of collected data for this module. */
|
---|
178 | RTLISTANCHOR LstRecords;
|
---|
179 | /** Semaphore protecting access to the probe and record list. */
|
---|
180 | RTSEMFASTMUTEX hMtx;
|
---|
181 | } DBGFFLOWTRACEMODINT;
|
---|
182 | /** Pointer to a const internal trace module instance data. */
|
---|
183 | typedef const DBGFFLOWTRACEMODINT *PCDBGFFLOWTRACEMODINT;
|
---|
184 |
|
---|
185 | /**
|
---|
186 | * Trace module probe location data.
|
---|
187 | */
|
---|
188 | typedef struct DBGFFLOWTRACEMODPROBELOC
|
---|
189 | {
|
---|
190 | /** List node for the list of probes. */
|
---|
191 | RTLISTNODE NdProbes;
|
---|
192 | /** The owning trace module. */
|
---|
193 | PDBGFFLOWTRACEMODINT pTraceMod;
|
---|
194 | /** The probe instance. */
|
---|
195 | PDBGFFLOWTRACEPROBEINT pProbe;
|
---|
196 | /** Address of the probe location. */
|
---|
197 | DBGFADDRESS AddrProbe;
|
---|
198 | /** The DBGF breakpoint handle. */
|
---|
199 | DBGFBP hBp;
|
---|
200 | /** Flags controlling the collection behavior for the probe. */
|
---|
201 | uint32_t fFlags;
|
---|
202 | } DBGFFLOWTRACEMODPROBELOC;
|
---|
203 |
|
---|
204 |
|
---|
205 | /**
|
---|
206 | * Flow trace report state.
|
---|
207 | */
|
---|
208 | typedef struct DBGFFLOWTRACEREPORTINT
|
---|
209 | {
|
---|
210 | /** The user mode VM handle. */
|
---|
211 | PUVM pUVM;
|
---|
212 | /** Reference count. */
|
---|
213 | volatile uint32_t cRefs;
|
---|
214 | /** Number of records. */
|
---|
215 | uint32_t cRecords;
|
---|
216 | /** Array with handle of records - variable in size. */
|
---|
217 | PDBGFFLOWTRACERECORDINT apRec[1];
|
---|
218 | } DBGFFLOWTRACEMODREPORTINT;
|
---|
219 | /** Pointer to the internal flow trace report state. */
|
---|
220 | typedef DBGFFLOWTRACEREPORTINT *PDBGFFLOWTRACEREPORTINT;
|
---|
221 |
|
---|
222 |
|
---|
223 | /*********************************************************************************************************************************
|
---|
224 | * Internal Functions *
|
---|
225 | *********************************************************************************************************************************/
|
---|
226 |
|
---|
227 | /**
|
---|
228 | * Creates a new trace record.
|
---|
229 | *
|
---|
230 | * @returns Pointer to the create flow trace record or NULL if out of memory.
|
---|
231 | * @param pProbeLoc The probe location to allocate the record for.
|
---|
232 | * @param idCpu The CPU ID this record was created for.
|
---|
233 | * @param ppbBuf Where to store the pointer to the data buffer for this probe.
|
---|
234 | * @param ppbBufCmn Where to store the pointer to the data buffer for the common probe
|
---|
235 | * if available.
|
---|
236 | */
|
---|
237 | static PDBGFFLOWTRACERECORDINT dbgfR3FlowTraceRecordCreate(PDBGFFLOWTRACEMODPROBELOC pProbeLoc, VMCPUID idCpu,
|
---|
238 | uint8_t **ppbBuf, uint8_t **ppbBufCmn)
|
---|
239 | {
|
---|
240 | PDBGFFLOWTRACEMODINT pTraceMod = pProbeLoc->pTraceMod;
|
---|
241 | PCDBGFFLOWTRACEPROBEINT pProbe = pProbeLoc->pProbe;
|
---|
242 | PCDBGFFLOWTRACEPROBEINT pProbeCmn = pTraceMod->pProbeCmn;
|
---|
243 | size_t cbProbeBuf = pProbe->cbProbe;
|
---|
244 | if (pProbeCmn)
|
---|
245 | cbProbeBuf += pProbeCmn->cbProbe;
|
---|
246 |
|
---|
247 | *ppbBuf = NULL;
|
---|
248 | *ppbBufCmn = NULL;
|
---|
249 |
|
---|
250 | PDBGFFLOWTRACERECORDINT pRecord = (PDBGFFLOWTRACERECORDINT)MMR3HeapAllocZU(pTraceMod->pUVM, MM_TAG_DBGF_FLOWTRACE,
|
---|
251 | sizeof(DBGFFLOWTRACERECORDINT) + cbProbeBuf);
|
---|
252 | if (RT_LIKELY(pRecord))
|
---|
253 | {
|
---|
254 | DBGFR3FlowTraceProbeRetain(pProbeLoc->pProbe);
|
---|
255 | if (pProbeLoc->pTraceMod->pProbeCmn)
|
---|
256 | DBGFR3FlowTraceProbeRetain(pProbeLoc->pTraceMod->pProbeCmn);
|
---|
257 |
|
---|
258 | pRecord->pProbe = pProbeLoc->pProbe;
|
---|
259 | pRecord->pProbeCmn = pProbeLoc->pTraceMod->pProbeCmn;
|
---|
260 | pRecord->AddrProbe = pProbeLoc->AddrProbe;
|
---|
261 | pRecord->cRefs = 1;
|
---|
262 | pRecord->idCpu = idCpu;
|
---|
263 | pRecord->u64SeqNo = ASMAtomicIncU64(&pTraceMod->u64SeqNoNext);
|
---|
264 | pRecord->u64TsCollected = RTTimeNanoTS();
|
---|
265 | pRecord->paValCmn = NULL;
|
---|
266 |
|
---|
267 | *ppbBuf = (uint8_t *)&pRecord->aVal[pProbe->cEntries];
|
---|
268 |
|
---|
269 | if (pProbeCmn)
|
---|
270 | {
|
---|
271 | size_t offValCmn = pProbe->cbProbe - pProbe->cEntries * sizeof(DBGFFLOWTRACEPROBEVAL);
|
---|
272 | pRecord->paValCmn = (PDBGFFLOWTRACEPROBEVAL)(*ppbBuf + offValCmn);
|
---|
273 | *ppbBufCmn = (uint8_t *)&pRecord->paValCmn[pProbeCmn->cEntries];
|
---|
274 | }
|
---|
275 | }
|
---|
276 |
|
---|
277 | return pRecord;
|
---|
278 | }
|
---|
279 |
|
---|
280 |
|
---|
281 | /**
|
---|
282 | * Destroys the given record.
|
---|
283 | *
|
---|
284 | * @param pRecord The record to destroy.
|
---|
285 | */
|
---|
286 | static void dbgfR3FlowTraceRecordDestroy(PDBGFFLOWTRACERECORDINT pRecord)
|
---|
287 | {
|
---|
288 | DBGFR3FlowTraceProbeRelease(pRecord->pProbe);
|
---|
289 | pRecord->pProbe = NULL;
|
---|
290 | MMR3HeapFree(pRecord);
|
---|
291 | }
|
---|
292 |
|
---|
293 |
|
---|
294 | /**
|
---|
295 | * Creates a new flow trace report which can hold the given amount o records.
|
---|
296 | *
|
---|
297 | * @returns Pointer to the newly created report state or NULL if out of memory.
|
---|
298 | * @param pUVM The usermode VM handle.
|
---|
299 | * @param cRecords Number of records the report shoudld be able to hold.
|
---|
300 | */
|
---|
301 | static PDBGFFLOWTRACEREPORTINT dbgfR3FlowTraceReportCreate(PUVM pUVM, uint32_t cRecords)
|
---|
302 | {
|
---|
303 | PDBGFFLOWTRACEREPORTINT pReport = (PDBGFFLOWTRACEREPORTINT)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_FLOWTRACE,
|
---|
304 | RT_UOFFSETOF_DYN(DBGFFLOWTRACEREPORTINT, apRec[cRecords]));
|
---|
305 | if (RT_LIKELY(pReport))
|
---|
306 | {
|
---|
307 | pReport->pUVM = pUVM;
|
---|
308 | pReport->cRefs = 1;
|
---|
309 | pReport->cRecords = cRecords;
|
---|
310 | }
|
---|
311 |
|
---|
312 | return pReport;
|
---|
313 | }
|
---|
314 |
|
---|
315 |
|
---|
316 | /**
|
---|
317 | * Destroys the given report releasing all references hold to the containing records.
|
---|
318 | *
|
---|
319 | * @param pReport The report to destroy.
|
---|
320 | */
|
---|
321 | static void dbgfR3FlowTraceReportDestroy(PDBGFFLOWTRACEREPORTINT pReport)
|
---|
322 | {
|
---|
323 | for (uint32_t i = 0; i < pReport->cRecords; i++)
|
---|
324 | DBGFR3FlowTraceRecordRelease(pReport->apRec[i]);
|
---|
325 | MMR3HeapFree(pReport);
|
---|
326 | }
|
---|
327 |
|
---|
328 |
|
---|
329 | /**
|
---|
330 | * Queries the given register and returns the value as a guest pointer.
|
---|
331 | *
|
---|
332 | * @returns VBox status code.
|
---|
333 | * @param pUVM The usermode VM handle.
|
---|
334 | * @param idCpu VM CPU identifier.
|
---|
335 | * @param pszReg The register name to query.
|
---|
336 | * @param pGCPtr Where to store the register value on success.
|
---|
337 | */
|
---|
338 | static int dbgfR3FlowTraceModProbeQueryRegAsGCPtr(PUVM pUVM, VMCPUID idCpu, const char *pszReg,
|
---|
339 | PRTGCPTR pGCPtr)
|
---|
340 | {
|
---|
341 | DBGFREGVAL Val;
|
---|
342 | DBGFREGVALTYPE enmValType;
|
---|
343 | int rc = DBGFR3RegNmQuery(pUVM, idCpu, pszReg, &Val, &enmValType);
|
---|
344 | if (RT_SUCCESS(rc))
|
---|
345 | {
|
---|
346 | switch (enmValType)
|
---|
347 | {
|
---|
348 | case DBGFREGVALTYPE_U8:
|
---|
349 | *pGCPtr = Val.u8;
|
---|
350 | break;
|
---|
351 | case DBGFREGVALTYPE_U16:
|
---|
352 | *pGCPtr = Val.u16;
|
---|
353 | break;
|
---|
354 | case DBGFREGVALTYPE_U32:
|
---|
355 | *pGCPtr = Val.u32;
|
---|
356 | break;
|
---|
357 | case DBGFREGVALTYPE_U64:
|
---|
358 | *pGCPtr = Val.u64;
|
---|
359 | break;
|
---|
360 | case DBGFREGVALTYPE_U128:
|
---|
361 | case DBGFREGVALTYPE_R80:
|
---|
362 | case DBGFREGVALTYPE_DTR:
|
---|
363 | default:
|
---|
364 | rc = VERR_INVALID_PARAMETER;
|
---|
365 | }
|
---|
366 | }
|
---|
367 |
|
---|
368 | return rc;
|
---|
369 | }
|
---|
370 |
|
---|
371 |
|
---|
372 | /**
|
---|
373 | * Resolves the guest address from an indirect memory probe entry.
|
---|
374 | *
|
---|
375 | * @returns VBox status code.
|
---|
376 | * @param pUVM The usermode VM handle.
|
---|
377 | * @param idCpu VM CPU identifier.
|
---|
378 | * @param pEntry The probe entry.
|
---|
379 | * @param pAddr Where to store the address on success.
|
---|
380 | */
|
---|
381 | static int dbgfR3FlowTraceModProbeResolveIndirectAddr(PUVM pUVM, VMCPUID idCpu, PDBGFFLOWTRACEPROBEENTRY pEntry,
|
---|
382 | PDBGFADDRESS pAddr)
|
---|
383 | {
|
---|
384 | Assert(pEntry->enmType == DBGFFLOWTRACEPROBEENTRYTYPE_INDIRECT_MEM);
|
---|
385 |
|
---|
386 | RTGCPTR GCPtrBase = 0;
|
---|
387 | RTGCPTR GCPtrIndex = 0;
|
---|
388 | int rc = dbgfR3FlowTraceModProbeQueryRegAsGCPtr(pUVM, idCpu, pEntry->Type.IndirectMem.RegBase.pszName,
|
---|
389 | &GCPtrBase);
|
---|
390 | if ( RT_SUCCESS(rc)
|
---|
391 | && pEntry->Type.IndirectMem.RegIndex.pszName)
|
---|
392 | rc = dbgfR3FlowTraceModProbeQueryRegAsGCPtr(pUVM, idCpu, pEntry->Type.IndirectMem.RegIndex.pszName,
|
---|
393 | &GCPtrIndex);
|
---|
394 | if (RT_SUCCESS(rc))
|
---|
395 | {
|
---|
396 | RTGCPTR GCPtr = GCPtrBase + GCPtrIndex * pEntry->Type.IndirectMem.uScale;
|
---|
397 | DBGFR3AddrFromFlat(pUVM, pAddr, GCPtr);
|
---|
398 | if (pEntry->Type.IndirectMem.iOffset > 0)
|
---|
399 | DBGFR3AddrAdd(pAddr, pEntry->Type.IndirectMem.iOffset);
|
---|
400 | else if (pEntry->Type.IndirectMem.iOffset < 0)
|
---|
401 | DBGFR3AddrSub(pAddr, -pEntry->Type.IndirectMem.iOffset);
|
---|
402 | }
|
---|
403 |
|
---|
404 | return rc;
|
---|
405 | }
|
---|
406 |
|
---|
407 |
|
---|
408 | /**
|
---|
409 | * Destroys the given flow trace module freeing all allocated resources.
|
---|
410 | *
|
---|
411 | * @param pThis The flow trace module instance data.
|
---|
412 | */
|
---|
413 | static void dbgfR3FlowTraceModDestroy(PDBGFFLOWTRACEMODINT pThis)
|
---|
414 | {
|
---|
415 | if (ASMAtomicReadU32((volatile uint32_t *)&pThis->enmState) == DBGFFLOWTRACEMODSTATE_ENABLED)
|
---|
416 | {
|
---|
417 | int rc = DBGFR3FlowTraceModDisable(pThis);
|
---|
418 | AssertRC(rc);
|
---|
419 | }
|
---|
420 |
|
---|
421 | Assert( pThis->enmState == DBGFFLOWTRACEMODSTATE_CREATED
|
---|
422 | || pThis->enmState == DBGFFLOWTRACEMODSTATE_VM_DESTROYED);
|
---|
423 |
|
---|
424 | /* Do the cleanup under the semaphore. */
|
---|
425 | RTSemFastMutexRequest(pThis->hMtx);
|
---|
426 | if (pThis->pProbeCmn)
|
---|
427 | DBGFR3FlowTraceProbeRelease(pThis->pProbeCmn);
|
---|
428 |
|
---|
429 | PDBGFFLOWTRACEMODPROBELOC pIt, pItNext;
|
---|
430 | RTListForEachSafe(&pThis->LstProbes, pIt, pItNext, DBGFFLOWTRACEMODPROBELOC, NdProbes)
|
---|
431 | {
|
---|
432 | RTListNodeRemove(&pIt->NdProbes);
|
---|
433 | ASMAtomicDecU32(&pIt->pProbe->cRefsMod);
|
---|
434 | DBGFR3FlowTraceProbeRelease(pIt->pProbe);
|
---|
435 | MMR3HeapFree(pIt);
|
---|
436 | }
|
---|
437 |
|
---|
438 | PDBGFFLOWTRACERECORDINT pRecIt, pRecItNext;
|
---|
439 | RTListForEachSafe(&pThis->LstRecords, pRecIt, pRecItNext, DBGFFLOWTRACERECORDINT, NdRecord)
|
---|
440 | {
|
---|
441 | RTListNodeRemove(&pRecIt->NdRecord);
|
---|
442 | DBGFR3FlowTraceRecordRelease(pRecIt);
|
---|
443 | }
|
---|
444 |
|
---|
445 | DBGFR3BpOwnerDestroy(pThis->pUVM, pThis->hBpOwner);
|
---|
446 | RTSemFastMutexRelease(pThis->hMtx);
|
---|
447 | RTSemFastMutexDestroy(pThis->hMtx);
|
---|
448 | MMR3HeapFree(pThis);
|
---|
449 | }
|
---|
450 |
|
---|
451 |
|
---|
452 | /**
|
---|
453 | * Checks whether the given basic block and address intersect.
|
---|
454 | *
|
---|
455 | * @returns true if they intersect, false otherwise.
|
---|
456 | * @param pAddr The address to check for.
|
---|
457 | * @param pAddrStart The start address.
|
---|
458 | * @param pAddrLast The last address.
|
---|
459 | */
|
---|
460 | static bool dbgfR3FlowTraceAddrIntersect(PDBGFADDRESS pAddr, PDBGFADDRESS pAddrStart,
|
---|
461 | PDBGFADDRESS pAddrLast)
|
---|
462 | {
|
---|
463 | return (pAddrStart->Sel == pAddr->Sel)
|
---|
464 | && (pAddrStart->off <= pAddr->off)
|
---|
465 | && (pAddrLast->off >= pAddr->off);
|
---|
466 | }
|
---|
467 |
|
---|
468 |
|
---|
469 | /**
|
---|
470 | * Matches a single value against a given filter value.
|
---|
471 | *
|
---|
472 | * @returns Flag whether the value matches against the single value.
|
---|
473 | * @param pVal The value to match.
|
---|
474 | * @param pValFilter The value filter to match against.
|
---|
475 | */
|
---|
476 | static bool dbgfR3FlowTraceRecordMatchSingleValue(PCDBGFFLOWTRACEPROBEVAL pVal,
|
---|
477 | PCDBGFFLOWTRACEPROBEVAL pValFilter)
|
---|
478 | {
|
---|
479 | if (pVal->pProbeEntry->enmType != pValFilter->pProbeEntry->enmType)
|
---|
480 | return false;
|
---|
481 |
|
---|
482 | switch (pVal->pProbeEntry->enmType)
|
---|
483 | {
|
---|
484 | case DBGFFLOWTRACEPROBEENTRYTYPE_REG:
|
---|
485 | {
|
---|
486 | if (pVal->Type.Reg.enmType != pValFilter->Type.Reg.enmType)
|
---|
487 | return false;
|
---|
488 |
|
---|
489 | if (strcmp(pVal->Type.Reg.pszName, pValFilter->Type.Reg.pszName))
|
---|
490 | return false;
|
---|
491 |
|
---|
492 | switch (pVal->Type.Reg.enmType)
|
---|
493 | {
|
---|
494 | case DBGFREGVALTYPE_U8:
|
---|
495 | if (pVal->Type.Reg.Val.u8 != pValFilter->Type.Reg.Val.u8)
|
---|
496 | return false;
|
---|
497 | break;
|
---|
498 | case DBGFREGVALTYPE_U16:
|
---|
499 | if (pVal->Type.Reg.Val.u16 != pValFilter->Type.Reg.Val.u16)
|
---|
500 | return false;
|
---|
501 | break;
|
---|
502 | case DBGFREGVALTYPE_U32:
|
---|
503 | if (pVal->Type.Reg.Val.u32 != pValFilter->Type.Reg.Val.u32)
|
---|
504 | return false;
|
---|
505 | break;
|
---|
506 | case DBGFREGVALTYPE_U64:
|
---|
507 | if (pVal->Type.Reg.Val.u64 != pValFilter->Type.Reg.Val.u64)
|
---|
508 | return false;
|
---|
509 | break;
|
---|
510 | case DBGFREGVALTYPE_U128:
|
---|
511 | if (memcmp(&pVal->Type.Reg.Val.u128, &pValFilter->Type.Reg.Val.u128,
|
---|
512 | sizeof(RTUINT128U)))
|
---|
513 | return false;
|
---|
514 | break;
|
---|
515 | case DBGFREGVALTYPE_R80:
|
---|
516 | if (memcmp(&pVal->Type.Reg.Val.r80Ex, &pValFilter->Type.Reg.Val.r80Ex,
|
---|
517 | sizeof(RTFLOAT80U2)))
|
---|
518 | return false;
|
---|
519 | break;
|
---|
520 | case DBGFREGVALTYPE_DTR:
|
---|
521 | if ( pVal->Type.Reg.Val.dtr.u64Base != pValFilter->Type.Reg.Val.dtr.u64Base
|
---|
522 | || pVal->Type.Reg.Val.dtr.u32Limit != pValFilter->Type.Reg.Val.dtr.u32Limit)
|
---|
523 | return false;
|
---|
524 | break;
|
---|
525 | default:
|
---|
526 | AssertFailed();
|
---|
527 | return false;
|
---|
528 | }
|
---|
529 | break;
|
---|
530 | }
|
---|
531 | case DBGFFLOWTRACEPROBEENTRYTYPE_CONST_MEM:
|
---|
532 | case DBGFFLOWTRACEPROBEENTRYTYPE_INDIRECT_MEM:
|
---|
533 | if ( memcmp(&pVal->Type.Mem.Addr, &pValFilter->Type.Mem.Addr,
|
---|
534 | sizeof(DBGFADDRESS))
|
---|
535 | || pVal->Type.Mem.cbBuf != pValFilter->Type.Mem.cbBuf
|
---|
536 | || memcmp(pVal->Type.Mem.pvBuf, pValFilter->Type.Mem.pvBuf,
|
---|
537 | pValFilter->Type.Mem.cbBuf))
|
---|
538 | return false;
|
---|
539 | break;
|
---|
540 | default:
|
---|
541 | AssertFailed();
|
---|
542 | return false;
|
---|
543 | }
|
---|
544 |
|
---|
545 | return true;
|
---|
546 | }
|
---|
547 |
|
---|
548 |
|
---|
549 | /**
|
---|
550 | * Matches the given values against the filter values returning a flag whether they match.
|
---|
551 | *
|
---|
552 | * @returns Flag whether the given values match the filter.
|
---|
553 | * @param paVal Pointer to the array of values.
|
---|
554 | * @param cVals Number of values in the array.
|
---|
555 | * @param paValFilter Pointer to the filter values.
|
---|
556 | * @param cValsFilter Number of entries in the filter values.
|
---|
557 | */
|
---|
558 | static bool dbgfR3FlowTraceRecordMatchValues(PCDBGFFLOWTRACEPROBEVAL paVal, uint32_t cVals,
|
---|
559 | PCDBGFFLOWTRACEPROBEVAL paValFilter, uint32_t cValsFilter)
|
---|
560 | {
|
---|
561 | bool fMatch = false;
|
---|
562 |
|
---|
563 | /*
|
---|
564 | * The order in which the filters and values are doesn't need to match but for every filter
|
---|
565 | * there should be at least one entry matching.
|
---|
566 | */
|
---|
567 | while ( cValsFilter-- > 0
|
---|
568 | && fMatch)
|
---|
569 | {
|
---|
570 | for (uint32_t i = 0; i < cVals; i++)
|
---|
571 | {
|
---|
572 | fMatch = dbgfR3FlowTraceRecordMatchSingleValue(&paVal[i], paValFilter);
|
---|
573 | if (fMatch)
|
---|
574 | break;
|
---|
575 | }
|
---|
576 | paValFilter++;
|
---|
577 | }
|
---|
578 |
|
---|
579 | return fMatch;
|
---|
580 | }
|
---|
581 |
|
---|
582 |
|
---|
583 | /**
|
---|
584 | * Checks the given record against the given filter, returning whether the filter
|
---|
585 | * matches.
|
---|
586 | *
|
---|
587 | * @returns Flag whether the record matches the given filter.
|
---|
588 | * @param pRecord The record to check.
|
---|
589 | * @param pFilter The filter to check against.
|
---|
590 | */
|
---|
591 | static bool dbgfR3FlowTraceRecordMatchSingleFilter(PDBGFFLOWTRACERECORDINT pRecord,
|
---|
592 | PDBGFFLOWTRACEREPORTFILTER pFilter)
|
---|
593 | {
|
---|
594 | bool fMatch = false;
|
---|
595 |
|
---|
596 | switch (pFilter->enmType)
|
---|
597 | {
|
---|
598 | case DBGFFLOWTRACEREPORTFILTERTYPE_SEQ_NUM:
|
---|
599 | {
|
---|
600 | if ( pRecord->u64SeqNo >= pFilter->Type.SeqNo.u64SeqNoFirst
|
---|
601 | && pRecord->u64SeqNo <= pFilter->Type.SeqNo.u64SeqNoLast)
|
---|
602 | fMatch = true;
|
---|
603 | break;
|
---|
604 | }
|
---|
605 | case DBGFFLOWTRACEREPORTFILTERTYPE_TIMESTAMP:
|
---|
606 | {
|
---|
607 | if ( pRecord->u64TsCollected >= pFilter->Type.Timestamp.u64TsFirst
|
---|
608 | && pRecord->u64TsCollected <= pFilter->Type.Timestamp.u64TsLast)
|
---|
609 | fMatch = true;
|
---|
610 | break;
|
---|
611 | }
|
---|
612 | case DBGFFLOWTRACEREPORTFILTERTYPE_ADDR:
|
---|
613 | {
|
---|
614 | if (dbgfR3FlowTraceAddrIntersect(&pRecord->AddrProbe,
|
---|
615 | &pFilter->Type.Addr.AddrStart,
|
---|
616 | &pFilter->Type.Addr.AddrLast))
|
---|
617 | fMatch = true;
|
---|
618 | break;
|
---|
619 | }
|
---|
620 | case DBGFFLOWTRACEREPORTFILTERTYPE_VMCPU_ID:
|
---|
621 | {
|
---|
622 | if ( pRecord->idCpu >= pFilter->Type.VCpuId.idCpuStart
|
---|
623 | && pRecord->idCpu <= pFilter->Type.VCpuId.idCpuLast)
|
---|
624 | fMatch = true;
|
---|
625 | break;
|
---|
626 | }
|
---|
627 | case DBGFFLOWTRACEREPORTFILTERTYPE_PROBE_DATA:
|
---|
628 | {
|
---|
629 | if (pFilter->Type.ProbeData.fValCmn)
|
---|
630 | {
|
---|
631 | if (pRecord->paValCmn)
|
---|
632 | {
|
---|
633 | PCDBGFFLOWTRACEPROBEINT pProbeCmn = pRecord->pProbeCmn;
|
---|
634 | AssertPtr(pProbeCmn);
|
---|
635 |
|
---|
636 | fMatch = dbgfR3FlowTraceRecordMatchValues(pRecord->paValCmn, pProbeCmn->cEntries,
|
---|
637 | pFilter->Type.ProbeData.paVal,
|
---|
638 | pFilter->Type.ProbeData.cVals);
|
---|
639 | }
|
---|
640 | }
|
---|
641 | else
|
---|
642 | fMatch = dbgfR3FlowTraceRecordMatchValues(&pRecord->aVal[0], pRecord->pProbe->cEntries,
|
---|
643 | pFilter->Type.ProbeData.paVal, pFilter->Type.ProbeData.cVals);
|
---|
644 | break;
|
---|
645 | }
|
---|
646 | default:
|
---|
647 | AssertMsgFailed(("Invalid filter type %u!\n", pFilter->enmType));
|
---|
648 | }
|
---|
649 |
|
---|
650 | return fMatch;
|
---|
651 | }
|
---|
652 |
|
---|
653 |
|
---|
654 | /**
|
---|
655 | * Checks the given record against the given filters.
|
---|
656 | *
|
---|
657 | * @returns Flag whether the record matches the filters.
|
---|
658 | * @param pRecord The record to check.
|
---|
659 | * @param paFilters Array of filters to check.
|
---|
660 | * @param cFilters Number of filters in the array.
|
---|
661 | * @param enmOp How the record should match against the filters.
|
---|
662 | */
|
---|
663 | static bool dbgfR3FlowTraceDoesRecordMatchFilter(PDBGFFLOWTRACERECORDINT pRecord,
|
---|
664 | PDBGFFLOWTRACEREPORTFILTER paFilters,
|
---|
665 | uint32_t cFilters, DBGFFLOWTRACEREPORTFILTEROP enmOp)
|
---|
666 | {
|
---|
667 | bool fMatch = false;
|
---|
668 |
|
---|
669 | if (enmOp == DBGFFLOWTRACEREPORTFILTEROP_AND)
|
---|
670 | {
|
---|
671 | fMatch = true;
|
---|
672 | while (cFilters-- > 0)
|
---|
673 | {
|
---|
674 | if (!dbgfR3FlowTraceRecordMatchSingleFilter(pRecord, &paFilters[cFilters]))
|
---|
675 | {
|
---|
676 | fMatch = false;
|
---|
677 | break;
|
---|
678 | }
|
---|
679 | }
|
---|
680 | }
|
---|
681 | else if (enmOp == DBGFFLOWTRACEREPORTFILTEROP_OR)
|
---|
682 | {
|
---|
683 | while (cFilters-- > 0)
|
---|
684 | {
|
---|
685 | if (dbgfR3FlowTraceRecordMatchSingleFilter(pRecord, &paFilters[cFilters]))
|
---|
686 | {
|
---|
687 | fMatch = true;
|
---|
688 | break;
|
---|
689 | }
|
---|
690 | }
|
---|
691 | }
|
---|
692 | else
|
---|
693 | AssertMsgFailed(("Invalid filter operation %u!\n", enmOp));
|
---|
694 |
|
---|
695 | return fMatch;
|
---|
696 | }
|
---|
697 |
|
---|
698 |
|
---|
699 | /**
|
---|
700 | * Collects all the data specified in the given probe.
|
---|
701 | *
|
---|
702 | * @returns Flag whether to enter the debugger.
|
---|
703 | * @param pUVM The user mode VM handle.
|
---|
704 | * @param idCpu The virtual CPU ID.
|
---|
705 | * @param pTraceMod The trace module instance.
|
---|
706 | * @param pAddrProbe Location of the probe, NULL if a common probe.
|
---|
707 | * @param pProbe The probe instance.
|
---|
708 | * @param pVal Pointer to the array of values to fill.
|
---|
709 | * @param pbBuf Poitner to the memory buffer holding additional data.
|
---|
710 | */
|
---|
711 | static bool dbgfR3FlowTraceModProbeCollectData(PUVM pUVM, VMCPUID idCpu,
|
---|
712 | PDBGFFLOWTRACEMODINT pTraceMod,
|
---|
713 | PCDBGFADDRESS pAddrProbe,
|
---|
714 | PDBGFFLOWTRACEPROBEINT pProbe,
|
---|
715 | PDBGFFLOWTRACEPROBEVAL pVal, uint8_t *pbBuf)
|
---|
716 | {
|
---|
717 | bool fDbgDefer = false;
|
---|
718 |
|
---|
719 | for (uint32_t i = 0; i < pProbe->cEntries; i++)
|
---|
720 | {
|
---|
721 | int rc;
|
---|
722 | PDBGFFLOWTRACEPROBEENTRY pEntry = &pProbe->paEntries[i];
|
---|
723 |
|
---|
724 | pVal->pProbeEntry = pEntry;
|
---|
725 |
|
---|
726 | switch (pEntry->enmType)
|
---|
727 | {
|
---|
728 | case DBGFFLOWTRACEPROBEENTRYTYPE_REG:
|
---|
729 | rc = DBGFR3RegNmQuery(pUVM, idCpu, pEntry->Type.Reg.pszName,
|
---|
730 | &pVal->Type.Reg.Val, &pVal->Type.Reg.enmType);
|
---|
731 | AssertRC(rc);
|
---|
732 | pVal->Type.Reg.pszName = pEntry->Type.Reg.pszName;
|
---|
733 | break;
|
---|
734 | case DBGFFLOWTRACEPROBEENTRYTYPE_INDIRECT_MEM:
|
---|
735 | {
|
---|
736 | DBGFADDRESS Addr;
|
---|
737 | rc = dbgfR3FlowTraceModProbeResolveIndirectAddr(pUVM, idCpu, pEntry, &Addr);
|
---|
738 | if (RT_SUCCESS(rc))
|
---|
739 | {
|
---|
740 | pVal->Type.Mem.pvBuf = pbBuf;
|
---|
741 | pVal->Type.Mem.cbBuf = pEntry->Type.IndirectMem.cbMem;
|
---|
742 | pVal->Type.Mem.Addr = Addr;
|
---|
743 | rc = DBGFR3MemRead(pUVM, idCpu, &pVal->Type.Mem.Addr, pbBuf,
|
---|
744 | pVal->Type.Mem.cbBuf);
|
---|
745 | AssertRC(rc);
|
---|
746 | pbBuf += pVal->Type.Mem.cbBuf;
|
---|
747 | }
|
---|
748 | break;
|
---|
749 | }
|
---|
750 | case DBGFFLOWTRACEPROBEENTRYTYPE_CONST_MEM:
|
---|
751 | pVal->Type.Mem.pvBuf = pbBuf;
|
---|
752 | pVal->Type.Mem.cbBuf = pEntry->Type.ConstMem.cbMem;
|
---|
753 | pVal->Type.Mem.Addr = pEntry->Type.ConstMem.AddrMem;
|
---|
754 | rc = DBGFR3MemRead(pUVM, idCpu, &pVal->Type.Mem.Addr, pbBuf,
|
---|
755 | pVal->Type.Mem.cbBuf);
|
---|
756 | AssertRC(rc);
|
---|
757 | pbBuf += pVal->Type.Mem.cbBuf;
|
---|
758 | break;
|
---|
759 | case DBGFFLOWTRACEPROBEENTRYTYPE_CALLBACK:
|
---|
760 | rc = pEntry->Type.Callback.pfnCallback(pUVM, idCpu, pTraceMod,
|
---|
761 | pAddrProbe, pProbe, pEntry,
|
---|
762 | pEntry->Type.Callback.pvUser);
|
---|
763 | break;
|
---|
764 | case DBGFFLOWTRACEPROBEENTRYTYPE_DEBUGGER:
|
---|
765 | fDbgDefer = true;
|
---|
766 | break;
|
---|
767 | default:
|
---|
768 | AssertFailed();
|
---|
769 | }
|
---|
770 |
|
---|
771 | pVal++;
|
---|
772 | }
|
---|
773 |
|
---|
774 | return fDbgDefer;
|
---|
775 | }
|
---|
776 |
|
---|
777 |
|
---|
778 | /**
|
---|
779 | * @callback_method_impl{FNDBGFBPHIT}
|
---|
780 | */
|
---|
781 | static DECLCALLBACK(VBOXSTRICTRC) dbgfR3FlowTraceModProbeFiredWorker(PVM pVM, VMCPUID idCpu, void *pvUserBp, DBGFBP hBp, PCDBGFBPPUB pBpPub, uint16_t fFlags)
|
---|
782 | {
|
---|
783 | RT_NOREF(pVM, hBp, pBpPub, fFlags);
|
---|
784 | LogFlowFunc(("pVM=%#p idCpu=%u pvUserBp=%#p hBp=%#x pBpPub=%p\n",
|
---|
785 | pVM, idCpu, pvUserBp, hBp, pBpPub));
|
---|
786 |
|
---|
787 | PDBGFFLOWTRACEMODPROBELOC pProbeLoc = (PDBGFFLOWTRACEMODPROBELOC)pvUserBp;
|
---|
788 | PDBGFFLOWTRACEPROBEINT pProbe = pProbeLoc->pProbe;
|
---|
789 | PDBGFFLOWTRACEMODINT pTraceMod = pProbeLoc->pTraceMod;
|
---|
790 | bool fDisabledModule = false;
|
---|
791 | bool fDbgDefer = false;
|
---|
792 |
|
---|
793 | /* Check whether the trace module is still active and we are tracing the correct VCPU. */
|
---|
794 | if (ASMAtomicReadU32((volatile uint32_t *)&pTraceMod->enmState) != DBGFFLOWTRACEMODSTATE_ENABLED
|
---|
795 | || ( idCpu != pTraceMod->idCpu
|
---|
796 | && pTraceMod->idCpu != VMCPUID_ANY))
|
---|
797 | return VINF_SUCCESS;
|
---|
798 |
|
---|
799 | if ( pTraceMod->fLimit
|
---|
800 | && ASMAtomicReadU32(&pTraceMod->cHitsLeft))
|
---|
801 | {
|
---|
802 | uint32_t cHitsLeftNew = ASMAtomicDecU32(&pTraceMod->cHitsLeft);
|
---|
803 | if (cHitsLeftNew > cHitsLeftNew + 1) /* Underflow => reached the limit. */
|
---|
804 | {
|
---|
805 | ASMAtomicIncU32(&pTraceMod->cHitsLeft);
|
---|
806 | return VINF_SUCCESS;
|
---|
807 | }
|
---|
808 |
|
---|
809 | if (!cHitsLeftNew)
|
---|
810 | {
|
---|
811 | /* We got the last record, disable the trace module. */
|
---|
812 | fDisabledModule = ASMAtomicCmpXchgU32((volatile uint32_t *)&pTraceMod->enmState, DBGFFLOWTRACEMODSTATE_CREATED,
|
---|
813 | DBGFFLOWTRACEMODSTATE_ENABLED);
|
---|
814 | }
|
---|
815 | }
|
---|
816 |
|
---|
817 | uint8_t *pbBuf = NULL;
|
---|
818 | uint8_t *pbBufCmn = NULL;
|
---|
819 | PDBGFFLOWTRACERECORDINT pRecord = dbgfR3FlowTraceRecordCreate(pProbeLoc, idCpu, &pbBuf, &pbBufCmn);
|
---|
820 | if (pRecord)
|
---|
821 | {
|
---|
822 | fDbgDefer = dbgfR3FlowTraceModProbeCollectData(pTraceMod->pUVM, idCpu, pTraceMod, &pProbeLoc->AddrProbe, pProbe,
|
---|
823 | &pRecord->aVal[0], pbBuf);
|
---|
824 | if (pTraceMod->pProbeCmn)
|
---|
825 | fDbgDefer = dbgfR3FlowTraceModProbeCollectData(pTraceMod->pUVM, idCpu, pTraceMod, NULL, pTraceMod->pProbeCmn,
|
---|
826 | pRecord->paValCmn, pbBufCmn);
|
---|
827 |
|
---|
828 | RTSemFastMutexRequest(pTraceMod->hMtx);
|
---|
829 | uint32_t cRecordsNew = ASMAtomicIncU32(&pTraceMod->cRecords);
|
---|
830 | RTListAppend(&pTraceMod->LstRecords, &pRecord->NdRecord);
|
---|
831 | if ( (cRecordsNew > pTraceMod->cRecordsMax)
|
---|
832 | && pTraceMod->cRecordsMax > 0)
|
---|
833 | {
|
---|
834 | /* Get the first record and destroy it. */
|
---|
835 | pRecord = RTListRemoveFirst(&pTraceMod->LstRecords, DBGFFLOWTRACERECORDINT, NdRecord);
|
---|
836 | AssertPtr(pRecord);
|
---|
837 | DBGFR3FlowTraceRecordRelease(pRecord);
|
---|
838 | ASMAtomicDecU32(&pTraceMod->cRecords);
|
---|
839 | }
|
---|
840 | RTSemFastMutexRelease(pTraceMod->hMtx);
|
---|
841 | }
|
---|
842 |
|
---|
843 | if (fDisabledModule)
|
---|
844 | {
|
---|
845 | int rc = DBGFR3FlowTraceModDisable(pTraceMod);
|
---|
846 | AssertRC(rc);
|
---|
847 | }
|
---|
848 |
|
---|
849 | return fDbgDefer ? VINF_DBGF_BP_HALT : VINF_SUCCESS;
|
---|
850 | }
|
---|
851 |
|
---|
852 |
|
---|
853 | /**
|
---|
854 | * Worker for DBGFR3FlowTraceModEnable(), doing the work in an EMT rendezvous point to
|
---|
855 | * ensure no probe is hit in an inconsistent state.
|
---|
856 | *
|
---|
857 | * @returns Strict VBox status code.
|
---|
858 | * @param pVM The VM instance data.
|
---|
859 | * @param pVCpu The virtual CPU we execute on.
|
---|
860 | * @param pvUser Opaque user data.
|
---|
861 | */
|
---|
862 | static DECLCALLBACK(VBOXSTRICTRC) dbgfR3FlowTraceModEnableWorker(PVM pVM, PVMCPU pVCpu, void *pvUser)
|
---|
863 | {
|
---|
864 | RT_NOREF2(pVM, pVCpu);
|
---|
865 | PDBGFFLOWTRACEMODINT pThis = (PDBGFFLOWTRACEMODINT)pvUser;
|
---|
866 | PDBGFFLOWTRACEMODPROBELOC pProbeLoc = NULL;
|
---|
867 | int rc = VINF_SUCCESS;
|
---|
868 |
|
---|
869 | pThis->enmState = DBGFFLOWTRACEMODSTATE_ENABLED;
|
---|
870 |
|
---|
871 | RTListForEach(&pThis->LstProbes, pProbeLoc, DBGFFLOWTRACEMODPROBELOC, NdProbes)
|
---|
872 | {
|
---|
873 | uint16_t fBpFlags = DBGF_BP_F_ENABLED;
|
---|
874 |
|
---|
875 | if (pProbeLoc->fFlags & DBGF_FLOW_TRACE_PROBE_ADD_F_BEFORE_EXEC)
|
---|
876 | fBpFlags |= DBGF_BP_F_HIT_EXEC_BEFORE;
|
---|
877 | if (pProbeLoc->fFlags & DBGF_FLOW_TRACE_PROBE_ADD_F_AFTER_EXEC)
|
---|
878 | fBpFlags |= DBGF_BP_F_HIT_EXEC_AFTER;
|
---|
879 |
|
---|
880 | rc = DBGFR3BpSetInt3Ex(pThis->pUVM, pThis->hBpOwner, pProbeLoc,
|
---|
881 | 0 /*idSrcCpu*/, &pProbeLoc->AddrProbe, fBpFlags,
|
---|
882 | 0 /*iHitTrigger*/, ~0ULL /*iHitDisable*/, &pProbeLoc->hBp);
|
---|
883 | if (RT_FAILURE(rc))
|
---|
884 | break;
|
---|
885 | }
|
---|
886 |
|
---|
887 | if (RT_FAILURE(rc))
|
---|
888 | pThis->enmState = DBGFFLOWTRACEMODSTATE_CREATED;
|
---|
889 |
|
---|
890 | return rc;
|
---|
891 | }
|
---|
892 |
|
---|
893 |
|
---|
894 | /**
|
---|
895 | * Worker for DBGFR3FlowTraceModDisable(), doing the work in an EMT rendezvous point to
|
---|
896 | * ensure no probe is hit in an inconsistent state.
|
---|
897 | *
|
---|
898 | * @returns Struct VBox status code.
|
---|
899 | * @param pVM The VM instance data.
|
---|
900 | * @param pVCpu The virtual CPU we execute on.
|
---|
901 | * @param pvUser Opaque user data.
|
---|
902 | */
|
---|
903 | static DECLCALLBACK(VBOXSTRICTRC) dbgfR3FlowTraceModDisableWorker(PVM pVM, PVMCPU pVCpu, void *pvUser)
|
---|
904 | {
|
---|
905 | RT_NOREF2(pVM, pVCpu);
|
---|
906 | PDBGFFLOWTRACEMODINT pThis = (PDBGFFLOWTRACEMODINT)pvUser;
|
---|
907 | PDBGFFLOWTRACEMODPROBELOC pProbeLoc = NULL;
|
---|
908 | int rc = VINF_SUCCESS;
|
---|
909 |
|
---|
910 | pThis->enmState = DBGFFLOWTRACEMODSTATE_CREATED;
|
---|
911 |
|
---|
912 | RTListForEach(&pThis->LstProbes, pProbeLoc, DBGFFLOWTRACEMODPROBELOC, NdProbes)
|
---|
913 | {
|
---|
914 | rc = DBGFR3BpClear(pThis->pUVM, pProbeLoc->hBp);
|
---|
915 | AssertRC(rc);
|
---|
916 | }
|
---|
917 |
|
---|
918 | return rc;
|
---|
919 | }
|
---|
920 |
|
---|
921 |
|
---|
922 | /**
|
---|
923 | * Checks whether both addresses are equal.
|
---|
924 | *
|
---|
925 | * @returns true if both addresses point to the same location, false otherwise.
|
---|
926 | * @param pAddr1 First address.
|
---|
927 | * @param pAddr2 Second address.
|
---|
928 | */
|
---|
929 | static bool dbgfR3FlowTraceAddrEqual(PCDBGFADDRESS pAddr1, PCDBGFADDRESS pAddr2)
|
---|
930 | {
|
---|
931 | return pAddr1->Sel == pAddr2->Sel
|
---|
932 | && pAddr1->off == pAddr2->off;
|
---|
933 | }
|
---|
934 |
|
---|
935 |
|
---|
936 | /**
|
---|
937 | * Returns the probe location pointer at the given address for the given trace module.
|
---|
938 | *
|
---|
939 | * @returns Pointer to the probe location or NULL if there is no probe at the given location.
|
---|
940 | * @param pThis The flow trace module instance data.
|
---|
941 | * @param pAddrProbe Address of the probe to check.
|
---|
942 | */
|
---|
943 | static PDBGFFLOWTRACEMODPROBELOC dbgfR3TraceModGetProbeLocAtAddr(PDBGFFLOWTRACEMODINT pThis, PCDBGFADDRESS pAddrProbe)
|
---|
944 | {
|
---|
945 | RTSemFastMutexRequest(pThis->hMtx);
|
---|
946 |
|
---|
947 | PDBGFFLOWTRACEMODPROBELOC pIt;
|
---|
948 | RTListForEach(&pThis->LstProbes, pIt, DBGFFLOWTRACEMODPROBELOC, NdProbes)
|
---|
949 | {
|
---|
950 | if (dbgfR3FlowTraceAddrEqual(&pIt->AddrProbe, pAddrProbe))
|
---|
951 | {
|
---|
952 | RTSemFastMutexRelease(pThis->hMtx);
|
---|
953 | return pIt;
|
---|
954 | }
|
---|
955 | }
|
---|
956 | RTSemFastMutexRelease(pThis->hMtx);
|
---|
957 | return NULL;
|
---|
958 | }
|
---|
959 |
|
---|
960 |
|
---|
961 | /**
|
---|
962 | * Cleans up any allocated resources for each entry in the given probe for the given range.
|
---|
963 | *
|
---|
964 | * @param pProbe The probe instance.
|
---|
965 | * @param idxStart Start index to clean up.
|
---|
966 | * @param cEntries How many entries to clean up.
|
---|
967 | */
|
---|
968 | static void dbgfR3ProbeEntryCleanup(PDBGFFLOWTRACEPROBEINT pProbe, uint32_t idxStart, uint32_t cEntries)
|
---|
969 | {
|
---|
970 | AssertReturnVoid(pProbe->cEntriesMax >= idxStart + cEntries);
|
---|
971 |
|
---|
972 | for (uint32_t i = idxStart; i < idxStart + cEntries; i++)
|
---|
973 | {
|
---|
974 | PDBGFFLOWTRACEPROBEENTRY pEntry = &pProbe->paEntries[i];
|
---|
975 |
|
---|
976 | switch (pEntry->enmType)
|
---|
977 | {
|
---|
978 | case DBGFFLOWTRACEPROBEENTRYTYPE_REG:
|
---|
979 | if (pEntry->Type.Reg.pszName)
|
---|
980 | MMR3HeapFree((void *)pEntry->Type.Reg.pszName);
|
---|
981 | pEntry->Type.Reg.pszName = NULL;
|
---|
982 | break;
|
---|
983 | case DBGFFLOWTRACEPROBEENTRYTYPE_CONST_MEM:
|
---|
984 | pEntry->Type.ConstMem.cbMem = 0;
|
---|
985 | break;
|
---|
986 | case DBGFFLOWTRACEPROBEENTRYTYPE_INDIRECT_MEM:
|
---|
987 | pEntry->Type.IndirectMem.uScale = 0;
|
---|
988 | pEntry->Type.IndirectMem.cbMem = 0;
|
---|
989 | if (pEntry->Type.IndirectMem.RegBase.pszName)
|
---|
990 | MMR3HeapFree((void *)pEntry->Type.IndirectMem.RegBase.pszName);
|
---|
991 | if (pEntry->Type.IndirectMem.RegIndex.pszName)
|
---|
992 | MMR3HeapFree((void *)pEntry->Type.IndirectMem.RegIndex.pszName);
|
---|
993 | pEntry->Type.IndirectMem.RegBase.pszName = NULL;
|
---|
994 | pEntry->Type.IndirectMem.RegIndex.pszName = NULL;
|
---|
995 | break;
|
---|
996 | case DBGFFLOWTRACEPROBEENTRYTYPE_CALLBACK:
|
---|
997 | pEntry->Type.Callback.pfnCallback = NULL;
|
---|
998 | pEntry->Type.Callback.pvUser = NULL;
|
---|
999 | break;
|
---|
1000 | case DBGFFLOWTRACEPROBEENTRYTYPE_DEBUGGER:
|
---|
1001 | break;
|
---|
1002 | default:
|
---|
1003 | AssertFailed();
|
---|
1004 | }
|
---|
1005 | }
|
---|
1006 | }
|
---|
1007 |
|
---|
1008 |
|
---|
1009 | /**
|
---|
1010 | * Destroys the given flow trace probe freeing all allocated resources.
|
---|
1011 | *
|
---|
1012 | * @param pProbe The flow trace probe instance data.
|
---|
1013 | */
|
---|
1014 | static void dbgfR3FlowTraceProbeDestroy(PDBGFFLOWTRACEPROBEINT pProbe)
|
---|
1015 | {
|
---|
1016 | dbgfR3ProbeEntryCleanup(pProbe, 0, pProbe->cEntries);
|
---|
1017 | MMR3HeapFree(pProbe->paEntries);
|
---|
1018 | MMR3HeapFree(pProbe);
|
---|
1019 | }
|
---|
1020 |
|
---|
1021 |
|
---|
1022 | /**
|
---|
1023 | * Ensures that the given probe has the given amount of additional entries available,
|
---|
1024 | * increasing the size if necessary.
|
---|
1025 | *
|
---|
1026 | * @returns VBox status code.
|
---|
1027 | * @retval VERR_NO_MEMORY if increasing the size failed due to an out of memory condition.
|
---|
1028 | * @param pProbe The probe insatnce.
|
---|
1029 | * @param cEntriesAdd Number of additional entries required.
|
---|
1030 | */
|
---|
1031 | static int dbgfR3ProbeEnsureSize(PDBGFFLOWTRACEPROBEINT pProbe, uint32_t cEntriesAdd)
|
---|
1032 | {
|
---|
1033 | uint32_t cEntriesNew = pProbe->cEntries + cEntriesAdd;
|
---|
1034 | int rc = VINF_SUCCESS;
|
---|
1035 |
|
---|
1036 | if (pProbe->cEntriesMax < cEntriesNew)
|
---|
1037 | {
|
---|
1038 | PDBGFFLOWTRACEPROBEENTRY paEntriesNew;
|
---|
1039 | if (!pProbe->cEntriesMax)
|
---|
1040 | paEntriesNew = (PDBGFFLOWTRACEPROBEENTRY)MMR3HeapAllocZU(pProbe->pUVM, MM_TAG_DBGF_FLOWTRACE,
|
---|
1041 | cEntriesNew * sizeof(DBGFFLOWTRACEPROBEENTRY));
|
---|
1042 | else
|
---|
1043 | paEntriesNew = (PDBGFFLOWTRACEPROBEENTRY)MMR3HeapRealloc(pProbe->paEntries,
|
---|
1044 | cEntriesNew * sizeof(DBGFFLOWTRACEPROBEENTRY));
|
---|
1045 | if (RT_LIKELY(paEntriesNew))
|
---|
1046 | {
|
---|
1047 | pProbe->paEntries = paEntriesNew;
|
---|
1048 | pProbe->cEntriesMax = cEntriesNew;
|
---|
1049 | }
|
---|
1050 | else
|
---|
1051 | rc = VERR_NO_MEMORY;
|
---|
1052 | }
|
---|
1053 |
|
---|
1054 | return rc;
|
---|
1055 | }
|
---|
1056 |
|
---|
1057 |
|
---|
1058 | /**
|
---|
1059 | * Duplicates a probe registry entry.
|
---|
1060 | * @returns VBox status code.
|
---|
1061 | * @param pUVM The usermode VM handle.
|
---|
1062 | * @param pDst Where to copy the entry to.
|
---|
1063 | * @param pSrc What to copy.
|
---|
1064 | */
|
---|
1065 | static int dbgfR3ProbeEntryRegDup(PUVM pUVM, PDBGFFLOWTRACEPROBEENTRYREG pDst, PCDBGFFLOWTRACEPROBEENTRYREG pSrc)
|
---|
1066 | {
|
---|
1067 | int rc = VINF_SUCCESS;
|
---|
1068 |
|
---|
1069 | pDst->enmType = pSrc->enmType;
|
---|
1070 | pDst->pszName = MMR3HeapStrDupU(pUVM, MM_TAG_DBGF_FLOWTRACE, pSrc->pszName);
|
---|
1071 | if (!pDst->pszName)
|
---|
1072 | rc = VERR_NO_MEMORY;
|
---|
1073 |
|
---|
1074 | return rc;
|
---|
1075 | }
|
---|
1076 |
|
---|
1077 |
|
---|
1078 | /**
|
---|
1079 | * Duplicates a given probe entry in the given destination doing a deep copy (strings are duplicated).
|
---|
1080 | *
|
---|
1081 | * @returns VBox status code.
|
---|
1082 | * @param pUVM The usermode VM handle.
|
---|
1083 | * @param pDst Where to copy the entry to.
|
---|
1084 | * @param pSrc What to copy.
|
---|
1085 | */
|
---|
1086 | static int dbgfR3ProbeEntryDup(PUVM pUVM, PDBGFFLOWTRACEPROBEENTRY pDst, PCDBGFFLOWTRACEPROBEENTRY pSrc)
|
---|
1087 | {
|
---|
1088 | int rc = VINF_SUCCESS;
|
---|
1089 |
|
---|
1090 | pDst->enmType = pSrc->enmType;
|
---|
1091 | pDst->pszDesc = NULL;
|
---|
1092 | if (pSrc->pszDesc)
|
---|
1093 | {
|
---|
1094 | pDst->pszDesc = MMR3HeapStrDupU(pUVM, MM_TAG_DBGF_FLOWTRACE, pSrc->pszDesc);
|
---|
1095 | if (!pDst->pszDesc)
|
---|
1096 | rc = VERR_NO_MEMORY;
|
---|
1097 | }
|
---|
1098 |
|
---|
1099 | if (RT_SUCCESS(rc))
|
---|
1100 | {
|
---|
1101 | switch (pDst->enmType)
|
---|
1102 | {
|
---|
1103 | case DBGFFLOWTRACEPROBEENTRYTYPE_REG:
|
---|
1104 | rc = dbgfR3ProbeEntryRegDup(pUVM, &pDst->Type.Reg, &pSrc->Type.Reg);
|
---|
1105 | break;
|
---|
1106 | case DBGFFLOWTRACEPROBEENTRYTYPE_CONST_MEM:
|
---|
1107 | pDst->Type.ConstMem.AddrMem = pSrc->Type.ConstMem.AddrMem;
|
---|
1108 | pDst->Type.ConstMem.cbMem = pSrc->Type.ConstMem.cbMem;
|
---|
1109 | break;
|
---|
1110 | case DBGFFLOWTRACEPROBEENTRYTYPE_INDIRECT_MEM:
|
---|
1111 | pDst->Type.IndirectMem.uScale = pSrc->Type.IndirectMem.uScale;
|
---|
1112 | pDst->Type.IndirectMem.cbMem = pSrc->Type.IndirectMem.cbMem;
|
---|
1113 | pDst->Type.IndirectMem.iOffset = pSrc->Type.IndirectMem.iOffset;
|
---|
1114 | rc = dbgfR3ProbeEntryRegDup(pUVM, &pDst->Type.IndirectMem.RegBase, &pSrc->Type.IndirectMem.RegBase);
|
---|
1115 | if ( RT_SUCCESS(rc)
|
---|
1116 | && pDst->Type.IndirectMem.RegIndex.pszName)
|
---|
1117 | {
|
---|
1118 | rc = dbgfR3ProbeEntryRegDup(pUVM, &pDst->Type.IndirectMem.RegIndex, &pSrc->Type.IndirectMem.RegIndex);
|
---|
1119 | if (RT_FAILURE(rc))
|
---|
1120 | MMR3HeapFree((void *)pDst->Type.IndirectMem.RegBase.pszName);
|
---|
1121 | }
|
---|
1122 | break;
|
---|
1123 | case DBGFFLOWTRACEPROBEENTRYTYPE_CALLBACK:
|
---|
1124 | pDst->Type.Callback.pfnCallback = pSrc->Type.Callback.pfnCallback;
|
---|
1125 | pDst->Type.Callback.pvUser = pSrc->Type.Callback.pvUser;
|
---|
1126 | break;
|
---|
1127 | case DBGFFLOWTRACEPROBEENTRYTYPE_DEBUGGER:
|
---|
1128 | break;
|
---|
1129 | default:
|
---|
1130 | rc = VERR_INVALID_PARAMETER;
|
---|
1131 | }
|
---|
1132 | }
|
---|
1133 |
|
---|
1134 | if ( RT_FAILURE(rc)
|
---|
1135 | && pDst->pszDesc)
|
---|
1136 | {
|
---|
1137 | MMR3HeapFree((void *)pDst->pszDesc);
|
---|
1138 | pDst->pszDesc = NULL;
|
---|
1139 | }
|
---|
1140 |
|
---|
1141 | return rc;
|
---|
1142 | }
|
---|
1143 |
|
---|
1144 |
|
---|
1145 | /**
|
---|
1146 | * Recalculates the size occupied by the data of this probe for each invocation.
|
---|
1147 | *
|
---|
1148 | * @param pProbe The probe instance.
|
---|
1149 | */
|
---|
1150 | static void dbgfR3ProbeRecalcSize(PDBGFFLOWTRACEPROBEINT pProbe)
|
---|
1151 | {
|
---|
1152 | size_t cbProbe = 0;
|
---|
1153 |
|
---|
1154 | for (uint32_t i = 0; i < pProbe->cEntries; i++)
|
---|
1155 | {
|
---|
1156 | PDBGFFLOWTRACEPROBEENTRY pEntry = &pProbe->paEntries[i];
|
---|
1157 |
|
---|
1158 | cbProbe += sizeof(DBGFFLOWTRACEPROBEVAL);
|
---|
1159 |
|
---|
1160 | switch (pEntry->enmType)
|
---|
1161 | {
|
---|
1162 | case DBGFFLOWTRACEPROBEENTRYTYPE_CONST_MEM:
|
---|
1163 | cbProbe += pEntry->Type.ConstMem.cbMem;
|
---|
1164 | break;
|
---|
1165 | case DBGFFLOWTRACEPROBEENTRYTYPE_INDIRECT_MEM:
|
---|
1166 | cbProbe += pEntry->Type.IndirectMem.cbMem;
|
---|
1167 | break;
|
---|
1168 | case DBGFFLOWTRACEPROBEENTRYTYPE_CALLBACK:
|
---|
1169 | case DBGFFLOWTRACEPROBEENTRYTYPE_REG:
|
---|
1170 | case DBGFFLOWTRACEPROBEENTRYTYPE_DEBUGGER:
|
---|
1171 | break;
|
---|
1172 | default:
|
---|
1173 | AssertFailed();
|
---|
1174 | }
|
---|
1175 | }
|
---|
1176 |
|
---|
1177 | pProbe->cbProbe = cbProbe;
|
---|
1178 | }
|
---|
1179 |
|
---|
1180 |
|
---|
1181 | /**
|
---|
1182 | * Creates a new empty flow trace module.
|
---|
1183 | *
|
---|
1184 | * @returns VBox status code.
|
---|
1185 | * @param pUVM The usermode VM handle.
|
---|
1186 | * @param idCpu CPU ID the module is for, use VMCPUID_ANY for any CPU.
|
---|
1187 | * @param hFlowTraceProbeCommon Optional probe handle of data to capture regardless of the actual
|
---|
1188 | * probe.
|
---|
1189 | * @param phFlowTraceMod Where to store the handle to the created module on success.
|
---|
1190 | */
|
---|
1191 | VMMR3DECL(int) DBGFR3FlowTraceModCreate(PUVM pUVM, VMCPUID idCpu,
|
---|
1192 | DBGFFLOWTRACEPROBE hFlowTraceProbeCommon,
|
---|
1193 | PDBGFFLOWTRACEMOD phFlowTraceMod)
|
---|
1194 | {
|
---|
1195 | int rc = VINF_SUCCESS;
|
---|
1196 | PDBGFFLOWTRACEMODINT pThis = (PDBGFFLOWTRACEMODINT)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_FLOWTRACE,
|
---|
1197 | sizeof(DBGFFLOWTRACEMODINT));
|
---|
1198 | if (RT_LIKELY(pThis))
|
---|
1199 | {
|
---|
1200 | pThis->cRefs = 1;
|
---|
1201 | pThis->pUVM = pUVM;
|
---|
1202 | pThis->idCpu = idCpu;
|
---|
1203 | pThis->enmState = DBGFFLOWTRACEMODSTATE_CREATED;
|
---|
1204 | pThis->u64SeqNoNext = 0;
|
---|
1205 | pThis->cHitsLeft = 0;
|
---|
1206 | pThis->cRecordsMax = 0;
|
---|
1207 | pThis->cRecords = 0;
|
---|
1208 | pThis->cProbes = 0;
|
---|
1209 | RTListInit(&pThis->LstProbes);
|
---|
1210 | RTListInit(&pThis->LstRecords);
|
---|
1211 |
|
---|
1212 | rc = RTSemFastMutexCreate(&pThis->hMtx);
|
---|
1213 | if (RT_SUCCESS(rc))
|
---|
1214 | {
|
---|
1215 | rc = DBGFR3BpOwnerCreate(pUVM, dbgfR3FlowTraceModProbeFiredWorker, NULL /*pfnBpIoHit*/, &pThis->hBpOwner);
|
---|
1216 | if (RT_SUCCESS(rc))
|
---|
1217 | {
|
---|
1218 | PDBGFFLOWTRACEPROBEINT pProbe = hFlowTraceProbeCommon;
|
---|
1219 | if (pProbe)
|
---|
1220 | {
|
---|
1221 | DBGFR3FlowTraceProbeRetain(pProbe);
|
---|
1222 | pThis->pProbeCmn = pProbe;
|
---|
1223 | }
|
---|
1224 | }
|
---|
1225 |
|
---|
1226 | *phFlowTraceMod = pThis;
|
---|
1227 | }
|
---|
1228 |
|
---|
1229 | if (RT_FAILURE(rc))
|
---|
1230 | MMR3HeapFree(pThis);
|
---|
1231 | }
|
---|
1232 | else
|
---|
1233 | rc = VERR_NO_MEMORY;
|
---|
1234 |
|
---|
1235 | return rc;
|
---|
1236 | }
|
---|
1237 |
|
---|
1238 |
|
---|
1239 | /**
|
---|
1240 | * Create a new flow trace module from the given control flow graph adding the given probes
|
---|
1241 | * at the entries, exits and branches.
|
---|
1242 | *
|
---|
1243 | * @returns VBox status code.
|
---|
1244 | * @param pUVM The usermode VM handle.
|
---|
1245 | * @param idCpu CPU ID the module is for, use VMCPUID_ANY for any CPU.
|
---|
1246 | * @param hFlow Control flow graph handle to use.
|
---|
1247 | * @param hFlowTraceProbeCommon Optional probe handle of data to capture regardless of the actual
|
---|
1248 | * probe.
|
---|
1249 | * @param hFlowTraceProbeEntry Probe handle to use for all entry blocks.
|
---|
1250 | * @param hFlowTraceProbeRegular Probe handle to use for all branches.
|
---|
1251 | * @param hFlowTraceProbeExit Probe handle to use for all exits.
|
---|
1252 | * @param phFlowTraceMod Where to store the handle to the created module on success.
|
---|
1253 | */
|
---|
1254 | VMMR3DECL(int) DBGFR3FlowTraceModCreateFromFlowGraph(PUVM pUVM, VMCPUID idCpu, DBGFFLOW hFlow,
|
---|
1255 | DBGFFLOWTRACEPROBE hFlowTraceProbeCommon,
|
---|
1256 | DBGFFLOWTRACEPROBE hFlowTraceProbeEntry,
|
---|
1257 | DBGFFLOWTRACEPROBE hFlowTraceProbeRegular,
|
---|
1258 | DBGFFLOWTRACEPROBE hFlowTraceProbeExit,
|
---|
1259 | PDBGFFLOWTRACEMOD phFlowTraceMod)
|
---|
1260 | {
|
---|
1261 | DBGFFLOWIT hFlowIt;
|
---|
1262 | int rc = DBGFR3FlowItCreate(hFlow, DBGFFLOWITORDER_BY_ADDR_LOWEST_FIRST, &hFlowIt);
|
---|
1263 | if (RT_SUCCESS(rc))
|
---|
1264 | {
|
---|
1265 | DBGFFLOWTRACEMOD hFlowTraceMod;
|
---|
1266 | rc = DBGFR3FlowTraceModCreate(pUVM, idCpu, hFlowTraceProbeCommon, &hFlowTraceMod);
|
---|
1267 | if (RT_SUCCESS(rc))
|
---|
1268 | {
|
---|
1269 | DBGFFLOWBB hFlowBb = DBGFR3FlowItNext(hFlowIt);
|
---|
1270 | while (hFlowBb && RT_SUCCESS(rc))
|
---|
1271 | {
|
---|
1272 | uint32_t fFlags = DBGFR3FlowBbGetFlags(hFlowBb);
|
---|
1273 |
|
---|
1274 | if (!(fFlags & (DBGF_FLOW_BB_F_EMPTY | DBGF_FLOW_BB_F_INCOMPLETE_ERR)))
|
---|
1275 | {
|
---|
1276 | DBGFADDRESS AddrInstr;
|
---|
1277 |
|
---|
1278 | if (fFlags & DBGF_FLOW_BB_F_ENTRY)
|
---|
1279 | {
|
---|
1280 | rc = DBGFR3FlowBbQueryInstr(hFlowBb, 0, &AddrInstr, NULL, NULL);
|
---|
1281 | AssertRC(rc);
|
---|
1282 |
|
---|
1283 | rc = DBGFR3FlowTraceModAddProbe(hFlowTraceMod, &AddrInstr, hFlowTraceProbeEntry,
|
---|
1284 | DBGF_FLOW_TRACE_PROBE_ADD_F_BEFORE_EXEC);
|
---|
1285 | }
|
---|
1286 | else
|
---|
1287 | {
|
---|
1288 | DBGFFLOWBBENDTYPE enmType = DBGFR3FlowBbGetType(hFlowBb);
|
---|
1289 | uint32_t cInstr = enmType == DBGFFLOWBBENDTYPE_EXIT ? DBGFR3FlowBbGetInstrCount(hFlowBb) - 1 : 0;
|
---|
1290 | rc = DBGFR3FlowBbQueryInstr(hFlowBb, cInstr, &AddrInstr, NULL, NULL);
|
---|
1291 | if (RT_SUCCESS(rc))
|
---|
1292 | {
|
---|
1293 | if (enmType == DBGFFLOWBBENDTYPE_EXIT)
|
---|
1294 | rc = DBGFR3FlowTraceModAddProbe(hFlowTraceMod, &AddrInstr, hFlowTraceProbeExit,
|
---|
1295 | DBGF_FLOW_TRACE_PROBE_ADD_F_AFTER_EXEC);
|
---|
1296 | else
|
---|
1297 | rc = DBGFR3FlowTraceModAddProbe(hFlowTraceMod, &AddrInstr, hFlowTraceProbeRegular,
|
---|
1298 | DBGF_FLOW_TRACE_PROBE_ADD_F_BEFORE_EXEC);
|
---|
1299 | }
|
---|
1300 | }
|
---|
1301 | }
|
---|
1302 |
|
---|
1303 | hFlowBb = DBGFR3FlowItNext(hFlowIt);
|
---|
1304 | }
|
---|
1305 |
|
---|
1306 | if (RT_FAILURE(rc))
|
---|
1307 | DBGFR3FlowTraceModRelease(hFlowTraceMod);
|
---|
1308 | else
|
---|
1309 | *phFlowTraceMod = hFlowTraceMod;
|
---|
1310 | }
|
---|
1311 |
|
---|
1312 | DBGFR3FlowItDestroy(hFlowIt);
|
---|
1313 | }
|
---|
1314 |
|
---|
1315 | return rc;
|
---|
1316 | }
|
---|
1317 |
|
---|
1318 |
|
---|
1319 | /**
|
---|
1320 | * Retain a reference to the given flow trace module.
|
---|
1321 | *
|
---|
1322 | * @returns New reference count.
|
---|
1323 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1324 | */
|
---|
1325 | VMMR3DECL(uint32_t) DBGFR3FlowTraceModRetain(DBGFFLOWTRACEMOD hFlowTraceMod)
|
---|
1326 | {
|
---|
1327 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1328 | AssertPtrReturn(pThis, UINT32_MAX);
|
---|
1329 |
|
---|
1330 | uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
|
---|
1331 | AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pThis));
|
---|
1332 | return cRefs;
|
---|
1333 | }
|
---|
1334 |
|
---|
1335 |
|
---|
1336 | /**
|
---|
1337 | * Release a reference of the given flow trace module.
|
---|
1338 | *
|
---|
1339 | * @returns New reference count, on 0 the module is destroyed and all containing records
|
---|
1340 | * are deleted.
|
---|
1341 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1342 | */
|
---|
1343 | VMMR3DECL(uint32_t) DBGFR3FlowTraceModRelease(DBGFFLOWTRACEMOD hFlowTraceMod)
|
---|
1344 | {
|
---|
1345 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1346 | if (!pThis)
|
---|
1347 | return 0;
|
---|
1348 | AssertPtrReturn(pThis, UINT32_MAX);
|
---|
1349 |
|
---|
1350 | uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
|
---|
1351 | AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pThis));
|
---|
1352 | if (cRefs == 0)
|
---|
1353 | dbgfR3FlowTraceModDestroy(pThis);
|
---|
1354 | return cRefs;
|
---|
1355 | }
|
---|
1356 |
|
---|
1357 |
|
---|
1358 | /**
|
---|
1359 | * Enables and arms all probes in the given flow trace module.
|
---|
1360 | *
|
---|
1361 | * @returns VBox status code.
|
---|
1362 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1363 | * @param cHits Number of hits inside this module until the module is disabled
|
---|
1364 | * automatically, 0 if not to disable automatically.
|
---|
1365 | * @param cRecordsMax Maximum number of records to keep until the oldest is evicted.
|
---|
1366 | */
|
---|
1367 | VMMR3DECL(int) DBGFR3FlowTraceModEnable(DBGFFLOWTRACEMOD hFlowTraceMod, uint32_t cHits, uint32_t cRecordsMax)
|
---|
1368 | {
|
---|
1369 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1370 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1371 | AssertReturn(pThis->cProbes > 0, VERR_INVALID_STATE);
|
---|
1372 | AssertReturn(pThis->enmState == DBGFFLOWTRACEMODSTATE_CREATED, VERR_INVALID_STATE);
|
---|
1373 |
|
---|
1374 | pThis->cHitsLeft = cHits;
|
---|
1375 | pThis->cRecordsMax = cRecordsMax;
|
---|
1376 |
|
---|
1377 | return VMMR3EmtRendezvous(pThis->pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE,
|
---|
1378 | dbgfR3FlowTraceModEnableWorker, pThis);
|
---|
1379 | }
|
---|
1380 |
|
---|
1381 |
|
---|
1382 | /**
|
---|
1383 | * Disables all probes in the given flow trace module.
|
---|
1384 | *
|
---|
1385 | * @returns VBox status code.
|
---|
1386 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1387 | */
|
---|
1388 | VMMR3DECL(int) DBGFR3FlowTraceModDisable(DBGFFLOWTRACEMOD hFlowTraceMod)
|
---|
1389 | {
|
---|
1390 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1391 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1392 | AssertReturn(pThis->enmState == DBGFFLOWTRACEMODSTATE_ENABLED, VERR_INVALID_STATE);
|
---|
1393 |
|
---|
1394 | return VMMR3EmtRendezvous(pThis->pUVM->pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE,
|
---|
1395 | dbgfR3FlowTraceModDisableWorker, pThis);
|
---|
1396 | }
|
---|
1397 |
|
---|
1398 |
|
---|
1399 | /**
|
---|
1400 | * Returns a report containing all existing records in the given flow trace module.
|
---|
1401 | *
|
---|
1402 | * @returns VBox status code.
|
---|
1403 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1404 | * @param phFlowTraceReport Where to store the flow trace report handle on success.
|
---|
1405 | */
|
---|
1406 | VMMR3DECL(int) DBGFR3FlowTraceModQueryReport(DBGFFLOWTRACEMOD hFlowTraceMod,
|
---|
1407 | PDBGFFLOWTRACEREPORT phFlowTraceReport)
|
---|
1408 | {
|
---|
1409 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1410 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1411 | AssertPtrReturn(phFlowTraceReport, VERR_INVALID_POINTER);
|
---|
1412 |
|
---|
1413 | /** @todo Locking. */
|
---|
1414 | int rc = VINF_SUCCESS;
|
---|
1415 | PDBGFFLOWTRACEREPORTINT pReport = dbgfR3FlowTraceReportCreate(pThis->pUVM, pThis->cRecords);
|
---|
1416 | if (RT_LIKELY(pReport))
|
---|
1417 | {
|
---|
1418 | PDBGFFLOWTRACERECORDINT pIt;
|
---|
1419 | uint32_t idx = 0;
|
---|
1420 |
|
---|
1421 | RTSemFastMutexRequest(pThis->hMtx);
|
---|
1422 | RTListForEach(&pThis->LstRecords, pIt, DBGFFLOWTRACERECORDINT, NdRecord)
|
---|
1423 | {
|
---|
1424 | DBGFR3FlowTraceRecordRetain(pIt);
|
---|
1425 | pReport->apRec[idx++] = pIt;
|
---|
1426 | }
|
---|
1427 | RTSemFastMutexRelease(pThis->hMtx);
|
---|
1428 |
|
---|
1429 | *phFlowTraceReport = pReport;
|
---|
1430 | }
|
---|
1431 | else
|
---|
1432 | rc = VERR_NO_MEMORY;
|
---|
1433 |
|
---|
1434 | return rc;
|
---|
1435 | }
|
---|
1436 |
|
---|
1437 |
|
---|
1438 | /**
|
---|
1439 | * Clears all records contained in the flow trace module.
|
---|
1440 | *
|
---|
1441 | * @returns VBox status code.
|
---|
1442 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1443 | */
|
---|
1444 | VMMR3DECL(int) DBGFR3FlowTraceModClear(DBGFFLOWTRACEMOD hFlowTraceMod)
|
---|
1445 | {
|
---|
1446 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1447 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1448 |
|
---|
1449 | RTSemFastMutexRequest(pThis->hMtx);
|
---|
1450 | RTLISTANCHOR LstTmp;
|
---|
1451 | RTListMove(&LstTmp, &pThis->LstRecords);
|
---|
1452 | ASMAtomicWriteU32(&pThis->cRecords, 0);
|
---|
1453 | RTSemFastMutexRelease(pThis->hMtx);
|
---|
1454 |
|
---|
1455 | PDBGFFLOWTRACERECORDINT pIt, pItNext;
|
---|
1456 | RTListForEachSafe(&LstTmp, pIt, pItNext, DBGFFLOWTRACERECORDINT, NdRecord)
|
---|
1457 | {
|
---|
1458 | RTListNodeRemove(&pIt->NdRecord);
|
---|
1459 | DBGFR3FlowTraceRecordRelease(pIt);
|
---|
1460 | }
|
---|
1461 |
|
---|
1462 | return VINF_SUCCESS;
|
---|
1463 | }
|
---|
1464 |
|
---|
1465 |
|
---|
1466 | /**
|
---|
1467 | * Adds a new probe to the given flow trace module.
|
---|
1468 | *
|
---|
1469 | * @returns VBox status code
|
---|
1470 | * @retval VERR_INVALID_STATE if the probe is active or was destroyed already.
|
---|
1471 | * @retval VERR_ALREADY_EXISTS if there is already a probe at the specified location.
|
---|
1472 | * @param hFlowTraceMod Flow trace module handle.
|
---|
1473 | * @param pAddrProbe Guest address to insert the probe at.
|
---|
1474 | * @param hFlowTraceProbe The handle of the probe to insert.
|
---|
1475 | * @param fFlags Combination of DBGF_FLOW_TRACE_PROBE_ADD_F_*.
|
---|
1476 | */
|
---|
1477 | VMMR3DECL(int) DBGFR3FlowTraceModAddProbe(DBGFFLOWTRACEMOD hFlowTraceMod, PCDBGFADDRESS pAddrProbe,
|
---|
1478 | DBGFFLOWTRACEPROBE hFlowTraceProbe, uint32_t fFlags)
|
---|
1479 | {
|
---|
1480 | PDBGFFLOWTRACEMODINT pThis = hFlowTraceMod;
|
---|
1481 | PDBGFFLOWTRACEPROBEINT pProbe = hFlowTraceProbe;
|
---|
1482 | AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
|
---|
1483 | AssertPtrReturn(pProbe, VERR_INVALID_HANDLE);
|
---|
1484 | AssertPtrReturn(pAddrProbe, VERR_INVALID_POINTER);
|
---|
1485 | AssertReturn(!(fFlags & ~DBGF_FLOW_TRACE_PROBE_ADD_F_VALID_MASK), VERR_INVALID_PARAMETER);
|
---|
1486 | AssertReturn(pThis->enmState == DBGFFLOWTRACEMODSTATE_CREATED, VERR_INVALID_STATE);
|
---|
1487 |
|
---|
1488 | int rc = VINF_SUCCESS;
|
---|
1489 | PDBGFFLOWTRACEMODPROBELOC pProbeLoc = dbgfR3TraceModGetProbeLocAtAddr(pThis, pAddrProbe);
|
---|
1490 | if (!pProbeLoc)
|
---|
1491 | {
|
---|
1492 | pProbeLoc = (PDBGFFLOWTRACEMODPROBELOC)MMR3HeapAllocZU(pThis->pUVM, MM_TAG_DBGF_FLOWTRACE,
|
---|
1493 | sizeof(DBGFFLOWTRACEMODPROBELOC));
|
---|
1494 | if (RT_LIKELY(pProbeLoc))
|
---|
1495 | {
|
---|
1496 | pProbeLoc->pTraceMod = pThis;
|
---|
1497 | pProbeLoc->pProbe = pProbe;
|
---|
1498 | pProbeLoc->AddrProbe = *pAddrProbe;
|
---|
1499 | pProbeLoc->fFlags = fFlags;
|
---|
1500 | ASMAtomicIncU32(&pProbe->cRefs);
|
---|
1501 | ASMAtomicIncU32(&pProbe->cRefsMod);
|
---|
1502 | RTSemFastMutexRequest(pThis->hMtx);
|
---|
1503 | RTListAppend(&pThis->LstProbes, &pProbeLoc->NdProbes);
|
---|
1504 | pThis->cProbes++;
|
---|
1505 | RTSemFastMutexRelease(pThis->hMtx);
|
---|
1506 | }
|
---|
1507 | else
|
---|
1508 | rc = VERR_NO_MEMORY;
|
---|
1509 | }
|
---|
1510 | else
|
---|
1511 | rc = VERR_ALREADY_EXISTS;
|
---|
1512 |
|
---|
1513 | return rc;
|
---|
1514 | }
|
---|
1515 |
|
---|
1516 |
|
---|
1517 | /**
|
---|
1518 | * Creates a new empty probe.
|
---|
1519 | *
|
---|
1520 | * @returns VBox status code.
|
---|
1521 | * @param pUVM The usermode VM handle.
|
---|
1522 | * @param pszDescr Description of the probe, optional.
|
---|
1523 | * @param phFlowTraceProbe Where to store the probe handle on success.
|
---|
1524 | */
|
---|
1525 | VMMR3DECL(int) DBGFR3FlowTraceProbeCreate(PUVM pUVM, const char *pszDescr, PDBGFFLOWTRACEPROBE phFlowTraceProbe)
|
---|
1526 | {
|
---|
1527 | int rc = VINF_SUCCESS;
|
---|
1528 | PDBGFFLOWTRACEPROBEINT pProbe = (PDBGFFLOWTRACEPROBEINT)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_FLOWTRACE,
|
---|
1529 | sizeof(DBGFFLOWTRACEPROBEINT));
|
---|
1530 | if (RT_LIKELY(pProbe))
|
---|
1531 | {
|
---|
1532 | pProbe->cRefs = 1;
|
---|
1533 | pProbe->cRefsMod = 0;
|
---|
1534 | pProbe->pUVM = pUVM;
|
---|
1535 | pProbe->cbProbe = 0;
|
---|
1536 | pProbe->cEntries = 0;
|
---|
1537 | pProbe->cEntriesMax = 0;
|
---|
1538 | pProbe->paEntries = NULL;
|
---|
1539 | pProbe->pszDescr = NULL;
|
---|
1540 | if (pszDescr)
|
---|
1541 | {
|
---|
1542 | pProbe->pszDescr = MMR3HeapStrDupU(pUVM, MM_TAG_DBGF_FLOWTRACE, pszDescr);
|
---|
1543 | if (!pProbe->pszDescr)
|
---|
1544 | {
|
---|
1545 | MMR3HeapFree(pProbe);
|
---|
1546 | rc = VERR_NO_MEMORY;
|
---|
1547 | }
|
---|
1548 | }
|
---|
1549 |
|
---|
1550 | if (RT_SUCCESS(rc))
|
---|
1551 | *phFlowTraceProbe = pProbe;
|
---|
1552 | }
|
---|
1553 | else
|
---|
1554 | rc = VERR_NO_MEMORY;
|
---|
1555 |
|
---|
1556 | return rc;
|
---|
1557 | }
|
---|
1558 |
|
---|
1559 |
|
---|
1560 | /**
|
---|
1561 | * Retains a reference to the probe.
|
---|
1562 | *
|
---|
1563 | * @returns New reference count.
|
---|
1564 | * @param hFlowTraceProbe Flow trace probe handle.
|
---|
1565 | */
|
---|
1566 | VMMR3DECL(uint32_t) DBGFR3FlowTraceProbeRetain(DBGFFLOWTRACEPROBE hFlowTraceProbe)
|
---|
1567 | {
|
---|
1568 | PDBGFFLOWTRACEPROBEINT pProbe = hFlowTraceProbe;
|
---|
1569 | AssertPtrReturn(pProbe, UINT32_MAX);
|
---|
1570 |
|
---|
1571 | uint32_t cRefs = ASMAtomicIncU32(&pProbe->cRefs);
|
---|
1572 | AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pProbe));
|
---|
1573 | return cRefs;
|
---|
1574 | }
|
---|
1575 |
|
---|
1576 |
|
---|
1577 | /**
|
---|
1578 | * Release a probe reference.
|
---|
1579 | *
|
---|
1580 | * @returns New reference count, on 0 the probe is destroyed.
|
---|
1581 | * @param hFlowTraceProbe Flow trace probe handle.
|
---|
1582 | */
|
---|
1583 | VMMR3DECL(uint32_t) DBGFR3FlowTraceProbeRelease(DBGFFLOWTRACEPROBE hFlowTraceProbe)
|
---|
1584 | {
|
---|
1585 | PDBGFFLOWTRACEPROBEINT pProbe = hFlowTraceProbe;
|
---|
1586 | if (!pProbe)
|
---|
1587 | return 0;
|
---|
1588 | AssertPtrReturn(pProbe, UINT32_MAX);
|
---|
1589 |
|
---|
1590 | uint32_t cRefs = ASMAtomicDecU32(&pProbe->cRefs);
|
---|
1591 | AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pProbe));
|
---|
1592 | if (cRefs == 0)
|
---|
1593 | dbgfR3FlowTraceProbeDestroy(pProbe);
|
---|
1594 | return cRefs;
|
---|
1595 | }
|
---|
1596 |
|
---|
1597 |
|
---|
1598 | /**
|
---|
1599 | * Adds new data to log in the given probe.
|
---|
1600 | *
|
---|
1601 | * @returns VBox status code.
|
---|
1602 | * @retval VERR_INVALID_STATE if the probe is already part of a trace module and it is not
|
---|
1603 | * possible to add new entries at this point.
|
---|
1604 | * @param hFlowTraceProbe Flow trace probe handle.
|
---|
1605 | * @param paEntries Pointer to the array of entry descriptors.
|
---|
1606 | * @param cEntries Number of entries in the array.
|
---|
1607 | */
|
---|
1608 | VMMR3DECL(int) DBGFR3FlowTraceProbeEntriesAdd(DBGFFLOWTRACEPROBE hFlowTraceProbe,
|
---|
1609 | PCDBGFFLOWTRACEPROBEENTRY paEntries, uint32_t cEntries)
|
---|
1610 | {
|
---|
1611 | PDBGFFLOWTRACEPROBEINT pProbe = hFlowTraceProbe;
|
---|
1612 | AssertPtrReturn(pProbe, VERR_INVALID_HANDLE);
|
---|
1613 | AssertPtrReturn(paEntries, VERR_INVALID_POINTER);
|
---|
1614 | AssertReturn(cEntries > 0, VERR_INVALID_PARAMETER);
|
---|
1615 | AssertReturn(!pProbe->cRefsMod, VERR_INVALID_STATE);
|
---|
1616 |
|
---|
1617 | int rc = dbgfR3ProbeEnsureSize(pProbe, cEntries);
|
---|
1618 | if (RT_SUCCESS(rc))
|
---|
1619 | {
|
---|
1620 | uint32_t idxEntry;
|
---|
1621 |
|
---|
1622 | for (idxEntry = 0; idxEntry < cEntries && RT_SUCCESS(rc); idxEntry++)
|
---|
1623 | {
|
---|
1624 | PCDBGFFLOWTRACEPROBEENTRY pEntry = &paEntries[idxEntry];
|
---|
1625 | PDBGFFLOWTRACEPROBEENTRY pProbeEntry = &pProbe->paEntries[pProbe->cEntries + idxEntry];
|
---|
1626 |
|
---|
1627 | rc = dbgfR3ProbeEntryDup(pProbe->pUVM, pProbeEntry, pEntry);
|
---|
1628 | }
|
---|
1629 |
|
---|
1630 | if (RT_FAILURE(rc))
|
---|
1631 | dbgfR3ProbeEntryCleanup(pProbe, pProbe->cEntries, idxEntry + 1);
|
---|
1632 | else
|
---|
1633 | {
|
---|
1634 | pProbe->cEntries += cEntries;
|
---|
1635 | dbgfR3ProbeRecalcSize(pProbe);
|
---|
1636 | }
|
---|
1637 | }
|
---|
1638 |
|
---|
1639 | return rc;
|
---|
1640 | }
|
---|
1641 |
|
---|
1642 |
|
---|
1643 | /**
|
---|
1644 | * Retains a reference to the given flow trace report.
|
---|
1645 | *
|
---|
1646 | * @returns New reference count.
|
---|
1647 | * @param hFlowTraceReport Flow trace report handle.
|
---|
1648 | */
|
---|
1649 | VMMR3DECL(uint32_t) DBGFR3FlowTraceReportRetain(DBGFFLOWTRACEREPORT hFlowTraceReport)
|
---|
1650 | {
|
---|
1651 | PDBGFFLOWTRACEREPORTINT pReport = hFlowTraceReport;
|
---|
1652 | AssertPtrReturn(pReport, UINT32_MAX);
|
---|
1653 |
|
---|
1654 | uint32_t cRefs = ASMAtomicIncU32(&pReport->cRefs);
|
---|
1655 | AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pReport));
|
---|
1656 | return cRefs;
|
---|
1657 | }
|
---|
1658 |
|
---|
1659 |
|
---|
1660 | /**
|
---|
1661 | * Releases a reference of the given flow trace report.
|
---|
1662 | *
|
---|
1663 | * @returns New reference count, on 0 the report is destroyed.
|
---|
1664 | * @param hFlowTraceReport Flow trace report handle.
|
---|
1665 | */
|
---|
1666 | VMMR3DECL(uint32_t) DBGFR3FlowTraceReportRelease(DBGFFLOWTRACEREPORT hFlowTraceReport)
|
---|
1667 | {
|
---|
1668 | PDBGFFLOWTRACEREPORTINT pReport = hFlowTraceReport;
|
---|
1669 | if (!pReport)
|
---|
1670 | return 0;
|
---|
1671 | AssertPtrReturn(pReport, UINT32_MAX);
|
---|
1672 |
|
---|
1673 | uint32_t cRefs = ASMAtomicDecU32(&pReport->cRefs);
|
---|
1674 | AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pReport));
|
---|
1675 | if (cRefs == 0)
|
---|
1676 | dbgfR3FlowTraceReportDestroy(pReport);
|
---|
1677 | return cRefs;
|
---|
1678 | }
|
---|
1679 |
|
---|
1680 |
|
---|
1681 | /**
|
---|
1682 | * Returns the number of records in the given report.
|
---|
1683 | *
|
---|
1684 | * @returns Number of records.
|
---|
1685 | * @param hFlowTraceReport Flow trace report handle.
|
---|
1686 | */
|
---|
1687 | VMMR3DECL(uint32_t) DBGFR3FlowTraceReportGetRecordCount(DBGFFLOWTRACEREPORT hFlowTraceReport)
|
---|
1688 | {
|
---|
1689 | PDBGFFLOWTRACEREPORTINT pReport = hFlowTraceReport;
|
---|
1690 | AssertPtrReturn(pReport, 0);
|
---|
1691 |
|
---|
1692 | return pReport->cRecords;
|
---|
1693 | }
|
---|
1694 |
|
---|
1695 |
|
---|
1696 | /**
|
---|
1697 | * Queries the specified record contained in the given report.
|
---|
1698 | *
|
---|
1699 | * @returns VBox status code.
|
---|
1700 | * @param hFlowTraceReport Flow trace report handle.
|
---|
1701 | * @param idxRec The record index to query.
|
---|
1702 | * @param phFlowTraceRec Where to store the retained handle of the record on success.
|
---|
1703 | */
|
---|
1704 | VMMR3DECL(int) DBGFR3FlowTraceReportQueryRecord(DBGFFLOWTRACEREPORT hFlowTraceReport, uint32_t idxRec, PDBGFFLOWTRACERECORD phFlowTraceRec)
|
---|
1705 | {
|
---|
1706 | PDBGFFLOWTRACEREPORTINT pReport = hFlowTraceReport;
|
---|
1707 | AssertPtrReturn(pReport, 0);
|
---|
1708 | AssertPtrReturn(phFlowTraceRec, VERR_INVALID_POINTER);
|
---|
1709 | AssertReturn(idxRec < pReport->cRecords, VERR_INVALID_PARAMETER);
|
---|
1710 |
|
---|
1711 | DBGFR3FlowTraceRecordRetain(pReport->apRec[idxRec]);
|
---|
1712 | *phFlowTraceRec = pReport->apRec[idxRec];
|
---|
1713 | return VINF_SUCCESS;
|
---|
1714 | }
|
---|
1715 |
|
---|
1716 |
|
---|
1717 | /**
|
---|
1718 | * Filters the given flow trace report by the given criterias and returns a filtered report.
|
---|
1719 | *
|
---|
1720 | * @returns VBox status code.
|
---|
1721 | * @param hFlowTraceReport Flow trace report handle.
|
---|
1722 | * @param fFlags Combination of DBGF_FLOW_TRACE_REPORT_FILTER_F_*.
|
---|
1723 | * @param paFilters Pointer to the array of filters.
|
---|
1724 | * @param cFilters Number of entries in the filter array.
|
---|
1725 | * @param enmOp How the filters are connected to each other.
|
---|
1726 | * @param phFlowTraceReportFiltered Where to return the handle to the report containing the
|
---|
1727 | * filtered records on success.
|
---|
1728 | */
|
---|
1729 | VMMR3DECL(int) DBGFR3FlowTraceReportQueryFiltered(DBGFFLOWTRACEREPORT hFlowTraceReport, uint32_t fFlags,
|
---|
1730 | PDBGFFLOWTRACEREPORTFILTER paFilters, uint32_t cFilters,
|
---|
1731 | DBGFFLOWTRACEREPORTFILTEROP enmOp,
|
---|
1732 | PDBGFFLOWTRACEREPORT phFlowTraceReportFiltered)
|
---|
1733 | {
|
---|
1734 | PDBGFFLOWTRACEREPORTINT pReport = hFlowTraceReport;
|
---|
1735 | AssertPtrReturn(pReport, VERR_INVALID_HANDLE);
|
---|
1736 | AssertReturn(!(fFlags & DBGF_FLOW_TRACE_REPORT_FILTER_F_VALID), VERR_INVALID_PARAMETER);
|
---|
1737 | AssertPtrReturn(paFilters, VERR_INVALID_POINTER);
|
---|
1738 | AssertReturn(cFilters > 0, VERR_INVALID_PARAMETER);
|
---|
1739 | AssertReturn(enmOp > DBGFFLOWTRACEREPORTFILTEROP_INVALID && enmOp <= DBGFFLOWTRACEREPORTFILTEROP_OR,
|
---|
1740 | VERR_INVALID_PARAMETER);
|
---|
1741 | AssertPtrReturn(phFlowTraceReportFiltered, VERR_INVALID_POINTER);
|
---|
1742 |
|
---|
1743 | int rc = VINF_SUCCESS;
|
---|
1744 | PDBGFFLOWTRACEREPORTINT pReportFiltered = dbgfR3FlowTraceReportCreate(pReport->pUVM, pReport->cRecords);
|
---|
1745 | if (RT_LIKELY(pReportFiltered))
|
---|
1746 | {
|
---|
1747 | uint32_t idxFiltered = 0;
|
---|
1748 |
|
---|
1749 | for (uint32_t i = 0; i < pReport->cRecords; i++)
|
---|
1750 | {
|
---|
1751 | PDBGFFLOWTRACERECORDINT pCur = pReport->apRec[i];
|
---|
1752 | bool fRecFilterMatch = dbgfR3FlowTraceDoesRecordMatchFilter(pCur, paFilters, cFilters, enmOp);
|
---|
1753 |
|
---|
1754 | if ( ( fRecFilterMatch
|
---|
1755 | && !(fFlags & DBGF_FLOW_TRACE_REPORT_FILTER_F_REVERSE))
|
---|
1756 | || ( !fRecFilterMatch
|
---|
1757 | && (fFlags & DBGF_FLOW_TRACE_REPORT_FILTER_F_REVERSE)))
|
---|
1758 | {
|
---|
1759 | DBGFR3FlowTraceRecordRetain(pCur);
|
---|
1760 | pReportFiltered->apRec[idxFiltered++] = pCur;
|
---|
1761 | }
|
---|
1762 | }
|
---|
1763 |
|
---|
1764 | pReportFiltered->cRecords = idxFiltered;
|
---|
1765 | *phFlowTraceReportFiltered = pReportFiltered;
|
---|
1766 | }
|
---|
1767 | else
|
---|
1768 | rc = VERR_NO_MEMORY;
|
---|
1769 |
|
---|
1770 | return rc;
|
---|
1771 | }
|
---|
1772 |
|
---|
1773 |
|
---|
1774 | /**
|
---|
1775 | * Enumerates all records in the given flow trace report calling the supplied
|
---|
1776 | * enumeration callback.
|
---|
1777 | *
|
---|
1778 | * @returns VBox status code, return value of pfnEnum on error.
|
---|
1779 | * @param hFlowTraceReport Flow trace report handle.
|
---|
1780 | * @param pfnEnum The callback to call for every record.
|
---|
1781 | * @param pvUser Opaque user data to pass to the callback.
|
---|
1782 | */
|
---|
1783 | VMMR3DECL(int) DBGFR3FlowTraceReportEnumRecords(DBGFFLOWTRACEREPORT hFlowTraceReport,
|
---|
1784 | PFNDBGFFLOWTRACEREPORTENUMCLBK pfnEnum,
|
---|
1785 | void *pvUser)
|
---|
1786 | {
|
---|
1787 | PDBGFFLOWTRACEREPORTINT pReport = hFlowTraceReport;
|
---|
1788 | AssertPtrReturn(pReport, VERR_INVALID_HANDLE);
|
---|
1789 |
|
---|
1790 | int rc = VINF_SUCCESS;
|
---|
1791 | for (uint32_t i = 0; i < pReport->cRecords && RT_SUCCESS(rc); i++)
|
---|
1792 | rc = pfnEnum(pReport, pReport->apRec[i], pvUser);
|
---|
1793 |
|
---|
1794 | return rc;
|
---|
1795 | }
|
---|
1796 |
|
---|
1797 |
|
---|
1798 | /**
|
---|
1799 | * Retains a reference to the given flow trace record handle.
|
---|
1800 | *
|
---|
1801 | * @returns New reference count.
|
---|
1802 | * @param hFlowTraceRecord The record handle to retain.
|
---|
1803 | */
|
---|
1804 | VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordRetain(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1805 | {
|
---|
1806 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1807 | AssertPtrReturn(pRecord, UINT32_MAX);
|
---|
1808 |
|
---|
1809 | uint32_t cRefs = ASMAtomicIncU32(&pRecord->cRefs);
|
---|
1810 | AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pRecord));
|
---|
1811 | return cRefs;
|
---|
1812 | }
|
---|
1813 |
|
---|
1814 |
|
---|
1815 | /**
|
---|
1816 | * Releases a reference of the given flow trace record.
|
---|
1817 | *
|
---|
1818 | * @returns New reference count, on 0 the record is destroyed.
|
---|
1819 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1820 | */
|
---|
1821 | VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordRelease(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1822 | {
|
---|
1823 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1824 | if (!pRecord)
|
---|
1825 | return 0;
|
---|
1826 | AssertPtrReturn(pRecord, UINT32_MAX);
|
---|
1827 |
|
---|
1828 | uint32_t cRefs = ASMAtomicDecU32(&pRecord->cRefs);
|
---|
1829 | AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pRecord));
|
---|
1830 | if (cRefs == 0)
|
---|
1831 | dbgfR3FlowTraceRecordDestroy(pRecord);
|
---|
1832 | return cRefs;
|
---|
1833 | }
|
---|
1834 |
|
---|
1835 |
|
---|
1836 | /**
|
---|
1837 | * Gets the sequence number of the given record handle.
|
---|
1838 | *
|
---|
1839 | * @returns Sequence number.
|
---|
1840 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1841 | */
|
---|
1842 | VMMR3DECL(uint64_t) DBGFR3FlowTraceRecordGetSeqNo(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1843 | {
|
---|
1844 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1845 | AssertPtrReturn(pRecord, 0);
|
---|
1846 |
|
---|
1847 | return pRecord->u64SeqNo;
|
---|
1848 | }
|
---|
1849 |
|
---|
1850 |
|
---|
1851 | /**
|
---|
1852 | * Returns the timestamp when the record was created.
|
---|
1853 | *
|
---|
1854 | * @returns Timestamp in nano seconds.
|
---|
1855 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1856 | */
|
---|
1857 | VMMR3DECL(uint64_t) DBGFR3FlowTraceRecordGetTimestamp(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1858 | {
|
---|
1859 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1860 | AssertPtrReturn(pRecord, 0);
|
---|
1861 |
|
---|
1862 | return pRecord->u64TsCollected;
|
---|
1863 | }
|
---|
1864 |
|
---|
1865 |
|
---|
1866 | /**
|
---|
1867 | * Gets the address in the guest the record was created.
|
---|
1868 | *
|
---|
1869 | * @returns Pointer to the address containing the guest location the record was created at.
|
---|
1870 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1871 | * @param pAddr Where to store the guest address.
|
---|
1872 | */
|
---|
1873 | VMMR3DECL(PDBGFADDRESS) DBGFR3FlowTraceRecordGetAddr(DBGFFLOWTRACERECORD hFlowTraceRecord, PDBGFADDRESS pAddr)
|
---|
1874 | {
|
---|
1875 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1876 | AssertPtrReturn(pRecord, NULL);
|
---|
1877 | AssertPtrReturn(pAddr, NULL);
|
---|
1878 |
|
---|
1879 | *pAddr = pRecord->AddrProbe;
|
---|
1880 | return pAddr;
|
---|
1881 | }
|
---|
1882 |
|
---|
1883 |
|
---|
1884 | /**
|
---|
1885 | * Returns the handle to the probe for the given record.
|
---|
1886 | *
|
---|
1887 | * @returns Handle to the probe.
|
---|
1888 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1889 | */
|
---|
1890 | VMMR3DECL(DBGFFLOWTRACEPROBE) DBGFR3FlowTraceRecordGetProbe(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1891 | {
|
---|
1892 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1893 | AssertPtrReturn(pRecord, NULL);
|
---|
1894 |
|
---|
1895 | DBGFR3FlowTraceProbeRetain(pRecord->pProbe);
|
---|
1896 | return pRecord->pProbe;
|
---|
1897 | }
|
---|
1898 |
|
---|
1899 |
|
---|
1900 | /**
|
---|
1901 | * Returns the number of values contained in the record.
|
---|
1902 | *
|
---|
1903 | * @returns Number of values in the record.
|
---|
1904 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1905 | */
|
---|
1906 | VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordGetValCount(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1907 | {
|
---|
1908 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1909 | AssertPtrReturn(pRecord, 0);
|
---|
1910 |
|
---|
1911 | return pRecord->pProbe->cEntries;
|
---|
1912 | }
|
---|
1913 |
|
---|
1914 |
|
---|
1915 | /**
|
---|
1916 | * Returns the number of values contained in the record.
|
---|
1917 | *
|
---|
1918 | * @returns Number of values in the record.
|
---|
1919 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1920 | */
|
---|
1921 | VMMR3DECL(uint32_t) DBGFR3FlowTraceRecordGetValCommonCount(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1922 | {
|
---|
1923 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1924 | AssertPtrReturn(pRecord, 0);
|
---|
1925 |
|
---|
1926 | return pRecord->pProbeCmn ? pRecord->pProbeCmn->cEntries : 0;
|
---|
1927 | }
|
---|
1928 |
|
---|
1929 |
|
---|
1930 | /**
|
---|
1931 | * Returns the values for the given record.
|
---|
1932 | *
|
---|
1933 | * @returns Pointer to the array of values.
|
---|
1934 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1935 | */
|
---|
1936 | VMMR3DECL(PCDBGFFLOWTRACEPROBEVAL) DBGFR3FlowTraceRecordGetVals(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1937 | {
|
---|
1938 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1939 | AssertPtrReturn(pRecord, NULL);
|
---|
1940 |
|
---|
1941 | return &pRecord->aVal[0];
|
---|
1942 | }
|
---|
1943 |
|
---|
1944 |
|
---|
1945 | /**
|
---|
1946 | * Returns data collected by the common probe for the trace module this record is in if one
|
---|
1947 | * is active.
|
---|
1948 | *
|
---|
1949 | * @returns Pointer to the array of common probe values or NULL if no common probe was specified
|
---|
1950 | * for the trace module.
|
---|
1951 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1952 | */
|
---|
1953 | VMMR3DECL(PCDBGFFLOWTRACEPROBEVAL) DBGFR3FlowTraceRecordGetValsCommon(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1954 | {
|
---|
1955 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1956 | AssertPtrReturn(pRecord, NULL);
|
---|
1957 |
|
---|
1958 | return pRecord->paValCmn;
|
---|
1959 | }
|
---|
1960 |
|
---|
1961 |
|
---|
1962 | /**
|
---|
1963 | * Returns the vCPU ID the record was created on.
|
---|
1964 | *
|
---|
1965 | * @returns vCPU ID.
|
---|
1966 | * @param hFlowTraceRecord Flow trace record handle.
|
---|
1967 | */
|
---|
1968 | VMMR3DECL(VMCPUID) DBGFR3FlowTraceRecordGetCpuId(DBGFFLOWTRACERECORD hFlowTraceRecord)
|
---|
1969 | {
|
---|
1970 | PDBGFFLOWTRACERECORDINT pRecord = hFlowTraceRecord;
|
---|
1971 | AssertPtrReturn(pRecord, VMCPUID_ANY);
|
---|
1972 |
|
---|
1973 | return pRecord->idCpu;
|
---|
1974 | }
|
---|
1975 |
|
---|