GuestImpl.cpp@ 69387

Last change on this file since 69387 was 67914, checked in by vboxsync, 7 years ago
src-client: Define LOG_GROUP according to interface or similar.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.9 KB

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

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

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

Download in other formats: