VBoxServiceStats.cpp@ 60641

Last change on this file since 60641 was 60268, checked in by vboxsync, 9 years ago
Additions/VBoxService: fixed usage of IPRT status and NT status code (thanks Parfait)
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 29.4 KB

Line
1	/* $Id: VBoxServiceStats.cpp 60268 2016-03-31 09:52:13Z vboxsync $ */
2	/** @file
3	* VBoxStats - Guest statistics notification
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 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_vgsvc_vmstats VBoxService - VM Statistics
19	*
20	* The VM statistics subservice helps out the performance collector API on the
21	* host side by providing metrics from inside the guest.
22	*
23	* See IPerformanceCollector, CollectorGuest and the "Guest/" submetrics that
24	* gets registered by Machine::i_registerMetrics in Main.
25	*/
26
27	/*********************************************************************************************************************************
28	* Header Files *
29	*********************************************************************************************************************************/
30	#if defined(RT_OS_WINDOWS)
31	# ifdef TARGET_NT4
32	# undef _WIN32_WINNT
33	# define _WIN32_WINNT 0x501
34	# endif
35	# include <windows.h>
36	# include <psapi.h>
37	# include <winternl.h>
38
39	#elif defined(RT_OS_LINUX)
40	# include <iprt/ctype.h>
41	# include <iprt/stream.h>
42	# include <unistd.h>
43
44	#elif defined(RT_OS_SOLARIS)
45	# include <kstat.h>
46	# include <sys/sysinfo.h>
47	# include <unistd.h>
48	#else
49	/** @todo port me. */
50
51	#endif
52
53	#include <iprt/assert.h>
54	#include <iprt/mem.h>
55	#include <iprt/ldr.h>
56	#include <VBox/param.h>
57	#include <iprt/semaphore.h>
58	#include <iprt/string.h>
59	#include <iprt/system.h>
60	#include <iprt/time.h>
61	#include <iprt/thread.h>
62	#include <VBox/VBoxGuestLib.h>
63	#include "VBoxServiceInternal.h"
64	#include "VBoxServiceUtils.h"
65
66
67	/*********************************************************************************************************************************
68	* Structures and Typedefs *
69	*********************************************************************************************************************************/
70	typedef struct _VBOXSTATSCONTEXT
71	{
72	RTMSINTERVAL cMsStatInterval;
73
74	uint64_t au64LastCpuLoad_Idle[VMM_MAX_CPU_COUNT];
75	uint64_t au64LastCpuLoad_Kernel[VMM_MAX_CPU_COUNT];
76	uint64_t au64LastCpuLoad_User[VMM_MAX_CPU_COUNT];
77	uint64_t au64LastCpuLoad_Nice[VMM_MAX_CPU_COUNT];
78
79	#ifdef RT_OS_WINDOWS
80	NTSTATUS (WINAPI *pfnNtQuerySystemInformation)(SYSTEM_INFORMATION_CLASS SystemInformationClass, PVOID SystemInformation,
81	ULONG SystemInformationLength, PULONG ReturnLength);
82	void (WINAPI *pfnGlobalMemoryStatusEx)(LPMEMORYSTATUSEX lpBuffer);
83	BOOL (WINAPI *pfnGetPerformanceInfo)(PPERFORMANCE_INFORMATION pPerformanceInformation, DWORD cb);
84	#endif
85	} VBOXSTATSCONTEXT;
86
87
88	/*********************************************************************************************************************************
89	* Global Variables *
90	*********************************************************************************************************************************/
91	/** Global data. */
92	static VBOXSTATSCONTEXT g_VMStat = {0};
93
94	/** The semaphore we're blocking on. */
95	static RTSEMEVENTMULTI g_VMStatEvent = NIL_RTSEMEVENTMULTI;
96
97
98	/**
99	* @interface_method_impl{VBOXSERVICE,pfnInit}
100	*/
101	static DECLCALLBACK(int) vgsvcVMStatsInit(void)
102	{
103	VGSvcVerbose(3, "vgsvcVMStatsInit\n");
104
105	int rc = RTSemEventMultiCreate(&g_VMStatEvent);
106	AssertRCReturn(rc, rc);
107
108	g_VMStat.cMsStatInterval = 0; /* default; update disabled */
109	RT_ZERO(g_VMStat.au64LastCpuLoad_Idle);
110	RT_ZERO(g_VMStat.au64LastCpuLoad_Kernel);
111	RT_ZERO(g_VMStat.au64LastCpuLoad_User);
112	RT_ZERO(g_VMStat.au64LastCpuLoad_Nice);
113
114	rc = VbglR3StatQueryInterval(&g_VMStat.cMsStatInterval);
115	if (RT_SUCCESS(rc))
116	VGSvcVerbose(3, "vgsvcVMStatsInit: New statistics interval %u seconds\n", g_VMStat.cMsStatInterval);
117	else
118	VGSvcVerbose(3, "vgsvcVMStatsInit: DeviceIoControl failed with %d\n", rc);
119
120	#ifdef RT_OS_WINDOWS
121	/* NtQuerySystemInformation might be dropped in future releases, so load
122	it dynamically as per Microsoft's recommendation. */
123	(void *)&g_VMStat.pfnNtQuerySystemInformation = RTLdrGetSystemSymbol("ntdll.dll", "NtQuerySystemInformation");
124	if (g_VMStat.pfnNtQuerySystemInformation)
125	VGSvcVerbose(3, "vgsvcVMStatsInit: g_VMStat.pfnNtQuerySystemInformation = %x\n", g_VMStat.pfnNtQuerySystemInformation);
126	else
127	{
128	VGSvcVerbose(3, "vgsvcVMStatsInit: ntdll.NtQuerySystemInformation not found!\n");
129	return VERR_SERVICE_DISABLED;
130	}
131
132	/* GlobalMemoryStatus is win2k and up, so load it dynamically */
133	(void *)&g_VMStat.pfnGlobalMemoryStatusEx = RTLdrGetSystemSymbol("kernel32.dll", "GlobalMemoryStatusEx");
134	if (g_VMStat.pfnGlobalMemoryStatusEx)
135	VGSvcVerbose(3, "vgsvcVMStatsInit: g_VMStat.GlobalMemoryStatusEx = %x\n", g_VMStat.pfnGlobalMemoryStatusEx);
136	else
137	{
138	/** @todo Now fails in NT4; do we care? */
139	VGSvcVerbose(3, "vgsvcVMStatsInit: kernel32.GlobalMemoryStatusEx not found!\n");
140	return VERR_SERVICE_DISABLED;
141	}
142
143	/* GetPerformanceInfo is xp and up, so load it dynamically */
144	(void *)&g_VMStat.pfnGetPerformanceInfo = RTLdrGetSystemSymbol("psapi.dll", "GetPerformanceInfo");
145	if (g_VMStat.pfnGetPerformanceInfo)
146	VGSvcVerbose(3, "vgsvcVMStatsInit: g_VMStat.pfnGetPerformanceInfo= %x\n", g_VMStat.pfnGetPerformanceInfo);
147	#endif /* RT_OS_WINDOWS */
148
149	return VINF_SUCCESS;
150	}
151
152
153	/**
154	* Gathers VM statistics and reports them to the host.
155	*/
156	static void vgsvcVMStatsReport(void)
157	{
158	#if defined(RT_OS_WINDOWS)
159	Assert(g_VMStat.pfnGlobalMemoryStatusEx && g_VMStat.pfnNtQuerySystemInformation);
160	if ( !g_VMStat.pfnGlobalMemoryStatusEx
161	\|\| !g_VMStat.pfnNtQuerySystemInformation)
162	return;
163
164	/* Clear the report so we don't report garbage should NtQuerySystemInformation
165	behave in an unexpected manner. */
166	VMMDevReportGuestStats req;
167	RT_ZERO(req);
168
169	/* Query and report guest statistics */
170	SYSTEM_INFO systemInfo;
171	GetSystemInfo(&systemInfo);
172
173	MEMORYSTATUSEX memStatus;
174	memStatus.dwLength = sizeof(memStatus);
175	g_VMStat.pfnGlobalMemoryStatusEx(&memStatus);
176
177	req.guestStats.u32PageSize = systemInfo.dwPageSize;
178	req.guestStats.u32PhysMemTotal = (uint32_t)(memStatus.ullTotalPhys / _4K);
179	req.guestStats.u32PhysMemAvail = (uint32_t)(memStatus.ullAvailPhys / _4K);
180	/* The current size of the committed memory limit, in bytes. This is physical
181	memory plus the size of the page file, minus a small overhead. */
182	req.guestStats.u32PageFileSize = (uint32_t)(memStatus.ullTotalPageFile / _4K) - req.guestStats.u32PhysMemTotal;
183	req.guestStats.u32MemoryLoad = memStatus.dwMemoryLoad;
184	req.guestStats.u32StatCaps = VBOX_GUEST_STAT_PHYS_MEM_TOTAL
185	\| VBOX_GUEST_STAT_PHYS_MEM_AVAIL
186	\| VBOX_GUEST_STAT_PAGE_FILE_SIZE
187	\| VBOX_GUEST_STAT_MEMORY_LOAD;
188	# ifdef VBOX_WITH_MEMBALLOON
189	req.guestStats.u32PhysMemBalloon = VGSvcBalloonQueryPages(_4K);
190	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_PHYS_MEM_BALLOON;
191	# else
192	req.guestStats.u32PhysMemBalloon = 0;
193	# endif
194
195	if (g_VMStat.pfnGetPerformanceInfo)
196	{
197	PERFORMANCE_INFORMATION perfInfo;
198
199	if (g_VMStat.pfnGetPerformanceInfo(&perfInfo, sizeof(perfInfo)))
200	{
201	req.guestStats.u32Processes = perfInfo.ProcessCount;
202	req.guestStats.u32Threads = perfInfo.ThreadCount;
203	req.guestStats.u32Handles = perfInfo.HandleCount;
204	req.guestStats.u32MemCommitTotal = perfInfo.CommitTotal; /* already in pages */
205	req.guestStats.u32MemKernelTotal = perfInfo.KernelTotal; /* already in pages */
206	req.guestStats.u32MemKernelPaged = perfInfo.KernelPaged; /* already in pages */
207	req.guestStats.u32MemKernelNonPaged = perfInfo.KernelNonpaged; /* already in pages */
208	req.guestStats.u32MemSystemCache = perfInfo.SystemCache; /* already in pages */
209	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_PROCESSES \| VBOX_GUEST_STAT_THREADS \| VBOX_GUEST_STAT_HANDLES
210	\| VBOX_GUEST_STAT_MEM_COMMIT_TOTAL \| VBOX_GUEST_STAT_MEM_KERNEL_TOTAL
211	\| VBOX_GUEST_STAT_MEM_KERNEL_PAGED \| VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED
212	\| VBOX_GUEST_STAT_MEM_SYSTEM_CACHE;
213	}
214	else
215	VGSvcVerbose(3, "vgsvcVMStatsReport: GetPerformanceInfo failed with %d\n", GetLastError());
216	}
217
218	/* Query CPU load information */
219	uint32_t cbStruct = systemInfo.dwNumberOfProcessors * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
220	PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION pProcInfo;
221	pProcInfo = (PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)RTMemAlloc(cbStruct);
222	if (!pProcInfo)
223	return;
224
225	/* Unfortunately GetSystemTimes is XP SP1 and up only, so we need to use the semi-undocumented NtQuerySystemInformation */
226	bool fCpuInfoAvail = false;
227	DWORD cbReturned;
228	NTSTATUS rcNt = g_VMStat.pfnNtQuerySystemInformation(SystemProcessorPerformanceInformation, pProcInfo, cbStruct, &cbReturned);
229	if ( !rcNt
230	&& cbReturned == cbStruct)
231	{
232	for (uint32_t i = 0; i < systemInfo.dwNumberOfProcessors; i++)
233	{
234	if (i >= VMM_MAX_CPU_COUNT)
235	{
236	VGSvcVerbose(3, "vgsvcVMStatsReport: skipping information for CPUs %u..%u\n", i, systemInfo.dwNumberOfProcessors);
237	break;
238	}
239
240	if (g_VMStat.au64LastCpuLoad_Kernel[i] == 0)
241	{
242	/* first time */
243	g_VMStat.au64LastCpuLoad_Idle[i] = pProcInfo[i].IdleTime.QuadPart;
244	g_VMStat.au64LastCpuLoad_Kernel[i] = pProcInfo[i].KernelTime.QuadPart;
245	g_VMStat.au64LastCpuLoad_User[i] = pProcInfo[i].UserTime.QuadPart;
246
247	Sleep(250);
248
249	rcNt = g_VMStat.pfnNtQuerySystemInformation(SystemProcessorPerformanceInformation, pProcInfo, cbStruct, &cbReturned);
250	Assert(!rcNt);
251	}
252
253	uint64_t deltaIdle = (pProcInfo[i].IdleTime.QuadPart - g_VMStat.au64LastCpuLoad_Idle[i]);
254	uint64_t deltaKernel = (pProcInfo[i].KernelTime.QuadPart - g_VMStat.au64LastCpuLoad_Kernel[i]);
255	uint64_t deltaUser = (pProcInfo[i].UserTime.QuadPart - g_VMStat.au64LastCpuLoad_User[i]);
256	deltaKernel -= deltaIdle; /* idle time is added to kernel time */
257	uint64_t ullTotalTime = deltaIdle + deltaKernel + deltaUser;
258	if (ullTotalTime == 0) /* Prevent division through zero. */
259	ullTotalTime = 1;
260
261	req.guestStats.u32CpuLoad_Idle = (uint32_t)(deltaIdle * 100 / ullTotalTime);
262	req.guestStats.u32CpuLoad_Kernel = (uint32_t)(deltaKernel* 100 / ullTotalTime);
263	req.guestStats.u32CpuLoad_User = (uint32_t)(deltaUser * 100 / ullTotalTime);
264
265	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_CPU_LOAD_IDLE \| VBOX_GUEST_STAT_CPU_LOAD_KERNEL
266	\| VBOX_GUEST_STAT_CPU_LOAD_USER;
267	req.guestStats.u32CpuId = i;
268	int rc = VbglR3StatReport(&req);
269	if (RT_SUCCESS(rc))
270	VGSvcVerbose(3, "vgsvcVMStatsReport: new statistics (CPU %u) reported successfully!\n", i);
271	else
272	VGSvcVerbose(3, "vgsvcVMStatsReport: VbglR3StatReport failed with rc=%Rrc\n", rc);
273
274	g_VMStat.au64LastCpuLoad_Idle[i] = pProcInfo[i].IdleTime.QuadPart;
275	g_VMStat.au64LastCpuLoad_Kernel[i] = pProcInfo[i].KernelTime.QuadPart;
276	g_VMStat.au64LastCpuLoad_User[i] = pProcInfo[i].UserTime.QuadPart;
277	}
278	}
279	RTMemFree(pProcInfo);
280
281	if (!fCpuInfoAvail)
282	{
283	VGSvcVerbose(3, "vgsvcVMStatsReport: CPU info not available!\n");
284	int rc = VbglR3StatReport(&req);
285	if (RT_SUCCESS(rc))
286	VGSvcVerbose(3, "vgsvcVMStatsReport: new statistics reported successfully!\n");
287	else
288	VGSvcVerbose(3, "vgsvcVMStatsReport: stats report failed with rc=%Rrc\n", rc);
289	}
290
291	#elif defined(RT_OS_LINUX)
292	VMMDevReportGuestStats req;
293	RT_ZERO(req);
294	PRTSTREAM pStrm;
295	char szLine[256];
296	char *psz;
297
298	int rc = RTStrmOpen("/proc/meminfo", "r", &pStrm);
299	if (RT_SUCCESS(rc))
300	{
301	uint64_t u64Kb;
302	uint64_t u64Total = 0, u64Free = 0, u64Buffers = 0, u64Cached = 0, u64PagedTotal = 0;
303	for (;;)
304	{
305	rc = RTStrmGetLine(pStrm, szLine, sizeof(szLine));
306	if (RT_FAILURE(rc))
307	break;
308	if (strstr(szLine, "MemTotal:") == szLine)
309	{
310	rc = RTStrToUInt64Ex(RTStrStripL(&szLine[9]), &psz, 0, &u64Kb);
311	if (RT_SUCCESS(rc))
312	u64Total = u64Kb * _1K;
313	}
314	else if (strstr(szLine, "MemFree:") == szLine)
315	{
316	rc = RTStrToUInt64Ex(RTStrStripL(&szLine[8]), &psz, 0, &u64Kb);
317	if (RT_SUCCESS(rc))
318	u64Free = u64Kb * _1K;
319	}
320	else if (strstr(szLine, "Buffers:") == szLine)
321	{
322	rc = RTStrToUInt64Ex(RTStrStripL(&szLine[8]), &psz, 0, &u64Kb);
323	if (RT_SUCCESS(rc))
324	u64Buffers = u64Kb * _1K;
325	}
326	else if (strstr(szLine, "Cached:") == szLine)
327	{
328	rc = RTStrToUInt64Ex(RTStrStripL(&szLine[7]), &psz, 0, &u64Kb);
329	if (RT_SUCCESS(rc))
330	u64Cached = u64Kb * _1K;
331	}
332	else if (strstr(szLine, "SwapTotal:") == szLine)
333	{
334	rc = RTStrToUInt64Ex(RTStrStripL(&szLine[10]), &psz, 0, &u64Kb);
335	if (RT_SUCCESS(rc))
336	u64PagedTotal = u64Kb * _1K;
337	}
338	}
339	req.guestStats.u32PhysMemTotal = u64Total / _4K;
340	req.guestStats.u32PhysMemAvail = (u64Free + u64Buffers + u64Cached) / _4K;
341	req.guestStats.u32MemSystemCache = (u64Buffers + u64Cached) / _4K;
342	req.guestStats.u32PageFileSize = u64PagedTotal / _4K;
343	RTStrmClose(pStrm);
344	}
345	else
346	VGSvcVerbose(3, "vgsvcVMStatsReport: memory info not available!\n");
347
348	req.guestStats.u32PageSize = getpagesize();
349	req.guestStats.u32StatCaps = VBOX_GUEST_STAT_PHYS_MEM_TOTAL
350	\| VBOX_GUEST_STAT_PHYS_MEM_AVAIL
351	\| VBOX_GUEST_STAT_MEM_SYSTEM_CACHE
352	\| VBOX_GUEST_STAT_PAGE_FILE_SIZE;
353	# ifdef VBOX_WITH_MEMBALLOON
354	req.guestStats.u32PhysMemBalloon = VGSvcBalloonQueryPages(_4K);
355	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_PHYS_MEM_BALLOON;
356	# else
357	req.guestStats.u32PhysMemBalloon = 0;
358	# endif
359
360
361	/** @todo req.guestStats.u32Threads */
362	/** @todo req.guestStats.u32Processes */
363	/* req.guestStats.u32Handles doesn't make sense here. */
364	/** @todo req.guestStats.u32MemoryLoad */
365	/** @todo req.guestStats.u32MemCommitTotal */
366	/** @todo req.guestStats.u32MemKernelTotal */
367	/** @todo req.guestStats.u32MemKernelPaged, make any sense? = u32MemKernelTotal? */
368	/** @todo req.guestStats.u32MemKernelNonPaged, make any sense? = 0? */
369
370	bool fCpuInfoAvail = false;
371	rc = RTStrmOpen("/proc/stat", "r", &pStrm);
372	if (RT_SUCCESS(rc))
373	{
374	for (;;)
375	{
376	rc = RTStrmGetLine(pStrm, szLine, sizeof(szLine));
377	if (RT_FAILURE(rc))
378	break;
379	if ( strstr(szLine, "cpu") == szLine
380	&& strlen(szLine) > 3
381	&& RT_C_IS_DIGIT(szLine[3]))
382	{
383	uint32_t u32CpuId;
384	rc = RTStrToUInt32Ex(&szLine[3], &psz, 0, &u32CpuId);
385	if (u32CpuId < VMM_MAX_CPU_COUNT)
386	{
387	uint64_t u64User = 0;
388	if (RT_SUCCESS(rc))
389	rc = RTStrToUInt64Ex(RTStrStripL(psz), &psz, 0, &u64User);
390
391	uint64_t u64Nice = 0;
392	if (RT_SUCCESS(rc))
393	rc = RTStrToUInt64Ex(RTStrStripL(psz), &psz, 0, &u64Nice);
394
395	uint64_t u64System = 0;
396	if (RT_SUCCESS(rc))
397	rc = RTStrToUInt64Ex(RTStrStripL(psz), &psz, 0, &u64System);
398
399	uint64_t u64Idle = 0;
400	if (RT_SUCCESS(rc))
401	rc = RTStrToUInt64Ex(RTStrStripL(psz), &psz, 0, &u64Idle);
402
403	uint64_t u64DeltaIdle = u64Idle - g_VMStat.au64LastCpuLoad_Idle[u32CpuId];
404	uint64_t u64DeltaSystem = u64System - g_VMStat.au64LastCpuLoad_Kernel[u32CpuId];
405	uint64_t u64DeltaUser = u64User - g_VMStat.au64LastCpuLoad_User[u32CpuId];
406	uint64_t u64DeltaNice = u64Nice - g_VMStat.au64LastCpuLoad_Nice[u32CpuId];
407
408	uint64_t u64DeltaAll = u64DeltaIdle
409	+ u64DeltaSystem
410	+ u64DeltaUser
411	+ u64DeltaNice;
412	if (u64DeltaAll == 0) /* Prevent division through zero. */
413	u64DeltaAll = 1;
414
415	g_VMStat.au64LastCpuLoad_Idle[u32CpuId] = u64Idle;
416	g_VMStat.au64LastCpuLoad_Kernel[u32CpuId] = u64System;
417	g_VMStat.au64LastCpuLoad_User[u32CpuId] = u64User;
418	g_VMStat.au64LastCpuLoad_Nice[u32CpuId] = u64Nice;
419
420	req.guestStats.u32CpuId = u32CpuId;
421	req.guestStats.u32CpuLoad_Idle = (uint32_t)(u64DeltaIdle * 100 / u64DeltaAll);
422	req.guestStats.u32CpuLoad_Kernel = (uint32_t)(u64DeltaSystem * 100 / u64DeltaAll);
423	req.guestStats.u32CpuLoad_User = (uint32_t)((u64DeltaUser
424	+ u64DeltaNice) * 100 / u64DeltaAll);
425	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_CPU_LOAD_IDLE
426	\| VBOX_GUEST_STAT_CPU_LOAD_KERNEL
427	\| VBOX_GUEST_STAT_CPU_LOAD_USER;
428	fCpuInfoAvail = true;
429	rc = VbglR3StatReport(&req);
430	if (RT_SUCCESS(rc))
431	VGSvcVerbose(3, "vgsvcVMStatsReport: new statistics (CPU %u) reported successfully!\n", u32CpuId);
432	else
433	VGSvcVerbose(3, "vgsvcVMStatsReport: stats report failed with rc=%Rrc\n", rc);
434	}
435	else
436	VGSvcVerbose(3, "vgsvcVMStatsReport: skipping information for CPU%u\n", u32CpuId);
437	}
438	}
439	RTStrmClose(pStrm);
440	}
441	if (!fCpuInfoAvail)
442	{
443	VGSvcVerbose(3, "vgsvcVMStatsReport: CPU info not available!\n");
444	rc = VbglR3StatReport(&req);
445	if (RT_SUCCESS(rc))
446	VGSvcVerbose(3, "vgsvcVMStatsReport: new statistics reported successfully!\n");
447	else
448	VGSvcVerbose(3, "vgsvcVMStatsReport: stats report failed with rc=%Rrc\n", rc);
449	}
450
451	#elif defined(RT_OS_SOLARIS)
452	VMMDevReportGuestStats req;
453	RT_ZERO(req);
454	kstat_ctl_t *pStatKern = kstat_open();
455	if (pStatKern)
456	{
457	/*
458	* Memory statistics.
459	*/
460	uint64_t u64Total = 0, u64Free = 0, u64Buffers = 0, u64Cached = 0, u64PagedTotal = 0;
461	int rc = -1;
462	kstat_t pStatPages = kstat_lookup(pStatKern, (char )"unix", 0 /* instance /, (char )"system_pages");
463	if (pStatPages)
464	{
465	rc = kstat_read(pStatKern, pStatPages, NULL /* optional-copy-buf */);
466	if (rc != -1)
467	{
468	kstat_named_t *pStat = NULL;
469	pStat = (kstat_named_t )kstat_data_lookup(pStatPages, (char )"pagestotal");
470	if (pStat)
471	u64Total = pStat->value.ul;
472
473	pStat = (kstat_named_t )kstat_data_lookup(pStatPages, (char )"freemem");
474	if (pStat)
475	u64Free = pStat->value.ul;
476	}
477	}
478
479	kstat_t pStatZFS = kstat_lookup(pStatKern, (char )"zfs", 0 /* instance /, (char )"arcstats");
480	if (pStatZFS)
481	{
482	rc = kstat_read(pStatKern, pStatZFS, NULL /* optional-copy-buf */);
483	if (rc != -1)
484	{
485	kstat_named_t pStat = (kstat_named_t )kstat_data_lookup(pStatZFS, (char *)"size");
486	if (pStat)
487	u64Cached = pStat->value.ul;
488	}
489	}
490
491	/*
492	* The vminfo are accumulative counters updated every "N" ticks. Let's get the
493	* number of stat updates so far and use that to divide the swap counter.
494	*/
495	kstat_t pStatInfo = kstat_lookup(pStatKern, (char )"unix", 0 /* instance /, (char )"sysinfo");
496	if (pStatInfo)
497	{
498	sysinfo_t SysInfo;
499	rc = kstat_read(pStatKern, pStatInfo, &SysInfo);
500	if (rc != -1)
501	{
502	kstat_t pStatVMInfo = kstat_lookup(pStatKern, (char )"unix", 0 /* instance /, (char )"vminfo");
503	if (pStatVMInfo)
504	{
505	vminfo_t VMInfo;
506	rc = kstat_read(pStatKern, pStatVMInfo, &VMInfo);
507	if (rc != -1)
508	{
509	Assert(SysInfo.updates != 0);
510	u64PagedTotal = VMInfo.swap_avail / SysInfo.updates;
511	}
512	}
513	}
514	}
515
516	req.guestStats.u32PhysMemTotal = u64Total; /* already in pages */
517	req.guestStats.u32PhysMemAvail = u64Free; /* already in pages */
518	req.guestStats.u32MemSystemCache = u64Cached / _4K;
519	req.guestStats.u32PageFileSize = u64PagedTotal; /* already in pages */
520	/** @todo req.guestStats.u32Threads */
521	/** @todo req.guestStats.u32Processes */
522	/** @todo req.guestStats.u32Handles -- ??? */
523	/** @todo req.guestStats.u32MemoryLoad */
524	/** @todo req.guestStats.u32MemCommitTotal */
525	/** @todo req.guestStats.u32MemKernelTotal */
526	/** @todo req.guestStats.u32MemKernelPaged */
527	/** @todo req.guestStats.u32MemKernelNonPaged */
528	req.guestStats.u32PageSize = getpagesize();
529
530	req.guestStats.u32StatCaps = VBOX_GUEST_STAT_PHYS_MEM_TOTAL
531	\| VBOX_GUEST_STAT_PHYS_MEM_AVAIL
532	\| VBOX_GUEST_STAT_MEM_SYSTEM_CACHE
533	\| VBOX_GUEST_STAT_PAGE_FILE_SIZE;
534	#ifdef VBOX_WITH_MEMBALLOON
535	req.guestStats.u32PhysMemBalloon = VGSvcBalloonQueryPages(_4K);
536	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_PHYS_MEM_BALLOON;
537	#else
538	req.guestStats.u32PhysMemBalloon = 0;
539	#endif
540
541	/*
542	* CPU statistics.
543	*/
544	cpu_stat_t StatCPU;
545	RT_ZERO(StatCPU);
546	kstat_t *pStatNode = NULL;
547	uint32_t cCPUs = 0;
548	bool fCpuInfoAvail = false;
549	for (pStatNode = pStatKern->kc_chain; pStatNode != NULL; pStatNode = pStatNode->ks_next)
550	{
551	if (!strcmp(pStatNode->ks_module, "cpu_stat"))
552	{
553	rc = kstat_read(pStatKern, pStatNode, &StatCPU);
554	if (rc == -1)
555	break;
556
557	if (cCPUs < VMM_MAX_CPU_COUNT)
558	{
559	uint64_t u64Idle = StatCPU.cpu_sysinfo.cpu[CPU_IDLE];
560	uint64_t u64User = StatCPU.cpu_sysinfo.cpu[CPU_USER];
561	uint64_t u64System = StatCPU.cpu_sysinfo.cpu[CPU_KERNEL];
562
563	uint64_t u64DeltaIdle = u64Idle - g_VMStat.au64LastCpuLoad_Idle[cCPUs];
564	uint64_t u64DeltaSystem = u64System - g_VMStat.au64LastCpuLoad_Kernel[cCPUs];
565	uint64_t u64DeltaUser = u64User - g_VMStat.au64LastCpuLoad_User[cCPUs];
566
567	uint64_t u64DeltaAll = u64DeltaIdle + u64DeltaSystem + u64DeltaUser;
568	if (u64DeltaAll == 0) /* Prevent division through zero. */
569	u64DeltaAll = 1;
570
571	g_VMStat.au64LastCpuLoad_Idle[cCPUs] = u64Idle;
572	g_VMStat.au64LastCpuLoad_Kernel[cCPUs] = u64System;
573	g_VMStat.au64LastCpuLoad_User[cCPUs] = u64User;
574
575	req.guestStats.u32CpuId = cCPUs;
576	req.guestStats.u32CpuLoad_Idle = (uint32_t)(u64DeltaIdle * 100 / u64DeltaAll);
577	req.guestStats.u32CpuLoad_Kernel = (uint32_t)(u64DeltaSystem * 100 / u64DeltaAll);
578	req.guestStats.u32CpuLoad_User = (uint32_t)(u64DeltaUser * 100 / u64DeltaAll);
579
580	req.guestStats.u32StatCaps \|= VBOX_GUEST_STAT_CPU_LOAD_IDLE
581	\| VBOX_GUEST_STAT_CPU_LOAD_KERNEL
582	\| VBOX_GUEST_STAT_CPU_LOAD_USER;
583	fCpuInfoAvail = true;
584
585	rc = VbglR3StatReport(&req);
586	if (RT_SUCCESS(rc))
587	VGSvcVerbose(3, "vgsvcVMStatsReport: new statistics (CPU %u) reported successfully!\n", cCPUs);
588	else
589	VGSvcVerbose(3, "vgsvcVMStatsReport: stats report failed with rc=%Rrc\n", rc);
590	cCPUs++;
591	}
592	else
593	VGSvcVerbose(3, "vgsvcVMStatsReport: skipping information for CPU%u\n", cCPUs);
594	}
595	}
596
597	/*
598	* Report whatever statistics were collected.
599	*/
600	if (!fCpuInfoAvail)
601	{
602	VGSvcVerbose(3, "vgsvcVMStatsReport: CPU info not available!\n");
603	rc = VbglR3StatReport(&req);
604	if (RT_SUCCESS(rc))
605	VGSvcVerbose(3, "vgsvcVMStatsReport: new statistics reported successfully!\n");
606	else
607	VGSvcVerbose(3, "vgsvcVMStatsReport: stats report failed with rc=%Rrc\n", rc);
608	}
609
610	kstat_close(pStatKern);
611	}
612
613	#else
614	/* todo: implement for other platforms. */
615
616	#endif
617	}
618
619
620	/**
621	* @interface_method_impl{VBOXSERVICE,pfnWorker}
622	*/
623	DECLCALLBACK(int) vgsvcVMStatsWorker(bool volatile *pfShutdown)
624	{
625	int rc = VINF_SUCCESS;
626
627	/* Start monitoring of the stat event change event. */
628	rc = VbglR3CtlFilterMask(VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST, 0);
629	if (RT_FAILURE(rc))
630	{
631	VGSvcVerbose(3, "vgsvcVMStatsWorker: VbglR3CtlFilterMask failed with %d\n", rc);
632	return rc;
633	}
634
635	/*
636	* Tell the control thread that it can continue
637	* spawning services.
638	*/
639	RTThreadUserSignal(RTThreadSelf());
640
641	/*
642	* Now enter the loop retrieving runtime data continuously.
643	*/
644	for (;;)
645	{
646	uint32_t fEvents = 0;
647	RTMSINTERVAL cWaitMillies;
648
649	/* Check if an update interval change is pending. */
650	rc = VbglR3WaitEvent(VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST, 0 /* no wait */, &fEvents);
651	if ( RT_SUCCESS(rc)
652	&& (fEvents & VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST))
653	VbglR3StatQueryInterval(&g_VMStat.cMsStatInterval);
654
655	if (g_VMStat.cMsStatInterval)
656	{
657	vgsvcVMStatsReport();
658	cWaitMillies = g_VMStat.cMsStatInterval;
659	}
660	else
661	cWaitMillies = 3000;
662
663	/*
664	* Block for a while.
665	*
666	* The event semaphore takes care of ignoring interruptions and it
667	* allows us to implement service wakeup later.
668	*/
669	if (*pfShutdown)
670	break;
671	int rc2 = RTSemEventMultiWait(g_VMStatEvent, cWaitMillies);
672	if (*pfShutdown)
673	break;
674	if (rc2 != VERR_TIMEOUT && RT_FAILURE(rc2))
675	{
676	VGSvcError("vgsvcVMStatsWorker: RTSemEventMultiWait failed; rc2=%Rrc\n", rc2);
677	rc = rc2;
678	break;
679	}
680	}
681
682	/* Cancel monitoring of the stat event change event. */
683	rc = VbglR3CtlFilterMask(0, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
684	if (RT_FAILURE(rc))
685	VGSvcVerbose(3, "vgsvcVMStatsWorker: VbglR3CtlFilterMask failed with %d\n", rc);
686
687	VGSvcVerbose(3, "VBoxStatsThread: finished statistics change request thread\n");
688	return 0;
689	}
690
691
692	/**
693	* @interface_method_impl{VBOXSERVICE,pfnStop}
694	*/
695	static DECLCALLBACK(void) vgsvcVMStatsStop(void)
696	{
697	RTSemEventMultiSignal(g_VMStatEvent);
698	}
699
700
701	/**
702	* @interface_method_impl{VBOXSERVICE,pfnTerm}
703	*/
704	static DECLCALLBACK(void) vgsvcVMStatsTerm(void)
705	{
706	if (g_VMStatEvent != NIL_RTSEMEVENTMULTI)
707	{
708	RTSemEventMultiDestroy(g_VMStatEvent);
709	g_VMStatEvent = NIL_RTSEMEVENTMULTI;
710	}
711	}
712
713
714	/**
715	* The 'vminfo' service description.
716	*/
717	VBOXSERVICE g_VMStatistics =
718	{
719	/* pszName. */
720	"vmstats",
721	/* pszDescription. */
722	"Virtual Machine Statistics",
723	/* pszUsage. */
724	NULL,
725	/* pszOptions. */
726	NULL,
727	/* methods */
728	VGSvcDefaultPreInit,
729	VGSvcDefaultOption,
730	vgsvcVMStatsInit,
731	vgsvcVMStatsWorker,
732	vgsvcVMStatsStop,
733	vgsvcVMStatsTerm
734	};
735

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

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceStats.cpp@ 60641

Download in other formats: