GuestImpl.cpp@ 56858

Last change on this file since 56858 was 56470, checked in by vboxsync, 9 years ago
Main: when reporting the guest CPU metrics, use the average between all VCPUs
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.7 KB

Line
1	/* $Id: GuestImpl.cpp 56470 2015-06-17 08:50:35Z vboxsync $ */
2	/** @file
3	* VirtualBox COM class implementation: Guest features.
4	*/
5
6	/*
7	* Copyright (C) 2006-2014 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	#include "GuestImpl.h"
19	#ifdef VBOX_WITH_GUEST_CONTROL
20	# include "GuestSessionImpl.h"
21	#endif
22	#include "Global.h"
23	#include "ConsoleImpl.h"
24	#include "ProgressImpl.h"
25	#ifdef VBOX_WITH_DRAG_AND_DROP
26	# include "GuestDnDPrivate.h"
27	#endif
28	#include "VMMDev.h"
29
30	#include "AutoCaller.h"
31	#include "Logging.h"
32	#include "Performance.h"
33	#include "VBoxEvents.h"
34
35	#include <VBox/VMMDev.h>
36	#include <iprt/cpp/utils.h>
37	#include <iprt/ctype.h>
38	#include <iprt/stream.h>
39	#include <iprt/timer.h>
40	#include <VBox/vmm/pgm.h>
41	#include <VBox/version.h>
42
43	// defines
44	/////////////////////////////////////////////////////////////////////////////
45
46	// constructor / destructor
47	/////////////////////////////////////////////////////////////////////////////
48
49	DEFINE_EMPTY_CTOR_DTOR(Guest)
50
51	HRESULT Guest::FinalConstruct()
52	{
53	return BaseFinalConstruct();
54	}
55
56	void Guest::FinalRelease()
57	{
58	uninit();
59	BaseFinalRelease();
60	}
61
62	// public methods only for internal purposes
63	/////////////////////////////////////////////////////////////////////////////
64
65	/**
66	* Initializes the guest object.
67	*/
68	HRESULT Guest::init(Console *aParent)
69	{
70	LogFlowThisFunc(("aParent=%p\n", aParent));
71
72	ComAssertRet(aParent, E_INVALIDARG);
73
74	/* Enclose the state transition NotReady->InInit->Ready */
75	AutoInitSpan autoInitSpan(this);
76	AssertReturn(autoInitSpan.isOk(), E_FAIL);
77
78	unconst(mParent) = aParent;
79
80	/* Confirm a successful initialization when it's the case */
81	autoInitSpan.setSucceeded();
82
83	ULONG aMemoryBalloonSize;
84	HRESULT hr = mParent->i_machine()->COMGETTER(MemoryBalloonSize)(&aMemoryBalloonSize);
85	if (hr == S_OK) /** @todo r=andy SUCCEEDED? */
86	mMemoryBalloonSize = aMemoryBalloonSize;
87	else
88	mMemoryBalloonSize = 0; /* Default is no ballooning */
89
90	BOOL fPageFusionEnabled;
91	hr = mParent->i_machine()->COMGETTER(PageFusionEnabled)(&fPageFusionEnabled);
92	if (hr == S_OK) /** @todo r=andy SUCCEEDED? */
93	mfPageFusionEnabled = fPageFusionEnabled;
94	else
95	mfPageFusionEnabled = false; /* Default is no page fusion*/
96
97	mStatUpdateInterval = 0; /* Default is not to report guest statistics at all */
98	mCollectVMMStats = false;
99
100	/* Clear statistics. */
101	mNetStatRx = mNetStatTx = 0;
102	mNetStatLastTs = RTTimeNanoTS();
103	for (unsigned i = 0 ; i < GUESTSTATTYPE_MAX; i++)
104	mCurrentGuestStat[i] = 0;
105	mVmValidStats = pm::VMSTATMASK_NONE;
106	RT_ZERO(mCurrentGuestCpuUserStat);
107	RT_ZERO(mCurrentGuestCpuKernelStat);
108	RT_ZERO(mCurrentGuestCpuIdleStat);
109
110	mMagic = GUEST_MAGIC;
111	int vrc = RTTimerLRCreate(&mStatTimer, 1000 /* ms */,
112	&Guest::i_staticUpdateStats, this);
113	AssertMsgRC(vrc, ("Failed to create guest statistics update timer (%Rrc)\n", vrc));
114
115	hr = unconst(mEventSource).createObject();
116	if (SUCCEEDED(hr))
117	hr = mEventSource->init();
118
119	mCpus = 1;
120
121	#ifdef VBOX_WITH_DRAG_AND_DROP
122	try
123	{
124	GuestDnD::createInstance(this /* pGuest */);
125	hr = unconst(mDnDSource).createObject();
126	if (SUCCEEDED(hr))
127	hr = mDnDSource->init(this /* pGuest */);
128	if (SUCCEEDED(hr))
129	{
130	hr = unconst(mDnDTarget).createObject();
131	if (SUCCEEDED(hr))
132	hr = mDnDTarget->init(this /* pGuest */);
133	}
134
135	LogFlowFunc(("Drag and drop initializied with hr=%Rhrc\n", hr));
136	}
137	catch (std::bad_alloc &)
138	{
139	hr = E_OUTOFMEMORY;
140	}
141	#endif
142
143	LogFlowFunc(("hr=%Rhrc\n", hr));
144	return hr;
145	}
146
147	/**
148	* Uninitializes the instance and sets the ready flag to FALSE.
149	* Called either from FinalRelease() or by the parent when it gets destroyed.
150	*/
151	void Guest::uninit()
152	{
153	LogFlowThisFunc(("\n"));
154
155	/* Enclose the state transition Ready->InUninit->NotReady */
156	AutoUninitSpan autoUninitSpan(this);
157	if (autoUninitSpan.uninitDone())
158	return;
159
160	/* Destroy stat update timer */
161	int vrc = RTTimerLRDestroy(mStatTimer);
162	AssertMsgRC(vrc, ("Failed to create guest statistics update timer(%Rra)\n", vrc));
163	mStatTimer = NULL;
164	mMagic = 0;
165
166	#ifdef VBOX_WITH_GUEST_CONTROL
167	LogFlowThisFunc(("Closing sessions (%RU64 total)\n",
168	mData.mGuestSessions.size()));
169	GuestSessions::iterator itSessions = mData.mGuestSessions.begin();
170	while (itSessions != mData.mGuestSessions.end())
171	{
172	# ifdef DEBUG
173	ULONG cRefs = itSessions->second->AddRef();
174	LogFlowThisFunc(("sessionID=%RU32, cRefs=%RU32\n", itSessions->first, cRefs > 1 ? cRefs - 1 : 0));
175	itSessions->second->Release();
176	# endif
177	itSessions->second->uninit();
178	++itSessions;
179	}
180	mData.mGuestSessions.clear();
181	#endif
182
183	#ifdef VBOX_WITH_DRAG_AND_DROP
184	GuestDnD::destroyInstance();
185	unconst(mDnDSource).setNull();
186	unconst(mDnDTarget).setNull();
187	#endif
188
189	unconst(mEventSource).setNull();
190	unconst(mParent) = NULL;
191
192	LogFlowFuncLeave();
193	}
194
195	/* static */
196	DECLCALLBACK(void) Guest::i_staticUpdateStats(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick)
197	{
198	AssertReturnVoid(pvUser != NULL);
199	Guest guest = static_cast<Guest >(pvUser);
200	Assert(guest->mMagic == GUEST_MAGIC);
201	if (guest->mMagic == GUEST_MAGIC)
202	guest->i_updateStats(iTick);
203
204	NOREF(hTimerLR);
205	}
206
207	/* static */
208	int Guest::i_staticEnumStatsCallback(const char pszName, STAMTYPE enmType, void pvSample, STAMUNIT enmUnit,
209	STAMVISIBILITY enmVisiblity, const char pszDesc, void pvUser)
210	{
211	AssertLogRelMsgReturn(enmType == STAMTYPE_COUNTER, ("Unexpected sample type %d ('%s')\n", enmType, pszName), VINF_SUCCESS);
212	AssertLogRelMsgReturn(enmUnit == STAMUNIT_BYTES, ("Unexpected sample unit %d ('%s')\n", enmUnit, pszName), VINF_SUCCESS);
213
214	/* Get the base name w/ slash. */
215	const char *pszLastSlash = strrchr(pszName, '/');
216	AssertLogRelMsgReturn(pszLastSlash, ("Unexpected sample '%s'\n", pszName), VINF_SUCCESS);
217
218	/* Receive or transmit? */
219	bool fRx;
220	if (!strcmp(pszLastSlash, "/BytesReceived"))
221	fRx = true;
222	else if (!strcmp(pszLastSlash, "/BytesTransmitted"))
223	fRx = false;
224	else
225	AssertLogRelMsgFailedReturn(("Unexpected sample '%s'\n", pszName), VINF_SUCCESS);
226
227	#if 0 /* not used for anything, so don't bother parsing it. */
228	/* Find start of instance number. ASSUMES '/Public/Net/Name<Instance digits>/Bytes...' */
229	do
230	--pszLastSlash;
231	while (pszLastSlash > pszName && RT_C_IS_DIGIT(*pszLastSlash));
232	pszLastSlash++;
233
234	uint8_t uInstance;
235	int rc = RTStrToUInt8Ex(pszLastSlash, NULL, 10, &uInstance);
236	AssertLogRelMsgReturn(RT_SUCCESS(rc) && rc != VWRN_NUMBER_TOO_BIG && rc != VWRN_NEGATIVE_UNSIGNED,
237	("%Rrc '%s'\n", rc, pszName), VINF_SUCCESS)
238	#endif
239
240	/* Add the bytes to our counters. */
241	PSTAMCOUNTER pCnt = (PSTAMCOUNTER)pvSample;
242	Guest pGuest = (Guest )pvUser;
243	uint64_t cb = pCnt->c;
244	#if 0
245	LogFlowFunc(("%s i=%u d=%s %llu bytes\n", pszName, uInstance, fRx ? "RX" : "TX", cb));
246	#else
247	LogFlowFunc(("%s d=%s %llu bytes\n", pszName, fRx ? "RX" : "TX", cb));
248	#endif
249	if (fRx)
250	pGuest->mNetStatRx += cb;
251	else
252	pGuest->mNetStatTx += cb;
253
254	return VINF_SUCCESS;
255	}
256
257	void Guest::i_updateStats(uint64_t iTick)
258	{
259	uint64_t cbFreeTotal = 0;
260	uint64_t cbAllocTotal = 0;
261	uint64_t cbBalloonedTotal = 0;
262	uint64_t cbSharedTotal = 0;
263	uint64_t cbSharedMem = 0;
264	ULONG uNetStatRx = 0;
265	ULONG uNetStatTx = 0;
266	ULONG aGuestStats[GUESTSTATTYPE_MAX];
267	RT_ZERO(aGuestStats);
268
269	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
270
271	ULONG validStats = mVmValidStats;
272	/* Check if we have anything to report */
273	if (validStats)
274	{
275	mVmValidStats = pm::VMSTATMASK_NONE;
276	memcpy(aGuestStats, mCurrentGuestStat, sizeof(aGuestStats));
277	}
278	alock.release();
279
280	/*
281	* Calling SessionMachine may take time as the object resides in VBoxSVC
282	* process. This is why we took a snapshot of currently collected stats
283	* and released the lock.
284	*/
285	Console::SafeVMPtrQuiet ptrVM(mParent);
286	if (ptrVM.isOk())
287	{
288	int rc;
289
290	/*
291	* There is no point in collecting VM shared memory if other memory
292	* statistics are not available yet. Or is there?
293	*/
294	if (validStats)
295	{
296	/* Query the missing per-VM memory statistics. */
297	uint64_t cbTotalMemIgn, cbPrivateMemIgn, cbZeroMemIgn;
298	rc = PGMR3QueryMemoryStats(ptrVM.rawUVM(), &cbTotalMemIgn, &cbPrivateMemIgn, &cbSharedMem, &cbZeroMemIgn);
299	if (rc == VINF_SUCCESS)
300	validStats \|= pm::VMSTATMASK_GUEST_MEMSHARED;
301	}
302
303	if (mCollectVMMStats)
304	{
305	rc = PGMR3QueryGlobalMemoryStats(ptrVM.rawUVM(), &cbAllocTotal, &cbFreeTotal, &cbBalloonedTotal, &cbSharedTotal);
306	AssertRC(rc);
307	if (rc == VINF_SUCCESS)
308	validStats \|= pm::VMSTATMASK_VMM_ALLOC \| pm::VMSTATMASK_VMM_FREE
309	\| pm::VMSTATMASK_VMM_BALOON \| pm::VMSTATMASK_VMM_SHARED;
310	}
311
312	uint64_t uRxPrev = mNetStatRx;
313	uint64_t uTxPrev = mNetStatTx;
314	mNetStatRx = mNetStatTx = 0;
315	rc = STAMR3Enum(ptrVM.rawUVM(), "/Public/Net//Bytes", i_staticEnumStatsCallback, this);
316	AssertRC(rc);
317
318	uint64_t uTsNow = RTTimeNanoTS();
319	uint64_t cNsPassed = uTsNow - mNetStatLastTs;
320	if (cNsPassed >= 1000)
321	{
322	mNetStatLastTs = uTsNow;
323
324	uNetStatRx = (ULONG)((mNetStatRx - uRxPrev) * 1000000 / (cNsPassed / 1000)); /* in bytes per second */
325	uNetStatTx = (ULONG)((mNetStatTx - uTxPrev) * 1000000 / (cNsPassed / 1000)); /* in bytes per second */
326	validStats \|= pm::VMSTATMASK_NET_RX \| pm::VMSTATMASK_NET_TX;
327	LogFlowThisFunc(("Net Rx=%llu Tx=%llu Ts=%llu Delta=%llu\n", mNetStatRx, mNetStatTx, uTsNow, cNsPassed));
328	}
329	else
330	{
331	/* Can happen on resume or if we're using a non-monotonic clock
332	source for the timer and the time is adjusted. */
333	mNetStatRx = uRxPrev;
334	mNetStatTx = uTxPrev;
335	LogThisFunc(("Net Ts=%llu cNsPassed=%llu - too small interval\n", uTsNow, cNsPassed));
336	}
337	}
338
339	mParent->i_reportVmStatistics(validStats,
340	aGuestStats[GUESTSTATTYPE_CPUUSER],
341	aGuestStats[GUESTSTATTYPE_CPUKERNEL],
342	aGuestStats[GUESTSTATTYPE_CPUIDLE],
343	/* Convert the units for RAM usage stats: page (4K) -> 1KB units */
344	mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] * (_4K/_1K),
345	mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] * (_4K/_1K),
346	mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] * (_4K/_1K),
347	(ULONG)(cbSharedMem / _1K), /* bytes -> KB */
348	mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] * (_4K/_1K),
349	mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] * (_4K/_1K),
350	(ULONG)(cbAllocTotal / _1K), /* bytes -> KB */
351	(ULONG)(cbFreeTotal / _1K),
352	(ULONG)(cbBalloonedTotal / _1K),
353	(ULONG)(cbSharedTotal / _1K),
354	uNetStatRx,
355	uNetStatTx);
356	}
357
358	// IGuest properties
359	/////////////////////////////////////////////////////////////////////////////
360
361	HRESULT Guest::getOSTypeId(com::Utf8Str &aOSTypeId)
362	{
363	HRESULT hrc = S_OK;
364	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
365	if (!mData.mInterfaceVersion.isEmpty())
366	aOSTypeId = mData.mOSTypeId;
367	else
368	{
369	/* Redirect the call to IMachine if no additions are installed. */
370	ComPtr<IMachine> ptrMachine(mParent->i_machine());
371	alock.release();
372	BSTR bstr;
373	hrc = ptrMachine->COMGETTER(OSTypeId)(&bstr);
374	aOSTypeId = bstr;
375	}
376	return hrc;
377	}
378
379	HRESULT Guest::getAdditionsRunLevel(AdditionsRunLevelType_T *aAdditionsRunLevel)
380	{
381	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
382
383	*aAdditionsRunLevel = mData.mAdditionsRunLevel;
384
385	return S_OK;
386	}
387
388	HRESULT Guest::getAdditionsVersion(com::Utf8Str &aAdditionsVersion)
389	{
390	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
391	HRESULT hrc = S_OK;
392
393	/*
394	* Return the ReportGuestInfo2 version info if available.
395	*/
396	if ( !mData.mAdditionsVersionNew.isEmpty()
397	\|\| mData.mAdditionsRunLevel <= AdditionsRunLevelType_None)
398	aAdditionsVersion = mData.mAdditionsVersionNew;
399	else
400	{
401	/*
402	* If we're running older guest additions (< 3.2.0) try get it from
403	* the guest properties. Detected switched around Version and
404	* Revision in early 3.1.x releases (see r57115).
405	*/
406	ComPtr<IMachine> ptrMachine = mParent->i_machine();
407	alock.release(); /* No need to hold this during the IPC fun. */
408
409	Bstr bstr;
410	hrc = ptrMachine->GetGuestPropertyValue(Bstr("/VirtualBox/GuestAdd/Version").raw(), bstr.asOutParam());
411	if ( SUCCEEDED(hrc)
412	&& !bstr.isEmpty())
413	{
414	Utf8Str str(bstr);
415	if (str.count('.') == 0)
416	hrc = ptrMachine->GetGuestPropertyValue(Bstr("/VirtualBox/GuestAdd/Revision").raw(), bstr.asOutParam());
417	str = bstr;
418	if (str.count('.') != 2)
419	hrc = E_FAIL;
420	}
421
422	if (SUCCEEDED(hrc))
423	aAdditionsVersion = bstr;
424	else
425	{
426	/* Returning 1.4 is better than nothing. */
427	alock.acquire();
428	aAdditionsVersion = mData.mInterfaceVersion;
429	hrc = S_OK;
430	}
431	}
432	return hrc;
433	}
434
435	HRESULT Guest::getAdditionsRevision(ULONG *aAdditionsRevision)
436	{
437	HRESULT hrc = S_OK;
438	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
439
440	/*
441	* Return the ReportGuestInfo2 version info if available.
442	*/
443	if ( !mData.mAdditionsVersionNew.isEmpty()
444	\|\| mData.mAdditionsRunLevel <= AdditionsRunLevelType_None)
445	*aAdditionsRevision = mData.mAdditionsRevision;
446	else
447	{
448	/*
449	* If we're running older guest additions (< 3.2.0) try get it from
450	* the guest properties. Detected switched around Version and
451	* Revision in early 3.1.x releases (see r57115).
452	*/
453	ComPtr<IMachine> ptrMachine = mParent->i_machine();
454	alock.release(); /* No need to hold this during the IPC fun. */
455
456	Bstr bstr;
457	hrc = ptrMachine->GetGuestPropertyValue(Bstr("/VirtualBox/GuestAdd/Revision").raw(), bstr.asOutParam());
458	if (SUCCEEDED(hrc))
459	{
460	Utf8Str str(bstr);
461	uint32_t uRevision;
462	int vrc = RTStrToUInt32Full(str.c_str(), 0, &uRevision);
463	if (vrc != VINF_SUCCESS && str.count('.') == 2)
464	{
465	hrc = ptrMachine->GetGuestPropertyValue(Bstr("/VirtualBox/GuestAdd/Version").raw(), bstr.asOutParam());
466	if (SUCCEEDED(hrc))
467	{
468	str = bstr;
469	vrc = RTStrToUInt32Full(str.c_str(), 0, &uRevision);
470	}
471	}
472	if (vrc == VINF_SUCCESS)
473	*aAdditionsRevision = uRevision;
474	else
475	hrc = VBOX_E_IPRT_ERROR;
476	}
477	if (FAILED(hrc))
478	{
479	/* Return 0 if we don't know. */
480	*aAdditionsRevision = 0;
481	hrc = S_OK;
482	}
483	}
484	return hrc;
485	}
486
487	HRESULT Guest::getDnDSource(ComPtr<IGuestDnDSource> &aDnDSource)
488	{
489	#ifndef VBOX_WITH_DRAG_AND_DROP
490	ReturnComNotImplemented();
491	#else
492	LogFlowThisFuncEnter();
493
494	/* No need to lock - lifetime constant. */
495	HRESULT hr = mDnDSource.queryInterfaceTo(aDnDSource.asOutParam());
496
497	LogFlowFuncLeaveRC(hr);
498	return hr;
499	#endif /* VBOX_WITH_DRAG_AND_DROP */
500	}
501
502	HRESULT Guest::getDnDTarget(ComPtr<IGuestDnDTarget> &aDnDTarget)
503	{
504	#ifndef VBOX_WITH_DRAG_AND_DROP
505	ReturnComNotImplemented();
506	#else
507	LogFlowThisFuncEnter();
508
509	/* No need to lock - lifetime constant. */
510	HRESULT hr = mDnDTarget.queryInterfaceTo(aDnDTarget.asOutParam());
511
512	LogFlowFuncLeaveRC(hr);
513	return hr;
514	#endif /* VBOX_WITH_DRAG_AND_DROP */
515	}
516
517	HRESULT Guest::getEventSource(ComPtr<IEventSource> &aEventSource)
518	{
519	LogFlowThisFuncEnter();
520
521	/* No need to lock - lifetime constant. */
522	mEventSource.queryInterfaceTo(aEventSource.asOutParam());
523
524	LogFlowFuncLeaveRC(S_OK);
525	return S_OK;
526	}
527
528	HRESULT Guest::getFacilities(std::vector<ComPtr<IAdditionsFacility> > &aFacilities)
529	{
530	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
531
532	aFacilities.resize(mData.mFacilityMap.size());
533	size_t i = 0;
534	for (FacilityMapIter it = mData.mFacilityMap.begin(); it != mData.mFacilityMap.end(); ++it, ++i)
535	it->second.queryInterfaceTo(aFacilities[i].asOutParam());
536
537	return S_OK;
538	}
539
540	HRESULT Guest::getSessions(std::vector<ComPtr<IGuestSession> > &aSessions)
541	{
542	#ifdef VBOX_WITH_GUEST_CONTROL
543	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
544
545	aSessions.resize(mData.mGuestSessions.size());
546	size_t i = 0;
547	for (GuestSessions::iterator it = mData.mGuestSessions.begin(); it != mData.mGuestSessions.end(); ++it, ++i)
548	it->second.queryInterfaceTo(aSessions[i].asOutParam());
549
550	return S_OK;
551	#else
552	ReturnComNotImplemented();
553	#endif
554	}
555
556	BOOL Guest::i_isPageFusionEnabled()
557	{
558	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
559
560	return mfPageFusionEnabled;
561	}
562
563	HRESULT Guest::getMemoryBalloonSize(ULONG *aMemoryBalloonSize)
564	{
565	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
566
567	*aMemoryBalloonSize = mMemoryBalloonSize;
568
569	return S_OK;
570	}
571
572	HRESULT Guest::setMemoryBalloonSize(ULONG aMemoryBalloonSize)
573	{
574	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
575
576	/* We must be 100% sure that IMachine::COMSETTER(MemoryBalloonSize)
577	* does not call us back in any way! */
578	HRESULT ret = mParent->i_machine()->COMSETTER(MemoryBalloonSize)(aMemoryBalloonSize);
579	if (ret == S_OK)
580	{
581	mMemoryBalloonSize = aMemoryBalloonSize;
582	/* forward the information to the VMM device */
583	VMMDev *pVMMDev = mParent->i_getVMMDev();
584	/* MUST release all locks before calling VMM device as its critsect
585	* has higher lock order than anything in Main. */
586	alock.release();
587	if (pVMMDev)
588	{
589	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
590	if (pVMMDevPort)
591	pVMMDevPort->pfnSetMemoryBalloon(pVMMDevPort, aMemoryBalloonSize);
592	}
593	}
594
595	return ret;
596	}
597
598	HRESULT Guest::getStatisticsUpdateInterval(ULONG *aStatisticsUpdateInterval)
599	{
600	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
601
602	*aStatisticsUpdateInterval = mStatUpdateInterval;
603	return S_OK;
604	}
605
606	HRESULT Guest::setStatisticsUpdateInterval(ULONG aStatisticsUpdateInterval)
607	{
608	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
609
610	if (mStatUpdateInterval)
611	if (aStatisticsUpdateInterval == 0)
612	RTTimerLRStop(mStatTimer);
613	else
614	RTTimerLRChangeInterval(mStatTimer, aStatisticsUpdateInterval);
615	else
616	if (aStatisticsUpdateInterval != 0)
617	{
618	RTTimerLRChangeInterval(mStatTimer, aStatisticsUpdateInterval);
619	RTTimerLRStart(mStatTimer, 0);
620	}
621	mStatUpdateInterval = aStatisticsUpdateInterval;
622	/* forward the information to the VMM device */
623	VMMDev *pVMMDev = mParent->i_getVMMDev();
624	/* MUST release all locks before calling VMM device as its critsect
625	* has higher lock order than anything in Main. */
626	alock.release();
627	if (pVMMDev)
628	{
629	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
630	if (pVMMDevPort)
631	pVMMDevPort->pfnSetStatisticsInterval(pVMMDevPort, aStatisticsUpdateInterval);
632	}
633
634	return S_OK;
635	}
636
637
638	HRESULT Guest::internalGetStatistics(ULONG aCpuUser, ULONG aCpuKernel, ULONG *aCpuIdle,
639	ULONG aMemTotal, ULONG aMemFree, ULONG *aMemBalloon,
640	ULONG aMemShared, ULONG aMemCache, ULONG *aPageTotal,
641	ULONG aMemAllocTotal, ULONG aMemFreeTotal,
642	ULONG aMemBalloonTotal, ULONG aMemSharedTotal)
643	{
644	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
645
646	*aCpuUser = mCurrentGuestStat[GUESTSTATTYPE_CPUUSER];
647	*aCpuKernel = mCurrentGuestStat[GUESTSTATTYPE_CPUKERNEL];
648	*aCpuIdle = mCurrentGuestStat[GUESTSTATTYPE_CPUIDLE];
649	aMemTotal = mCurrentGuestStat[GUESTSTATTYPE_MEMTOTAL] (_4K/_1K); /* page (4K) -> 1KB units */
650	aMemFree = mCurrentGuestStat[GUESTSTATTYPE_MEMFREE] (_4K/_1K); /* page (4K) -> 1KB units */
651	aMemBalloon = mCurrentGuestStat[GUESTSTATTYPE_MEMBALLOON] (_4K/_1K); /* page (4K) -> 1KB units */
652	aMemCache = mCurrentGuestStat[GUESTSTATTYPE_MEMCACHE] (_4K/_1K); /* page (4K) -> 1KB units */
653	aPageTotal = mCurrentGuestStat[GUESTSTATTYPE_PAGETOTAL] (_4K/_1K); /* page (4K) -> 1KB units */
654
655	/* Play safe or smth? */
656	*aMemAllocTotal = 0;
657	*aMemFreeTotal = 0;
658	*aMemBalloonTotal = 0;
659	*aMemSharedTotal = 0;
660	*aMemShared = 0;
661
662	/* MUST release all locks before calling any PGM statistics queries,
663	* as they are executed by EMT and that might deadlock us by VMM device
664	* activity which waits for the Guest object lock. */
665	alock.release();
666	Console::SafeVMPtr ptrVM(mParent);
667	if (!ptrVM.isOk())
668	return E_FAIL;
669
670	uint64_t cbFreeTotal, cbAllocTotal, cbBalloonedTotal, cbSharedTotal;
671	int rc = PGMR3QueryGlobalMemoryStats(ptrVM.rawUVM(), &cbAllocTotal, &cbFreeTotal, &cbBalloonedTotal, &cbSharedTotal);
672	AssertRCReturn(rc, E_FAIL);
673
674	aMemAllocTotal = (ULONG)(cbAllocTotal / _1K); / bytes -> KB */
675	*aMemFreeTotal = (ULONG)(cbFreeTotal / _1K);
676	*aMemBalloonTotal = (ULONG)(cbBalloonedTotal / _1K);
677	*aMemSharedTotal = (ULONG)(cbSharedTotal / _1K);
678
679	/* Query the missing per-VM memory statistics. */
680	uint64_t cbTotalMemIgn, cbPrivateMemIgn, cbSharedMem, cbZeroMemIgn;
681	rc = PGMR3QueryMemoryStats(ptrVM.rawUVM(), &cbTotalMemIgn, &cbPrivateMemIgn, &cbSharedMem, &cbZeroMemIgn);
682	AssertRCReturn(rc, E_FAIL);
683	*aMemShared = (ULONG)(cbSharedMem / _1K);
684
685	return S_OK;
686	}
687
688	HRESULT Guest::i_setStatistic(ULONG aCpuId, GUESTSTATTYPE enmType, ULONG aVal)
689	{
690	static ULONG indexToPerfMask[] =
691	{
692	pm::VMSTATMASK_GUEST_CPUUSER,
693	pm::VMSTATMASK_GUEST_CPUKERNEL,
694	pm::VMSTATMASK_GUEST_CPUIDLE,
695	pm::VMSTATMASK_GUEST_MEMTOTAL,
696	pm::VMSTATMASK_GUEST_MEMFREE,
697	pm::VMSTATMASK_GUEST_MEMBALLOON,
698	pm::VMSTATMASK_GUEST_MEMCACHE,
699	pm::VMSTATMASK_GUEST_PAGETOTAL,
700	pm::VMSTATMASK_NONE
701	};
702	AutoCaller autoCaller(this);
703	if (FAILED(autoCaller.rc())) return autoCaller.rc();
704
705	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
706
707	if (enmType >= GUESTSTATTYPE_MAX)
708	return E_INVALIDARG;
709
710	if (aCpuId < VMM_MAX_CPU_COUNT)
711	{
712	ULONG *paCpuStats;
713	switch (enmType)
714	{
715	case GUESTSTATTYPE_CPUUSER: paCpuStats = mCurrentGuestCpuUserStat; break;
716	case GUESTSTATTYPE_CPUKERNEL: paCpuStats = mCurrentGuestCpuKernelStat; break;
717	case GUESTSTATTYPE_CPUIDLE: paCpuStats = mCurrentGuestCpuIdleStat; break;
718	default: paCpuStats = NULL; break;
719	}
720	if (paCpuStats)
721	{
722	paCpuStats[aCpuId] = aVal;
723	aVal = 0;
724	for (uint32_t i = 0; i < mCpus && i < VMM_MAX_CPU_COUNT; i++)
725	aVal += paCpuStats[i];
726	aVal /= mCpus;
727	}
728	}
729
730	mCurrentGuestStat[enmType] = aVal;
731	mVmValidStats \|= indexToPerfMask[enmType];
732	return S_OK;
733	}
734
735	/**
736	* Returns the status of a specified Guest Additions facility.
737	*
738	* @return aStatus Current status of specified facility.
739	* @param aType Facility to get the status from.
740	* @param aTimestamp Timestamp of last facility status update in ms (optional).
741	*/
742	HRESULT Guest::getFacilityStatus(AdditionsFacilityType_T aFacility, LONG64 aTimestamp, AdditionsFacilityStatus_T aStatus)
743	{
744	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
745
746	/* Not checking for aTimestamp is intentional; it's optional. */
747	FacilityMapIterConst it = mData.mFacilityMap.find(aFacility);
748	if (it != mData.mFacilityMap.end())
749	{
750	AdditionsFacility *pFacility = it->second;
751	ComAssert(pFacility);
752	*aStatus = pFacility->i_getStatus();
753	if (aTimestamp)
754	*aTimestamp = pFacility->i_getLastUpdated();
755	}
756	else
757	{
758	/*
759	* Do not fail here -- could be that the facility never has been brought up (yet) but
760	* the host wants to have its status anyway. So just tell we don't know at this point.
761	*/
762	*aStatus = AdditionsFacilityStatus_Unknown;
763	if (aTimestamp)
764	*aTimestamp = RTTimeMilliTS();
765	}
766	return S_OK;
767	}
768
769	HRESULT Guest::getAdditionsStatus(AdditionsRunLevelType_T aLevel, BOOL *aActive)
770	{
771	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
772
773	HRESULT rc = S_OK;
774	switch (aLevel)
775	{
776	case AdditionsRunLevelType_System:
777	*aActive = (mData.mAdditionsRunLevel > AdditionsRunLevelType_None);
778	break;
779
780	case AdditionsRunLevelType_Userland:
781	*aActive = (mData.mAdditionsRunLevel >= AdditionsRunLevelType_Userland);
782	break;
783
784	case AdditionsRunLevelType_Desktop:
785	*aActive = (mData.mAdditionsRunLevel >= AdditionsRunLevelType_Desktop);
786	break;
787
788	default:
789	rc = setError(VBOX_E_NOT_SUPPORTED,
790	tr("Invalid status level defined: %u"), aLevel);
791	break;
792	}
793
794	return rc;
795	}
796	HRESULT Guest::setCredentials(const com::Utf8Str &aUserName, const com::Utf8Str &aPassword,
797	const com::Utf8Str &aDomain, BOOL aAllowInteractiveLogon)
798	{
799	/* Check for magic domain names which are used to pass encryption keys to the disk. */
800	if (Utf8Str(aDomain) == "@@disk")
801	return mParent->i_setDiskEncryptionKeys(aPassword);
802	else if (Utf8Str(aDomain) == "@@mem")
803	{
804	/** @todo */
805	return E_NOTIMPL;
806	}
807	else
808	{
809	/* forward the information to the VMM device */
810	VMMDev *pVMMDev = mParent->i_getVMMDev();
811	if (pVMMDev)
812	{
813	PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
814	if (pVMMDevPort)
815	{
816	uint32_t u32Flags = VMMDEV_SETCREDENTIALS_GUESTLOGON;
817	if (!aAllowInteractiveLogon)
818	u32Flags = VMMDEV_SETCREDENTIALS_NOLOCALLOGON;
819
820	pVMMDevPort->pfnSetCredentials(pVMMDevPort,
821	aUserName.c_str(),
822	aPassword.c_str(),
823	aDomain.c_str(),
824	u32Flags);
825	return S_OK;
826	}
827	}
828	}
829
830	return setError(VBOX_E_VM_ERROR,
831	tr("VMM device is not available (is the VM running?)"));
832	}
833
834	// public methods only for internal purposes
835	/////////////////////////////////////////////////////////////////////////////
836
837	/**
838	* Sets the general Guest Additions information like
839	* API (interface) version and OS type. Gets called by
840	* vmmdevUpdateGuestInfo.
841	*
842	* @param aInterfaceVersion
843	* @param aOsType
844	*/
845	void Guest::i_setAdditionsInfo(com::Utf8Str aInterfaceVersion, VBOXOSTYPE aOsType)
846	{
847	RTTIMESPEC TimeSpecTS;
848	RTTimeNow(&TimeSpecTS);
849
850	AutoCaller autoCaller(this);
851	AssertComRCReturnVoid(autoCaller.rc());
852
853	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
854
855
856	/*
857	* Note: The Guest Additions API (interface) version is deprecated
858	* and will not be used anymore! We might need it to at least report
859	* something as version number if really ancient Guest Additions are
860	* installed (without the guest version + revision properties having set).
861	*/
862	mData.mInterfaceVersion = aInterfaceVersion;
863
864	/*
865	* Older Additions rely on the Additions API version whether they
866	* are assumed to be active or not. Since newer Additions do report
867	* the Additions version before calling this function (by calling
868	* VMMDevReportGuestInfo2, VMMDevReportGuestStatus, VMMDevReportGuestInfo,
869	* in that order) we can tell apart old and new Additions here. Old
870	* Additions never would set VMMDevReportGuestInfo2 (which set mData.mAdditionsVersion)
871	* so they just rely on the aInterfaceVersion string (which gets set by
872	* VMMDevReportGuestInfo).
873	*
874	* So only mark the Additions as being active (run level = system) when we
875	* don't have the Additions version set.
876	*/
877	if (mData.mAdditionsVersionNew.isEmpty())
878	{
879	if (aInterfaceVersion.isEmpty())
880	mData.mAdditionsRunLevel = AdditionsRunLevelType_None;
881	else
882	{
883	mData.mAdditionsRunLevel = AdditionsRunLevelType_System;
884
885	/*
886	* To keep it compatible with the old Guest Additions behavior we need to set the
887	* "graphics" (feature) facility to active as soon as we got the Guest Additions
888	* interface version.
889	*/
890	i_facilityUpdate(VBoxGuestFacilityType_Graphics, VBoxGuestFacilityStatus_Active, 0 /fFlags/, &TimeSpecTS);
891	}
892	}
893
894	/*
895	* Older Additions didn't have this finer grained capability bit,
896	* so enable it by default. Newer Additions will not enable this here
897	* and use the setSupportedFeatures function instead.
898	*/
899	/** @todo r=bird: I don't get the above comment nor the code below...
900	* One talks about capability bits, the one always does something to a facility.
901	* Then there is the comment below it all, which is placed like it addresses the
902	* mOSTypeId, but talks about something which doesn't remotely like mOSTypeId...
903	*
904	* Andy, could you please try clarify and make the comments shorter and more
905	* coherent! Also, explain why this is important and what depends on it.
906	*
907	* PS. There is the VMMDEV_GUEST_SUPPORTS_GRAPHICS capability* report... It
908	* should come in pretty quickly after this update, normally.
909	*/
910	i_facilityUpdate(VBoxGuestFacilityType_Graphics,
911	i_facilityIsActive(VBoxGuestFacilityType_VBoxGuestDriver)
912	? VBoxGuestFacilityStatus_Active : VBoxGuestFacilityStatus_Inactive,
913	0 /fFlags/, &TimeSpecTS); /** @todo the timestamp isn't gonna be right here on saved state restore. */
914
915	/*
916	* Note! There is a race going on between setting mAdditionsRunLevel and
917	* mSupportsGraphics here and disabling/enabling it later according to
918	* its real status when using new(er) Guest Additions.
919	*/
920	mData.mOSType = aOsType;
921	mData.mOSTypeId = Global::OSTypeId(aOsType);
922	}
923
924	/**
925	* Sets the Guest Additions version information details.
926	*
927	* Gets called by vmmdevUpdateGuestInfo2 and vmmdevUpdateGuestInfo (to clear the
928	* state).
929	*
930	* @param a_uFullVersion VBoxGuestInfo2::additionsMajor,
931	* VBoxGuestInfo2::additionsMinor and
932	* VBoxGuestInfo2::additionsBuild combined into
933	* one value by VBOX_FULL_VERSION_MAKE.
934	*
935	* When this is 0, it's vmmdevUpdateGuestInfo
936	* calling to reset the state.
937	*
938	* @param a_pszName Build type tag and/or publisher tag, empty
939	* string if neiter of those are present.
940	* @param a_uRevision See VBoxGuestInfo2::additionsRevision.
941	* @param a_fFeatures See VBoxGuestInfo2::additionsFeatures.
942	*/
943	void Guest::i_setAdditionsInfo2(uint32_t a_uFullVersion, const char *a_pszName, uint32_t a_uRevision, uint32_t a_fFeatures)
944	{
945	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
946
947	if (a_uFullVersion)
948	{
949	mData.mAdditionsVersionNew = Utf8StrFmt(*a_pszName ? "%u.%u.%u_%s" : "%u.%u.%u",
950	VBOX_FULL_VERSION_GET_MAJOR(a_uFullVersion),
951	VBOX_FULL_VERSION_GET_MINOR(a_uFullVersion),
952	VBOX_FULL_VERSION_GET_BUILD(a_uFullVersion),
953	a_pszName);
954	mData.mAdditionsVersionFull = a_uFullVersion;
955	mData.mAdditionsRevision = a_uRevision;
956	mData.mAdditionsFeatures = a_fFeatures;
957	}
958	else
959	{
960	Assert(!a_fFeatures && !a_uRevision && !*a_pszName);
961	mData.mAdditionsVersionNew.setNull();
962	mData.mAdditionsVersionFull = 0;
963	mData.mAdditionsRevision = 0;
964	mData.mAdditionsFeatures = 0;
965	}
966	}
967
968	bool Guest::i_facilityIsActive(VBoxGuestFacilityType enmFacility)
969	{
970	Assert(enmFacility < INT32_MAX);
971	FacilityMapIterConst it = mData.mFacilityMap.find((AdditionsFacilityType_T)enmFacility);
972	if (it != mData.mFacilityMap.end())
973	{
974	AdditionsFacility *pFac = it->second;
975	return (pFac->i_getStatus() == AdditionsFacilityStatus_Active);
976	}
977	return false;
978	}
979
980	void Guest::i_facilityUpdate(VBoxGuestFacilityType a_enmFacility, VBoxGuestFacilityStatus a_enmStatus,
981	uint32_t a_fFlags, PCRTTIMESPEC a_pTimeSpecTS)
982	{
983	AssertReturnVoid( a_enmFacility < VBoxGuestFacilityType_All
984	&& a_enmFacility > VBoxGuestFacilityType_Unknown);
985
986	FacilityMapIter it = mData.mFacilityMap.find((AdditionsFacilityType_T)a_enmFacility);
987	if (it != mData.mFacilityMap.end())
988	{
989	AdditionsFacility *pFac = it->second;
990	pFac->i_update((AdditionsFacilityStatus_T)a_enmStatus, a_fFlags, a_pTimeSpecTS);
991	}
992	else
993	{
994	if (mData.mFacilityMap.size() > 64)
995	{
996	/* The easy way out for now. We could automatically destroy
997	inactive facilities like VMMDev does if we like... */
998	AssertFailedReturnVoid();
999	}
1000
1001	ComObjPtr<AdditionsFacility> ptrFac;
1002	ptrFac.createObject();
1003	AssertReturnVoid(!ptrFac.isNull());
1004
1005	HRESULT hrc = ptrFac->init(this, (AdditionsFacilityType_T)a_enmFacility, (AdditionsFacilityStatus_T)a_enmStatus,
1006	a_fFlags, a_pTimeSpecTS);
1007	if (SUCCEEDED(hrc))
1008	mData.mFacilityMap.insert(std::make_pair((AdditionsFacilityType_T)a_enmFacility, ptrFac));
1009	}
1010	}
1011
1012	/**
1013	* Issued by the guest when a guest user changed its state.
1014	*
1015	* @return IPRT status code.
1016	* @param aUser Guest user name.
1017	* @param aDomain Domain of guest user account. Optional.
1018	* @param enmState New state to indicate.
1019	* @param pbDetails Pointer to state details. Optional.
1020	* @param cbDetails Size (in bytes) of state details. Pass 0 if not used.
1021	*/
1022	void Guest::i_onUserStateChange(Bstr aUser, Bstr aDomain, VBoxGuestUserState enmState,
1023	const uint8_t *pbDetails, uint32_t cbDetails)
1024	{
1025	LogFlowThisFunc(("\n"));
1026
1027	AutoCaller autoCaller(this);
1028	AssertComRCReturnVoid(autoCaller.rc());
1029
1030	Bstr strDetails; /** @todo Implement state details here. */
1031
1032	fireGuestUserStateChangedEvent(mEventSource, aUser.raw(), aDomain.raw(),
1033	(GuestUserState_T)enmState, strDetails.raw());
1034	LogFlowFuncLeave();
1035	}
1036
1037	/**
1038	* Sets the status of a certain Guest Additions facility.
1039	*
1040	* Gets called by vmmdevUpdateGuestStatus, which just passes the report along.
1041	*
1042	* @param a_pInterface Pointer to this interface.
1043	* @param a_enmFacility The facility.
1044	* @param a_enmStatus The status.
1045	* @param a_fFlags Flags assoicated with the update. Currently
1046	* reserved and should be ignored.
1047	* @param a_pTimeSpecTS Pointer to the timestamp of this report.
1048	* @sa PDMIVMMDEVCONNECTOR::pfnUpdateGuestStatus, vmmdevUpdateGuestStatus
1049	* @thread The emulation thread.
1050	*/
1051	void Guest::i_setAdditionsStatus(VBoxGuestFacilityType a_enmFacility, VBoxGuestFacilityStatus a_enmStatus,
1052	uint32_t a_fFlags, PCRTTIMESPEC a_pTimeSpecTS)
1053	{
1054	Assert( a_enmFacility > VBoxGuestFacilityType_Unknown
1055	&& a_enmFacility <= VBoxGuestFacilityType_All); /* Paranoia, VMMDev checks for this. */
1056
1057	AutoCaller autoCaller(this);
1058	AssertComRCReturnVoid(autoCaller.rc());
1059
1060	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1061
1062	/*
1063	* Set a specific facility status.
1064	*/
1065	if (a_enmFacility == VBoxGuestFacilityType_All)
1066	for (FacilityMapIter it = mData.mFacilityMap.begin(); it != mData.mFacilityMap.end(); ++it)
1067	i_facilityUpdate((VBoxGuestFacilityType)it->first, a_enmStatus, a_fFlags, a_pTimeSpecTS);
1068	else /* Update one facility only. */
1069	i_facilityUpdate(a_enmFacility, a_enmStatus, a_fFlags, a_pTimeSpecTS);
1070
1071	/*
1072	* Recalc the runlevel.
1073	*/
1074	if (i_facilityIsActive(VBoxGuestFacilityType_VBoxTrayClient))
1075	mData.mAdditionsRunLevel = AdditionsRunLevelType_Desktop;
1076	else if (i_facilityIsActive(VBoxGuestFacilityType_VBoxService))
1077	mData.mAdditionsRunLevel = AdditionsRunLevelType_Userland;
1078	else if (i_facilityIsActive(VBoxGuestFacilityType_VBoxGuestDriver))
1079	mData.mAdditionsRunLevel = AdditionsRunLevelType_System;
1080	else
1081	mData.mAdditionsRunLevel = AdditionsRunLevelType_None;
1082	}
1083
1084	/**
1085	* Sets the supported features (and whether they are active or not).
1086	*
1087	* @param fCaps Guest capability bit mask (VMMDEV_GUEST_SUPPORTS_XXX).
1088	*/
1089	void Guest::i_setSupportedFeatures(uint32_t aCaps)
1090	{
1091	AutoCaller autoCaller(this);
1092	AssertComRCReturnVoid(autoCaller.rc());
1093
1094	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1095
1096	/** @todo A nit: The timestamp is wrong on saved state restore. Would be better
1097	* to move the graphics and seamless capability -> facility translation to
1098	* VMMDev so this could be saved. */
1099	RTTIMESPEC TimeSpecTS;
1100	RTTimeNow(&TimeSpecTS);
1101
1102	i_facilityUpdate(VBoxGuestFacilityType_Seamless,
1103	aCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? VBoxGuestFacilityStatus_Active : VBoxGuestFacilityStatus_Inactive,
1104	0 /fFlags/, &TimeSpecTS);
1105	/** @todo Add VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING */
1106	}

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

source: vbox/trunk/src/VBox/Main/src-client/GuestImpl.cpp@ 56858

Download in other formats: