DBGFR3SampleReport.cpp@ 92341

Last change on this file since 92341 was 90549, checked in by vboxsync, 3 years ago
VMM,*: s/DBGFR3InfoGenricGetOptError/DBGFR3InfoGenericGetOptError/g
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.7 KB

Line
1	/* $Id: DBGFR3SampleReport.cpp 90549 2021-08-06 13:57:29Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Sample report creation.
4	*/
5
6	/*
7	* Copyright (C) 2021 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	/** @page pg_dbgf_sample_report DBGFR3SampleReport - Sample Report Interface
20	*
21	* @todo
22	*/
23
24
25	/*********************************************************************************************************************************
26	* Header Files *
27	*********************************************************************************************************************************/
28	#define LOG_GROUP LOG_GROUP_DBGF
29	#include <VBox/vmm/dbgf.h>
30	#include "DBGFInternal.h"
31	#include <VBox/vmm/mm.h>
32	#include <VBox/vmm/uvm.h>
33	#include <VBox/vmm/vm.h>
34	#include <VBox/err.h>
35	#include <VBox/log.h>
36
37	#include <iprt/assert.h>
38	#include <iprt/semaphore.h>
39	#include <iprt/list.h>
40	#include <iprt/mem.h>
41	#include <iprt/time.h>
42	#include <iprt/timer.h>
43	#include <iprt/sort.h>
44	#include <iprt/string.h>
45	#include <iprt/stream.h>
46
47
48	/*********************************************************************************************************************************
49	* Defined Constants And Macros *
50	*********************************************************************************************************************************/
51
52	/** Maximum stack frame depth. */
53	#define DBGF_SAMPLE_REPORT_FRAME_DEPTH_MAX 64
54
55
56	/*********************************************************************************************************************************
57	* Structures and Typedefs *
58	*********************************************************************************************************************************/
59
60	/**
61	* Sample report state.
62	*/
63	typedef enum DBGFSAMPLEREPORTSTATE
64	{
65	/** Invalid state do not use. */
66	DBGFSAMPLEREPORTSTATE_INVALID = 0,
67	/** The sample report is ready to run. */
68	DBGFSAMPLEREPORTSTATE_READY,
69	/** The sampple process is running currently. */
70	DBGFSAMPLEREPORTSTATE_RUNNING,
71	/** The sample process is about to stop. */
72	DBGFSAMPLEREPORTSTATE_STOPPING,
73	/** 32bit hack. */
74	DBGFSAMPLEREPORTSTATE_32BIT_HACK = 0x7fffffff
75	} DBGFSAMPLEREPORTSTATE;
76
77	/** Pointer to a single sample frame. */
78	typedef struct DBGFSAMPLEFRAME *PDBGFSAMPLEFRAME;
79
80	/**
81	* Frame information.
82	*/
83	typedef struct DBGFSAMPLEFRAME
84	{
85	/** Frame address. */
86	DBGFADDRESS AddrFrame;
87	/** Number of times this frame was encountered. */
88	uint64_t cSamples;
89	/** Pointer to the array of frames below in the call stack. */
90	PDBGFSAMPLEFRAME paFrames;
91	/** Number of valid entries in the frams array. */
92	uint64_t cFramesValid;
93	/** Maximum number of entries in the frames array. */
94	uint64_t cFramesMax;
95	} DBGFSAMPLEFRAME;
96	typedef const DBGFSAMPLEFRAME *PCDBGFSAMPLEFRAME;
97
98
99	/**
100	* Per VCPU sample report data.
101	*/
102	typedef struct DBGFSAMPLEREPORTVCPU
103	{
104	/** The root frame. */
105	DBGFSAMPLEFRAME FrameRoot;
106	} DBGFSAMPLEREPORTVCPU;
107	/** Pointer to the per VCPU sample report data. */
108	typedef DBGFSAMPLEREPORTVCPU *PDBGFSAMPLEREPORTVCPU;
109	/** Pointer to const per VCPU sample report data. */
110	typedef const DBGFSAMPLEREPORTVCPU *PCDBGFSAMPLEREPORTVCPU;
111
112
113	/**
114	* Internal sample report instance data.
115	*/
116	typedef struct DBGFSAMPLEREPORTINT
117	{
118	/** References hold for this trace module. */
119	volatile uint32_t cRefs;
120	/** The user mode VM handle. */
121	PUVM pUVM;
122	/** State the sample report is currently in. */
123	volatile DBGFSAMPLEREPORTSTATE enmState;
124	/** Flags passed during report creation. */
125	uint32_t fFlags;
126	/** The timer handle for the sample report collector. */
127	PRTTIMER hTimer;
128	/** The sample interval in microseconds. */
129	uint32_t cSampleIntervalUs;
130	/** THe progress callback if set. */
131	PFNDBGFPROGRESS pfnProgress;
132	/** Opaque user data passed with the progress callback. */
133	void *pvProgressUser;
134	/** Number of microseconds left for sampling. */
135	uint64_t cSampleUsLeft;
136	/** The report created after sampling was stopped. */
137	char *pszReport;
138	/** Number of EMTs having a guest sample operation queued. */
139	volatile uint32_t cEmtsActive;
140	/** Array of per VCPU samples collected. */
141	DBGFSAMPLEREPORTVCPU aCpus[1];
142	} DBGFSAMPLEREPORTINT;
143	/** Pointer to a const internal trace module instance data. */
144	typedef DBGFSAMPLEREPORTINT *PDBGFSAMPLEREPORTINT;
145	/** Pointer to a const internal trace module instance data. */
146	typedef const DBGFSAMPLEREPORTINT *PCDBGFSAMPLEREPORTINT;
147
148
149	/**
150	* Structure to pass to DBGFR3Info() and for doing all other
151	* output during fatal dump.
152	*/
153	typedef struct DBGFSAMPLEREPORTINFOHLP
154	{
155	/** The helper core. */
156	DBGFINFOHLP Core;
157	/** Pointer to the allocated character buffer. */
158	char *pachBuf;
159	/** Number of bytes allocated for the character buffer. */
160	size_t cbBuf;
161	/** Offset into the character buffer. */
162	size_t offBuf;
163	} DBGFSAMPLEREPORTINFOHLP, *PDBGFSAMPLEREPORTINFOHLP;
164	/** Pointer to a DBGFSAMPLEREPORTINFOHLP structure. */
165	typedef const DBGFSAMPLEREPORTINFOHLP *PCDBGFSAMPLEREPORTINFOHLP;
166
167
168	/*********************************************************************************************************************************
169	* Internal Functions *
170	*********************************************************************************************************************************/
171
172	/**
173	* Print formatted string.
174	*
175	* @param pHlp Pointer to this structure.
176	* @param pszFormat The format string.
177	* @param ... Arguments.
178	*/
179	static DECLCALLBACK(void) dbgfR3SampleReportInfoHlp_pfnPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
180	{
181	va_list args;
182	va_start(args, pszFormat);
183	pHlp->pfnPrintfV(pHlp, pszFormat, args);
184	va_end(args);
185	}
186
187
188	/**
189	* Print formatted string.
190	*
191	* @param pHlp Pointer to this structure.
192	* @param pszFormat The format string.
193	* @param args Argument list.
194	*/
195	static DECLCALLBACK(void) dbgfR3SampleReportInfoHlp_pfnPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
196	{
197	PDBGFSAMPLEREPORTINFOHLP pMyHlp = (PDBGFSAMPLEREPORTINFOHLP)pHlp;
198
199	va_list args2;
200	va_copy(args2, args);
201	ssize_t cch = RTStrPrintf2V(&pMyHlp->pachBuf[pMyHlp->offBuf], pMyHlp->cbBuf - pMyHlp->offBuf, pszFormat, args2);
202	if (cch < 0)
203	{
204	/* Try increase the buffer. */
205	char pachBufNew = (char )RTMemRealloc(pMyHlp->pachBuf, pMyHlp->cbBuf + RT_MAX(_4K, -cch));
206	if (pachBufNew)
207	{
208	pMyHlp->pachBuf = pachBufNew;
209	pMyHlp->cbBuf += RT_MAX(_4K, -cch);
210	cch = RTStrPrintf2V(&pMyHlp->pachBuf[pMyHlp->offBuf], pMyHlp->cbBuf - pMyHlp->offBuf, pszFormat, args2);
211	Assert(cch > 0);
212	pMyHlp->offBuf += cch;
213	}
214	}
215	else
216	pMyHlp->offBuf += cch;
217	va_end(args2);
218	}
219
220
221	/**
222	* Initializes the sample report output helper.
223	*
224	* @param pHlp The structure to initialize.
225	*/
226	static void dbgfR3SampleReportInfoHlpInit(PDBGFSAMPLEREPORTINFOHLP pHlp)
227	{
228	RT_BZERO(pHlp, sizeof(*pHlp));
229
230	pHlp->Core.pfnPrintf = dbgfR3SampleReportInfoHlp_pfnPrintf;
231	pHlp->Core.pfnPrintfV = dbgfR3SampleReportInfoHlp_pfnPrintfV;
232	pHlp->Core.pfnGetOptError = DBGFR3InfoGenericGetOptError;
233
234	pHlp->pachBuf = (char *)RTMemAllocZ(_4K);
235	if (pHlp->pachBuf)
236	pHlp->cbBuf = _4K;
237	}
238
239
240	/**
241	* Deletes the sample report output helper.
242	*
243	* @param pHlp The structure to delete.
244	*/
245	static void dbgfR3SampleReportInfoHlpDelete(PDBGFSAMPLEREPORTINFOHLP pHlp)
246	{
247	if (pHlp->pachBuf)
248	RTMemFree(pHlp->pachBuf);
249	}
250
251
252	/**
253	* Frees the given frame and all its descendants.
254	*
255	* @returns nothing.
256	* @param pFrame The frame to free.
257	*/
258	static void dbgfR3SampleReportFrameFree(PDBGFSAMPLEFRAME pFrame)
259	{
260	for (uint32_t i = 0; i < pFrame->cFramesValid; i++)
261	dbgfR3SampleReportFrameFree(&pFrame->paFrames[i]); /** @todo Recursion... */
262
263	MMR3HeapFree(pFrame->paFrames);
264	memset(pFrame, 0, sizeof(*pFrame));
265	}
266
267
268	/**
269	* Destroys the given sample report freeing all allocated resources.
270	*
271	* @returns nothing.
272	* @param pThis The sample report instance data.
273	*/
274	static void dbgfR3SampleReportDestroy(PDBGFSAMPLEREPORTINT pThis)
275	{
276	for (uint32_t i = 0; i < pThis->pUVM->cCpus; i++)
277	dbgfR3SampleReportFrameFree(&pThis->aCpus[i].FrameRoot);
278	MMR3HeapFree(pThis);
279	}
280
281
282	/**
283	* Returns the frame belonging to the given address or NULL if not found.
284	*
285	* @returns Pointer to the descendant frame or NULL if not found.
286	* @param pFrame The frame to look for descendants with the matching address.
287	* @param pAddr The guest address to search for.
288	*/
289	static PDBGFSAMPLEFRAME dbgfR3SampleReportFrameFindByAddr(PCDBGFSAMPLEFRAME pFrame, PCDBGFADDRESS pAddr)
290	{
291	for (uint32_t i = 0; i < pFrame->cFramesValid; i++)
292	if (!memcmp(pAddr, &pFrame->paFrames[i].AddrFrame, sizeof(*pAddr)))
293	return &pFrame->paFrames[i];
294
295	return NULL;
296	}
297
298
299	/**
300	* Adds the given address to as a descendant to the given frame.
301	*
302	* @returns Pointer to the newly inserted frame identified by the given address.
303	* @param pUVM The usermode VM handle.
304	* @param pFrame The frame to add the new one to as a descendant.
305	* @param pAddr The guest address to add.
306	*/
307	static PDBGFSAMPLEFRAME dbgfR3SampleReportAddFrameByAddr(PUVM pUVM, PDBGFSAMPLEFRAME pFrame, PCDBGFADDRESS pAddr)
308	{
309	if (pFrame->cFramesValid == pFrame->cFramesMax)
310	{
311	uint32_t cFramesMaxNew = pFrame->cFramesMax + 10;
312	PDBGFSAMPLEFRAME paFramesNew = NULL;
313	if (pFrame->paFrames)
314	paFramesNew = (PDBGFSAMPLEFRAME)MMR3HeapRealloc(pFrame->paFrames, sizeof(pFrame->paFrames) cFramesMaxNew);
315	else
316	paFramesNew = (PDBGFSAMPLEFRAME)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF, sizeof(pFrame->paFrames) cFramesMaxNew);
317
318	if (!paFramesNew)
319	return NULL;
320
321	pFrame->cFramesMax = cFramesMaxNew;
322	pFrame->paFrames = paFramesNew;
323	}
324
325	PDBGFSAMPLEFRAME pFrameNew = &pFrame->paFrames[pFrame->cFramesValid++];
326	pFrameNew->AddrFrame = *pAddr;
327	pFrameNew->cSamples = 1;
328	pFrameNew->paFrames = NULL;
329	pFrameNew->cFramesMax = 0;
330	pFrameNew->cFramesValid = 0;
331	return pFrameNew;
332	}
333
334
335	/**
336	* @copydoc FNRTSORTCMP
337	*/
338	static DECLCALLBACK(int) dbgfR3SampleReportFrameSortCmp(void const pvElement1, void const pvElement2, void *pvUser)
339	{
340	RT_NOREF(pvUser);
341	PCDBGFSAMPLEFRAME pFrame1 = (PCDBGFSAMPLEFRAME)pvElement1;
342	PCDBGFSAMPLEFRAME pFrame2 = (PCDBGFSAMPLEFRAME)pvElement2;
343
344	if (pFrame1->cSamples < pFrame2->cSamples)
345	return 1;
346	if (pFrame1->cSamples > pFrame2->cSamples)
347	return -1;
348
349	return 0;
350	}
351
352
353	/**
354	* Dumps a single given frame to the release log.
355	*
356	* @returns nothing.
357	* @param pHlp The debug info helper used for printing.
358	* @param pUVM The usermode VM handle.
359	* @param pFrame The frame to dump.
360	* @param idxFrame The frame number.
361	*/
362	static void dbgfR3SampleReportDumpFrame(PCDBGFINFOHLP pHlp, PUVM pUVM, PCDBGFSAMPLEFRAME pFrame, uint32_t idxFrame)
363	{
364	RTGCINTPTR offDisp;
365	RTDBGMOD hMod;
366	RTDBGSYMBOL SymPC;
367
368	if (DBGFR3AddrIsValid(pUVM, &pFrame->AddrFrame))
369	{
370	int rc = DBGFR3AsSymbolByAddr(pUVM, DBGF_AS_GLOBAL, &pFrame->AddrFrame,
371	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL \| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
372	&offDisp, &SymPC, &hMod);
373	if (RT_SUCCESS(rc))
374	{
375	const char *pszModName = hMod != NIL_RTDBGMOD ? RTDbgModName(hMod) : NULL;
376
377	pHlp->pfnPrintf(pHlp,
378	"%s%RU64 %s+%llx (%s) [%RGv]\n", idxFrame 4, " ",
379	pFrame->cSamples,
380	SymPC.szName, offDisp,
381	hMod ? pszModName : "",
382	pFrame->AddrFrame.FlatPtr);
383	RTDbgModRelease(hMod);
384	}
385	else
386	pHlp->pfnPrintf(pHlp, "%s%RU64 %RGv\n", idxFrame 4, " ", pFrame->cSamples, pFrame->AddrFrame.FlatPtr);
387	}
388	else
389	pHlp->pfnPrintf(pHlp, "%s%RU64 %RGv\n", idxFrame 4, " ", pFrame->cSamples, pFrame->AddrFrame.FlatPtr);
390
391	/* Sort by sample count. */
392	RTSortShell(pFrame->paFrames, pFrame->cFramesValid, sizeof(*pFrame->paFrames), dbgfR3SampleReportFrameSortCmp, NULL);
393
394	for (uint32_t i = 0; i < pFrame->cFramesValid; i++)
395	dbgfR3SampleReportDumpFrame(pHlp, pUVM, &pFrame->paFrames[i], idxFrame + 1);
396	}
397
398
399	/**
400	* Worker for dbgfR3SampleReportTakeSample(), doing the work in an EMT rendezvous point on
401	* each VCPU.
402	*
403	* @returns nothing.
404	* @param pThis Pointer to the sample report instance.
405	*/
406	static DECLCALLBACK(void) dbgfR3SampleReportSample(PDBGFSAMPLEREPORTINT pThis)
407	{
408	PVM pVM = pThis->pUVM->pVM;
409	PVMCPU pVCpu = VMMGetCpu(pVM);
410
411	PCDBGFSTACKFRAME pFrameFirst;
412	int rc = DBGFR3StackWalkBegin(pThis->pUVM, pVCpu->idCpu, DBGFCODETYPE_GUEST, &pFrameFirst);
413	if (RT_SUCCESS(rc))
414	{
415	DBGFADDRESS aFrameAddresses[DBGF_SAMPLE_REPORT_FRAME_DEPTH_MAX];
416	uint32_t idxFrame = 0;
417
418	PDBGFSAMPLEFRAME pFrame = &pThis->aCpus[pVCpu->idCpu].FrameRoot;
419	pFrame->cSamples++;
420
421	for (PCDBGFSTACKFRAME pStackFrame = pFrameFirst;
422	pStackFrame && idxFrame < RT_ELEMENTS(aFrameAddresses);
423	pStackFrame = DBGFR3StackWalkNext(pStackFrame))
424	{
425	if (pThis->fFlags & DBGF_SAMPLE_REPORT_F_STACK_REVERSE)
426	{
427	PDBGFSAMPLEFRAME pFrameNext = dbgfR3SampleReportFrameFindByAddr(pFrame, &pStackFrame->AddrPC);
428	if (!pFrameNext)
429	pFrameNext = dbgfR3SampleReportAddFrameByAddr(pThis->pUVM, pFrame, &pStackFrame->AddrPC);
430	else
431	pFrameNext->cSamples++;
432
433	pFrame = pFrameNext;
434	}
435	else
436	aFrameAddresses[idxFrame] = pStackFrame->AddrPC;
437
438	idxFrame++;
439	}
440
441	DBGFR3StackWalkEnd(pFrameFirst);
442
443	if (!(pThis->fFlags & DBGF_SAMPLE_REPORT_F_STACK_REVERSE))
444	{
445	/* Walk the frame stack backwards and construct the call stack. */
446	while (idxFrame--)
447	{
448	PDBGFSAMPLEFRAME pFrameNext = dbgfR3SampleReportFrameFindByAddr(pFrame, &aFrameAddresses[idxFrame]);
449	if (!pFrameNext)
450	pFrameNext = dbgfR3SampleReportAddFrameByAddr(pThis->pUVM, pFrame, &aFrameAddresses[idxFrame]);
451	else
452	pFrameNext->cSamples++;
453
454	pFrame = pFrameNext;
455	}
456	}
457	}
458	else
459	LogRelMax(10, ("Sampling guest stack on VCPU %u failed with rc=%Rrc\n", pVCpu->idCpu, rc));
460
461	/* Last EMT finishes the report when sampling was stopped. */
462	uint32_t cEmtsActive = ASMAtomicDecU32(&pThis->cEmtsActive);
463	if ( ASMAtomicReadU32((volatile uint32_t *)&pThis->enmState) == DBGFSAMPLEREPORTSTATE_STOPPING
464	&& !cEmtsActive)
465	{
466	rc = RTTimerDestroy(pThis->hTimer); AssertRC(rc); RT_NOREF(rc);
467	pThis->hTimer = NULL;
468
469	DBGFSAMPLEREPORTINFOHLP Hlp;
470	PCDBGFINFOHLP pHlp = &Hlp.Core;
471
472	dbgfR3SampleReportInfoHlpInit(&Hlp);
473
474	/* Some early dump code. */
475	for (uint32_t i = 0; i < pThis->pUVM->cCpus; i++)
476	{
477	PCDBGFSAMPLEREPORTVCPU pSampleVCpu = &pThis->aCpus[i];
478
479	pHlp->pfnPrintf(pHlp, "Sample report for vCPU %u:\n", i);
480	dbgfR3SampleReportDumpFrame(pHlp, pThis->pUVM, &pSampleVCpu->FrameRoot, 0);
481	}
482
483	/* Shameless copy from VMMGuruMeditation.cpp */
484	static struct
485	{
486	const char *pszInfo;
487	const char *pszArgs;
488	} const aInfo[] =
489	{
490	{ "mappings", NULL },
491	{ "mode", "all" },
492	{ "handlers", "phys virt hyper stats" },
493	{ "timers", NULL },
494	{ "activetimers", NULL },
495	};
496	for (unsigned i = 0; i < RT_ELEMENTS(aInfo); i++)
497	{
498	pHlp->pfnPrintf(pHlp,
499	"!!\n"
500	"!! {%s, %s}\n"
501	"!!\n",
502	aInfo[i].pszInfo, aInfo[i].pszArgs);
503	DBGFR3Info(pVM->pUVM, aInfo[i].pszInfo, aInfo[i].pszArgs, pHlp);
504	}
505
506	/* All other info items */
507	DBGFR3InfoMulti(pVM,
508	"*",
509	"mappings\|hma\|cpum\|cpumguest\|cpumguesthwvirt\|cpumguestinstr\|cpumhyper\|cpumhost\|cpumvmxfeat\|mode\|cpuid"
510	"\|pgmpd\|pgmcr3\|timers\|activetimers\|handlers\|help\|cfgm",
511	"!!\n"
512	"!! {%s}\n"
513	"!!\n",
514	pHlp);
515
516
517	/* done */
518	pHlp->pfnPrintf(pHlp,
519	"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
520
521	if (pThis->pszReport)
522	RTMemFree(pThis->pszReport);
523	pThis->pszReport = Hlp.pachBuf;
524	Hlp.pachBuf = NULL;
525	dbgfR3SampleReportInfoHlpDelete(&Hlp);
526
527	ASMAtomicXchgU32((volatile uint32_t *)&pThis->enmState, DBGFSAMPLEREPORTSTATE_READY);
528
529	if (pThis->pfnProgress)
530	{
531	pThis->pfnProgress(pThis->pvProgressUser, 100);
532	pThis->pfnProgress = NULL;
533	pThis->pvProgressUser = NULL;
534	}
535
536	DBGFR3SampleReportRelease(pThis);
537	}
538	}
539
540
541	/**
542	* @copydoc FNRTTIMER
543	*/
544	static DECLCALLBACK(void) dbgfR3SampleReportTakeSample(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
545	{
546	PDBGFSAMPLEREPORTINT pThis = (PDBGFSAMPLEREPORTINT)pvUser;
547
548	if (pThis->cSampleUsLeft != UINT32_MAX)
549	{
550	int rc = VINF_SUCCESS;
551	uint64_t cUsSampled = iTick * pThis->cSampleIntervalUs; /** @todo Wrong if the timer resolution is different from what we've requested. */
552
553	/* Update progress. */
554	if (pThis->pfnProgress)
555	rc = pThis->pfnProgress(pThis->pvProgressUser, cUsSampled * 99 / pThis->cSampleUsLeft);
556
557	if ( cUsSampled >= pThis->cSampleUsLeft
558	\|\| rc == VERR_DBGF_CANCELLED)
559	{
560	/*
561	* Let the EMTs do one last round in order to be able to destroy the timer (can't do this on the timer thread)
562	* and gather information from the devices.
563	*/
564	ASMAtomicCmpXchgU32((volatile uint32_t *)&pThis->enmState, DBGFSAMPLEREPORTSTATE_STOPPING,
565	DBGFSAMPLEREPORTSTATE_RUNNING);
566
567	rc = RTTimerStop(pTimer); AssertRC(rc); RT_NOREF(rc);
568	}
569	}
570
571	ASMAtomicAddU32(&pThis->cEmtsActive, pThis->pUVM->cCpus);
572
573	for (uint32_t i = 0; i < pThis->pUVM->cCpus; i++)
574	{
575	int rc = VMR3ReqCallVoidNoWait(pThis->pUVM->pVM, i, (PFNRT)dbgfR3SampleReportSample, 1, pThis);
576	AssertRC(rc);
577	if (RT_FAILURE(rc))
578	ASMAtomicDecU32(&pThis->cEmtsActive);
579	}
580	}
581
582
583	/**
584	* Creates a new sample report instance for the specified VM.
585	*
586	* @returns VBox status code.
587	* @param pUVM The usermode VM handle.
588	* @param cSampleIntervalUs The sample interval in micro seconds.
589	* @param fFlags Combination of DBGF_SAMPLE_REPORT_F_XXX.
590	* @param phSample Where to return the handle to the sample report on success.
591	*/
592	VMMR3DECL(int) DBGFR3SampleReportCreate(PUVM pUVM, uint32_t cSampleIntervalUs, uint32_t fFlags, PDBGFSAMPLEREPORT phSample)
593	{
594	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
595	AssertReturn(!(fFlags & ~DBGF_SAMPLE_REPORT_F_VALID_MASK), VERR_INVALID_PARAMETER);
596	AssertPtrReturn(phSample, VERR_INVALID_POINTER);
597
598	int rc = VINF_SUCCESS;
599	PDBGFSAMPLEREPORTINT pThis = (PDBGFSAMPLEREPORTINT)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF,
600	RT_UOFFSETOF_DYN(DBGFSAMPLEREPORTINT, aCpus[pUVM->cCpus]));
601	if (RT_LIKELY(pThis))
602	{
603	pThis->cRefs = 1;
604	pThis->pUVM = pUVM;
605	pThis->fFlags = fFlags;
606	pThis->cSampleIntervalUs = cSampleIntervalUs;
607	pThis->enmState = DBGFSAMPLEREPORTSTATE_READY;
608	pThis->cEmtsActive = 0;
609
610	for (uint32_t i = 0; i < pUVM->cCpus; i++)
611	{
612	pThis->aCpus[i].FrameRoot.paFrames = NULL;
613	pThis->aCpus[i].FrameRoot.cSamples = 0;
614	pThis->aCpus[i].FrameRoot.cFramesValid = 0;
615	pThis->aCpus[i].FrameRoot.cFramesMax = 0;
616	}
617
618	*phSample = pThis;
619	return VINF_SUCCESS;
620	}
621	else
622	rc = VERR_NO_MEMORY;
623
624	return rc;
625	}
626
627
628	/**
629	* Retains a reference to the given sample report handle.
630	*
631	* @returns New reference count.
632	* @param hSample Sample report handle.
633	*/
634	VMMR3DECL(uint32_t) DBGFR3SampleReportRetain(DBGFSAMPLEREPORT hSample)
635	{
636	PDBGFSAMPLEREPORTINT pThis = hSample;
637	AssertPtrReturn(pThis, UINT32_MAX);
638
639	uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
640	AssertMsg(cRefs > 1 && cRefs < _1M, ("%#x %p\n", cRefs, pThis));
641	return cRefs;
642	}
643
644
645	/**
646	* Release a given sample report handle reference.
647	*
648	* @returns New reference count, on 0 the sample report instance is destroyed.
649	* @param hSample Sample report handle.
650	*/
651	VMMR3DECL(uint32_t) DBGFR3SampleReportRelease(DBGFSAMPLEREPORT hSample)
652	{
653	PDBGFSAMPLEREPORTINT pThis = hSample;
654	if (!pThis)
655	return 0;
656	AssertPtrReturn(pThis, UINT32_MAX);
657	AssertReturn(ASMAtomicReadU32((volatile uint32_t *)&pThis->enmState) == DBGFSAMPLEREPORTSTATE_READY,
658	0);
659
660	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
661	AssertMsg(cRefs < _1M, ("%#x %p\n", cRefs, pThis));
662	if (cRefs == 0)
663	dbgfR3SampleReportDestroy(pThis);
664	return cRefs;
665	}
666
667
668	/**
669	* Starts collecting samples for the given sample report.
670	*
671	* @returns VBox status code.
672	* @param hSample Sample report handle.
673	* @param cSampleUs Number of microseconds to sample at the interval given during creation.
674	* Use UINT32_MAX to sample for an indefinite amount of time.
675	* @param pfnProgress Optional progress callback.
676	* @param pvUser Opaque user data to pass to the progress callback.
677	*/
678	VMMR3DECL(int) DBGFR3SampleReportStart(DBGFSAMPLEREPORT hSample, uint64_t cSampleUs, PFNDBGFPROGRESS pfnProgress, void *pvUser)
679	{
680	PDBGFSAMPLEREPORTINT pThis = hSample;
681
682	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
683	AssertReturn(ASMAtomicCmpXchgU32((volatile uint32_t *)&pThis->enmState, DBGFSAMPLEREPORTSTATE_RUNNING, DBGFSAMPLEREPORTSTATE_READY),
684	VERR_INVALID_STATE);
685
686	pThis->pfnProgress = pfnProgress;
687	pThis->pvProgressUser = pvUser;
688	pThis->cSampleUsLeft = cSampleUs;
689
690	/* Try to detect the guest OS first so we can get more accurate symbols and addressing. */
691	char szName[64];
692	int rc = DBGFR3OSDetect(pThis->pUVM, &szName[0], sizeof(szName));
693	if (RT_SUCCESS(rc))
694	{
695	LogRel(("DBGF/SampleReport: Detected guest OS \"%s\"\n", szName));
696	char szVersion[512];
697	int rc2 = DBGFR3OSQueryNameAndVersion(pThis->pUVM, NULL, 0, szVersion, sizeof(szVersion));
698	if (RT_SUCCESS(rc2))
699	LogRel(("DBGF/SampleReport: Version : \"%s\"\n", szVersion));
700	}
701	else
702	LogRel(("DBGF/SampleReport: Couldn't detect guest operating system rc=%Rcr\n", rc));
703
704	/*
705	* We keep an additional reference to ensure that the sample report stays alive,
706	* it will be dropped when the sample process is stopped.
707	*/
708	DBGFR3SampleReportRetain(pThis);
709
710	rc = RTTimerCreateEx(&pThis->hTimer, pThis->cSampleIntervalUs * 1000,
711	RTTIMER_FLAGS_CPU_ANY \| RTTIMER_FLAGS_HIGH_RES,
712	dbgfR3SampleReportTakeSample, pThis);
713	if (RT_SUCCESS(rc))
714	rc = RTTimerStart(pThis->hTimer, 0 /u64First/);
715	if (RT_FAILURE(rc))
716	{
717	if (pThis->hTimer)
718	{
719	int rc2 = RTTimerDestroy(pThis->hTimer);
720	AssertRC(rc2); RT_NOREF(rc2);
721	pThis->hTimer = NULL;
722	}
723
724	bool fXchg = ASMAtomicCmpXchgU32((volatile uint32_t *)&pThis->enmState, DBGFSAMPLEREPORTSTATE_READY,
725	DBGFSAMPLEREPORTSTATE_RUNNING);
726	Assert(fXchg); RT_NOREF(fXchg);
727	DBGFR3SampleReportRelease(pThis);
728	}
729
730	return rc;
731	}
732
733
734	/**
735	* Stops collecting samples for the given sample report.
736	*
737	* @returns VBox status code.
738	* @param hSample Sample report handle.
739	*/
740	VMMR3DECL(int) DBGFR3SampleReportStop(DBGFSAMPLEREPORT hSample)
741	{
742	PDBGFSAMPLEREPORTINT pThis = hSample;
743
744	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
745	AssertReturn(ASMAtomicCmpXchgU32((volatile uint32_t *)&pThis->enmState, DBGFSAMPLEREPORTSTATE_STOPPING,
746	DBGFSAMPLEREPORTSTATE_RUNNING),
747	VERR_INVALID_STATE);
748	return VINF_SUCCESS;
749	}
750
751
752	/**
753	* Dumps the current sample report to the given file.
754	*
755	* @returns VBox status code.
756	* @retval VERR_INVALID_STATE if nothing was sampled so far for reporting.
757	* @param hSample Sample report handle.
758	* @param pszFilename The filename to dump the report to.
759	*/
760	VMMR3DECL(int) DBGFR3SampleReportDumpToFile(DBGFSAMPLEREPORT hSample, const char *pszFilename)
761	{
762	PDBGFSAMPLEREPORTINT pThis = hSample;
763
764	AssertReturn(pThis->pszReport, VERR_INVALID_STATE);
765
766	PRTSTREAM hStream;
767	int rc = RTStrmOpen(pszFilename, "w", &hStream);
768	if (RT_SUCCESS(rc))
769	{
770	rc = RTStrmPutStr(hStream, pThis->pszReport);
771	RTStrmClose(hStream);
772	}
773
774	return rc;
775	}
776

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFR3SampleReport.cpp@ 92341

Download in other formats: