STAM.cpp@ 30647

Last change on this file since 30647 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 69.4 KB

Line
1	/* $Id: STAM.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2	/** @file
3	* STAM - The Statistics Manager.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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	/** @page pg_stam STAM - The Statistics Manager
19	*
20	* The purpose for the statistics manager is to present the rest of the system
21	* with a somewhat uniform way of accessing VMM statistics. STAM sports a
22	* couple of different APIs for accessing them: STAMR3EnumU, STAMR3SnapshotU,
23	* STAMR3DumpU, STAMR3DumpToReleaseLogU and the debugger. Main is exposing the
24	* XML based one, STAMR3SnapshotU.
25	*
26	* The rest of the VMM together with the devices and drivers registers their
27	* statistics with STAM giving them a name. The name is hierarchical, the
28	* components separated by slashes ('/') and must start with a slash.
29	*
30	* Each item registered with STAM - also, half incorrectly, called a sample -
31	* has a type, unit, visibility, data pointer and description associated with it
32	* in addition to the name (described above). The type tells STAM what kind of
33	* structure the pointer is pointing to. The visibility allows unused
34	* statistics from cluttering the output or showing up in the GUI. All the bits
35	* together makes STAM able to present the items in a sensible way to the user.
36	* Some types also allows STAM to reset the data, which is very convenient when
37	* digging into specific operations and such.
38	*
39	* PS. The VirtualBox Debugger GUI has a viewer for inspecting the statistics
40	* STAM provides. You will also find statistics in the release and debug logs.
41	* And as mentioned in the introduction, the debugger console features a couple
42	* of command: .stats and .statsreset.
43	*
44	* @see grp_stam
45	*/
46
47	/*******************************************************************************
48	* Header Files *
49	*******************************************************************************/
50	#define LOG_GROUP LOG_GROUP_STAM
51	#include <VBox/stam.h>
52	#include "STAMInternal.h"
53	#include <VBox/vm.h>
54	#include <VBox/uvm.h>
55	#include <VBox/err.h>
56	#include <VBox/dbg.h>
57	#include <VBox/log.h>
58
59	#include <iprt/assert.h>
60	#include <iprt/asm.h>
61	#include <iprt/alloc.h>
62	#include <iprt/stream.h>
63	#include <iprt/string.h>
64
65
66	/*******************************************************************************
67	* Structures and Typedefs *
68	*******************************************************************************/
69	/**
70	* Argument structure for stamR3PrintOne().
71	*/
72	typedef struct STAMR3PRINTONEARGS
73	{
74	PVM pVM;
75	void *pvArg;
76	DECLCALLBACKMEMBER(void, pfnPrintf)(struct STAMR3PRINTONEARGS pvArg, const char pszFormat, ...);
77	} STAMR3PRINTONEARGS, *PSTAMR3PRINTONEARGS;
78
79
80	/**
81	* Argument structure to stamR3EnumOne().
82	*/
83	typedef struct STAMR3ENUMONEARGS
84	{
85	PVM pVM;
86	PFNSTAMR3ENUM pfnEnum;
87	void *pvUser;
88	} STAMR3ENUMONEARGS, *PSTAMR3ENUMONEARGS;
89
90
91	/**
92	* The snapshot status structure.
93	* Argument package passed to stamR3SnapshotOne, stamR3SnapshotPrintf and stamR3SnapshotOutput.
94	*/
95	typedef struct STAMR3SNAPSHOTONE
96	{
97	/** Pointer to the buffer start. */
98	char *pszStart;
99	/** Pointer to the buffer end. */
100	char *pszEnd;
101	/** Pointer to the current buffer position. */
102	char *psz;
103	/** The VM handle. */
104	PVM pVM;
105	/** The number of bytes allocated. */
106	size_t cbAllocated;
107	/** The status code. */
108	int rc;
109	/** Whether to include the description strings. */
110	bool fWithDesc;
111	} STAMR3SNAPSHOTONE, *PSTAMR3SNAPSHOTONE;
112
113
114	/**
115	* Init record for a ring-0 statistic sample.
116	*/
117	typedef struct STAMR0SAMPLE
118	{
119	/** The GVMMSTATS structure offset of the variable. */
120	unsigned offVar;
121	/** The type. */
122	STAMTYPE enmType;
123	/** The unit. */
124	STAMUNIT enmUnit;
125	/** The name. */
126	const char *pszName;
127	/** The description. */
128	const char *pszDesc;
129	} STAMR0SAMPLE;
130
131
132	/*******************************************************************************
133	* Internal Functions *
134	*******************************************************************************/
135	static int stamR3RegisterU(PUVM pUVM, void *pvSample, PFNSTAMR3CALLBACKRESET pfnReset, PFNSTAMR3CALLBACKPRINT pfnPrint,
136	STAMTYPE enmType, STAMVISIBILITY enmVisibility, const char pszName, STAMUNIT enmUnit, const char pszDesc);
137	static int stamR3ResetOne(PSTAMDESC pDesc, void *pvArg);
138	static DECLCALLBACK(void) stamR3EnumLogPrintf(PSTAMR3PRINTONEARGS pvArg, const char *pszFormat, ...);
139	static DECLCALLBACK(void) stamR3EnumRelLogPrintf(PSTAMR3PRINTONEARGS pvArg, const char *pszFormat, ...);
140	static DECLCALLBACK(void) stamR3EnumPrintf(PSTAMR3PRINTONEARGS pvArg, const char *pszFormat, ...);
141	static int stamR3SnapshotOne(PSTAMDESC pDesc, void *pvArg);
142	static int stamR3SnapshotPrintf(PSTAMR3SNAPSHOTONE pThis, const char *pszFormat, ...);
143	static int stamR3PrintOne(PSTAMDESC pDesc, void *pvArg);
144	static int stamR3EnumOne(PSTAMDESC pDesc, void *pvArg);
145	static bool stamR3MultiMatch(const char * const papszExpressions, unsigned cExpressions, unsigned piExpression, const char *pszName);
146	static char ** stamR3SplitPattern(const char pszPat, unsigned pcExpressions, char **ppszCopy);
147	static int stamR3EnumU(PUVM pUVM, const char pszPat, bool fUpdateRing0, int (pfnCallback)(PSTAMDESC pDesc, void pvArg), void *pvArg);
148	static void stamR3Ring0StatsRegisterU(PUVM pUVM);
149	static void stamR3Ring0StatsUpdateU(PUVM pUVM, const char *pszPat);
150	static void stamR3Ring0StatsUpdateMultiU(PUVM pUVM, const char * const *papszExpressions, unsigned cExpressions);
151
152	#ifdef VBOX_WITH_DEBUGGER
153	static DECLCALLBACK(int) stamR3CmdStats(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
154	static DECLCALLBACK(void) stamR3EnumDbgfPrintf(PSTAMR3PRINTONEARGS pArgs, const char *pszFormat, ...);
155	static DECLCALLBACK(int) stamR3CmdStatsReset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
156	#endif
157
158
159	/*******************************************************************************
160	* Global Variables *
161	*******************************************************************************/
162	#ifdef VBOX_WITH_DEBUGGER
163	/** Pattern argument. */
164	static const DBGCVARDESC g_aArgPat[] =
165	{
166	/* cTimesMin, cTimesMax, enmCategory, fFlags, pszName, pszDescription */
167	{ 0, 1, DBGCVAR_CAT_STRING, 0, "pattern", "Which samples the command shall be applied to. Use '*' as wildcard. Use ';' to separate expression." }
168	};
169
170	/** Command descriptors. */
171	static const DBGCCMD g_aCmds[] =
172	{
173	/* pszCmd, cArgsMin, cArgsMax, paArgDesc, cArgDescs, pResultDesc, fFlags, pfnHandler pszSyntax, ....pszDescription */
174	{ "stats", 0, 1, &g_aArgPat[0], RT_ELEMENTS(g_aArgPat), NULL, 0, stamR3CmdStats, "[pattern]", "Display statistics." },
175	{ "statsreset", 0, 1, &g_aArgPat[0], RT_ELEMENTS(g_aArgPat), NULL, 0, stamR3CmdStatsReset,"[pattern]", "Resets statistics." }
176	};
177	#endif
178
179
180	/**
181	* The GVMM mapping records.
182	*/
183	static const STAMR0SAMPLE g_aGVMMStats[] =
184	{
185	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cHaltCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/HaltCalls", "The number of calls to GVMMR0SchedHalt." },
186	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cHaltBlocking), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/HaltBlocking", "The number of times we did go to sleep in GVMMR0SchedHalt." },
187	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cHaltTimeouts), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/HaltTimeouts", "The number of times we timed out in GVMMR0SchedHalt." },
188	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cHaltNotBlocking), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/HaltNotBlocking", "The number of times we didn't go to sleep in GVMMR0SchedHalt." },
189	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cHaltWakeUps), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/HaltWakeUps", "The number of wake ups done during GVMMR0SchedHalt." },
190	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cWakeUpCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/WakeUpCalls", "The number of calls to GVMMR0WakeUp." },
191	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cWakeUpNotHalted), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/WakeUpNotHalted", "The number of times the EMT thread wasn't actually halted when GVMMR0WakeUp was called." },
192	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cWakeUpWakeUps), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/WakeUpWakeUps", "The number of wake ups done during GVMMR0WakeUp (not counting the explicit one)." },
193	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cPokeCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/PokeCalls", "The number of calls to GVMMR0Poke." },
194	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cPokeNotBusy), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/PokeNotBusy", "The number of times the EMT thread wasn't actually busy when GVMMR0Poke was called." },
195	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cPollCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/PollCalls", "The number of calls to GVMMR0SchedPoll." },
196	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cPollHalts), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/PollHalts", "The number of times the EMT has halted in a GVMMR0SchedPoll call." },
197	{ RT_UOFFSETOF(GVMMSTATS, SchedVM.cPollWakeUps), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/VM/PollWakeUps", "The number of wake ups done during GVMMR0SchedPoll." },
198
199	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cHaltCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/HaltCalls", "The number of calls to GVMMR0SchedHalt." },
200	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cHaltBlocking), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/HaltBlocking", "The number of times we did go to sleep in GVMMR0SchedHalt." },
201	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cHaltTimeouts), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/HaltTimeouts", "The number of times we timed out in GVMMR0SchedHalt." },
202	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cHaltNotBlocking), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/HaltNotBlocking", "The number of times we didn't go to sleep in GVMMR0SchedHalt." },
203	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cHaltWakeUps), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/HaltWakeUps", "The number of wake ups done during GVMMR0SchedHalt." },
204	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cWakeUpCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/WakeUpCalls", "The number of calls to GVMMR0WakeUp." },
205	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cWakeUpNotHalted), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/WakeUpNotHalted", "The number of times the EMT thread wasn't actually halted when GVMMR0WakeUp was called." },
206	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cWakeUpWakeUps), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/WakeUpWakeUps", "The number of wake ups done during GVMMR0WakeUp (not counting the explicit one)." },
207	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cPokeCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/PokeCalls", "The number of calls to GVMMR0Poke." },
208	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cPokeNotBusy), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/PokeNotBusy", "The number of times the EMT thread wasn't actually busy when GVMMR0Poke was called." },
209	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cPollCalls), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/PollCalls", "The number of calls to GVMMR0SchedPoll." },
210	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cPollHalts), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/PollHalts", "The number of times the EMT has halted in a GVMMR0SchedPoll call." },
211	{ RT_UOFFSETOF(GVMMSTATS, SchedSum.cPollWakeUps), STAMTYPE_U64_RESET, STAMUNIT_CALLS, "/GVMM/Sum/PollWakeUps", "The number of wake ups done during GVMMR0SchedPoll." },
212
213	{ RT_UOFFSETOF(GVMMSTATS, cVMs), STAMTYPE_U32, STAMUNIT_CALLS, "/GVMM/VMs", "The number of VMs accessible to the caller." },
214	{ RT_UOFFSETOF(GVMMSTATS, cEMTs), STAMTYPE_U32, STAMUNIT_CALLS, "/GVMM/EMTs", "The number of emulation threads." },
215	};
216
217
218	/**
219	* Initializes the STAM.
220	*
221	* @returns VBox status code.
222	* @param pVM The VM to operate on.
223	*/
224	VMMR3DECL(int) STAMR3InitUVM(PUVM pUVM)
225	{
226	LogFlow(("STAMR3Init\n"));
227
228	/*
229	* Assert alignment and sizes.
230	*/
231	AssertCompile(sizeof(pUVM->stam.s) <= sizeof(pUVM->stam.padding));
232	AssertRelease(sizeof(pUVM->stam.s) <= sizeof(pUVM->stam.padding));
233
234	/*
235	* Setup any fixed pointers and offsets.
236	*/
237	int rc = RTSemRWCreate(&pUVM->stam.s.RWSem);
238	AssertRCReturn(rc, rc);
239
240	/*
241	* Register the ring-0 statistics (GVMM/GMM).
242	*/
243	stamR3Ring0StatsRegisterU(pUVM);
244
245	#ifdef VBOX_WITH_DEBUGGER
246	/*
247	* Register debugger commands.
248	*/
249	static bool fRegisteredCmds = false;
250	if (!fRegisteredCmds)
251	{
252	rc = DBGCRegisterCommands(&g_aCmds[0], RT_ELEMENTS(g_aCmds));
253	if (RT_SUCCESS(rc))
254	fRegisteredCmds = true;
255	}
256	#endif
257
258	return VINF_SUCCESS;
259	}
260
261
262	/**
263	* Terminates the STAM.
264	*
265	* @param pUVM Pointer to the user mode VM structure.
266	*/
267	VMMR3DECL(void) STAMR3TermUVM(PUVM pUVM)
268	{
269	/*
270	* Free used memory and the RWLock.
271	*/
272	PSTAMDESC pCur = pUVM->stam.s.pHead;
273	while (pCur)
274	{
275	void *pvFree = pCur;
276	pCur = pCur->pNext;
277	RTMemFree(pvFree);
278	}
279	pUVM->stam.s.pHead = NULL;
280
281	Assert(pUVM->stam.s.RWSem != NIL_RTSEMRW);
282	RTSemRWDestroy(pUVM->stam.s.RWSem);
283	pUVM->stam.s.RWSem = NIL_RTSEMRW;
284	}
285
286
287	/**
288	* Registers a sample with the statistics mamanger.
289	*
290	* Statistics are maintained on a per VM basis and is normally registered
291	* during the VM init stage, but there is nothing preventing you from
292	* register them at runtime.
293	*
294	* Use STAMR3Deregister() to deregister statistics at runtime, however do
295	* not bother calling at termination time.
296	*
297	* It is not possible to register the same sample twice.
298	*
299	* @returns VBox status.
300	* @param pUVM Pointer to the user mode VM structure.
301	* @param pvSample Pointer to the sample.
302	* @param enmType Sample type. This indicates what pvSample is pointing at.
303	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
304	* @param pszName Sample name. The name is on this form "/<component>/<sample>".
305	* Further nesting is possible.
306	* @param enmUnit Sample unit.
307	* @param pszDesc Sample description.
308	*/
309	VMMR3DECL(int) STAMR3RegisterU(PUVM pUVM, void pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, const char pszName, STAMUNIT enmUnit, const char *pszDesc)
310	{
311	AssertReturn(enmType != STAMTYPE_CALLBACK, VERR_INVALID_PARAMETER);
312	return stamR3RegisterU(pUVM, pvSample, NULL, NULL, enmType, enmVisibility, pszName, enmUnit, pszDesc);
313	}
314
315
316	/**
317	* Registers a sample with the statistics mamanger.
318	*
319	* Statistics are maintained on a per VM basis and is normally registered
320	* during the VM init stage, but there is nothing preventing you from
321	* register them at runtime.
322	*
323	* Use STAMR3Deregister() to deregister statistics at runtime, however do
324	* not bother calling at termination time.
325	*
326	* It is not possible to register the same sample twice.
327	*
328	* @returns VBox status.
329	* @param pVM The VM handle.
330	* @param pvSample Pointer to the sample.
331	* @param enmType Sample type. This indicates what pvSample is pointing at.
332	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
333	* @param pszName Sample name. The name is on this form "/<component>/<sample>".
334	* Further nesting is possible.
335	* @param enmUnit Sample unit.
336	* @param pszDesc Sample description.
337	*/
338	VMMR3DECL(int) STAMR3Register(PVM pVM, void pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, const char pszName, STAMUNIT enmUnit, const char *pszDesc)
339	{
340	AssertReturn(enmType != STAMTYPE_CALLBACK, VERR_INVALID_PARAMETER);
341	return stamR3RegisterU(pVM->pUVM, pvSample, NULL, NULL, enmType, enmVisibility, pszName, enmUnit, pszDesc);
342	}
343
344
345	/**
346	* Same as STAMR3RegisterU except that the name is specified in a
347	* RTStrPrintf like fashion.
348	*
349	* @returns VBox status.
350	* @param pUVM Pointer to the user mode VM structure.
351	* @param pvSample Pointer to the sample.
352	* @param enmType Sample type. This indicates what pvSample is pointing at.
353	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
354	* @param enmUnit Sample unit.
355	* @param pszDesc Sample description.
356	* @param pszName The sample name format string.
357	* @param ... Arguments to the format string.
358	*/
359	VMMR3DECL(int) STAMR3RegisterFU(PUVM pUVM, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
360	const char pszDesc, const char pszName, ...)
361	{
362	va_list args;
363	va_start(args, pszName);
364	int rc = STAMR3RegisterVU(pUVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
365	va_end(args);
366	return rc;
367	}
368
369
370	/**
371	* Same as STAMR3Register except that the name is specified in a
372	* RTStrPrintf like fashion.
373	*
374	* @returns VBox status.
375	* @param pVM The VM handle.
376	* @param pvSample Pointer to the sample.
377	* @param enmType Sample type. This indicates what pvSample is pointing at.
378	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
379	* @param enmUnit Sample unit.
380	* @param pszDesc Sample description.
381	* @param pszName The sample name format string.
382	* @param ... Arguments to the format string.
383	*/
384	VMMR3DECL(int) STAMR3RegisterF(PVM pVM, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
385	const char pszDesc, const char pszName, ...)
386	{
387	va_list args;
388	va_start(args, pszName);
389	int rc = STAMR3RegisterVU(pVM->pUVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
390	va_end(args);
391	return rc;
392	}
393
394
395	/**
396	* Same as STAMR3Register except that the name is specified in a
397	* RTStrPrintfV like fashion.
398	*
399	* @returns VBox status.
400	* @param pVM The VM handle.
401	* @param pvSample Pointer to the sample.
402	* @param enmType Sample type. This indicates what pvSample is pointing at.
403	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
404	* @param enmUnit Sample unit.
405	* @param pszDesc Sample description.
406	* @param pszName The sample name format string.
407	* @param args Arguments to the format string.
408	*/
409	VMMR3DECL(int) STAMR3RegisterVU(PUVM pUVM, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
410	const char pszDesc, const char pszName, va_list args)
411	{
412	AssertReturn(enmType != STAMTYPE_CALLBACK, VERR_INVALID_PARAMETER);
413
414	char *pszFormattedName;
415	RTStrAPrintfV(&pszFormattedName, pszName, args);
416	if (!pszFormattedName)
417	return VERR_NO_MEMORY;
418
419	int rc = STAMR3RegisterU(pUVM, pvSample, enmType, enmVisibility, pszFormattedName, enmUnit, pszDesc);
420	RTStrFree(pszFormattedName);
421	return rc;
422	}
423
424
425	/**
426	* Same as STAMR3Register except that the name is specified in a
427	* RTStrPrintfV like fashion.
428	*
429	* @returns VBox status.
430	* @param pVM The VM handle.
431	* @param pvSample Pointer to the sample.
432	* @param enmType Sample type. This indicates what pvSample is pointing at.
433	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
434	* @param enmUnit Sample unit.
435	* @param pszDesc Sample description.
436	* @param pszName The sample name format string.
437	* @param args Arguments to the format string.
438	*/
439	VMMR3DECL(int) STAMR3RegisterV(PVM pVM, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
440	const char pszDesc, const char pszName, va_list args)
441	{
442	return STAMR3RegisterVU(pVM->pUVM, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
443	}
444
445
446	/**
447	* Similar to STAMR3Register except for the two callbacks, the implied type (STAMTYPE_CALLBACK),
448	* and name given in an RTStrPrintf like fashion.
449	*
450	* @returns VBox status.
451	* @param pVM The VM handle.
452	* @param pvSample Pointer to the sample.
453	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
454	* @param enmUnit Sample unit.
455	* @param pfnReset Callback for resetting the sample. NULL should be used if the sample can't be reset.
456	* @param pfnPrint Print the sample.
457	* @param pszDesc Sample description.
458	* @param pszName The sample name format string.
459	* @param ... Arguments to the format string.
460	* @remark There is currently no device or driver variant of this API. Add one if it should become necessary!
461	*/
462	VMMR3DECL(int) STAMR3RegisterCallback(PVM pVM, void *pvSample, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
463	PFNSTAMR3CALLBACKRESET pfnReset, PFNSTAMR3CALLBACKPRINT pfnPrint,
464	const char pszDesc, const char pszName, ...)
465	{
466	va_list args;
467	va_start(args, pszName);
468	int rc = STAMR3RegisterCallbackV(pVM, pvSample, enmVisibility, enmUnit, pfnReset, pfnPrint, pszDesc, pszName, args);
469	va_end(args);
470	return rc;
471	}
472
473
474	/**
475	* Same as STAMR3RegisterCallback() except for the ellipsis which is a va_list here.
476	*
477	* @returns VBox status.
478	* @param pVM The VM handle.
479	* @param pvSample Pointer to the sample.
480	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
481	* @param enmUnit Sample unit.
482	* @param pfnReset Callback for resetting the sample. NULL should be used if the sample can't be reset.
483	* @param pfnPrint Print the sample.
484	* @param pszDesc Sample description.
485	* @param pszName The sample name format string.
486	* @param args Arguments to the format string.
487	* @remark There is currently no device or driver variant of this API. Add one if it should become necessary!
488	*/
489	VMMR3DECL(int) STAMR3RegisterCallbackV(PVM pVM, void *pvSample, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
490	PFNSTAMR3CALLBACKRESET pfnReset, PFNSTAMR3CALLBACKPRINT pfnPrint,
491	const char pszDesc, const char pszName, va_list args)
492	{
493	char *pszFormattedName;
494	RTStrAPrintfV(&pszFormattedName, pszName, args);
495	if (!pszFormattedName)
496	return VERR_NO_MEMORY;
497
498	int rc = stamR3RegisterU(pVM->pUVM, pvSample, pfnReset, pfnPrint, STAMTYPE_CALLBACK, enmVisibility, pszFormattedName, enmUnit, pszDesc);
499	RTStrFree(pszFormattedName);
500	return rc;
501	}
502
503
504	/**
505	* Divide the strings into sub-strings using '/' as delimiter
506	* and then compare them in strcmp fashion.
507	*
508	* @returns Difference.
509	* @retval 0 if equal.
510	* @retval < 0 if psz1 is less than psz2.
511	* @retval > 0 if psz1 greater than psz2.
512	*
513	* @param psz1 The first string.
514	* @param psz2 The second string.
515	*/
516	static int stamR3SlashCompare(const char psz1, const char psz2)
517	{
518	for (;;)
519	{
520	unsigned int ch1 = *psz1++;
521	unsigned int ch2 = *psz2++;
522	if (ch1 != ch2)
523	{
524	/* slash is end-of-sub-string, so it trumps everything but '\0'. */
525	if (ch1 == '/')
526	return ch2 ? -1 : 1;
527	if (ch2 == '/')
528	return ch1 ? 1 : -1;
529	return ch1 - ch2;
530	}
531
532	/* done? */
533	if (ch1 == '\0')
534	return 0;
535	}
536	}
537
538
539	/**
540	* Internal worker for the different register calls.
541	*
542	* @returns VBox status.
543	* @param pUVM Pointer to the user mode VM structure.
544	* @param pvSample Pointer to the sample.
545	* @param pfnReset Callback for resetting the sample. NULL should be used if the sample can't be reset.
546	* @param pfnPrint Print the sample.
547	* @param enmType Sample type. This indicates what pvSample is pointing at.
548	* @param enmVisibility Visibility type specifying whether unused statistics should be visible or not.
549	* @param enmUnit Sample unit.
550	* @param pszDesc Sample description.
551	* @param pszName The sample name format string.
552	* @param args Arguments to the format string.
553	* @remark There is currently no device or driver variant of this API. Add one if it should become necessary!
554	*/
555	static int stamR3RegisterU(PUVM pUVM, void *pvSample, PFNSTAMR3CALLBACKRESET pfnReset, PFNSTAMR3CALLBACKPRINT pfnPrint,
556	STAMTYPE enmType, STAMVISIBILITY enmVisibility, const char pszName, STAMUNIT enmUnit, const char pszDesc)
557	{
558	STAM_LOCK_WR(pUVM);
559
560	/*
561	* Check if exists.
562	*/
563	PSTAMDESC pPrev = NULL;
564	PSTAMDESC pCur = pUVM->stam.s.pHead;
565	while (pCur)
566	{
567	int iDiff = strcmp(pCur->pszName, pszName);
568	/* passed it */
569	if (iDiff > 0)
570	break;
571	/* found it. */
572	if (!iDiff)
573	{
574	STAM_UNLOCK_WR(pUVM);
575	AssertMsgFailed(("Duplicate sample name: %s\n", pszName));
576	return VERR_ALREADY_EXISTS;
577	}
578
579	/* next */
580	pPrev = pCur;
581	pCur = pCur->pNext;
582	}
583
584	/*
585	* Check that the name doesn't screw up sorting order when taking
586	* slashes into account. The QT4 GUI makes some assumptions.
587	* Problematic chars are: !"#$%&'()*+,-.
588	*/
589	Assert(pszName[0] == '/');
590	if (pPrev)
591	Assert(stamR3SlashCompare(pPrev->pszName, pszName) < 0);
592	if (pCur)
593	Assert(stamR3SlashCompare(pCur->pszName, pszName) > 0);
594
595	#ifdef VBOX_STRICT
596	/*
597	* Check alignment requirements.
598	*/
599	switch (enmType)
600	{
601	/* 8 byte / 64-bit */
602	case STAMTYPE_U64:
603	case STAMTYPE_U64_RESET:
604	case STAMTYPE_X64:
605	case STAMTYPE_X64_RESET:
606	case STAMTYPE_COUNTER:
607	case STAMTYPE_PROFILE:
608	case STAMTYPE_PROFILE_ADV:
609	AssertMsg(!((uintptr_t)pvSample & 7), ("%p - %s\n", pvSample, pszName));
610	break;
611
612	/* 4 byte / 32-bit */
613	case STAMTYPE_RATIO_U32:
614	case STAMTYPE_RATIO_U32_RESET:
615	case STAMTYPE_U32:
616	case STAMTYPE_U32_RESET:
617	case STAMTYPE_X32:
618	case STAMTYPE_X32_RESET:
619	AssertMsg(!((uintptr_t)pvSample & 3), ("%p - %s\n", pvSample, pszName));
620	break;
621
622	/* 2 byte / 32-bit */
623	case STAMTYPE_U16:
624	case STAMTYPE_U16_RESET:
625	case STAMTYPE_X16:
626	case STAMTYPE_X16_RESET:
627	AssertMsg(!((uintptr_t)pvSample & 1), ("%p - %s\n", pvSample, pszName));
628	break;
629
630	/* 1 byte / 8-bit / unaligned */
631	case STAMTYPE_U8:
632	case STAMTYPE_U8_RESET:
633	case STAMTYPE_X8:
634	case STAMTYPE_X8_RESET:
635	case STAMTYPE_CALLBACK:
636	break;
637
638	default:
639	AssertMsgFailed(("%d\n", enmType));
640	break;
641	}
642	#endif /* VBOX_STRICT */
643
644	/*
645	* Create a new node and insert it at the current location.
646	*/
647	int rc;
648	size_t cchName = strlen(pszName) + 1;
649	size_t cchDesc = pszDesc ? strlen(pszDesc) + 1 : 0;
650	PSTAMDESC pNew = (PSTAMDESC)RTMemAlloc(sizeof(*pNew) + cchName + cchDesc);
651	if (pNew)
652	{
653	pNew->pszName = (char )memcpy((char )(pNew + 1), pszName, cchName);
654	pNew->enmType = enmType;
655	pNew->enmVisibility = enmVisibility;
656	if (enmType != STAMTYPE_CALLBACK)
657	pNew->u.pv = pvSample;
658	else
659	{
660	pNew->u.Callback.pvSample = pvSample;
661	pNew->u.Callback.pfnReset = pfnReset;
662	pNew->u.Callback.pfnPrint = pfnPrint;
663	}
664	pNew->enmUnit = enmUnit;
665	pNew->pszDesc = NULL;
666	if (pszDesc)
667	pNew->pszDesc = (char )memcpy((char )(pNew + 1) + cchName, pszDesc, cchDesc);
668
669	pNew->pNext = pCur;
670	if (pPrev)
671	pPrev->pNext = pNew;
672	else
673	pUVM->stam.s.pHead = pNew;
674
675	stamR3ResetOne(pNew, pUVM->pVM);
676	rc = VINF_SUCCESS;
677	}
678	else
679	rc = VERR_NO_MEMORY;
680
681	STAM_UNLOCK_WR(pUVM);
682	return rc;
683	}
684
685
686	/**
687	* Deregisters a sample previously registered by STAR3Register().
688	*
689	* This is intended used for devices which can be unplugged and for
690	* temporary samples.
691	*
692	* @returns VBox status.
693	* @param pUVM Pointer to the user mode VM structure.
694	* @param pvSample Pointer to the sample registered with STAMR3Register().
695	*/
696	VMMR3DECL(int) STAMR3DeregisterU(PUVM pUVM, void *pvSample)
697	{
698	STAM_LOCK_WR(pUVM);
699
700	/*
701	* Search for it.
702	*/
703	int rc = VERR_INVALID_HANDLE;
704	PSTAMDESC pPrev = NULL;
705	PSTAMDESC pCur = pUVM->stam.s.pHead;
706	while (pCur)
707	{
708	if (pCur->u.pv == pvSample)
709	{
710	void *pvFree = pCur;
711	pCur = pCur->pNext;
712	if (pPrev)
713	pPrev->pNext = pCur;
714	else
715	pUVM->stam.s.pHead = pCur;
716
717	RTMemFree(pvFree);
718	rc = VINF_SUCCESS;
719	continue;
720	}
721
722	/* next */
723	pPrev = pCur;
724	pCur = pCur->pNext;
725	}
726
727	STAM_UNLOCK_WR(pUVM);
728	return rc;
729	}
730
731
732	/**
733	* Deregisters a sample previously registered by STAR3Register().
734	*
735	* This is intended used for devices which can be unplugged and for
736	* temporary samples.
737	*
738	* @returns VBox status.
739	* @param pVM The VM handle.
740	* @param pvSample Pointer to the sample registered with STAMR3Register().
741	*/
742	VMMR3DECL(int) STAMR3Deregister(PVM pVM, void *pvSample)
743	{
744	return STAMR3DeregisterU(pVM->pUVM, pvSample);
745	}
746
747
748	/**
749	* Resets statistics for the specified VM.
750	* It's possible to select a subset of the samples.
751	*
752	* @returns VBox status. (Basically, it cannot fail.)
753	* @param pVM The VM handle.
754	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
755	* If NULL all samples are reset.
756	* @remarks Don't confuse this with the other 'XYZR3Reset' methods, it's not called at VM reset.
757	*/
758	VMMR3DECL(int) STAMR3ResetU(PUVM pUVM, const char *pszPat)
759	{
760	int rc = VINF_SUCCESS;
761
762	/* ring-0 */
763	GVMMRESETSTATISTICSSREQ GVMMReq;
764	//GMMRESETSTATISTICSSREQ GMMReq;
765	bool fGVMMMatched = !pszPat \|\| !*pszPat;
766	//bool fGMMMatched = fGVMMMatched;
767	if (fGVMMMatched)
768	memset(&GVMMReq.Stats, 0xff, sizeof(GVMMReq.Stats));
769	else
770	{
771	char *pszCopy;
772	unsigned cExpressions;
773	char **papszExpressions = stamR3SplitPattern(pszPat, &cExpressions, &pszCopy);
774	if (!papszExpressions)
775	return VERR_NO_MEMORY;
776
777	/* GVMM */
778	memset(&GVMMReq.Stats, 0, sizeof(GVMMReq.Stats));
779	for (unsigned i = 0; i < RT_ELEMENTS(g_aGVMMStats); i++)
780	if (stamR3MultiMatch(papszExpressions, cExpressions, NULL, g_aGVMMStats[i].pszName))
781	{
782	((uint8_t )&GVMMReq.Stats + g_aGVMMStats[i].offVar) = 0xff;
783	fGVMMMatched = true;
784	}
785
786	/* GMM */
787	// memset(&GMMReq.Stats, 0, sizeof(GMMReq.Stats));
788	// for (unsigned i = 0; i < RT_ELEMENTS(g_aGMMStats); i++)
789	// if (stamR3MultiMatch(papszExpressions, cExpressions, NULL, g_aGMMStats[i].pszName))
790	// {
791	// ((uint8_t )&GMMReq.Stats + g_aGMMStats[i].offVar) = 0xff;
792	// fGMMMatched = true;
793	// }
794
795	RTMemTmpFree(papszExpressions);
796	RTStrFree(pszCopy);
797	}
798
799	STAM_LOCK_WR(pUVM);
800	if (fGVMMMatched)
801	{
802	PVM pVM = pUVM->pVM;
803	GVMMReq.Hdr.cbReq = sizeof(GVMMReq);
804	GVMMReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
805	GVMMReq.pSession = pVM->pSession;
806	rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GVMM_RESET_STATISTICS, 0, &GVMMReq.Hdr);
807	}
808
809	// if (fGMMMatched)
810	// {
811	// PVM pVM = pUVM->pVM;
812	// GMMReq.Hdr.cbReq = sizeof(Req);
813	// GMMReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
814	// GMMReq.pSession = pVM->pSession;
815	// rc = SUPR3CallVMMR0Ex(pVM->pVMR0, VMMR0_DO_GMM_RESET_STATISTICS, 0, &Req.Hdr);
816	// }
817
818	/* and the reset */
819	stamR3EnumU(pUVM, pszPat, false /* fUpdateRing0 */, stamR3ResetOne, pUVM->pVM);
820
821	STAM_UNLOCK_WR(pUVM);
822	return rc;
823	}
824
825	/**
826	* Resets statistics for the specified VM.
827	* It's possible to select a subset of the samples.
828	*
829	* @returns VBox status. (Basically, it cannot fail.)
830	* @param pVM The VM handle.
831	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
832	* If NULL all samples are reset.
833	* @remarks Don't confuse this with the other 'XYZR3Reset' methods, it's not called at VM reset.
834	*/
835	VMMR3DECL(int) STAMR3Reset(PVM pVM, const char *pszPat)
836	{
837	return STAMR3ResetU(pVM->pUVM, pszPat);
838	}
839
840
841	/**
842	* Resets one statistics sample.
843	* Callback for stamR3EnumU().
844	*
845	* @returns VINF_SUCCESS
846	* @param pDesc Pointer to the current descriptor.
847	* @param pvArg User argument - The VM handle.
848	*/
849	static int stamR3ResetOne(PSTAMDESC pDesc, void *pvArg)
850	{
851	switch (pDesc->enmType)
852	{
853	case STAMTYPE_COUNTER:
854	ASMAtomicXchgU64(&pDesc->u.pCounter->c, 0);
855	break;
856
857	case STAMTYPE_PROFILE:
858	case STAMTYPE_PROFILE_ADV:
859	ASMAtomicXchgU64(&pDesc->u.pProfile->cPeriods, 0);
860	ASMAtomicXchgU64(&pDesc->u.pProfile->cTicks, 0);
861	ASMAtomicXchgU64(&pDesc->u.pProfile->cTicksMax, 0);
862	ASMAtomicXchgU64(&pDesc->u.pProfile->cTicksMin, ~0);
863	break;
864
865	case STAMTYPE_RATIO_U32_RESET:
866	ASMAtomicXchgU32(&pDesc->u.pRatioU32->u32A, 0);
867	ASMAtomicXchgU32(&pDesc->u.pRatioU32->u32B, 0);
868	break;
869
870	case STAMTYPE_CALLBACK:
871	if (pDesc->u.Callback.pfnReset)
872	pDesc->u.Callback.pfnReset((PVM)pvArg, pDesc->u.Callback.pvSample);
873	break;
874
875	case STAMTYPE_U8_RESET:
876	case STAMTYPE_X8_RESET:
877	ASMAtomicXchgU8(pDesc->u.pu8, 0);
878	break;
879
880	case STAMTYPE_U16_RESET:
881	case STAMTYPE_X16_RESET:
882	ASMAtomicXchgU16(pDesc->u.pu16, 0);
883	break;
884
885	case STAMTYPE_U32_RESET:
886	case STAMTYPE_X32_RESET:
887	ASMAtomicXchgU32(pDesc->u.pu32, 0);
888	break;
889
890	case STAMTYPE_U64_RESET:
891	case STAMTYPE_X64_RESET:
892	ASMAtomicXchgU64(pDesc->u.pu64, 0);
893	break;
894
895	/* These are custom and will not be touched. */
896	case STAMTYPE_U8:
897	case STAMTYPE_X8:
898	case STAMTYPE_U16:
899	case STAMTYPE_X16:
900	case STAMTYPE_U32:
901	case STAMTYPE_X32:
902	case STAMTYPE_U64:
903	case STAMTYPE_X64:
904	case STAMTYPE_RATIO_U32:
905	break;
906
907	default:
908	AssertMsgFailed(("enmType=%d\n", pDesc->enmType));
909	break;
910	}
911	NOREF(pvArg);
912	return VINF_SUCCESS;
913	}
914
915
916	/**
917	* Get a snapshot of the statistics.
918	* It's possible to select a subset of the samples.
919	*
920	* @returns VBox status. (Basically, it cannot fail.)
921	* @param pUVM Pointer to the user mode VM structure.
922	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
923	* If NULL all samples are reset.
924	* @param fWithDesc Whether to include the descriptions.
925	* @param ppszSnapshot Where to store the pointer to the snapshot data.
926	* The format of the snapshot should be XML, but that will have to be discussed
927	* when this function is implemented.
928	* The returned pointer must be freed by calling STAMR3SnapshotFree().
929	* @param pcchSnapshot Where to store the size of the snapshot data. (Excluding the trailing '\0')
930	*/
931	VMMR3DECL(int) STAMR3SnapshotU(PUVM pUVM, const char pszPat, char ppszSnapshot, size_t pcchSnapshot, bool fWithDesc)
932	{
933	STAMR3SNAPSHOTONE State = { NULL, NULL, NULL, pUVM->pVM, 0, VINF_SUCCESS, fWithDesc };
934
935	/*
936	* Write the XML header.
937	*/
938	/** @todo Make this proper & valid XML. */
939	stamR3SnapshotPrintf(&State, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n");
940
941	/*
942	* Write the content.
943	*/
944	stamR3SnapshotPrintf(&State, "<Statistics>\n");
945	STAM_LOCK_RD(pUVM);
946	int rc = stamR3EnumU(pUVM, pszPat, true /* fUpdateRing0 */, stamR3SnapshotOne, &State);
947	STAM_UNLOCK_RD(pUVM);
948	stamR3SnapshotPrintf(&State, "</Statistics>\n");
949
950	if (RT_SUCCESS(rc))
951	rc = State.rc;
952	else
953	{
954	RTMemFree(State.pszStart);
955	State.pszStart = State.pszEnd = State.psz = NULL;
956	State.cbAllocated = 0;
957	}
958
959	/*
960	* Done.
961	*/
962	*ppszSnapshot = State.pszStart;
963	if (pcchSnapshot)
964	*pcchSnapshot = State.psz - State.pszStart;
965	return rc;
966	}
967
968
969	/**
970	* Get a snapshot of the statistics.
971	* It's possible to select a subset of the samples.
972	*
973	* @returns VBox status. (Basically, it cannot fail.)
974	* @param pVM The VM handle.
975	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
976	* If NULL all samples are reset.
977	* @param fWithDesc Whether to include the descriptions.
978	* @param ppszSnapshot Where to store the pointer to the snapshot data.
979	* The format of the snapshot should be XML, but that will have to be discussed
980	* when this function is implemented.
981	* The returned pointer must be freed by calling STAMR3SnapshotFree().
982	* @param pcchSnapshot Where to store the size of the snapshot data.
983	* (Excluding the trailing '\\0')
984	*/
985	VMMR3DECL(int) STAMR3Snapshot(PVM pVM, const char pszPat, char ppszSnapshot, size_t pcchSnapshot, bool fWithDesc)
986	{
987	return STAMR3SnapshotU(pVM->pUVM, pszPat, ppszSnapshot, pcchSnapshot, fWithDesc);
988	}
989
990
991	/**
992	* stamR3EnumU callback employed by STAMR3Snapshot.
993	*
994	* @returns VBox status code, but it's interpreted as 0 == success / !0 == failure by enmR3Enum.
995	* @param pDesc The sample.
996	* @param pvArg The snapshot status structure.
997	*/
998	static int stamR3SnapshotOne(PSTAMDESC pDesc, void *pvArg)
999	{
1000	PSTAMR3SNAPSHOTONE pThis = (PSTAMR3SNAPSHOTONE)pvArg;
1001
1002	switch (pDesc->enmType)
1003	{
1004	case STAMTYPE_COUNTER:
1005	if (pDesc->enmVisibility == STAMVISIBILITY_USED && pDesc->u.pCounter->c == 0)
1006	return VINF_SUCCESS;
1007	stamR3SnapshotPrintf(pThis, "<Counter c=\"%lld\"", pDesc->u.pCounter->c);
1008	break;
1009
1010	case STAMTYPE_PROFILE:
1011	case STAMTYPE_PROFILE_ADV:
1012	if (pDesc->enmVisibility == STAMVISIBILITY_USED && pDesc->u.pProfile->cPeriods == 0)
1013	return VINF_SUCCESS;
1014	stamR3SnapshotPrintf(pThis, "<Profile cPeriods=\"%lld\" cTicks=\"%lld\" cTicksMin=\"%lld\" cTicksMax=\"%lld\"",
1015	pDesc->u.pProfile->cPeriods, pDesc->u.pProfile->cTicks, pDesc->u.pProfile->cTicksMin,
1016	pDesc->u.pProfile->cTicksMax);
1017	break;
1018
1019	case STAMTYPE_RATIO_U32:
1020	case STAMTYPE_RATIO_U32_RESET:
1021	if (pDesc->enmVisibility == STAMVISIBILITY_USED && !pDesc->u.pRatioU32->u32A && !pDesc->u.pRatioU32->u32B)
1022	return VINF_SUCCESS;
1023	stamR3SnapshotPrintf(pThis, "<Ratio32 u32A=\"%lld\" u32B=\"%lld\"",
1024	pDesc->u.pRatioU32->u32A, pDesc->u.pRatioU32->u32B);
1025	break;
1026
1027	case STAMTYPE_CALLBACK:
1028	{
1029	char szBuf[512];
1030	pDesc->u.Callback.pfnPrint(pThis->pVM, pDesc->u.Callback.pvSample, szBuf, sizeof(szBuf));
1031	stamR3SnapshotPrintf(pThis, "<Callback val=\"%s\"", szBuf);
1032	break;
1033	}
1034
1035	case STAMTYPE_U8:
1036	case STAMTYPE_U8_RESET:
1037	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu8 == 0)
1038	return VINF_SUCCESS;
1039	stamR3SnapshotPrintf(pThis, "<U8 val=\"%u\"", *pDesc->u.pu8);
1040	break;
1041
1042	case STAMTYPE_X8:
1043	case STAMTYPE_X8_RESET:
1044	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu8 == 0)
1045	return VINF_SUCCESS;
1046	stamR3SnapshotPrintf(pThis, "<X8 val=\"%#x\"", *pDesc->u.pu8);
1047	break;
1048
1049	case STAMTYPE_U16:
1050	case STAMTYPE_U16_RESET:
1051	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu16 == 0)
1052	return VINF_SUCCESS;
1053	stamR3SnapshotPrintf(pThis, "<U16 val=\"%u\"", *pDesc->u.pu16);
1054	break;
1055
1056	case STAMTYPE_X16:
1057	case STAMTYPE_X16_RESET:
1058	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu16 == 0)
1059	return VINF_SUCCESS;
1060	stamR3SnapshotPrintf(pThis, "<X16 val=\"%#x\"", *pDesc->u.pu16);
1061	break;
1062
1063	case STAMTYPE_U32:
1064	case STAMTYPE_U32_RESET:
1065	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu32 == 0)
1066	return VINF_SUCCESS;
1067	stamR3SnapshotPrintf(pThis, "<U32 val=\"%u\"", *pDesc->u.pu32);
1068	break;
1069
1070	case STAMTYPE_X32:
1071	case STAMTYPE_X32_RESET:
1072	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu32 == 0)
1073	return VINF_SUCCESS;
1074	stamR3SnapshotPrintf(pThis, "<X32 val=\"%#x\"", *pDesc->u.pu32);
1075	break;
1076
1077	case STAMTYPE_U64:
1078	case STAMTYPE_U64_RESET:
1079	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu64 == 0)
1080	return VINF_SUCCESS;
1081	stamR3SnapshotPrintf(pThis, "<U64 val=\"%llu\"", *pDesc->u.pu64);
1082	break;
1083
1084	case STAMTYPE_X64:
1085	case STAMTYPE_X64_RESET:
1086	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu64 == 0)
1087	return VINF_SUCCESS;
1088	stamR3SnapshotPrintf(pThis, "<X64 val=\"%#llx\"", *pDesc->u.pu64);
1089	break;
1090
1091	default:
1092	AssertMsgFailed(("%d\n", pDesc->enmType));
1093	return 0;
1094	}
1095
1096	stamR3SnapshotPrintf(pThis, " unit=\"%s\"", STAMR3GetUnit(pDesc->enmUnit));
1097
1098	switch (pDesc->enmVisibility)
1099	{
1100	default:
1101	case STAMVISIBILITY_ALWAYS:
1102	break;
1103	case STAMVISIBILITY_USED:
1104	stamR3SnapshotPrintf(pThis, " vis=\"used\"");
1105	break;
1106	case STAMVISIBILITY_NOT_GUI:
1107	stamR3SnapshotPrintf(pThis, " vis=\"not-gui\"");
1108	break;
1109	}
1110
1111	stamR3SnapshotPrintf(pThis, " name=\"%s\"", pDesc->pszName);
1112
1113	if (pThis->fWithDesc && pDesc->pszDesc)
1114	{
1115	/*
1116	* The description is a bit tricky as it may include chars that
1117	* xml requires to be escaped.
1118	*/
1119	const char *pszBadChar = strpbrk(pDesc->pszDesc, "&<>\"'");
1120	if (!pszBadChar)
1121	return stamR3SnapshotPrintf(pThis, " desc=\"%s\"/>\n", pDesc->pszDesc);
1122
1123	stamR3SnapshotPrintf(pThis, " desc=\"");
1124	const char *pszCur = pDesc->pszDesc;
1125	do
1126	{
1127	stamR3SnapshotPrintf(pThis, "%.*s", pszBadChar - pszCur, pszCur);
1128	switch (*pszBadChar)
1129	{
1130	case '&': stamR3SnapshotPrintf(pThis, "&"); break;
1131	case '<': stamR3SnapshotPrintf(pThis, "<"); break;
1132	case '>': stamR3SnapshotPrintf(pThis, ">"); break;
1133	case '"': stamR3SnapshotPrintf(pThis, """); break;
1134	case '\'': stamR3SnapshotPrintf(pThis, "'"); break;
1135	default: AssertMsgFailed(("%c", *pszBadChar)); break;
1136	}
1137	pszCur = pszBadChar + 1;
1138	pszBadChar = strpbrk(pszCur, "&<>\"'");
1139	} while (pszBadChar);
1140	return stamR3SnapshotPrintf(pThis, "%s\"/>\n", pszCur);
1141	}
1142	return stamR3SnapshotPrintf(pThis, "/>\n");
1143	}
1144
1145
1146	/**
1147	* Output callback for stamR3SnapshotPrintf.
1148	*
1149	* @returns number of bytes written.
1150	* @param pvArg The snapshot status structure.
1151	* @param pach Pointer to an array of characters (bytes).
1152	* @param cch The number or chars (bytes) to write from the array.
1153	*/
1154	static DECLCALLBACK(size_t) stamR3SnapshotOutput(void pvArg, const char pach, size_t cch)
1155	{
1156	PSTAMR3SNAPSHOTONE pThis = (PSTAMR3SNAPSHOTONE)pvArg;
1157
1158	/*
1159	* Make sure we've got space for it.
1160	*/
1161	if (RT_UNLIKELY((uintptr_t)pThis->pszEnd - (uintptr_t)pThis->psz < cch + 1))
1162	{
1163	if (RT_FAILURE(pThis->rc))
1164	return 0;
1165
1166	size_t cbNewSize = pThis->cbAllocated;
1167	if (cbNewSize > cch)
1168	cbNewSize *= 2;
1169	else
1170	cbNewSize += RT_ALIGN(cch + 1, 0x1000);
1171	char pszNew = (char )RTMemRealloc(pThis->pszStart, cbNewSize);
1172	if (!pszNew)
1173	{
1174	/*
1175	* Free up immediately, out-of-memory is bad news and this
1176	* isn't an important allocations / API.
1177	*/
1178	pThis->rc = VERR_NO_MEMORY;
1179	RTMemFree(pThis->pszStart);
1180	pThis->pszStart = pThis->pszEnd = pThis->psz = NULL;
1181	pThis->cbAllocated = 0;
1182	return 0;
1183	}
1184
1185	pThis->psz = pszNew + (pThis->psz - pThis->pszStart);
1186	pThis->pszStart = pszNew;
1187	pThis->pszEnd = pszNew + cbNewSize;
1188	pThis->cbAllocated = cbNewSize;
1189	}
1190
1191	/*
1192	* Copy the chars to the buffer and terminate it.
1193	*/
1194	memcpy(pThis->psz, pach, cch);
1195	pThis->psz += cch;
1196	*pThis->psz = '\0';
1197	return cch;
1198	}
1199
1200
1201	/**
1202	* Wrapper around RTStrFormatV for use by the snapshot API.
1203	*
1204	* @returns VBox status code.
1205	* @param pThis The snapshot status structure.
1206	* @param pszFormat The format string.
1207	* @param ... Optional arguments.
1208	*/
1209	static int stamR3SnapshotPrintf(PSTAMR3SNAPSHOTONE pThis, const char *pszFormat, ...)
1210	{
1211	va_list va;
1212	va_start(va, pszFormat);
1213	RTStrFormatV(stamR3SnapshotOutput, pThis, NULL, NULL, pszFormat, va);
1214	va_end(va);
1215	return pThis->rc;
1216	}
1217
1218
1219	/**
1220	* Releases a statistics snapshot returned by STAMR3Snapshot().
1221	*
1222	* @returns VBox status.
1223	* @param pUVM Pointer to the user mode VM structure.
1224	* @param pszSnapshot The snapshot data pointer returned by STAMR3Snapshot().
1225	* NULL is allowed.
1226	*/
1227	VMMR3DECL(int) STAMR3SnapshotFreeU(PUVM pUVM, char *pszSnapshot)
1228	{
1229	if (!pszSnapshot)
1230	RTMemFree(pszSnapshot);
1231	return VINF_SUCCESS;
1232	}
1233
1234
1235	/**
1236	* Releases a statistics snapshot returned by STAMR3Snapshot().
1237	*
1238	* @returns VBox status.
1239	* @param pVM The VM handle.
1240	* @param pszSnapshot The snapshot data pointer returned by STAMR3Snapshot().
1241	* NULL is allowed.
1242	*/
1243	VMMR3DECL(int) STAMR3SnapshotFree(PVM pVM, char *pszSnapshot)
1244	{
1245	return STAMR3SnapshotFreeU(pVM->pUVM, pszSnapshot);
1246	}
1247
1248
1249	/**
1250	* Dumps the selected statistics to the log.
1251	*
1252	* @returns VBox status.
1253	* @param pUVM Pointer to the user mode VM structure.
1254	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
1255	* If NULL all samples are written to the log.
1256	*/
1257	VMMR3DECL(int) STAMR3DumpU(PUVM pUVM, const char *pszPat)
1258	{
1259	STAMR3PRINTONEARGS Args;
1260	Args.pVM = pUVM->pVM;
1261	Args.pvArg = NULL;
1262	Args.pfnPrintf = stamR3EnumLogPrintf;
1263
1264	STAM_LOCK_RD(pUVM);
1265	stamR3EnumU(pUVM, pszPat, true /* fUpdateRing0 */, stamR3PrintOne, &Args);
1266	STAM_UNLOCK_RD(pUVM);
1267	return VINF_SUCCESS;
1268	}
1269
1270
1271	/**
1272	* Dumps the selected statistics to the log.
1273	*
1274	* @returns VBox status.
1275	* @param pVM The VM handle.
1276	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
1277	* If NULL all samples are written to the log.
1278	*/
1279	VMMR3DECL(int) STAMR3Dump(PVM pVM, const char *pszPat)
1280	{
1281	return STAMR3DumpU(pVM->pUVM, pszPat);
1282	}
1283
1284
1285	/**
1286	* Prints to the log.
1287	*
1288	* @param pArgs Pointer to the print one argument structure.
1289	* @param pszFormat Format string.
1290	* @param ... Format arguments.
1291	*/
1292	static DECLCALLBACK(void) stamR3EnumLogPrintf(PSTAMR3PRINTONEARGS pArgs, const char *pszFormat, ...)
1293	{
1294	va_list va;
1295	va_start(va, pszFormat);
1296	RTLogPrintfV(pszFormat, va);
1297	va_end(va);
1298	NOREF(pArgs);
1299	}
1300
1301
1302	/**
1303	* Dumps the selected statistics to the release log.
1304	*
1305	* @returns VBox status.
1306	* @param pUVM Pointer to the user mode VM structure.
1307	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
1308	* If NULL all samples are written to the log.
1309	*/
1310	VMMR3DECL(int) STAMR3DumpToReleaseLogU(PUVM pUVM, const char *pszPat)
1311	{
1312	STAMR3PRINTONEARGS Args;
1313	Args.pVM = pUVM->pVM;
1314	Args.pvArg = NULL;
1315	Args.pfnPrintf = stamR3EnumRelLogPrintf;
1316
1317	STAM_LOCK_RD(pUVM);
1318	stamR3EnumU(pUVM, pszPat, true /* fUpdateRing0 */, stamR3PrintOne, &Args);
1319	STAM_UNLOCK_RD(pUVM);
1320	return VINF_SUCCESS;
1321	}
1322
1323
1324	/**
1325	* Dumps the selected statistics to the release log.
1326	*
1327	* @returns VBox status.
1328	* @param pVM The VM handle.
1329	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
1330	* If NULL all samples are written to the log.
1331	*/
1332	VMMR3DECL(int) STAMR3DumpToReleaseLog(PVM pVM, const char *pszPat)
1333	{
1334	return STAMR3DumpToReleaseLogU(pVM->pUVM, pszPat);
1335	}
1336
1337
1338	/**
1339	* Prints to the release log.
1340	*
1341	* @param pArgs Pointer to the print one argument structure.
1342	* @param pszFormat Format string.
1343	* @param ... Format arguments.
1344	*/
1345	static DECLCALLBACK(void) stamR3EnumRelLogPrintf(PSTAMR3PRINTONEARGS pArgs, const char *pszFormat, ...)
1346	{
1347	va_list va;
1348	va_start(va, pszFormat);
1349	RTLogRelPrintfV(pszFormat, va);
1350	va_end(va);
1351	NOREF(pArgs);
1352	}
1353
1354
1355	/**
1356	* Prints the selected statistics to standard out.
1357	*
1358	* @returns VBox status.
1359	* @param pVM The VM handle.
1360	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
1361	* If NULL all samples are reset.
1362	*/
1363	VMMR3DECL(int) STAMR3PrintU(PUVM pUVM, const char *pszPat)
1364	{
1365	STAMR3PRINTONEARGS Args;
1366	Args.pVM = pUVM->pVM;
1367	Args.pvArg = NULL;
1368	Args.pfnPrintf = stamR3EnumPrintf;
1369
1370	STAM_LOCK_RD(pUVM);
1371	stamR3EnumU(pUVM, pszPat, true /* fUpdateRing0 */, stamR3PrintOne, &Args);
1372	STAM_UNLOCK_RD(pUVM);
1373	return VINF_SUCCESS;
1374	}
1375
1376
1377	/**
1378	* Prints the selected statistics to standard out.
1379	*
1380	* @returns VBox status.
1381	* @param pVM The VM handle.
1382	* @param pszPat The name matching pattern. See somewhere_where_this_is_described_in_detail.
1383	* If NULL all samples are reset.
1384	*/
1385	VMMR3DECL(int) STAMR3Print(PVM pVM, const char *pszPat)
1386	{
1387	return STAMR3PrintU(pVM->pUVM, pszPat);
1388	}
1389
1390
1391	/**
1392	* Prints to stdout.
1393	*
1394	* @param pArgs Pointer to the print one argument structure.
1395	* @param pszFormat Format string.
1396	* @param ... Format arguments.
1397	*/
1398	static DECLCALLBACK(void) stamR3EnumPrintf(PSTAMR3PRINTONEARGS pArgs, const char *pszFormat, ...)
1399	{
1400	va_list va;
1401	va_start(va, pszFormat);
1402	RTPrintfV(pszFormat, va);
1403	va_end(va);
1404	NOREF(pArgs);
1405	}
1406
1407
1408	/**
1409	* Prints one sample.
1410	* Callback for stamR3EnumU().
1411	*
1412	* @returns VINF_SUCCESS
1413	* @param pDesc Pointer to the current descriptor.
1414	* @param pvArg User argument - STAMR3PRINTONEARGS.
1415	*/
1416	static int stamR3PrintOne(PSTAMDESC pDesc, void *pvArg)
1417	{
1418	PSTAMR3PRINTONEARGS pArgs = (PSTAMR3PRINTONEARGS)pvArg;
1419
1420	switch (pDesc->enmType)
1421	{
1422	case STAMTYPE_COUNTER:
1423	if (pDesc->enmVisibility == STAMVISIBILITY_USED && pDesc->u.pCounter->c == 0)
1424	return VINF_SUCCESS;
1425
1426	pArgs->pfnPrintf(pArgs, "%-32s %8llu %s\n", pDesc->pszName, pDesc->u.pCounter->c, STAMR3GetUnit(pDesc->enmUnit));
1427	break;
1428
1429	case STAMTYPE_PROFILE:
1430	case STAMTYPE_PROFILE_ADV:
1431	{
1432	if (pDesc->enmVisibility == STAMVISIBILITY_USED && pDesc->u.pProfile->cPeriods == 0)
1433	return VINF_SUCCESS;
1434
1435	uint64_t u64 = pDesc->u.pProfile->cPeriods ? pDesc->u.pProfile->cPeriods : 1;
1436	pArgs->pfnPrintf(pArgs, "%-32s %8llu %s (%12llu ticks, %7llu times, max %9llu, min %7lld)\n", pDesc->pszName,
1437	pDesc->u.pProfile->cTicks / u64, STAMR3GetUnit(pDesc->enmUnit),
1438	pDesc->u.pProfile->cTicks, pDesc->u.pProfile->cPeriods, pDesc->u.pProfile->cTicksMax, pDesc->u.pProfile->cTicksMin);
1439	break;
1440	}
1441
1442	case STAMTYPE_RATIO_U32:
1443	case STAMTYPE_RATIO_U32_RESET:
1444	if (pDesc->enmVisibility == STAMVISIBILITY_USED && !pDesc->u.pRatioU32->u32A && !pDesc->u.pRatioU32->u32B)
1445	return VINF_SUCCESS;
1446	pArgs->pfnPrintf(pArgs, "%-32s %8u:%-8u %s\n", pDesc->pszName,
1447	pDesc->u.pRatioU32->u32A, pDesc->u.pRatioU32->u32B, STAMR3GetUnit(pDesc->enmUnit));
1448	break;
1449
1450	case STAMTYPE_CALLBACK:
1451	{
1452	char szBuf[512];
1453	pDesc->u.Callback.pfnPrint(pArgs->pVM, pDesc->u.Callback.pvSample, szBuf, sizeof(szBuf));
1454	pArgs->pfnPrintf(pArgs, "%-32s %s %s\n", pDesc->pszName, szBuf, STAMR3GetUnit(pDesc->enmUnit));
1455	break;
1456	}
1457
1458	case STAMTYPE_U8:
1459	case STAMTYPE_U8_RESET:
1460	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu8 == 0)
1461	return VINF_SUCCESS;
1462	pArgs->pfnPrintf(pArgs, "%-32s %8u %s\n", pDesc->pszName, *pDesc->u.pu8, STAMR3GetUnit(pDesc->enmUnit));
1463	break;
1464
1465	case STAMTYPE_X8:
1466	case STAMTYPE_X8_RESET:
1467	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu8 == 0)
1468	return VINF_SUCCESS;
1469	pArgs->pfnPrintf(pArgs, "%-32s %8x %s\n", pDesc->pszName, *pDesc->u.pu8, STAMR3GetUnit(pDesc->enmUnit));
1470	break;
1471
1472	case STAMTYPE_U16:
1473	case STAMTYPE_U16_RESET:
1474	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu16 == 0)
1475	return VINF_SUCCESS;
1476	pArgs->pfnPrintf(pArgs, "%-32s %8u %s\n", pDesc->pszName, *pDesc->u.pu16, STAMR3GetUnit(pDesc->enmUnit));
1477	break;
1478
1479	case STAMTYPE_X16:
1480	case STAMTYPE_X16_RESET:
1481	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu16 == 0)
1482	return VINF_SUCCESS;
1483	pArgs->pfnPrintf(pArgs, "%-32s %8x %s\n", pDesc->pszName, *pDesc->u.pu16, STAMR3GetUnit(pDesc->enmUnit));
1484	break;
1485
1486	case STAMTYPE_U32:
1487	case STAMTYPE_U32_RESET:
1488	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu32 == 0)
1489	return VINF_SUCCESS;
1490	pArgs->pfnPrintf(pArgs, "%-32s %8u %s\n", pDesc->pszName, *pDesc->u.pu32, STAMR3GetUnit(pDesc->enmUnit));
1491	break;
1492
1493	case STAMTYPE_X32:
1494	case STAMTYPE_X32_RESET:
1495	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu32 == 0)
1496	return VINF_SUCCESS;
1497	pArgs->pfnPrintf(pArgs, "%-32s %8x %s\n", pDesc->pszName, *pDesc->u.pu32, STAMR3GetUnit(pDesc->enmUnit));
1498	break;
1499
1500	case STAMTYPE_U64:
1501	case STAMTYPE_U64_RESET:
1502	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu64 == 0)
1503	return VINF_SUCCESS;
1504	pArgs->pfnPrintf(pArgs, "%-32s %8llu %s\n", pDesc->pszName, *pDesc->u.pu64, STAMR3GetUnit(pDesc->enmUnit));
1505	break;
1506
1507	case STAMTYPE_X64:
1508	case STAMTYPE_X64_RESET:
1509	if (pDesc->enmVisibility == STAMVISIBILITY_USED && *pDesc->u.pu64 == 0)
1510	return VINF_SUCCESS;
1511	pArgs->pfnPrintf(pArgs, "%-32s %8llx %s\n", pDesc->pszName, *pDesc->u.pu64, STAMR3GetUnit(pDesc->enmUnit));
1512	break;
1513
1514	default:
1515	AssertMsgFailed(("enmType=%d\n", pDesc->enmType));
1516	break;
1517	}
1518	NOREF(pvArg);
1519	return VINF_SUCCESS;
1520	}
1521
1522
1523	/**
1524	* Enumerate the statistics by the means of a callback function.
1525	*
1526	* @returns Whatever the callback returns.
1527	*
1528	* @param pUVM Pointer to the user mode VM structure.
1529	* @param pszPat The pattern to match samples.
1530	* @param pfnEnum The callback function.
1531	* @param pvUser The pvUser argument of the callback function.
1532	*/
1533	VMMR3DECL(int) STAMR3EnumU(PUVM pUVM, const char pszPat, PFNSTAMR3ENUM pfnEnum, void pvUser)
1534	{
1535	STAMR3ENUMONEARGS Args;
1536	Args.pVM = pUVM->pVM;
1537	Args.pfnEnum = pfnEnum;
1538	Args.pvUser = pvUser;
1539
1540	STAM_LOCK_RD(pUVM);
1541	int rc = stamR3EnumU(pUVM, pszPat, true /* fUpdateRing0 */, stamR3EnumOne, &Args);
1542	STAM_UNLOCK_RD(pUVM);
1543	return rc;
1544	}
1545
1546
1547	/**
1548	* Enumerate the statistics by the means of a callback function.
1549	*
1550	* @returns Whatever the callback returns.
1551	*
1552	* @param pVM The VM handle.
1553	* @param pszPat The pattern to match samples.
1554	* @param pfnEnum The callback function.
1555	* @param pvUser The pvUser argument of the callback function.
1556	*/
1557	VMMR3DECL(int) STAMR3Enum(PVM pVM, const char pszPat, PFNSTAMR3ENUM pfnEnum, void pvUser)
1558	{
1559	return STAMR3EnumU(pVM->pUVM, pszPat, pfnEnum, pvUser);
1560	}
1561
1562
1563	/**
1564	* Callback function for STARTR3Enum().
1565	*
1566	* @returns whatever the callback returns.
1567	* @param pDesc Pointer to the current descriptor.
1568	* @param pvArg Points to a STAMR3ENUMONEARGS structure.
1569	*/
1570	static int stamR3EnumOne(PSTAMDESC pDesc, void *pvArg)
1571	{
1572	PSTAMR3ENUMONEARGS pArgs = (PSTAMR3ENUMONEARGS)pvArg;
1573	int rc;
1574	if (pDesc->enmType == STAMTYPE_CALLBACK)
1575	{
1576	/* Give the enumerator something useful. */
1577	char szBuf[512];
1578	pDesc->u.Callback.pfnPrint(pArgs->pVM, pDesc->u.Callback.pvSample, szBuf, sizeof(szBuf));
1579	rc = pArgs->pfnEnum(pDesc->pszName, pDesc->enmType, szBuf, pDesc->enmUnit,
1580	pDesc->enmVisibility, pDesc->pszDesc, pArgs->pvUser);
1581	}
1582	else
1583	rc = pArgs->pfnEnum(pDesc->pszName, pDesc->enmType, pDesc->u.pv, pDesc->enmUnit,
1584	pDesc->enmVisibility, pDesc->pszDesc, pArgs->pvUser);
1585	return rc;
1586	}
1587
1588
1589	/**
1590	* Match a name against an array of patterns.
1591	*
1592	* @returns true if it matches, false if it doesn't match.
1593	* @param papszExpressions The array of pattern expressions.
1594	* @param cExpressions The number of array entries.
1595	* @param piExpression Where to read/store the current skip index. Optional.
1596	* @param pszName The name to match.
1597	*/
1598	static bool stamR3MultiMatch(const char * const *papszExpressions, unsigned cExpressions,
1599	unsigned piExpression, const char pszName)
1600	{
1601	for (unsigned i = piExpression ? *piExpression : 0; i < cExpressions; i++)
1602	{
1603	const char *pszPat = papszExpressions[i];
1604	if (RTStrSimplePatternMatch(pszPat, pszName))
1605	{
1606	/* later:
1607	if (piExpression && i > *piExpression)
1608	{
1609	check if we can skip some expressions
1610	}*/
1611	return true;
1612	}
1613	}
1614	return false;
1615	}
1616
1617
1618	/**
1619	* Splits a multi pattern into single ones.
1620	*
1621	* @returns Pointer to an array of single patterns. Free it with RTMemTmpFree.
1622	* @param pszPat The pattern to split.
1623	* @param pcExpressions The number of array elements.
1624	* @param pszCopy The pattern copy to free using RTStrFree.
1625	*/
1626	static char *stamR3SplitPattern(const char pszPat, unsigned pcExpressions, char *ppszCopy)
1627	{
1628	Assert(pszPat && *pszPat);
1629
1630	char *pszCopy = RTStrDup(pszPat);
1631	if (!pszCopy)
1632	return NULL;
1633
1634	/* count them & allocate array. */
1635	char *psz = pszCopy;
1636	unsigned cExpressions = 1;
1637	while ((psz = strchr(psz, '\|')) != NULL)
1638	cExpressions++, psz++;
1639
1640	char papszExpressions = (char )RTMemTmpAllocZ((cExpressions + 1) * sizeof(char *));
1641	if (!papszExpressions)
1642	{
1643	RTStrFree(pszCopy);
1644	return NULL;
1645	}
1646
1647	/* split */
1648	psz = pszCopy;
1649	for (unsigned i = 0;;)
1650	{
1651	papszExpressions[i] = psz;
1652	if (++i >= cExpressions)
1653	break;
1654	psz = strchr(psz, '\|');
1655	*psz++ = '\0';
1656	}
1657
1658	/* sort the array, putting '' last. /
1659	/** @todo sort it... */
1660
1661	*pcExpressions = cExpressions;
1662	*ppszCopy = pszCopy;
1663	return papszExpressions;
1664	}
1665
1666
1667	/**
1668	* Enumerates the nodes selected by a pattern or all nodes if no pattern
1669	* is specified.
1670	*
1671	* The call must own at least a read lock to the STAM data.
1672	*
1673	* @returns The rc from the callback.
1674	* @param pUVM Pointer to the user mode VM structure.
1675	* @param pszPat Pattern.
1676	* @param fUpdateRing0 Update the ring-0 .
1677	* @param pfnCallback Callback function which shall be called for matching nodes.
1678	* If it returns anything but VINF_SUCCESS the enumeration is
1679	* terminated and the status code returned to the caller.
1680	* @param pvArg User parameter for the callback.
1681	*/
1682	static int stamR3EnumU(PUVM pUVM, const char pszPat, bool fUpdateRing0, int (pfnCallback)(PSTAMDESC pDesc, void pvArg), void pvArg)
1683	{
1684	int rc = VINF_SUCCESS;
1685
1686	/*
1687	* All
1688	*/
1689	if (!pszPat \|\| !pszPat \|\| !strcmp(pszPat, ""))
1690	{
1691	if (fUpdateRing0)
1692	stamR3Ring0StatsUpdateU(pUVM, "*");
1693
1694	PSTAMDESC pCur = pUVM->stam.s.pHead;
1695	while (pCur)
1696	{
1697	rc = pfnCallback(pCur, pvArg);
1698	if (rc)
1699	break;
1700
1701	/* next */
1702	pCur = pCur->pNext;
1703	}
1704	}
1705
1706	/*
1707	* Single expression pattern.
1708	*/
1709	else if (!strchr(pszPat, '\|'))
1710	{
1711	if (fUpdateRing0)
1712	stamR3Ring0StatsUpdateU(pUVM, pszPat);
1713
1714	/** @todo This needs to be optimized since the GUI is using this path for the VM info dialog.
1715	* Note that it's doing exact matching. Organizing the samples in a tree would speed up thing
1716	* no end (at least for debug and profile builds). */
1717	for (PSTAMDESC pCur = pUVM->stam.s.pHead; pCur; pCur = pCur->pNext)
1718	if (RTStrSimplePatternMatch(pszPat, pCur->pszName))
1719	{
1720	rc = pfnCallback(pCur, pvArg);
1721	if (rc)
1722	break;
1723	}
1724	}
1725
1726	/*
1727	* Multi expression pattern.
1728	*/
1729	else
1730	{
1731	/*
1732	* Split up the pattern first.
1733	*/
1734	char *pszCopy;
1735	unsigned cExpressions;
1736	char **papszExpressions = stamR3SplitPattern(pszPat, &cExpressions, &pszCopy);
1737	if (!papszExpressions)
1738	return VERR_NO_MEMORY;
1739
1740	/*
1741	* Perform the enumeration.
1742	*/
1743	if (fUpdateRing0)
1744	stamR3Ring0StatsUpdateMultiU(pUVM, papszExpressions, cExpressions);
1745
1746	unsigned iExpression = 0;
1747	for (PSTAMDESC pCur = pUVM->stam.s.pHead; pCur; pCur = pCur->pNext)
1748	if (stamR3MultiMatch(papszExpressions, cExpressions, &iExpression, pCur->pszName))
1749	{
1750	rc = pfnCallback(pCur, pvArg);
1751	if (rc)
1752	break;
1753	}
1754
1755	RTMemTmpFree(papszExpressions);
1756	RTStrFree(pszCopy);
1757	}
1758
1759	return rc;
1760	}
1761
1762
1763	/**
1764	* Registers the ring-0 statistics.
1765	*
1766	* @param pUVM Pointer to the user mode VM structure.
1767	*/
1768	static void stamR3Ring0StatsRegisterU(PUVM pUVM)
1769	{
1770	/* GVMM */
1771	for (unsigned i = 0; i < RT_ELEMENTS(g_aGVMMStats); i++)
1772	stamR3RegisterU(pUVM, (uint8_t *)&pUVM->stam.s.GVMMStats + g_aGVMMStats[i].offVar, NULL, NULL,
1773	g_aGVMMStats[i].enmType, STAMVISIBILITY_ALWAYS, g_aGVMMStats[i].pszName,
1774	g_aGVMMStats[i].enmUnit, g_aGVMMStats[i].pszDesc);
1775	}
1776
1777
1778	/**
1779	* Updates the ring-0 statistics (the copy).
1780	*
1781	* @param pUVM Pointer to the user mode VM structure.
1782	* @param pszPat The pattern.
1783	*/
1784	static void stamR3Ring0StatsUpdateU(PUVM pUVM, const char *pszPat)
1785	{
1786	stamR3Ring0StatsUpdateMultiU(pUVM, &pszPat, 1);
1787	}
1788
1789
1790	/**
1791	* Updates the ring-0 statistics.
1792	*
1793	* The ring-0 statistics aren't directly addressable from ring-3 and
1794	* must be copied when needed.
1795	*
1796	* @param pUVM Pointer to the user mode VM structure.
1797	* @param pszPat The pattern (for knowing when to skip).
1798	*/
1799	static void stamR3Ring0StatsUpdateMultiU(PUVM pUVM, const char * const *papszExpressions, unsigned cExpressions)
1800	{
1801	PVM pVM = pUVM->pVM;
1802	if (!pVM \|\| !pVM->pSession)
1803	return;
1804
1805	/* GVMM */
1806	bool fUpdate = false;
1807	for (unsigned i = 0; i < RT_ELEMENTS(g_aGVMMStats); i++)
1808	if (stamR3MultiMatch(papszExpressions, cExpressions, NULL, g_aGVMMStats[i].pszName))
1809	{
1810	fUpdate = true;
1811	break;
1812	}
1813	if (fUpdate)
1814	{
1815	GVMMQUERYSTATISTICSSREQ Req;
1816	Req.Hdr.cbReq = sizeof(Req);
1817	Req.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
1818	Req.pSession = pVM->pSession;
1819	int rc = SUPR3CallVMMR0Ex(pVM->pVMR0, NIL_VMCPUID, VMMR0_DO_GVMM_QUERY_STATISTICS, 0, &Req.Hdr);
1820	if (RT_SUCCESS(rc))
1821	pUVM->stam.s.GVMMStats = Req.Stats;
1822	}
1823	}
1824
1825
1826	/**
1827	* Get the unit string.
1828	*
1829	* @returns Pointer to read only unit string.
1830	* @param enmUnit The unit.
1831	*/
1832	VMMR3DECL(const char *) STAMR3GetUnit(STAMUNIT enmUnit)
1833	{
1834	switch (enmUnit)
1835	{
1836	case STAMUNIT_NONE: return "";
1837	case STAMUNIT_CALLS: return "calls";
1838	case STAMUNIT_COUNT: return "count";
1839	case STAMUNIT_BYTES: return "bytes";
1840	case STAMUNIT_PAGES: return "pages";
1841	case STAMUNIT_ERRORS: return "errors";
1842	case STAMUNIT_OCCURENCES: return "times";
1843	case STAMUNIT_TICKS: return "ticks";
1844	case STAMUNIT_TICKS_PER_CALL: return "ticks/call";
1845	case STAMUNIT_TICKS_PER_OCCURENCE: return "ticks/time";
1846	case STAMUNIT_GOOD_BAD: return "good:bad";
1847	case STAMUNIT_MEGABYTES: return "megabytes";
1848	case STAMUNIT_KILOBYTES: return "kilobytes";
1849	case STAMUNIT_NS: return "ns";
1850	case STAMUNIT_NS_PER_CALL: return "ns/call";
1851	case STAMUNIT_NS_PER_OCCURENCE: return "ns/time";
1852	case STAMUNIT_PCT: return "%";
1853
1854	default:
1855	AssertMsgFailed(("Unknown unit %d\n", enmUnit));
1856	return "(?unit?)";
1857	}
1858	}
1859
1860	#ifdef VBOX_WITH_DEBUGGER
1861
1862	/**
1863	* The '.stats' command.
1864	*
1865	* @returns VBox status.
1866	* @param pCmd Pointer to the command descriptor (as registered).
1867	* @param pCmdHlp Pointer to command helper functions.
1868	* @param pVM Pointer to the current VM (if any).
1869	* @param paArgs Pointer to (readonly) array of arguments.
1870	* @param cArgs Number of arguments in the array.
1871	*/
1872	static DECLCALLBACK(int) stamR3CmdStats(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1873	{
1874	/*
1875	* Validate input.
1876	*/
1877	if (!pVM)
1878	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The command requires VM to be selected.\n");
1879	PUVM pUVM = pVM->pUVM;
1880	if (!pUVM->stam.s.pHead)
1881	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Sorry, no statistics present.\n");
1882
1883	/*
1884	* Do the printing.
1885	*/
1886	STAMR3PRINTONEARGS Args;
1887	Args.pVM = pVM;
1888	Args.pvArg = pCmdHlp;
1889	Args.pfnPrintf = stamR3EnumDbgfPrintf;
1890
1891	STAM_LOCK_RD(pUVM);
1892	int rc = stamR3EnumU(pUVM, cArgs ? paArgs[0].u.pszString : NULL, true /* fUpdateRing0 */, stamR3PrintOne, &Args);
1893	STAM_UNLOCK_RD(pUVM);
1894
1895	return rc;
1896	}
1897
1898
1899	/**
1900	* Display one sample in the debugger.
1901	*
1902	* @param pArgs Pointer to the print one argument structure.
1903	* @param pszFormat Format string.
1904	* @param ... Format arguments.
1905	*/
1906	static DECLCALLBACK(void) stamR3EnumDbgfPrintf(PSTAMR3PRINTONEARGS pArgs, const char *pszFormat, ...)
1907	{
1908	PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP)pArgs->pvArg;
1909
1910	va_list va;
1911	va_start(va, pszFormat);
1912	pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, va);
1913	va_end(va);
1914	NOREF(pArgs);
1915	}
1916
1917
1918	/**
1919	* The '.statsreset' command.
1920	*
1921	* @returns VBox status.
1922	* @param pCmd Pointer to the command descriptor (as registered).
1923	* @param pCmdHlp Pointer to command helper functions.
1924	* @param pVM Pointer to the current VM (if any).
1925	* @param paArgs Pointer to (readonly) array of arguments.
1926	* @param cArgs Number of arguments in the array.
1927	*/
1928	static DECLCALLBACK(int) stamR3CmdStatsReset(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
1929	{
1930	/*
1931	* Validate input.
1932	*/
1933	if (!pVM)
1934	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The command requires VM to be selected.\n");
1935	PUVM pUVM = pVM->pUVM;
1936	if (!pUVM->stam.s.pHead)
1937	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Sorry, no statistics present.\n");
1938
1939	/*
1940	* Execute reset.
1941	*/
1942	int rc = STAMR3ResetU(pUVM, cArgs ? paArgs[0].u.pszString : NULL);
1943	if (RT_SUCCESS(rc))
1944	return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "info: Statistics reset.\n");
1945
1946	return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "Restting statistics.\n");
1947	}
1948
1949	#endif /* VBOX_WITH_DEBUGGER */
1950

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

source: vbox/trunk/src/VBox/VMM/STAM.cpp@ 30647

Download in other formats: