VMMDev.cpp@ 69304

Last change on this file since 69304 was 68314, checked in by vboxsync, 7 years ago
added OS types for macOS 10.12 and 10.13
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 163.3 KB

Line
1	/* $Id: VMMDev.cpp 68314 2017-08-07 10:14:51Z vboxsync $ */
2	/** @file
3	* VMMDev - Guest <-> VMM/Host communication device.
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	/** @page pg_vmmdev The VMM Device.
19	*
20	* The VMM device is a custom hardware device emulation for communicating with
21	* the guest additions.
22	*
23	* Whenever host wants to inform guest about something an IRQ notification will
24	* be raised.
25	*
26	* VMMDev PDM interface will contain the guest notification method.
27	*
28	* There is a 32 bit event mask which will be read by guest on an interrupt. A
29	* non zero bit in the mask means that the specific event occurred and requires
30	* processing on guest side.
31	*
32	* After reading the event mask guest must issue a generic request
33	* AcknowlegdeEvents.
34	*
35	* IRQ line is set to 1 (request) if there are unprocessed events, that is the
36	* event mask is not zero.
37	*
38	* After receiving an interrupt and checking event mask, the guest must process
39	* events using the event specific mechanism.
40	*
41	* That is if mouse capabilities were changed, guest will use
42	* VMMDev_GetMouseStatus generic request.
43	*
44	* Event mask is only a set of flags indicating that guest must proceed with a
45	* procedure.
46	*
47	* Unsupported events are therefore ignored. The guest additions must inform
48	* host which events they want to receive, to avoid unnecessary IRQ processing.
49	* By default no events are signalled to guest.
50	*
51	* This seems to be fast method. It requires only one context switch for an
52	* event processing.
53	*
54	*
55	* @section sec_vmmdev_heartbeat Heartbeat
56	*
57	* The heartbeat is a feature to monitor whether the guest OS is hung or not.
58	*
59	* The main kernel component of the guest additions, VBoxGuest, sets up a timer
60	* at a frequency returned by VMMDevReq_HeartbeatConfigure
61	* (VMMDevReqHeartbeat::cNsInterval, VMMDEV::cNsHeartbeatInterval) and performs
62	* a VMMDevReq_GuestHeartbeat request every time the timer ticks.
63	*
64	* The host side (VMMDev) arms a timer with a more distant deadline
65	* (VMMDEV::cNsHeartbeatTimeout), twice cNsHeartbeatInterval by default. Each
66	* time a VMMDevReq_GuestHeartbeat request comes in, the timer is rearmed with
67	* the same relative deadline. So, as long as VMMDevReq_GuestHeartbeat comes
68	* when they should, the host timer will never fire.
69	*
70	* When the timer fires, we consider the guest as hung / flatlined / dead.
71	* Currently we only LogRel that, but it's easy to extend this with an event in
72	* Main API.
73	*
74	* Should the guest reawaken at some later point, we LogRel that event and
75	* continue as normal. Again something which would merit an API event.
76	*
77	*/
78
79
80	/*********************************************************************************************************************************
81	* Header Files *
82	*********************************************************************************************************************************/
83	/* Enable dev_vmm Log3 statements to get IRQ-related logging. */
84	#define LOG_GROUP LOG_GROUP_DEV_VMM
85	#include <VBoxVideo.h> /* For VBVA definitions. */
86	#include <VBox/VMMDev.h>
87	#include <VBox/vmm/mm.h>
88	#include <VBox/log.h>
89	#include <VBox/param.h>
90	#include <iprt/path.h>
91	#include <iprt/dir.h>
92	#include <iprt/file.h>
93	#include <VBox/vmm/pgm.h>
94	#include <VBox/err.h>
95	#include <VBox/vmm/vm.h> /* for VM_IS_EMT */
96	#include <VBox/dbg.h>
97	#include <VBox/version.h>
98
99	#include <iprt/asm.h>
100	#include <iprt/asm-amd64-x86.h>
101	#include <iprt/assert.h>
102	#include <iprt/buildconfig.h>
103	#include <iprt/string.h>
104	#include <iprt/time.h>
105	#ifndef IN_RC
106	# include <iprt/mem.h>
107	#endif
108	#ifdef IN_RING3
109	# include <iprt/uuid.h>
110	#endif
111
112	#include "VMMDevState.h"
113	#ifdef VBOX_WITH_HGCM
114	# include "VMMDevHGCM.h"
115	#endif
116	#ifndef VBOX_WITHOUT_TESTING_FEATURES
117	# include "VMMDevTesting.h"
118	#endif
119
120
121	/*********************************************************************************************************************************
122	* Defined Constants And Macros *
123	*********************************************************************************************************************************/
124	#define VMMDEV_INTERFACE_VERSION_IS_1_03(s) \
125	( RT_HIWORD((s)->guestInfo.interfaceVersion) == 1 \
126	&& RT_LOWORD((s)->guestInfo.interfaceVersion) == 3 )
127
128	#define VMMDEV_INTERFACE_VERSION_IS_OK(additionsVersion) \
129	( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
130	&& RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) )
131
132	#define VMMDEV_INTERFACE_VERSION_IS_OLD(additionsVersion) \
133	( (RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) \
134	\|\| ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
135	&& RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) ) )
136
137	#define VMMDEV_INTERFACE_VERSION_IS_TOO_OLD(additionsVersion) \
138	( RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) )
139
140	#define VMMDEV_INTERFACE_VERSION_IS_NEW(additionsVersion) \
141	( RT_HIWORD(additionsVersion) > RT_HIWORD(VMMDEV_VERSION) \
142	\|\| ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
143	&& RT_LOWORD(additionsVersion) > RT_LOWORD(VMMDEV_VERSION) ) )
144
145	/** The saved state version. */
146	#define VMMDEV_SAVED_STATE_VERSION VMMDEV_SAVED_STATE_VERSION_HEARTBEAT
147	/** The saved state version with heartbeat state. */
148	#define VMMDEV_SAVED_STATE_VERSION_HEARTBEAT 16
149	/** The saved state version without heartbeat state. */
150	#define VMMDEV_SAVED_STATE_VERSION_NO_HEARTBEAT 15
151	/** The saved state version which is missing the guest facility statuses. */
152	#define VMMDEV_SAVED_STATE_VERSION_MISSING_FACILITY_STATUSES 14
153	/** The saved state version which is missing the guestInfo2 bits. */
154	#define VMMDEV_SAVED_STATE_VERSION_MISSING_GUEST_INFO_2 13
155	/** The saved state version used by VirtualBox 3.0.
156	* This doesn't have the config part. */
157	#define VMMDEV_SAVED_STATE_VERSION_VBOX_30 11
158	/** Default interval in nanoseconds between guest heartbeats.
159	* Used when no HeartbeatInterval is set in CFGM and for setting
160	* HB check timer if the guest's heartbeat frequency is less than 1Hz. */
161	#define VMMDEV_HEARTBEAT_DEFAULT_INTERVAL (2U*RT_NS_1SEC_64)
162
163
164	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
165
166	/* -=-=-=-=- Misc Helpers -=-=-=-=- */
167
168	/**
169	* Log information about the Guest Additions.
170	*
171	* @param pGuestInfo The information we've got from the Guest Additions driver.
172	*/
173	static void vmmdevLogGuestOsInfo(VBoxGuestInfo *pGuestInfo)
174	{
175	const char *pszOs;
176	switch (pGuestInfo->osType & ~VBOXOSTYPE_x64)
177	{
178	case VBOXOSTYPE_DOS: pszOs = "DOS"; break;
179	case VBOXOSTYPE_Win31: pszOs = "Windows 3.1"; break;
180	case VBOXOSTYPE_Win9x: pszOs = "Windows 9x"; break;
181	case VBOXOSTYPE_Win95: pszOs = "Windows 95"; break;
182	case VBOXOSTYPE_Win98: pszOs = "Windows 98"; break;
183	case VBOXOSTYPE_WinMe: pszOs = "Windows Me"; break;
184	case VBOXOSTYPE_WinNT: pszOs = "Windows NT"; break;
185	case VBOXOSTYPE_WinNT4: pszOs = "Windows NT4"; break;
186	case VBOXOSTYPE_Win2k: pszOs = "Windows 2k"; break;
187	case VBOXOSTYPE_WinXP: pszOs = "Windows XP"; break;
188	case VBOXOSTYPE_Win2k3: pszOs = "Windows 2k3"; break;
189	case VBOXOSTYPE_WinVista: pszOs = "Windows Vista"; break;
190	case VBOXOSTYPE_Win2k8: pszOs = "Windows 2k8"; break;
191	case VBOXOSTYPE_Win7: pszOs = "Windows 7"; break;
192	case VBOXOSTYPE_Win8: pszOs = "Windows 8"; break;
193	case VBOXOSTYPE_Win2k12_x64 & ~VBOXOSTYPE_x64: pszOs = "Windows 2k12"; break;
194	case VBOXOSTYPE_Win81: pszOs = "Windows 8.1"; break;
195	case VBOXOSTYPE_Win10: pszOs = "Windows 10"; break;
196	case VBOXOSTYPE_Win2k16_x64 & ~VBOXOSTYPE_x64: pszOs = "Windows 2k16"; break;
197	case VBOXOSTYPE_OS2: pszOs = "OS/2"; break;
198	case VBOXOSTYPE_OS2Warp3: pszOs = "OS/2 Warp 3"; break;
199	case VBOXOSTYPE_OS2Warp4: pszOs = "OS/2 Warp 4"; break;
200	case VBOXOSTYPE_OS2Warp45: pszOs = "OS/2 Warp 4.5"; break;
201	case VBOXOSTYPE_ECS: pszOs = "OS/2 ECS"; break;
202	case VBOXOSTYPE_OS21x: pszOs = "OS/2 2.1x"; break;
203	case VBOXOSTYPE_Linux: pszOs = "Linux"; break;
204	case VBOXOSTYPE_Linux22: pszOs = "Linux 2.2"; break;
205	case VBOXOSTYPE_Linux24: pszOs = "Linux 2.4"; break;
206	case VBOXOSTYPE_Linux26: pszOs = "Linux >= 2.6"; break;
207	case VBOXOSTYPE_ArchLinux: pszOs = "ArchLinux"; break;
208	case VBOXOSTYPE_Debian: pszOs = "Debian"; break;
209	case VBOXOSTYPE_OpenSUSE: pszOs = "openSUSE"; break;
210	case VBOXOSTYPE_FedoraCore: pszOs = "Fedora"; break;
211	case VBOXOSTYPE_Gentoo: pszOs = "Gentoo"; break;
212	case VBOXOSTYPE_Mandriva: pszOs = "Mandriva"; break;
213	case VBOXOSTYPE_RedHat: pszOs = "RedHat"; break;
214	case VBOXOSTYPE_Turbolinux: pszOs = "TurboLinux"; break;
215	case VBOXOSTYPE_Ubuntu: pszOs = "Ubuntu"; break;
216	case VBOXOSTYPE_Xandros: pszOs = "Xandros"; break;
217	case VBOXOSTYPE_Oracle: pszOs = "Oracle Linux"; break;
218	case VBOXOSTYPE_FreeBSD: pszOs = "FreeBSD"; break;
219	case VBOXOSTYPE_OpenBSD: pszOs = "OpenBSD"; break;
220	case VBOXOSTYPE_NetBSD: pszOs = "NetBSD"; break;
221	case VBOXOSTYPE_Netware: pszOs = "Netware"; break;
222	case VBOXOSTYPE_Solaris: pszOs = "Solaris"; break;
223	case VBOXOSTYPE_OpenSolaris: pszOs = "OpenSolaris"; break;
224	case VBOXOSTYPE_Solaris11_x64 & ~VBOXOSTYPE_x64: pszOs = "Solaris 11"; break;
225	case VBOXOSTYPE_MacOS: pszOs = "Mac OS X"; break;
226	case VBOXOSTYPE_MacOS106: pszOs = "Mac OS X 10.6"; break;
227	case VBOXOSTYPE_MacOS107_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.7"; break;
228	case VBOXOSTYPE_MacOS108_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.8"; break;
229	case VBOXOSTYPE_MacOS109_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.9"; break;
230	case VBOXOSTYPE_MacOS1010_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.10"; break;
231	case VBOXOSTYPE_MacOS1011_x64 & ~VBOXOSTYPE_x64: pszOs = "Mac OS X 10.11"; break;
232	case VBOXOSTYPE_MacOS1012_x64 & ~VBOXOSTYPE_x64: pszOs = "macOS 10.12"; break;
233	case VBOXOSTYPE_MacOS1013_x64 & ~VBOXOSTYPE_x64: pszOs = "macOS 10.13"; break;
234	case VBOXOSTYPE_Haiku: pszOs = "Haiku"; break;
235	default: pszOs = "unknown"; break;
236	}
237	LogRel(("VMMDev: Guest Additions information report: Interface = 0x%08X osType = 0x%08X (%s, %u-bit)\n",
238	pGuestInfo->interfaceVersion, pGuestInfo->osType, pszOs,
239	pGuestInfo->osType & VBOXOSTYPE_x64 ? 64 : 32));
240	}
241
242	/**
243	* Sets the IRQ (raise it or lower it) for 1.03 additions.
244	*
245	* @param pThis The VMMDev state.
246	* @thread Any.
247	* @remarks Must be called owning the critical section.
248	*/
249	static void vmmdevSetIRQ_Legacy(PVMMDEV pThis)
250	{
251	if (pThis->fu32AdditionsOk)
252	{
253	/* Filter unsupported events */
254	uint32_t fEvents = pThis->u32HostEventFlags & pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
255
256	Log(("vmmdevSetIRQ: fEvents=%#010x, u32HostEventFlags=%#010x, u32GuestEventMask=%#010x.\n",
257	fEvents, pThis->u32HostEventFlags, pThis->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
258
259	/* Move event flags to VMMDev RAM */
260	pThis->pVMMDevRAMR3->V.V1_03.u32HostEvents = fEvents;
261
262	uint32_t uIRQLevel = 0;
263	if (fEvents)
264	{
265	/* Clear host flags which will be delivered to guest. */
266	pThis->u32HostEventFlags &= ~fEvents;
267	Log(("vmmdevSetIRQ: u32HostEventFlags=%#010x\n", pThis->u32HostEventFlags));
268	uIRQLevel = 1;
269	}
270
271	/* Set IRQ level for pin 0 (see NoWait comment in vmmdevMaybeSetIRQ). */
272	/** @todo make IRQ pin configurable, at least a symbolic constant */
273	PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, uIRQLevel);
274	Log(("vmmdevSetIRQ: IRQ set %d\n", uIRQLevel));
275	}
276	else
277	Log(("vmmdevSetIRQ: IRQ is not generated, guest has not yet reported to us.\n"));
278	}
279
280	/**
281	* Sets the IRQ if there are events to be delivered.
282	*
283	* @param pThis The VMMDev state.
284	* @thread Any.
285	* @remarks Must be called owning the critical section.
286	*/
287	static void vmmdevMaybeSetIRQ(PVMMDEV pThis)
288	{
289	Log3(("vmmdevMaybeSetIRQ: u32HostEventFlags=%#010x, u32GuestFilterMask=%#010x.\n",
290	pThis->u32HostEventFlags, pThis->u32GuestFilterMask));
291
292	if (pThis->u32HostEventFlags & pThis->u32GuestFilterMask)
293	{
294	/*
295	* Note! No need to wait for the IRQs to be set (if we're not luck
296	* with the locks, etc). It is a notification about something,
297	* which has already happened.
298	*/
299	pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = true;
300	PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 1);
301	Log3(("vmmdevMaybeSetIRQ: IRQ set.\n"));
302	}
303	}
304
305	/**
306	* Notifies the guest about new events (@a fAddEvents).
307	*
308	* @param pThis The VMMDev state.
309	* @param fAddEvents New events to add.
310	* @thread Any.
311	* @remarks Must be called owning the critical section.
312	*/
313	static void vmmdevNotifyGuestWorker(PVMMDEV pThis, uint32_t fAddEvents)
314	{
315	Log3(("vmmdevNotifyGuestWorker: fAddEvents=%#010x.\n", fAddEvents));
316	Assert(PDMCritSectIsOwner(&pThis->CritSect));
317
318	if (!VMMDEV_INTERFACE_VERSION_IS_1_03(pThis))
319	{
320	Log3(("vmmdevNotifyGuestWorker: New additions detected.\n"));
321
322	if (pThis->fu32AdditionsOk)
323	{
324	const bool fHadEvents = (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
325
326	Log3(("vmmdevNotifyGuestWorker: fHadEvents=%d, u32HostEventFlags=%#010x, u32GuestFilterMask=%#010x.\n",
327	fHadEvents, pThis->u32HostEventFlags, pThis->u32GuestFilterMask));
328
329	pThis->u32HostEventFlags \|= fAddEvents;
330
331	if (!fHadEvents)
332	vmmdevMaybeSetIRQ(pThis);
333	}
334	else
335	{
336	pThis->u32HostEventFlags \|= fAddEvents;
337	Log(("vmmdevNotifyGuestWorker: IRQ is not generated, guest has not yet reported to us.\n"));
338	}
339	}
340	else
341	{
342	Log3(("vmmdevNotifyGuestWorker: Old additions detected.\n"));
343
344	pThis->u32HostEventFlags \|= fAddEvents;
345	vmmdevSetIRQ_Legacy(pThis);
346	}
347	}
348
349
350
351	/* -=-=-=-=- Interfaces shared with VMMDevHGCM.cpp -=-=-=-=- */
352
353	/**
354	* Notifies the guest about new events (@a fAddEvents).
355	*
356	* This is used by VMMDev.cpp as well as VMMDevHGCM.cpp.
357	*
358	* @param pThis The VMMDev state.
359	* @param fAddEvents New events to add.
360	* @thread Any.
361	*/
362	void VMMDevNotifyGuest(PVMMDEV pThis, uint32_t fAddEvents)
363	{
364	Log3(("VMMDevNotifyGuest: fAddEvents=%#010x\n", fAddEvents));
365
366	/*
367	* Only notify the VM when it's running.
368	*/
369	VMSTATE enmVMState = PDMDevHlpVMState(pThis->pDevIns);
370	/** @todo r=bird: Shouldn't there be more states here? Wouldn't we drop
371	* notifications now when we're in the process of suspending or
372	* similar? */
373	if ( enmVMState == VMSTATE_RUNNING
374	\|\| enmVMState == VMSTATE_RUNNING_LS)
375	{
376	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
377	vmmdevNotifyGuestWorker(pThis, fAddEvents);
378	PDMCritSectLeave(&pThis->CritSect);
379	}
380	}
381
382	/**
383	* Code shared by VMMDevReq_CtlGuestFilterMask and HGCM for controlling the
384	* events the guest are interested in.
385	*
386	* @param pThis The VMMDev state.
387	* @param fOrMask Events to add (VMMDEV_EVENT_XXX). Pass 0 for no
388	* change.
389	* @param fNotMask Events to remove (VMMDEV_EVENT_XXX). Pass 0 for no
390	* change.
391	*
392	* @remarks When HGCM will automatically enable VMMDEV_EVENT_HGCM when the guest
393	* starts submitting HGCM requests. Otherwise, the events are
394	* controlled by the guest.
395	*/
396	void VMMDevCtlSetGuestFilterMask(PVMMDEV pThis, uint32_t fOrMask, uint32_t fNotMask)
397	{
398	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
399
400	const bool fHadEvents = (pThis->u32HostEventFlags & pThis->u32GuestFilterMask) != 0;
401
402	Log(("VMMDevCtlSetGuestFilterMask: fOrMask=%#010x, u32NotMask=%#010x, fHadEvents=%d.\n", fOrMask, fNotMask, fHadEvents));
403	if (fHadEvents)
404	{
405	if (!pThis->fNewGuestFilterMask)
406	pThis->u32NewGuestFilterMask = pThis->u32GuestFilterMask;
407
408	pThis->u32NewGuestFilterMask \|= fOrMask;
409	pThis->u32NewGuestFilterMask &= ~fNotMask;
410	pThis->fNewGuestFilterMask = true;
411	}
412	else
413	{
414	pThis->u32GuestFilterMask \|= fOrMask;
415	pThis->u32GuestFilterMask &= ~fNotMask;
416	vmmdevMaybeSetIRQ(pThis);
417	}
418
419	PDMCritSectLeave(&pThis->CritSect);
420	}
421
422
423
424	/* -=-=-=-=- Request processing functions. -=-=-=-=- */
425
426	/**
427	* Handles VMMDevReq_ReportGuestInfo.
428	*
429	* @returns VBox status code that the guest should see.
430	* @param pThis The VMMDev instance data.
431	* @param pRequestHeader The header of the request to handle.
432	*/
433	static int vmmdevReqHandler_ReportGuestInfo(PVMMDEV pThis, VMMDevRequestHeader *pRequestHeader)
434	{
435	AssertMsgReturn(pRequestHeader->size == sizeof(VMMDevReportGuestInfo), ("%u\n", pRequestHeader->size), VERR_INVALID_PARAMETER);
436	VBoxGuestInfo const pInfo = &((VMMDevReportGuestInfo )pRequestHeader)->guestInfo;
437
438	if (memcmp(&pThis->guestInfo, pInfo, sizeof(*pInfo)) != 0)
439	{
440	/* Make a copy of supplied information. */
441	pThis->guestInfo = *pInfo;
442
443	/* Check additions interface version. */
444	pThis->fu32AdditionsOk = VMMDEV_INTERFACE_VERSION_IS_OK(pThis->guestInfo.interfaceVersion);
445
446	vmmdevLogGuestOsInfo(&pThis->guestInfo);
447
448	if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestInfo)
449	pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
450	}
451
452	if (!pThis->fu32AdditionsOk)
453	return VERR_VERSION_MISMATCH;
454
455	/* Clear our IRQ in case it was high for whatever reason. */
456	PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 0);
457
458	return VINF_SUCCESS;
459	}
460
461
462	/**
463	* Handles VMMDevReq_GuestHeartbeat.
464	*
465	* @returns VBox status code that the guest should see.
466	* @param pThis The VMMDev instance data.
467	*/
468	static int vmmDevReqHandler_GuestHeartbeat(PVMMDEV pThis)
469	{
470	int rc;
471	if (pThis->fHeartbeatActive)
472	{
473	uint64_t const nsNowTS = TMTimerGetNano(pThis->pFlatlinedTimer);
474	if (!pThis->fFlatlined)
475	{ /* likely */ }
476	else
477	{
478	LogRel(("VMMDev: GuestHeartBeat: Guest is alive (gone %'llu ns)\n", nsNowTS - pThis->nsLastHeartbeatTS));
479	ASMAtomicWriteBool(&pThis->fFlatlined, false);
480	}
481	ASMAtomicWriteU64(&pThis->nsLastHeartbeatTS, nsNowTS);
482
483	/* Postpone (or restart if we missed a beat) the timeout timer. */
484	rc = TMTimerSetNano(pThis->pFlatlinedTimer, pThis->cNsHeartbeatTimeout);
485	}
486	else
487	rc = VINF_SUCCESS;
488	return rc;
489	}
490
491
492	/**
493	* Timer that fires when where have been no heartbeats for a given time.
494	*
495	* @remarks Does not take the VMMDev critsect.
496	*/
497	static DECLCALLBACK(void) vmmDevHeartbeatFlatlinedTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
498	{
499	RT_NOREF1(pDevIns);
500	PVMMDEV pThis = (PVMMDEV)pvUser;
501	if (pThis->fHeartbeatActive)
502	{
503	uint64_t cNsElapsed = TMTimerGetNano(pTimer) - pThis->nsLastHeartbeatTS;
504	if ( !pThis->fFlatlined
505	&& cNsElapsed >= pThis->cNsHeartbeatInterval)
506	{
507	LogRel(("VMMDev: vmmDevHeartbeatFlatlinedTimer: Guest seems to be unresponsive. Last heartbeat received %RU64 seconds ago\n",
508	cNsElapsed / RT_NS_1SEC));
509	ASMAtomicWriteBool(&pThis->fFlatlined, true);
510	}
511	}
512	}
513
514
515	/**
516	* Handles VMMDevReq_HeartbeatConfigure.
517	*
518	* @returns VBox status code that the guest should see.
519	* @param pThis The VMMDev instance data.
520	* @param pReqHdr The header of the request to handle.
521	*/
522	static int vmmDevReqHandler_HeartbeatConfigure(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
523	{
524	AssertMsgReturn(pReqHdr->size == sizeof(VMMDevReqHeartbeat), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
525	VMMDevReqHeartbeat pReq = (VMMDevReqHeartbeat )pReqHdr;
526	int rc;
527
528	pReq->cNsInterval = pThis->cNsHeartbeatInterval;
529
530	if (pReq->fEnabled != pThis->fHeartbeatActive)
531	{
532	ASMAtomicWriteBool(&pThis->fHeartbeatActive, pReq->fEnabled);
533	if (pReq->fEnabled)
534	{
535	/*
536	* Activate the heartbeat monitor.
537	*/
538	pThis->nsLastHeartbeatTS = TMTimerGetNano(pThis->pFlatlinedTimer);
539	rc = TMTimerSetNano(pThis->pFlatlinedTimer, pThis->cNsHeartbeatTimeout);
540	if (RT_SUCCESS(rc))
541	LogRel(("VMMDev: Heartbeat flatline timer set to trigger after %'RU64 ns\n", pThis->cNsHeartbeatTimeout));
542	else
543	LogRel(("VMMDev: Error starting flatline timer (heartbeat): %Rrc\n", rc));
544	}
545	else
546	{
547	/*
548	* Deactivate the heartbeat monitor.
549	*/
550	rc = TMTimerStop(pThis->pFlatlinedTimer);
551	LogRel(("VMMDev: Heartbeat checking timer has been stopped (rc=%Rrc)\n", rc));
552	}
553	}
554	else
555	{
556	LogRel(("VMMDev: vmmDevReqHandler_HeartbeatConfigure: No change (fHeartbeatActive=%RTbool).\n", pThis->fHeartbeatActive));
557	rc = VINF_SUCCESS;
558	}
559
560	return rc;
561	}
562
563
564	/**
565	* Validates a publisher tag.
566	*
567	* @returns true / false.
568	* @param pszTag Tag to validate.
569	*/
570	static bool vmmdevReqIsValidPublisherTag(const char *pszTag)
571	{
572	/* Note! This character set is also found in Config.kmk. */
573	static char const s_szValidChars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz()[]{}+-.,";
574
575	while (*pszTag != '\0')
576	{
577	if (!strchr(s_szValidChars, *pszTag))
578	return false;
579	pszTag++;
580	}
581	return true;
582	}
583
584
585	/**
586	* Validates a build tag.
587	*
588	* @returns true / false.
589	* @param pszTag Tag to validate.
590	*/
591	static bool vmmdevReqIsValidBuildTag(const char *pszTag)
592	{
593	int cchPrefix;
594	if (!strncmp(pszTag, "RC", 2))
595	cchPrefix = 2;
596	else if (!strncmp(pszTag, "BETA", 4))
597	cchPrefix = 4;
598	else if (!strncmp(pszTag, "ALPHA", 5))
599	cchPrefix = 5;
600	else
601	return false;
602
603	if (pszTag[cchPrefix] == '\0')
604	return true;
605
606	uint8_t u8;
607	int rc = RTStrToUInt8Full(&pszTag[cchPrefix], 10, &u8);
608	return rc == VINF_SUCCESS;
609	}
610
611
612	/**
613	* Handles VMMDevReq_ReportGuestInfo2.
614	*
615	* @returns VBox status code that the guest should see.
616	* @param pThis The VMMDev instance data.
617	* @param pReqHdr The header of the request to handle.
618	*/
619	static int vmmdevReqHandler_ReportGuestInfo2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
620	{
621	AssertMsgReturn(pReqHdr->size == sizeof(VMMDevReportGuestInfo2), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
622	VBoxGuestInfo2 const pInfo2 = &((VMMDevReportGuestInfo2 )pReqHdr)->guestInfo;
623
624	LogRel(("VMMDev: Guest Additions information report: Version %d.%d.%d r%d '%.*s'\n",
625	pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild,
626	pInfo2->additionsRevision, sizeof(pInfo2->szName), pInfo2->szName));
627
628	/* The interface was introduced in 3.2 and will definitely not be
629	backported beyond 3.0 (bird). */
630	AssertMsgReturn(pInfo2->additionsMajor >= 3,
631	("%u.%u.%u\n", pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild),
632	VERR_INVALID_PARAMETER);
633
634	/* The version must fit in a full version compression. */
635	uint32_t uFullVersion = VBOX_FULL_VERSION_MAKE(pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild);
636	AssertMsgReturn( VBOX_FULL_VERSION_GET_MAJOR(uFullVersion) == pInfo2->additionsMajor
637	&& VBOX_FULL_VERSION_GET_MINOR(uFullVersion) == pInfo2->additionsMinor
638	&& VBOX_FULL_VERSION_GET_BUILD(uFullVersion) == pInfo2->additionsBuild,
639	("%u.%u.%u\n", pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild),
640	VERR_OUT_OF_RANGE);
641
642	/*
643	* Validate the name.
644	* Be less strict towards older additions (< v4.1.50).
645	*/
646	AssertCompile(sizeof(pThis->guestInfo2.szName) == sizeof(pInfo2->szName));
647	AssertReturn(RTStrEnd(pInfo2->szName, sizeof(pInfo2->szName)) != NULL, VERR_INVALID_PARAMETER);
648	const char *pszName = pInfo2->szName;
649
650	/* The version number which shouldn't be there. */
651	char szTmp[sizeof(pInfo2->szName)];
652	size_t cchStart = RTStrPrintf(szTmp, sizeof(szTmp), "%u.%u.%u", pInfo2->additionsMajor, pInfo2->additionsMinor, pInfo2->additionsBuild);
653	AssertMsgReturn(!strncmp(pszName, szTmp, cchStart), ("%s != %s\n", pszName, szTmp), VERR_INVALID_PARAMETER);
654	pszName += cchStart;
655
656	/* Now we can either have nothing or a build tag or/and a publisher tag. */
657	if (*pszName != '\0')
658	{
659	const char *pszRelaxedName = "";
660	bool const fStrict = pInfo2->additionsMajor > 4
661	\|\| (pInfo2->additionsMajor == 4 && pInfo2->additionsMinor > 1)
662	\|\| (pInfo2->additionsMajor == 4 && pInfo2->additionsMinor == 1 && pInfo2->additionsBuild >= 50);
663	bool fOk = false;
664	if (*pszName == '_')
665	{
666	pszName++;
667	strcpy(szTmp, pszName);
668	char *pszTag2 = strchr(szTmp, '_');
669	if (!pszTag2)
670	{
671	fOk = vmmdevReqIsValidBuildTag(szTmp)
672	\|\| vmmdevReqIsValidPublisherTag(szTmp);
673	}
674	else
675	{
676	*pszTag2++ = '\0';
677	fOk = vmmdevReqIsValidBuildTag(szTmp);
678	if (fOk)
679	{
680	fOk = vmmdevReqIsValidPublisherTag(pszTag2);
681	if (!fOk)
682	pszRelaxedName = szTmp;
683	}
684	}
685	}
686
687	if (!fOk)
688	{
689	AssertLogRelMsgReturn(!fStrict, ("%s", pszName), VERR_INVALID_PARAMETER);
690
691	/* non-strict mode, just zap the extra stuff. */
692	LogRel(("VMMDev: ReportGuestInfo2: Ignoring unparsable version name bits: '%s' -> '%s'.\n", pszName, pszRelaxedName));
693	pszName = pszRelaxedName;
694	}
695	}
696
697	/*
698	* Save the info and tell Main or whoever is listening.
699	*/
700	pThis->guestInfo2.uFullVersion = uFullVersion;
701	pThis->guestInfo2.uRevision = pInfo2->additionsRevision;
702	pThis->guestInfo2.fFeatures = pInfo2->additionsFeatures;
703	strcpy(pThis->guestInfo2.szName, pszName);
704
705	if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestInfo2)
706	pThis->pDrv->pfnUpdateGuestInfo2(pThis->pDrv, uFullVersion, pszName, pInfo2->additionsRevision, pInfo2->additionsFeatures);
707
708	/* Clear our IRQ in case it was high for whatever reason. */
709	PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 0);
710
711	return VINF_SUCCESS;
712	}
713
714
715	/**
716	* Allocates a new facility status entry, initializing it to inactive.
717	*
718	* @returns Pointer to a facility status entry on success, NULL on failure
719	* (table full).
720	* @param pThis The VMMDev instance data.
721	* @param enmFacility The facility type code.
722	* @param fFixed This is set when allocating the standard entries
723	* from the constructor.
724	* @param pTimeSpecNow Optionally giving the entry timestamp to use (ctor).
725	*/
726	static PVMMDEVFACILITYSTATUSENTRY
727	vmmdevAllocFacilityStatusEntry(PVMMDEV pThis, VBoxGuestFacilityType enmFacility, bool fFixed, PCRTTIMESPEC pTimeSpecNow)
728	{
729	/* If full, expunge one inactive entry. */
730	if (pThis->cFacilityStatuses == RT_ELEMENTS(pThis->aFacilityStatuses))
731	{
732	uint32_t i = pThis->cFacilityStatuses;
733	while (i-- > 0)
734	{
735	if ( pThis->aFacilityStatuses[i].enmStatus == VBoxGuestFacilityStatus_Inactive
736	&& !pThis->aFacilityStatuses[i].fFixed)
737	{
738	pThis->cFacilityStatuses--;
739	int cToMove = pThis->cFacilityStatuses - i;
740	if (cToMove)
741	memmove(&pThis->aFacilityStatuses[i], &pThis->aFacilityStatuses[i + 1],
742	cToMove * sizeof(pThis->aFacilityStatuses[i]));
743	RT_ZERO(pThis->aFacilityStatuses[pThis->cFacilityStatuses]);
744	break;
745	}
746	}
747
748	if (pThis->cFacilityStatuses == RT_ELEMENTS(pThis->aFacilityStatuses))
749	return NULL;
750	}
751
752	/* Find location in array (it's sorted). */
753	uint32_t i = pThis->cFacilityStatuses;
754	while (i-- > 0)
755	if ((uint32_t)pThis->aFacilityStatuses[i].enmFacility < (uint32_t)enmFacility)
756	break;
757	i++;
758
759	/* Move. */
760	int cToMove = pThis->cFacilityStatuses - i;
761	if (cToMove > 0)
762	memmove(&pThis->aFacilityStatuses[i + 1], &pThis->aFacilityStatuses[i],
763	cToMove * sizeof(pThis->aFacilityStatuses[i]));
764	pThis->cFacilityStatuses++;
765
766	/* Initialize. */
767	pThis->aFacilityStatuses[i].enmFacility = enmFacility;
768	pThis->aFacilityStatuses[i].enmStatus = VBoxGuestFacilityStatus_Inactive;
769	pThis->aFacilityStatuses[i].fFixed = fFixed;
770	pThis->aFacilityStatuses[i].afPadding[0] = 0;
771	pThis->aFacilityStatuses[i].afPadding[1] = 0;
772	pThis->aFacilityStatuses[i].afPadding[2] = 0;
773	pThis->aFacilityStatuses[i].fFlags = 0;
774	if (pTimeSpecNow)
775	pThis->aFacilityStatuses[i].TimeSpecTS = *pTimeSpecNow;
776	else
777	RTTimeSpecSetNano(&pThis->aFacilityStatuses[i].TimeSpecTS, 0);
778
779	return &pThis->aFacilityStatuses[i];
780	}
781
782
783	/**
784	* Gets a facility status entry, allocating a new one if not already present.
785	*
786	* @returns Pointer to a facility status entry on success, NULL on failure
787	* (table full).
788	* @param pThis The VMMDev instance data.
789	* @param enmFacility The facility type code.
790	*/
791	static PVMMDEVFACILITYSTATUSENTRY vmmdevGetFacilityStatusEntry(PVMMDEV pThis, VBoxGuestFacilityType enmFacility)
792	{
793	/** @todo change to binary search. */
794	uint32_t i = pThis->cFacilityStatuses;
795	while (i-- > 0)
796	{
797	if (pThis->aFacilityStatuses[i].enmFacility == enmFacility)
798	return &pThis->aFacilityStatuses[i];
799	if ((uint32_t)pThis->aFacilityStatuses[i].enmFacility < (uint32_t)enmFacility)
800	break;
801	}
802	return vmmdevAllocFacilityStatusEntry(pThis, enmFacility, false /fFixed/, NULL);
803	}
804
805
806	/**
807	* Handles VMMDevReq_ReportGuestStatus.
808	*
809	* @returns VBox status code that the guest should see.
810	* @param pThis The VMMDev instance data.
811	* @param pReqHdr The header of the request to handle.
812	*/
813	static int vmmdevReqHandler_ReportGuestStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
814	{
815	/*
816	* Validate input.
817	*/
818	AssertMsgReturn(pReqHdr->size == sizeof(VMMDevReportGuestStatus), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
819	VBoxGuestStatus pStatus = &((VMMDevReportGuestStatus )pReqHdr)->guestStatus;
820	AssertMsgReturn( pStatus->facility > VBoxGuestFacilityType_Unknown
821	&& pStatus->facility <= VBoxGuestFacilityType_All,
822	("%d\n", pStatus->facility),
823	VERR_INVALID_PARAMETER);
824	AssertMsgReturn(pStatus->status == (VBoxGuestFacilityStatus)(uint16_t)pStatus->status,
825	("%#x (%u)\n", pStatus->status, pStatus->status),
826	VERR_OUT_OF_RANGE);
827
828	/*
829	* Do the update.
830	*/
831	RTTIMESPEC Now;
832	RTTimeNow(&Now);
833	if (pStatus->facility == VBoxGuestFacilityType_All)
834	{
835	uint32_t i = pThis->cFacilityStatuses;
836	while (i-- > 0)
837	{
838	pThis->aFacilityStatuses[i].TimeSpecTS = Now;
839	pThis->aFacilityStatuses[i].enmStatus = pStatus->status;
840	pThis->aFacilityStatuses[i].fFlags = pStatus->flags;
841	}
842	}
843	else
844	{
845	PVMMDEVFACILITYSTATUSENTRY pEntry = vmmdevGetFacilityStatusEntry(pThis, pStatus->facility);
846	if (!pEntry)
847	{
848	LogRelMax(10, ("VMMDev: Facility table is full - facility=%u status=%u\n", pStatus->facility, pStatus->status));
849	return VERR_OUT_OF_RESOURCES;
850	}
851
852	pEntry->TimeSpecTS = Now;
853	pEntry->enmStatus = pStatus->status;
854	pEntry->fFlags = pStatus->flags;
855	}
856
857	if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestStatus)
858	pThis->pDrv->pfnUpdateGuestStatus(pThis->pDrv, pStatus->facility, pStatus->status, pStatus->flags, &Now);
859
860	return VINF_SUCCESS;
861	}
862
863
864	/**
865	* Handles VMMDevReq_ReportGuestUserState.
866	*
867	* @returns VBox status code that the guest should see.
868	* @param pThis The VMMDev instance data.
869	* @param pReqHdr The header of the request to handle.
870	*/
871	static int vmmdevReqHandler_ReportGuestUserState(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
872	{
873	/*
874	* Validate input.
875	*/
876	VMMDevReportGuestUserState pReq = (VMMDevReportGuestUserState )pReqHdr;
877	AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReqHdr->size), VERR_INVALID_PARAMETER);
878
879	if ( pThis->pDrv
880	&& pThis->pDrv->pfnUpdateGuestUserState)
881	{
882	/* Play safe. */
883	AssertReturn(pReq->header.size <= _2K, VERR_TOO_MUCH_DATA);
884	AssertReturn(pReq->status.cbUser <= 256, VERR_TOO_MUCH_DATA);
885	AssertReturn(pReq->status.cbDomain <= 256, VERR_TOO_MUCH_DATA);
886	AssertReturn(pReq->status.cbDetails <= _1K, VERR_TOO_MUCH_DATA);
887
888	/* pbDynamic marks the beginning of the struct's dynamically
889	* allocated data area. */
890	uint8_t pbDynamic = (uint8_t )&pReq->status.szUser;
891	uint32_t cbLeft = pReqHdr->size - RT_OFFSETOF(VMMDevReportGuestUserState, status.szUser);
892
893	/* The user. */
894	AssertReturn(pReq->status.cbUser > 0, VERR_INVALID_PARAMETER); /* User name is required. */
895	AssertReturn(pReq->status.cbUser <= cbLeft, VERR_INVALID_PARAMETER);
896	const char pszUser = (const char )pbDynamic;
897	AssertReturn(RTStrEnd(pszUser, pReq->status.cbUser), VERR_INVALID_PARAMETER);
898	int rc = RTStrValidateEncoding(pszUser);
899	AssertRCReturn(rc, rc);
900
901	/* Advance to the next field. */
902	pbDynamic += pReq->status.cbUser;
903	cbLeft -= pReq->status.cbUser;
904
905	/* pszDomain can be NULL. */
906	AssertReturn(pReq->status.cbDomain <= cbLeft, VERR_INVALID_PARAMETER);
907	const char *pszDomain = NULL;
908	if (pReq->status.cbDomain)
909	{
910	pszDomain = (const char *)pbDynamic;
911	AssertReturn(RTStrEnd(pszDomain, pReq->status.cbDomain), VERR_INVALID_PARAMETER);
912	rc = RTStrValidateEncoding(pszDomain);
913	AssertRCReturn(rc, rc);
914
915	/* Advance to the next field. */
916	pbDynamic += pReq->status.cbDomain;
917	cbLeft -= pReq->status.cbDomain;
918	}
919
920	/* pbDetails can be NULL. */
921	const uint8_t *pbDetails = NULL;
922	AssertReturn(pReq->status.cbDetails <= cbLeft, VERR_INVALID_PARAMETER);
923	if (pReq->status.cbDetails > 0)
924	pbDetails = pbDynamic;
925
926	pThis->pDrv->pfnUpdateGuestUserState(pThis->pDrv, pszUser, pszDomain, (uint32_t)pReq->status.state,
927	pbDetails, pReq->status.cbDetails);
928	}
929
930	return VINF_SUCCESS;
931	}
932
933
934	/**
935	* Handles VMMDevReq_ReportGuestCapabilities.
936	*
937	* @returns VBox status code that the guest should see.
938	* @param pThis The VMMDev instance data.
939	* @param pReqHdr The header of the request to handle.
940	*/
941	static int vmmdevReqHandler_ReportGuestCapabilities(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
942	{
943	VMMDevReqGuestCapabilities pReq = (VMMDevReqGuestCapabilities )pReqHdr;
944	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
945
946	/* Enable VMMDEV_GUEST_SUPPORTS_GRAPHICS automatically for guests using the old
947	* request to report their capabilities.
948	*/
949	const uint32_t fu32Caps = pReq->caps \| VMMDEV_GUEST_SUPPORTS_GRAPHICS;
950
951	if (pThis->guestCaps != fu32Caps)
952	{
953	/* make a copy of supplied information */
954	pThis->guestCaps = fu32Caps;
955
956	LogRel(("VMMDev: Guest Additions capability report (legacy): (0x%x) seamless: %s, hostWindowMapping: %s, graphics: yes\n",
957	fu32Caps,
958	fu32Caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
959	fu32Caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no"));
960
961	if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
962	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, fu32Caps);
963	}
964	return VINF_SUCCESS;
965	}
966
967
968	/**
969	* Handles VMMDevReq_SetGuestCapabilities.
970	*
971	* @returns VBox status code that the guest should see.
972	* @param pThis The VMMDev instance data.
973	* @param pReqHdr The header of the request to handle.
974	*/
975	static int vmmdevReqHandler_SetGuestCapabilities(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
976	{
977	VMMDevReqGuestCapabilities2 pReq = (VMMDevReqGuestCapabilities2 )pReqHdr;
978	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
979
980	uint32_t fu32Caps = pThis->guestCaps;
981	fu32Caps \|= pReq->u32OrMask;
982	fu32Caps &= ~pReq->u32NotMask;
983
984	LogRel(("VMMDev: Guest Additions capability report: (%#x -> %#x) seamless: %s, hostWindowMapping: %s, graphics: %s\n",
985	pThis->guestCaps, fu32Caps,
986	fu32Caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
987	fu32Caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
988	fu32Caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
989
990	pThis->guestCaps = fu32Caps;
991
992	if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
993	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, fu32Caps);
994
995	return VINF_SUCCESS;
996	}
997
998
999	/**
1000	* Handles VMMDevReq_GetMouseStatus.
1001	*
1002	* @returns VBox status code that the guest should see.
1003	* @param pThis The VMMDev instance data.
1004	* @param pReqHdr The header of the request to handle.
1005	*/
1006	static int vmmdevReqHandler_GetMouseStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1007	{
1008	VMMDevReqMouseStatus pReq = (VMMDevReqMouseStatus )pReqHdr;
1009	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1010
1011	pReq->mouseFeatures = pThis->mouseCapabilities
1012	& VMMDEV_MOUSE_MASK;
1013	pReq->pointerXPos = pThis->mouseXAbs;
1014	pReq->pointerYPos = pThis->mouseYAbs;
1015	LogRel2(("VMMDev: vmmdevReqHandler_GetMouseStatus: mouseFeatures=%#x, xAbs=%d, yAbs=%d\n",
1016	pReq->mouseFeatures, pReq->pointerXPos, pReq->pointerYPos));
1017	return VINF_SUCCESS;
1018	}
1019
1020
1021	/**
1022	* Handles VMMDevReq_SetMouseStatus.
1023	*
1024	* @returns VBox status code that the guest should see.
1025	* @param pThis The VMMDev instance data.
1026	* @param pReqHdr The header of the request to handle.
1027	*/
1028	static int vmmdevReqHandler_SetMouseStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1029	{
1030	VMMDevReqMouseStatus pReq = (VMMDevReqMouseStatus )pReqHdr;
1031	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1032
1033	LogRelFlow(("VMMDev: vmmdevReqHandler_SetMouseStatus: mouseFeatures=%#x\n", pReq->mouseFeatures));
1034
1035	bool fNotify = false;
1036	if ( (pReq->mouseFeatures & VMMDEV_MOUSE_NOTIFY_HOST_MASK)
1037	!= ( pThis->mouseCapabilities
1038	& VMMDEV_MOUSE_NOTIFY_HOST_MASK))
1039	fNotify = true;
1040
1041	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
1042	pThis->mouseCapabilities \|= (pReq->mouseFeatures & VMMDEV_MOUSE_GUEST_MASK);
1043
1044	LogRelFlow(("VMMDev: vmmdevReqHandler_SetMouseStatus: New host capabilities: %#x\n", pThis->mouseCapabilities));
1045
1046	/*
1047	* Notify connector if something changed.
1048	*/
1049	if (fNotify)
1050	{
1051	LogRelFlow(("VMMDev: vmmdevReqHandler_SetMouseStatus: Notifying connector\n"));
1052	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
1053	}
1054
1055	return VINF_SUCCESS;
1056	}
1057
1058	static int vmmdevVerifyPointerShape(VMMDevReqMousePointer *pReq)
1059	{
1060	/* Should be enough for most mouse pointers. */
1061	if (pReq->width > 8192 \|\| pReq->height > 8192)
1062	return VERR_INVALID_PARAMETER;
1063
1064	uint32_t cbShape = (pReq->width + 7) / 8 * pReq->height; /* size of the AND mask */
1065	cbShape = ((cbShape + 3) & ~3) + pReq->width * 4 * pReq->height; /* + gap + size of the XOR mask */
1066	if (RT_UOFFSETOF(VMMDevReqMousePointer, pointerData) + cbShape > pReq->header.size)
1067	return VERR_INVALID_PARAMETER;
1068
1069	return VINF_SUCCESS;
1070	}
1071
1072	/**
1073	* Handles VMMDevReq_SetPointerShape.
1074	*
1075	* @returns VBox status code that the guest should see.
1076	* @param pThis The VMMDev instance data.
1077	* @param pReqHdr The header of the request to handle.
1078	*/
1079	static int vmmdevReqHandler_SetPointerShape(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1080	{
1081	VMMDevReqMousePointer pReq = (VMMDevReqMousePointer )pReqHdr;
1082	if (pReq->header.size < sizeof(*pReq))
1083	{
1084	AssertMsg(pReq->header.size == 0x10028 && pReq->header.version == 10000, /* don't complain about legacy!!! */
1085	("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
1086	pReq->header.size, pReq->header.size, pReq->header.version));
1087	return VERR_INVALID_PARAMETER;
1088	}
1089
1090	bool fVisible = RT_BOOL(pReq->fFlags & VBOX_MOUSE_POINTER_VISIBLE);
1091	bool fAlpha = RT_BOOL(pReq->fFlags & VBOX_MOUSE_POINTER_ALPHA);
1092	bool fShape = RT_BOOL(pReq->fFlags & VBOX_MOUSE_POINTER_SHAPE);
1093
1094	Log(("VMMDevReq_SetPointerShape: visible: %d, alpha: %d, shape = %d, width: %d, height: %d\n",
1095	fVisible, fAlpha, fShape, pReq->width, pReq->height));
1096
1097	if (pReq->header.size == sizeof(VMMDevReqMousePointer))
1098	{
1099	/* The guest did not provide the shape actually. */
1100	fShape = false;
1101	}
1102
1103	/* forward call to driver */
1104	if (fShape)
1105	{
1106	int rc = vmmdevVerifyPointerShape(pReq);
1107	if (RT_FAILURE(rc))
1108	return rc;
1109
1110	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
1111	fVisible,
1112	fAlpha,
1113	pReq->xHot, pReq->yHot,
1114	pReq->width, pReq->height,
1115	pReq->pointerData);
1116	}
1117	else
1118	{
1119	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
1120	fVisible,
1121	0,
1122	0, 0,
1123	0, 0,
1124	NULL);
1125	}
1126
1127	pThis->fHostCursorRequested = fVisible;
1128	return VINF_SUCCESS;
1129	}
1130
1131
1132	/**
1133	* Handles VMMDevReq_GetHostTime.
1134	*
1135	* @returns VBox status code that the guest should see.
1136	* @param pThis The VMMDev instance data.
1137	* @param pReqHdr The header of the request to handle.
1138	*/
1139	static int vmmdevReqHandler_GetHostTime(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1140	{
1141	VMMDevReqHostTime pReq = (VMMDevReqHostTime )pReqHdr;
1142	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1143
1144	if (RT_LIKELY(!pThis->fGetHostTimeDisabled))
1145	{
1146	RTTIMESPEC now;
1147	pReq->time = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pThis->pDevIns, &now));
1148	return VINF_SUCCESS;
1149	}
1150	return VERR_NOT_SUPPORTED;
1151	}
1152
1153
1154	/**
1155	* Handles VMMDevReq_GetHypervisorInfo.
1156	*
1157	* @returns VBox status code that the guest should see.
1158	* @param pThis The VMMDev instance data.
1159	* @param pReqHdr The header of the request to handle.
1160	*/
1161	static int vmmdevReqHandler_GetHypervisorInfo(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1162	{
1163	VMMDevReqHypervisorInfo pReq = (VMMDevReqHypervisorInfo )pReqHdr;
1164	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1165
1166	return PGMR3MappingsSize(PDMDevHlpGetVM(pThis->pDevIns), &pReq->hypervisorSize);
1167	}
1168
1169
1170	/**
1171	* Handles VMMDevReq_SetHypervisorInfo.
1172	*
1173	* @returns VBox status code that the guest should see.
1174	* @param pThis The VMMDev instance data.
1175	* @param pReqHdr The header of the request to handle.
1176	*/
1177	static int vmmdevReqHandler_SetHypervisorInfo(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1178	{
1179	VMMDevReqHypervisorInfo pReq = (VMMDevReqHypervisorInfo )pReqHdr;
1180	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1181
1182	int rc;
1183	PVM pVM = PDMDevHlpGetVM(pThis->pDevIns);
1184	if (pReq->hypervisorStart == 0)
1185	rc = PGMR3MappingsUnfix(pVM);
1186	else
1187	{
1188	/* only if the client has queried the size before! */
1189	uint32_t cbMappings;
1190	rc = PGMR3MappingsSize(pVM, &cbMappings);
1191	if (RT_SUCCESS(rc) && pReq->hypervisorSize == cbMappings)
1192	{
1193	/* new reservation */
1194	rc = PGMR3MappingsFix(pVM, pReq->hypervisorStart, pReq->hypervisorSize);
1195	LogRel(("VMMDev: Guest reported fixed hypervisor window at 0%010x LB %#x (rc=%Rrc)\n",
1196	pReq->hypervisorStart, pReq->hypervisorSize, rc));
1197	}
1198	else if (RT_FAILURE(rc))
1199	rc = VERR_TRY_AGAIN;
1200	}
1201	return rc;
1202	}
1203
1204
1205	/**
1206	* Handles VMMDevReq_RegisterPatchMemory.
1207	*
1208	* @returns VBox status code that the guest should see.
1209	* @param pThis The VMMDev instance data.
1210	* @param pReqHdr The header of the request to handle.
1211	*/
1212	static int vmmdevReqHandler_RegisterPatchMemory(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1213	{
1214	VMMDevReqPatchMemory pReq = (VMMDevReqPatchMemory )pReqHdr;
1215	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1216
1217	return VMMR3RegisterPatchMemory(PDMDevHlpGetVM(pThis->pDevIns), pReq->pPatchMem, pReq->cbPatchMem);
1218	}
1219
1220
1221	/**
1222	* Handles VMMDevReq_DeregisterPatchMemory.
1223	*
1224	* @returns VBox status code that the guest should see.
1225	* @param pThis The VMMDev instance data.
1226	* @param pReqHdr The header of the request to handle.
1227	*/
1228	static int vmmdevReqHandler_DeregisterPatchMemory(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1229	{
1230	VMMDevReqPatchMemory pReq = (VMMDevReqPatchMemory )pReqHdr;
1231	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1232
1233	return VMMR3DeregisterPatchMemory(PDMDevHlpGetVM(pThis->pDevIns), pReq->pPatchMem, pReq->cbPatchMem);
1234	}
1235
1236
1237	/**
1238	* Handles VMMDevReq_SetPowerStatus.
1239	*
1240	* @returns VBox status code that the guest should see.
1241	* @param pThis The VMMDev instance data.
1242	* @param pReqHdr The header of the request to handle.
1243	*/
1244	static int vmmdevReqHandler_SetPowerStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1245	{
1246	VMMDevPowerStateRequest pReq = (VMMDevPowerStateRequest )pReqHdr;
1247	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1248
1249	switch (pReq->powerState)
1250	{
1251	case VMMDevPowerState_Pause:
1252	{
1253	LogRel(("VMMDev: Guest requests the VM to be suspended (paused)\n"));
1254	return PDMDevHlpVMSuspend(pThis->pDevIns);
1255	}
1256
1257	case VMMDevPowerState_PowerOff:
1258	{
1259	LogRel(("VMMDev: Guest requests the VM to be turned off\n"));
1260	return PDMDevHlpVMPowerOff(pThis->pDevIns);
1261	}
1262
1263	case VMMDevPowerState_SaveState:
1264	{
1265	if (true /pThis->fAllowGuestToSaveState/)
1266	{
1267	LogRel(("VMMDev: Guest requests the VM to be saved and powered off\n"));
1268	return PDMDevHlpVMSuspendSaveAndPowerOff(pThis->pDevIns);
1269	}
1270	LogRel(("VMMDev: Guest requests the VM to be saved and powered off, declined\n"));
1271	return VERR_ACCESS_DENIED;
1272	}
1273
1274	default:
1275	AssertMsgFailed(("VMMDev: Invalid power state request: %d\n", pReq->powerState));
1276	return VERR_INVALID_PARAMETER;
1277	}
1278	}
1279
1280
1281	/**
1282	* Handles VMMDevReq_GetDisplayChangeRequest
1283	*
1284	* @returns VBox status code that the guest should see.
1285	* @param pThis The VMMDev instance data.
1286	* @param pReqHdr The header of the request to handle.
1287	* @remarks Deprecated.
1288	*/
1289	static int vmmdevReqHandler_GetDisplayChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1290	{
1291	VMMDevDisplayChangeRequest pReq = (VMMDevDisplayChangeRequest )pReqHdr;
1292	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1293
1294	/**
1295	* @todo It looks like a multi-monitor guest which only uses
1296	* @c VMMDevReq_GetDisplayChangeRequest (not the *2 version) will get
1297	* into a @c VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST event loop if it tries
1298	* to acknowlege host requests for additional monitors. Should the loop
1299	* which checks for those requests be removed?
1300	*/
1301
1302	DISPLAYCHANGEREQUEST *pDispRequest = &pThis->displayChangeData.aRequests[0];
1303
1304	if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1305	{
1306	/* Current request has been read at least once. */
1307	pDispRequest->fPending = false;
1308
1309	/* Check if there are more pending requests. */
1310	for (unsigned i = 1; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1311	{
1312	if (pThis->displayChangeData.aRequests[i].fPending)
1313	{
1314	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1315	break;
1316	}
1317	}
1318
1319	/* Remember which resolution the client has queried, subsequent reads
1320	* will return the same values. */
1321	pDispRequest->lastReadDisplayChangeRequest = pDispRequest->displayChangeRequest;
1322	pThis->displayChangeData.fGuestSentChangeEventAck = true;
1323	}
1324
1325	if (pThis->displayChangeData.fGuestSentChangeEventAck)
1326	{
1327	pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
1328	pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
1329	pReq->bpp = pDispRequest->lastReadDisplayChangeRequest.bpp;
1330	}
1331	else
1332	{
1333	/* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1334	* read the last valid video mode hint. This happens when the guest X server
1335	* determines the initial mode. */
1336	pReq->xres = pDispRequest->displayChangeRequest.xres;
1337	pReq->yres = pDispRequest->displayChangeRequest.yres;
1338	pReq->bpp = pDispRequest->displayChangeRequest.bpp;
1339	}
1340	Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n", pReq->xres, pReq->yres, pReq->bpp));
1341
1342	return VINF_SUCCESS;
1343	}
1344
1345
1346	/**
1347	* Handles VMMDevReq_GetDisplayChangeRequest2.
1348	*
1349	* @returns VBox status code that the guest should see.
1350	* @param pThis The VMMDev instance data.
1351	* @param pReqHdr The header of the request to handle.
1352	*/
1353	static int vmmdevReqHandler_GetDisplayChangeRequest2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1354	{
1355	VMMDevDisplayChangeRequest2 pReq = (VMMDevDisplayChangeRequest2 )pReqHdr;
1356	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1357
1358	DISPLAYCHANGEREQUEST *pDispRequest = NULL;
1359
1360	if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1361	{
1362	/* Select a pending request to report. */
1363	unsigned i;
1364	for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1365	{
1366	if (pThis->displayChangeData.aRequests[i].fPending)
1367	{
1368	pDispRequest = &pThis->displayChangeData.aRequests[i];
1369	/* Remember which request should be reported. */
1370	pThis->displayChangeData.iCurrentMonitor = i;
1371	Log3(("VMMDev: will report pending request for %u\n", i));
1372	break;
1373	}
1374	}
1375
1376	/* Check if there are more pending requests. */
1377	i++;
1378	for (; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1379	{
1380	if (pThis->displayChangeData.aRequests[i].fPending)
1381	{
1382	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1383	Log3(("VMMDev: another pending at %u\n", i));
1384	break;
1385	}
1386	}
1387
1388	if (pDispRequest)
1389	{
1390	/* Current request has been read at least once. */
1391	pDispRequest->fPending = false;
1392
1393	/* Remember which resolution the client has queried, subsequent reads
1394	* will return the same values. */
1395	pDispRequest->lastReadDisplayChangeRequest = pDispRequest->displayChangeRequest;
1396	pThis->displayChangeData.fGuestSentChangeEventAck = true;
1397	}
1398	else
1399	{
1400	Log3(("VMMDev: no pending request!!!\n"));
1401	}
1402	}
1403
1404	if (!pDispRequest)
1405	{
1406	Log3(("VMMDev: default to %d\n", pThis->displayChangeData.iCurrentMonitor));
1407	pDispRequest = &pThis->displayChangeData.aRequests[pThis->displayChangeData.iCurrentMonitor];
1408	}
1409
1410	if (pThis->displayChangeData.fGuestSentChangeEventAck)
1411	{
1412	pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
1413	pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
1414	pReq->bpp = pDispRequest->lastReadDisplayChangeRequest.bpp;
1415	pReq->display = pDispRequest->lastReadDisplayChangeRequest.display;
1416	}
1417	else
1418	{
1419	/* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1420	* read the last valid video mode hint. This happens when the guest X server
1421	* determines the initial video mode. */
1422	pReq->xres = pDispRequest->displayChangeRequest.xres;
1423	pReq->yres = pDispRequest->displayChangeRequest.yres;
1424	pReq->bpp = pDispRequest->displayChangeRequest.bpp;
1425	pReq->display = pDispRequest->displayChangeRequest.display;
1426	}
1427	Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
1428	pReq->xres, pReq->yres, pReq->bpp, pReq->display));
1429
1430	return VINF_SUCCESS;
1431	}
1432
1433
1434	/**
1435	* Handles VMMDevReq_GetDisplayChangeRequestEx.
1436	*
1437	* @returns VBox status code that the guest should see.
1438	* @param pThis The VMMDev instance data.
1439	* @param pReqHdr The header of the request to handle.
1440	*/
1441	static int vmmdevReqHandler_GetDisplayChangeRequestEx(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1442	{
1443	VMMDevDisplayChangeRequestEx pReq = (VMMDevDisplayChangeRequestEx )pReqHdr;
1444	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1445
1446	DISPLAYCHANGEREQUEST *pDispRequest = NULL;
1447
1448	if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1449	{
1450	/* Select a pending request to report. */
1451	unsigned i;
1452	for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1453	{
1454	if (pThis->displayChangeData.aRequests[i].fPending)
1455	{
1456	pDispRequest = &pThis->displayChangeData.aRequests[i];
1457	/* Remember which request should be reported. */
1458	pThis->displayChangeData.iCurrentMonitor = i;
1459	Log3(("VMMDev: will report pending request for %d\n",
1460	i));
1461	break;
1462	}
1463	}
1464
1465	/* Check if there are more pending requests. */
1466	i++;
1467	for (; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1468	{
1469	if (pThis->displayChangeData.aRequests[i].fPending)
1470	{
1471	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1472	Log3(("VMMDev: another pending at %d\n",
1473	i));
1474	break;
1475	}
1476	}
1477
1478	if (pDispRequest)
1479	{
1480	/* Current request has been read at least once. */
1481	pDispRequest->fPending = false;
1482
1483	/* Remember which resolution the client has queried, subsequent reads
1484	* will return the same values. */
1485	pDispRequest->lastReadDisplayChangeRequest = pDispRequest->displayChangeRequest;
1486	pThis->displayChangeData.fGuestSentChangeEventAck = true;
1487	}
1488	else
1489	{
1490	Log3(("VMMDev: no pending request!!!\n"));
1491	}
1492	}
1493
1494	if (!pDispRequest)
1495	{
1496	Log3(("VMMDev: default to %d\n",
1497	pThis->displayChangeData.iCurrentMonitor));
1498	pDispRequest = &pThis->displayChangeData.aRequests[pThis->displayChangeData.iCurrentMonitor];
1499	}
1500
1501	if (pThis->displayChangeData.fGuestSentChangeEventAck)
1502	{
1503	pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
1504	pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
1505	pReq->bpp = pDispRequest->lastReadDisplayChangeRequest.bpp;
1506	pReq->display = pDispRequest->lastReadDisplayChangeRequest.display;
1507	pReq->cxOrigin = pDispRequest->lastReadDisplayChangeRequest.xOrigin;
1508	pReq->cyOrigin = pDispRequest->lastReadDisplayChangeRequest.yOrigin;
1509	pReq->fEnabled = pDispRequest->lastReadDisplayChangeRequest.fEnabled;
1510	pReq->fChangeOrigin = pDispRequest->lastReadDisplayChangeRequest.fChangeOrigin;
1511	}
1512	else
1513	{
1514	/* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1515	* read the last valid video mode hint. This happens when the guest X server
1516	* determines the initial video mode. */
1517	pReq->xres = pDispRequest->displayChangeRequest.xres;
1518	pReq->yres = pDispRequest->displayChangeRequest.yres;
1519	pReq->bpp = pDispRequest->displayChangeRequest.bpp;
1520	pReq->display = pDispRequest->displayChangeRequest.display;
1521	pReq->cxOrigin = pDispRequest->displayChangeRequest.xOrigin;
1522	pReq->cyOrigin = pDispRequest->displayChangeRequest.yOrigin;
1523	pReq->fEnabled = pDispRequest->displayChangeRequest.fEnabled;
1524	pReq->fChangeOrigin = pDispRequest->displayChangeRequest.fChangeOrigin;
1525
1526	}
1527	Log(("VMMDevEx: returning display change request xres = %d, yres = %d, bpp = %d id %d xPos = %d, yPos = %d & Enabled=%d\n",
1528	pReq->xres, pReq->yres, pReq->bpp, pReq->display, pReq->cxOrigin, pReq->cyOrigin, pReq->fEnabled));
1529
1530	return VINF_SUCCESS;
1531	}
1532
1533
1534	/**
1535	* Handles VMMDevReq_VideoModeSupported.
1536	*
1537	* Query whether the given video mode is supported.
1538	*
1539	* @returns VBox status code that the guest should see.
1540	* @param pThis The VMMDev instance data.
1541	* @param pReqHdr The header of the request to handle.
1542	*/
1543	static int vmmdevReqHandler_VideoModeSupported(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1544	{
1545	VMMDevVideoModeSupportedRequest pReq = (VMMDevVideoModeSupportedRequest )pReqHdr;
1546	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1547
1548	/* forward the call */
1549	return pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1550	0, /* primary screen. */
1551	pReq->width,
1552	pReq->height,
1553	pReq->bpp,
1554	&pReq->fSupported);
1555	}
1556
1557
1558	/**
1559	* Handles VMMDevReq_VideoModeSupported2.
1560	*
1561	* Query whether the given video mode is supported for a specific display
1562	*
1563	* @returns VBox status code that the guest should see.
1564	* @param pThis The VMMDev instance data.
1565	* @param pReqHdr The header of the request to handle.
1566	*/
1567	static int vmmdevReqHandler_VideoModeSupported2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1568	{
1569	VMMDevVideoModeSupportedRequest2 pReq = (VMMDevVideoModeSupportedRequest2 )pReqHdr;
1570	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1571
1572	/* forward the call */
1573	return pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1574	pReq->display,
1575	pReq->width,
1576	pReq->height,
1577	pReq->bpp,
1578	&pReq->fSupported);
1579	}
1580
1581
1582
1583	/**
1584	* Handles VMMDevReq_GetHeightReduction.
1585	*
1586	* @returns VBox status code that the guest should see.
1587	* @param pThis The VMMDev instance data.
1588	* @param pReqHdr The header of the request to handle.
1589	*/
1590	static int vmmdevReqHandler_GetHeightReduction(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1591	{
1592	VMMDevGetHeightReductionRequest pReq = (VMMDevGetHeightReductionRequest )pReqHdr;
1593	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1594
1595	/* forward the call */
1596	return pThis->pDrv->pfnGetHeightReduction(pThis->pDrv, &pReq->heightReduction);
1597	}
1598
1599
1600	/**
1601	* Handles VMMDevReq_AcknowledgeEvents.
1602	*
1603	* @returns VBox status code that the guest should see.
1604	* @param pThis The VMMDev instance data.
1605	* @param pReqHdr The header of the request to handle.
1606	*/
1607	static int vmmdevReqHandler_AcknowledgeEvents(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1608	{
1609	VMMDevEvents pReq = (VMMDevEvents )pReqHdr;
1610	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1611
1612	if (!VMMDEV_INTERFACE_VERSION_IS_1_03(pThis))
1613	{
1614	if (pThis->fNewGuestFilterMask)
1615	{
1616	pThis->fNewGuestFilterMask = false;
1617	pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
1618	}
1619
1620	pReq->events = pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
1621
1622	pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
1623	pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = false;
1624	PDMDevHlpPCISetIrqNoWait(pThis->pDevIns, 0, 0);
1625	}
1626	else
1627	vmmdevSetIRQ_Legacy(pThis);
1628	return VINF_SUCCESS;
1629	}
1630
1631
1632	/**
1633	* Handles VMMDevReq_CtlGuestFilterMask.
1634	*
1635	* @returns VBox status code that the guest should see.
1636	* @param pThis The VMMDev instance data.
1637	* @param pReqHdr The header of the request to handle.
1638	*/
1639	static int vmmdevReqHandler_CtlGuestFilterMask(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1640	{
1641	VMMDevCtlGuestFilterMask pReq = (VMMDevCtlGuestFilterMask )pReqHdr;
1642	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1643
1644	LogRelFlow(("VMMDev: vmmdevReqHandler_CtlGuestFilterMask: OR mask: %#x, NOT mask: %#x\n", pReq->u32OrMask, pReq->u32NotMask));
1645
1646	/* HGCM event notification is enabled by the VMMDev device
1647	* automatically when any HGCM command is issued. The guest
1648	* cannot disable these notifications. */
1649	VMMDevCtlSetGuestFilterMask(pThis, pReq->u32OrMask, pReq->u32NotMask & ~VMMDEV_EVENT_HGCM);
1650	return VINF_SUCCESS;
1651	}
1652
1653	#ifdef VBOX_WITH_HGCM
1654
1655	/**
1656	* Handles VMMDevReq_HGCMConnect.
1657	*
1658	* @returns VBox status code that the guest should see.
1659	* @param pThis The VMMDev instance data.
1660	* @param pReqHdr The header of the request to handle.
1661	* @param GCPhysReqHdr The guest physical address of the request header.
1662	*/
1663	static int vmmdevReqHandler_HGCMConnect(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1664	{
1665	VMMDevHGCMConnect pReq = (VMMDevHGCMConnect )pReqHdr;
1666	AssertMsgReturn(pReq->header.header.size >= sizeof(pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER); /* @todo Not sure why this is >= ... */
1667
1668	if (pThis->pHGCMDrv)
1669	{
1670	Log(("VMMDevReq_HGCMConnect\n"));
1671	return vmmdevHGCMConnect(pThis, pReq, GCPhysReqHdr);
1672	}
1673
1674	Log(("VMMDevReq_HGCMConnect: HGCM Connector is NULL!\n"));
1675	return VERR_NOT_SUPPORTED;
1676	}
1677
1678
1679	/**
1680	* Handles VMMDevReq_HGCMDisconnect.
1681	*
1682	* @returns VBox status code that the guest should see.
1683	* @param pThis The VMMDev instance data.
1684	* @param pReqHdr The header of the request to handle.
1685	* @param GCPhysReqHdr The guest physical address of the request header.
1686	*/
1687	static int vmmdevReqHandler_HGCMDisconnect(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1688	{
1689	VMMDevHGCMDisconnect pReq = (VMMDevHGCMDisconnect )pReqHdr;
1690	AssertMsgReturn(pReq->header.header.size >= sizeof(pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER); /* @todo Not sure why this >= ... */
1691
1692	if (pThis->pHGCMDrv)
1693	{
1694	Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
1695	return vmmdevHGCMDisconnect(pThis, pReq, GCPhysReqHdr);
1696	}
1697
1698	Log(("VMMDevReq_VMMDevHGCMDisconnect: HGCM Connector is NULL!\n"));
1699	return VERR_NOT_SUPPORTED;
1700	}
1701
1702
1703	/**
1704	* Handles VMMDevReq_HGCMCall.
1705	*
1706	* @returns VBox status code that the guest should see.
1707	* @param pThis The VMMDev instance data.
1708	* @param pReqHdr The header of the request to handle.
1709	* @param GCPhysReqHdr The guest physical address of the request header.
1710	*/
1711	static int vmmdevReqHandler_HGCMCall(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1712	{
1713	VMMDevHGCMCall pReq = (VMMDevHGCMCall )pReqHdr;
1714	AssertMsgReturn(pReq->header.header.size >= sizeof(*pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER);
1715
1716	if (pThis->pHGCMDrv)
1717	{
1718	Log2(("VMMDevReq_HGCMCall: sizeof(VMMDevHGCMRequest) = %04X\n", sizeof(VMMDevHGCMCall)));
1719	Log2(("%.*Rhxd\n", pReq->header.header.size, pReq));
1720
1721	#ifdef VBOX_WITH_64_BITS_GUESTS
1722	bool f64Bits = (pReq->header.header.requestType == VMMDevReq_HGCMCall64);
1723	#else
1724	bool f64Bits = false;
1725	#endif /* VBOX_WITH_64_BITS_GUESTS */
1726
1727	return vmmdevHGCMCall(pThis, pReq, pReq->header.header.size, GCPhysReqHdr, f64Bits);
1728	}
1729
1730	Log(("VMMDevReq_HGCMCall: HGCM Connector is NULL!\n"));
1731	return VERR_NOT_SUPPORTED;
1732	}
1733
1734	/**
1735	* Handles VMMDevReq_HGCMCancel.
1736	*
1737	* @returns VBox status code that the guest should see.
1738	* @param pThis The VMMDev instance data.
1739	* @param pReqHdr The header of the request to handle.
1740	* @param GCPhysReqHdr The guest physical address of the request header.
1741	*/
1742	static int vmmdevReqHandler_HGCMCancel(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr, RTGCPHYS GCPhysReqHdr)
1743	{
1744	VMMDevHGCMCancel pReq = (VMMDevHGCMCancel )pReqHdr;
1745	AssertMsgReturn(pReq->header.header.size >= sizeof(pReq), ("%u\n", pReq->header.header.size), VERR_INVALID_PARAMETER); /* @todo Not sure why this >= ... */
1746
1747	if (pThis->pHGCMDrv)
1748	{
1749	Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1750	return vmmdevHGCMCancel(pThis, pReq, GCPhysReqHdr);
1751	}
1752
1753	Log(("VMMDevReq_VMMDevHGCMCancel: HGCM Connector is NULL!\n"));
1754	return VERR_NOT_SUPPORTED;
1755	}
1756
1757
1758	/**
1759	* Handles VMMDevReq_HGCMCancel2.
1760	*
1761	* @returns VBox status code that the guest should see.
1762	* @param pThis The VMMDev instance data.
1763	* @param pReqHdr The header of the request to handle.
1764	*/
1765	static int vmmdevReqHandler_HGCMCancel2(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1766	{
1767	VMMDevHGCMCancel2 pReq = (VMMDevHGCMCancel2 )pReqHdr;
1768	AssertMsgReturn(pReq->header.size >= sizeof(pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER); /* @todo Not sure why this >= ... */
1769
1770	if (pThis->pHGCMDrv)
1771	{
1772	Log(("VMMDevReq_HGCMCancel2\n"));
1773	return vmmdevHGCMCancel2(pThis, pReq->physReqToCancel);
1774	}
1775
1776	Log(("VMMDevReq_HGCMConnect2: HGCM Connector is NULL!\n"));
1777	return VERR_NOT_SUPPORTED;
1778	}
1779
1780	#endif /* VBOX_WITH_HGCM */
1781
1782
1783	/**
1784	* Handles VMMDevReq_VideoAccelEnable.
1785	*
1786	* @returns VBox status code that the guest should see.
1787	* @param pThis The VMMDev instance data.
1788	* @param pReqHdr The header of the request to handle.
1789	*/
1790	static int vmmdevReqHandler_VideoAccelEnable(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1791	{
1792	VMMDevVideoAccelEnable pReq = (VMMDevVideoAccelEnable )pReqHdr;
1793	AssertMsgReturn(pReq->header.size >= sizeof(pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER); /* @todo Not sure why this >= ... */
1794
1795	if (!pThis->pDrv)
1796	{
1797	Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!\n"));
1798	return VERR_NOT_SUPPORTED;
1799	}
1800
1801	if (pReq->cbRingBuffer != VMMDEV_VBVA_RING_BUFFER_SIZE)
1802	{
1803	/* The guest driver seems compiled with different headers. */
1804	LogRelMax(16,("VMMDevReq_VideoAccelEnable guest ring buffer size %#x, should be %#x!!\n", pReq->cbRingBuffer, VMMDEV_VBVA_RING_BUFFER_SIZE));
1805	return VERR_INVALID_PARAMETER;
1806	}
1807
1808	/* The request is correct. */
1809	pReq->fu32Status \|= VBVA_F_STATUS_ACCEPTED;
1810
1811	LogFlow(("VMMDevReq_VideoAccelEnable pReq->u32Enable = %d\n", pReq->u32Enable));
1812
1813	int rc = pReq->u32Enable
1814	? pThis->pDrv->pfnVideoAccelEnable(pThis->pDrv, true, &pThis->pVMMDevRAMR3->vbvaMemory)
1815	: pThis->pDrv->pfnVideoAccelEnable(pThis->pDrv, false, NULL);
1816
1817	if ( pReq->u32Enable
1818	&& RT_SUCCESS(rc))
1819	{
1820	pReq->fu32Status \|= VBVA_F_STATUS_ENABLED;
1821
1822	/* Remember that guest successfully enabled acceleration.
1823	* We need to reestablish it on restoring the VM from saved state.
1824	*/
1825	pThis->u32VideoAccelEnabled = 1;
1826	}
1827	else
1828	{
1829	/* The acceleration was not enabled. Remember that. */
1830	pThis->u32VideoAccelEnabled = 0;
1831	}
1832	return VINF_SUCCESS;
1833	}
1834
1835
1836	/**
1837	* Handles VMMDevReq_VideoAccelFlush.
1838	*
1839	* @returns VBox status code that the guest should see.
1840	* @param pThis The VMMDev instance data.
1841	* @param pReqHdr The header of the request to handle.
1842	*/
1843	static int vmmdevReqHandler_VideoAccelFlush(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1844	{
1845	VMMDevVideoAccelFlush pReq = (VMMDevVideoAccelFlush )pReqHdr;
1846	AssertMsgReturn(pReq->header.size >= sizeof(pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER); /* @todo Not sure why this >= ... */
1847
1848	if (!pThis->pDrv)
1849	{
1850	Log(("VMMDevReq_VideoAccelFlush: Connector is NULL!!!\n"));
1851	return VERR_NOT_SUPPORTED;
1852	}
1853
1854	pThis->pDrv->pfnVideoAccelFlush(pThis->pDrv);
1855	return VINF_SUCCESS;
1856	}
1857
1858
1859	/**
1860	* Handles VMMDevReq_VideoSetVisibleRegion.
1861	*
1862	* @returns VBox status code that the guest should see.
1863	* @param pThis The VMMDev instance data.
1864	* @param pReqHdr The header of the request to handle.
1865	*/
1866	static int vmmdevReqHandler_VideoSetVisibleRegion(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1867	{
1868	VMMDevVideoSetVisibleRegion pReq = (VMMDevVideoSetVisibleRegion )pReqHdr;
1869	AssertMsgReturn(pReq->header.size + sizeof(RTRECT) >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1870
1871	if (!pThis->pDrv)
1872	{
1873	Log(("VMMDevReq_VideoSetVisibleRegion: Connector is NULL!!!\n"));
1874	return VERR_NOT_SUPPORTED;
1875	}
1876
1877	if ( pReq->cRect > _1M /* restrict to sane range */
1878	\|\| pReq->header.size != sizeof(VMMDevVideoSetVisibleRegion) + pReq->cRect * sizeof(RTRECT) - sizeof(RTRECT))
1879	{
1880	Log(("VMMDevReq_VideoSetVisibleRegion: cRects=%#x doesn't match size=%#x or is out of bounds\n",
1881	pReq->cRect, pReq->header.size));
1882	return VERR_INVALID_PARAMETER;
1883	}
1884
1885	Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", pReq->cRect));
1886	/* forward the call */
1887	return pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, pReq->cRect, &pReq->Rect);
1888	}
1889
1890
1891	/**
1892	* Handles VMMDevReq_GetSeamlessChangeRequest.
1893	*
1894	* @returns VBox status code that the guest should see.
1895	* @param pThis The VMMDev instance data.
1896	* @param pReqHdr The header of the request to handle.
1897	*/
1898	static int vmmdevReqHandler_GetSeamlessChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1899	{
1900	VMMDevSeamlessChangeRequest pReq = (VMMDevSeamlessChangeRequest )pReqHdr;
1901	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1902
1903	/* just pass on the information */
1904	Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
1905	if (pThis->fSeamlessEnabled)
1906	pReq->mode = VMMDev_Seamless_Visible_Region;
1907	else
1908	pReq->mode = VMMDev_Seamless_Disabled;
1909
1910	if (pReq->eventAck == VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
1911	{
1912	/* Remember which mode the client has queried. */
1913	pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
1914	}
1915
1916	return VINF_SUCCESS;
1917	}
1918
1919
1920	/**
1921	* Handles VMMDevReq_GetVRDPChangeRequest.
1922	*
1923	* @returns VBox status code that the guest should see.
1924	* @param pThis The VMMDev instance data.
1925	* @param pReqHdr The header of the request to handle.
1926	*/
1927	static int vmmdevReqHandler_GetVRDPChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1928	{
1929	VMMDevVRDPChangeRequest pReq = (VMMDevVRDPChangeRequest )pReqHdr;
1930	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1931
1932	/* just pass on the information */
1933	Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->uVRDPExperienceLevel));
1934
1935	pReq->u8VRDPActive = pThis->fVRDPEnabled;
1936	pReq->u32VRDPExperienceLevel = pThis->uVRDPExperienceLevel;
1937
1938	return VINF_SUCCESS;
1939	}
1940
1941
1942	/**
1943	* Handles VMMDevReq_GetMemBalloonChangeRequest.
1944	*
1945	* @returns VBox status code that the guest should see.
1946	* @param pThis The VMMDev instance data.
1947	* @param pReqHdr The header of the request to handle.
1948	*/
1949	static int vmmdevReqHandler_GetMemBalloonChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1950	{
1951	VMMDevGetMemBalloonChangeRequest pReq = (VMMDevGetMemBalloonChangeRequest )pReqHdr;
1952	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1953
1954	/* just pass on the information */
1955	Log(("VMMDev: returning memory balloon size =%d\n", pThis->cMbMemoryBalloon));
1956	pReq->cBalloonChunks = pThis->cMbMemoryBalloon;
1957	pReq->cPhysMemChunks = pThis->cbGuestRAM / (uint64_t)_1M;
1958
1959	if (pReq->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
1960	{
1961	/* Remember which mode the client has queried. */
1962	pThis->cMbMemoryBalloonLast = pThis->cMbMemoryBalloon;
1963	}
1964
1965	return VINF_SUCCESS;
1966	}
1967
1968
1969	/**
1970	* Handles VMMDevReq_ChangeMemBalloon.
1971	*
1972	* @returns VBox status code that the guest should see.
1973	* @param pThis The VMMDev instance data.
1974	* @param pReqHdr The header of the request to handle.
1975	*/
1976	static int vmmdevReqHandler_ChangeMemBalloon(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
1977	{
1978	VMMDevChangeMemBalloon pReq = (VMMDevChangeMemBalloon )pReqHdr;
1979	AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1980	AssertMsgReturn(pReq->cPages == VMMDEV_MEMORY_BALLOON_CHUNK_PAGES, ("%u\n", pReq->cPages), VERR_INVALID_PARAMETER);
1981	AssertMsgReturn(pReq->header.size == (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[pReq->cPages]),
1982	("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
1983
1984	Log(("VMMDevReq_ChangeMemBalloon\n"));
1985	int rc = PGMR3PhysChangeMemBalloon(PDMDevHlpGetVM(pThis->pDevIns), !!pReq->fInflate, pReq->cPages, pReq->aPhysPage);
1986	if (pReq->fInflate)
1987	STAM_REL_U32_INC(&pThis->StatMemBalloonChunks);
1988	else
1989	STAM_REL_U32_DEC(&pThis->StatMemBalloonChunks);
1990	return rc;
1991	}
1992
1993
1994	/**
1995	* Handles VMMDevReq_GetStatisticsChangeRequest.
1996	*
1997	* @returns VBox status code that the guest should see.
1998	* @param pThis The VMMDev instance data.
1999	* @param pReqHdr The header of the request to handle.
2000	*/
2001	static int vmmdevReqHandler_GetStatisticsChangeRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2002	{
2003	VMMDevGetStatisticsChangeRequest pReq = (VMMDevGetStatisticsChangeRequest )pReqHdr;
2004	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2005
2006	Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
2007	/* just pass on the information */
2008	Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
2009	pReq->u32StatInterval = pThis->u32StatIntervalSize;
2010
2011	if (pReq->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
2012	{
2013	/* Remember which mode the client has queried. */
2014	pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
2015	}
2016
2017	return VINF_SUCCESS;
2018	}
2019
2020
2021	/**
2022	* Handles VMMDevReq_ReportGuestStats.
2023	*
2024	* @returns VBox status code that the guest should see.
2025	* @param pThis The VMMDev instance data.
2026	* @param pReqHdr The header of the request to handle.
2027	*/
2028	static int vmmdevReqHandler_ReportGuestStats(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2029	{
2030	VMMDevReportGuestStats pReq = (VMMDevReportGuestStats )pReqHdr;
2031	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2032
2033	Log(("VMMDevReq_ReportGuestStats\n"));
2034	#ifdef LOG_ENABLED
2035	VBoxGuestStatistics *pGuestStats = &pReq->guestStats;
2036
2037	Log(("Current statistics:\n"));
2038	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_IDLE)
2039	Log(("CPU%u: CPU Load Idle %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Idle));
2040
2041	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_KERNEL)
2042	Log(("CPU%u: CPU Load Kernel %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Kernel));
2043
2044	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_USER)
2045	Log(("CPU%u: CPU Load User %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_User));
2046
2047	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_THREADS)
2048	Log(("CPU%u: Thread %d\n", pGuestStats->u32CpuId, pGuestStats->u32Threads));
2049
2050	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PROCESSES)
2051	Log(("CPU%u: Processes %d\n", pGuestStats->u32CpuId, pGuestStats->u32Processes));
2052
2053	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_HANDLES)
2054	Log(("CPU%u: Handles %d\n", pGuestStats->u32CpuId, pGuestStats->u32Handles));
2055
2056	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEMORY_LOAD)
2057	Log(("CPU%u: Memory Load %d%%\n", pGuestStats->u32CpuId, pGuestStats->u32MemoryLoad));
2058
2059	/* Note that reported values are in pages; upper layers expect them in megabytes */
2060	Log(("CPU%u: Page size %-4d bytes\n", pGuestStats->u32CpuId, pGuestStats->u32PageSize));
2061	Assert(pGuestStats->u32PageSize == 4096);
2062
2063	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)
2064	Log(("CPU%u: Total physical memory %-4d MB\n", pGuestStats->u32CpuId, (pGuestStats->u32PhysMemTotal + (_1M/_4K)-1) / (_1M/_4K)));
2065
2066	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_AVAIL)
2067	Log(("CPU%u: Free physical memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemAvail / (_1M/_4K)));
2068
2069	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_BALLOON)
2070	Log(("CPU%u: Memory balloon size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemBalloon / (_1M/_4K)));
2071
2072	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_COMMIT_TOTAL)
2073	Log(("CPU%u: Committed memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemCommitTotal / (_1M/_4K)));
2074
2075	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_TOTAL)
2076	Log(("CPU%u: Total kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelTotal / (_1M/_4K)));
2077
2078	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_PAGED)
2079	Log(("CPU%u: Paged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelPaged / (_1M/_4K)));
2080
2081	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED)
2082	Log(("CPU%u: Nonpaged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelNonPaged / (_1M/_4K)));
2083
2084	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_SYSTEM_CACHE)
2085	Log(("CPU%u: System cache size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemSystemCache / (_1M/_4K)));
2086
2087	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PAGE_FILE_SIZE)
2088	Log(("CPU%u: Page file size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PageFileSize / (_1M/_4K)));
2089	Log(("Statistics end *******************\n"));
2090	#endif /* LOG_ENABLED */
2091
2092	/* forward the call */
2093	return pThis->pDrv->pfnReportStatistics(pThis->pDrv, &pReq->guestStats);
2094	}
2095
2096
2097	/**
2098	* Handles VMMDevReq_QueryCredentials.
2099	*
2100	* @returns VBox status code that the guest should see.
2101	* @param pThis The VMMDev instance data.
2102	* @param pReqHdr The header of the request to handle.
2103	*/
2104	static int vmmdevReqHandler_QueryCredentials(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2105	{
2106	VMMDevCredentials pReq = (VMMDevCredentials )pReqHdr;
2107	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2108
2109	/* let's start by nulling out the data */
2110	memset(pReq->szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2111	memset(pReq->szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2112	memset(pReq->szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2113
2114	/* should we return whether we got credentials for a logon? */
2115	if (pReq->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
2116	{
2117	if ( pThis->pCredentials->Logon.szUserName[0]
2118	\|\| pThis->pCredentials->Logon.szPassword[0]
2119	\|\| pThis->pCredentials->Logon.szDomain[0])
2120	pReq->u32Flags \|= VMMDEV_CREDENTIALS_PRESENT;
2121	else
2122	pReq->u32Flags &= ~VMMDEV_CREDENTIALS_PRESENT;
2123	}
2124
2125	/* does the guest want to read logon credentials? */
2126	if (pReq->u32Flags & VMMDEV_CREDENTIALS_READ)
2127	{
2128	if (pThis->pCredentials->Logon.szUserName[0])
2129	strcpy(pReq->szUserName, pThis->pCredentials->Logon.szUserName);
2130	if (pThis->pCredentials->Logon.szPassword[0])
2131	strcpy(pReq->szPassword, pThis->pCredentials->Logon.szPassword);
2132	if (pThis->pCredentials->Logon.szDomain[0])
2133	strcpy(pReq->szDomain, pThis->pCredentials->Logon.szDomain);
2134	if (!pThis->pCredentials->Logon.fAllowInteractiveLogon)
2135	pReq->u32Flags \|= VMMDEV_CREDENTIALS_NOLOCALLOGON;
2136	else
2137	pReq->u32Flags &= ~VMMDEV_CREDENTIALS_NOLOCALLOGON;
2138	}
2139
2140	if (!pThis->fKeepCredentials)
2141	{
2142	/* does the caller want us to destroy the logon credentials? */
2143	if (pReq->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
2144	{
2145	memset(pThis->pCredentials->Logon.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2146	memset(pThis->pCredentials->Logon.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2147	memset(pThis->pCredentials->Logon.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2148	}
2149	}
2150
2151	/* does the guest want to read credentials for verification? */
2152	if (pReq->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
2153	{
2154	if (pThis->pCredentials->Judge.szUserName[0])
2155	strcpy(pReq->szUserName, pThis->pCredentials->Judge.szUserName);
2156	if (pThis->pCredentials->Judge.szPassword[0])
2157	strcpy(pReq->szPassword, pThis->pCredentials->Judge.szPassword);
2158	if (pThis->pCredentials->Judge.szDomain[0])
2159	strcpy(pReq->szDomain, pThis->pCredentials->Judge.szDomain);
2160	}
2161
2162	/* does the caller want us to destroy the judgement credentials? */
2163	if (pReq->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
2164	{
2165	memset(pThis->pCredentials->Judge.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2166	memset(pThis->pCredentials->Judge.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2167	memset(pThis->pCredentials->Judge.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2168	}
2169
2170	return VINF_SUCCESS;
2171	}
2172
2173
2174	/**
2175	* Handles VMMDevReq_ReportCredentialsJudgement.
2176	*
2177	* @returns VBox status code that the guest should see.
2178	* @param pThis The VMMDev instance data.
2179	* @param pReqHdr The header of the request to handle.
2180	*/
2181	static int vmmdevReqHandler_ReportCredentialsJudgement(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2182	{
2183	VMMDevCredentials pReq = (VMMDevCredentials )pReqHdr;
2184	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2185
2186	/* what does the guest think about the credentials? (note: the order is important here!) */
2187	if (pReq->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
2188	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
2189	else if (pReq->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
2190	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
2191	else if (pReq->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
2192	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
2193	else
2194	{
2195	Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", pReq->u32Flags));
2196	/** @todo why don't we return VERR_INVALID_PARAMETER to the guest? */
2197	}
2198
2199	return VINF_SUCCESS;
2200	}
2201
2202
2203	/**
2204	* Handles VMMDevReq_GetHostVersion.
2205	*
2206	* @returns VBox status code that the guest should see.
2207	* @param pReqHdr The header of the request to handle.
2208	* @since 3.1.0
2209	* @note The ring-0 VBoxGuestLib uses this to check whether
2210	* VMMDevHGCMParmType_PageList is supported.
2211	*/
2212	static int vmmdevReqHandler_GetHostVersion(VMMDevRequestHeader *pReqHdr)
2213	{
2214	VMMDevReqHostVersion pReq = (VMMDevReqHostVersion )pReqHdr;
2215	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2216
2217	pReq->major = RTBldCfgVersionMajor();
2218	pReq->minor = RTBldCfgVersionMinor();
2219	pReq->build = RTBldCfgVersionBuild();
2220	pReq->revision = RTBldCfgRevision();
2221	pReq->features = VMMDEV_HVF_HGCM_PHYS_PAGE_LIST;
2222	return VINF_SUCCESS;
2223	}
2224
2225
2226	/**
2227	* Handles VMMDevReq_GetCpuHotPlugRequest.
2228	*
2229	* @returns VBox status code that the guest should see.
2230	* @param pThis The VMMDev instance data.
2231	* @param pReqHdr The header of the request to handle.
2232	*/
2233	static int vmmdevReqHandler_GetCpuHotPlugRequest(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2234	{
2235	VMMDevGetCpuHotPlugRequest pReq = (VMMDevGetCpuHotPlugRequest )pReqHdr;
2236	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2237
2238	pReq->enmEventType = pThis->enmCpuHotPlugEvent;
2239	pReq->idCpuCore = pThis->idCpuCore;
2240	pReq->idCpuPackage = pThis->idCpuPackage;
2241
2242	/* Clear the event */
2243	pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_None;
2244	pThis->idCpuCore = UINT32_MAX;
2245	pThis->idCpuPackage = UINT32_MAX;
2246
2247	return VINF_SUCCESS;
2248	}
2249
2250
2251	/**
2252	* Handles VMMDevReq_SetCpuHotPlugStatus.
2253	*
2254	* @returns VBox status code that the guest should see.
2255	* @param pThis The VMMDev instance data.
2256	* @param pReqHdr The header of the request to handle.
2257	*/
2258	static int vmmdevReqHandler_SetCpuHotPlugStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2259	{
2260	VMMDevCpuHotPlugStatusRequest pReq = (VMMDevCpuHotPlugStatusRequest )pReqHdr;
2261	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2262
2263	if (pReq->enmStatusType == VMMDevCpuStatusType_Disable)
2264	pThis->fCpuHotPlugEventsEnabled = false;
2265	else if (pReq->enmStatusType == VMMDevCpuStatusType_Enable)
2266	pThis->fCpuHotPlugEventsEnabled = true;
2267	else
2268	return VERR_INVALID_PARAMETER;
2269	return VINF_SUCCESS;
2270	}
2271
2272
2273	#ifdef DEBUG
2274	/**
2275	* Handles VMMDevReq_LogString.
2276	*
2277	* @returns VBox status code that the guest should see.
2278	* @param pReqHdr The header of the request to handle.
2279	*/
2280	static int vmmdevReqHandler_LogString(VMMDevRequestHeader *pReqHdr)
2281	{
2282	VMMDevReqLogString pReq = (VMMDevReqLogString )pReqHdr;
2283	AssertMsgReturn(pReq->header.size >= sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2284	AssertMsgReturn(pReq->szString[pReq->header.size - RT_OFFSETOF(VMMDevReqLogString, szString) - 1] == '\0',
2285	("not null terminated\n"), VERR_INVALID_PARAMETER);
2286
2287	LogIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("DEBUG LOG: %s", pReq->szString));
2288	return VINF_SUCCESS;
2289	}
2290	#endif /* DEBUG */
2291
2292	/**
2293	* Handles VMMDevReq_GetSessionId.
2294	*
2295	* Get a unique "session" ID for this VM, where the ID will be different after each
2296	* start, reset or restore of the VM. This can be used for restore detection
2297	* inside the guest.
2298	*
2299	* @returns VBox status code that the guest should see.
2300	* @param pThis The VMMDev instance data.
2301	* @param pReqHdr The header of the request to handle.
2302	*/
2303	static int vmmdevReqHandler_GetSessionId(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2304	{
2305	VMMDevReqSessionId pReq = (VMMDevReqSessionId )pReqHdr;
2306	AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2307
2308	pReq->idSession = pThis->idSession;
2309	return VINF_SUCCESS;
2310	}
2311
2312
2313	#ifdef VBOX_WITH_PAGE_SHARING
2314
2315	/**
2316	* Handles VMMDevReq_RegisterSharedModule.
2317	*
2318	* @returns VBox status code that the guest should see.
2319	* @param pThis The VMMDev instance data.
2320	* @param pReqHdr The header of the request to handle.
2321	*/
2322	static int vmmdevReqHandler_RegisterSharedModule(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2323	{
2324	/*
2325	* Basic input validation (more done by GMM).
2326	*/
2327	VMMDevSharedModuleRegistrationRequest pReq = (VMMDevSharedModuleRegistrationRequest )pReqHdr;
2328	AssertMsgReturn(pReq->header.size >= sizeof(VMMDevSharedModuleRegistrationRequest),
2329	("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2330	AssertMsgReturn(pReq->header.size == RT_UOFFSETOF(VMMDevSharedModuleRegistrationRequest, aRegions[pReq->cRegions]),
2331	("%u cRegions=%u\n", pReq->header.size, pReq->cRegions), VERR_INVALID_PARAMETER);
2332
2333	AssertReturn(RTStrEnd(pReq->szName, sizeof(pReq->szName)), VERR_INVALID_PARAMETER);
2334	AssertReturn(RTStrEnd(pReq->szVersion, sizeof(pReq->szVersion)), VERR_INVALID_PARAMETER);
2335	int rc = RTStrValidateEncoding(pReq->szName);
2336	AssertRCReturn(rc, rc);
2337	rc = RTStrValidateEncoding(pReq->szVersion);
2338	AssertRCReturn(rc, rc);
2339
2340	/*
2341	* Forward the request to the VMM.
2342	*/
2343	return PGMR3SharedModuleRegister(PDMDevHlpGetVM(pThis->pDevIns), pReq->enmGuestOS, pReq->szName, pReq->szVersion,
2344	pReq->GCBaseAddr, pReq->cbModule, pReq->cRegions, pReq->aRegions);
2345	}
2346
2347	/**
2348	* Handles VMMDevReq_UnregisterSharedModule.
2349	*
2350	* @returns VBox status code that the guest should see.
2351	* @param pThis The VMMDev instance data.
2352	* @param pReqHdr The header of the request to handle.
2353	*/
2354	static int vmmdevReqHandler_UnregisterSharedModule(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2355	{
2356	/*
2357	* Basic input validation.
2358	*/
2359	VMMDevSharedModuleUnregistrationRequest pReq = (VMMDevSharedModuleUnregistrationRequest )pReqHdr;
2360	AssertMsgReturn(pReq->header.size == sizeof(VMMDevSharedModuleUnregistrationRequest),
2361	("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2362
2363	AssertReturn(RTStrEnd(pReq->szName, sizeof(pReq->szName)), VERR_INVALID_PARAMETER);
2364	AssertReturn(RTStrEnd(pReq->szVersion, sizeof(pReq->szVersion)), VERR_INVALID_PARAMETER);
2365	int rc = RTStrValidateEncoding(pReq->szName);
2366	AssertRCReturn(rc, rc);
2367	rc = RTStrValidateEncoding(pReq->szVersion);
2368	AssertRCReturn(rc, rc);
2369
2370	/*
2371	* Forward the request to the VMM.
2372	*/
2373	return PGMR3SharedModuleUnregister(PDMDevHlpGetVM(pThis->pDevIns), pReq->szName, pReq->szVersion,
2374	pReq->GCBaseAddr, pReq->cbModule);
2375	}
2376
2377	/**
2378	* Handles VMMDevReq_CheckSharedModules.
2379	*
2380	* @returns VBox status code that the guest should see.
2381	* @param pThis The VMMDev instance data.
2382	* @param pReqHdr The header of the request to handle.
2383	*/
2384	static int vmmdevReqHandler_CheckSharedModules(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2385	{
2386	VMMDevSharedModuleCheckRequest pReq = (VMMDevSharedModuleCheckRequest )pReqHdr;
2387	AssertMsgReturn(pReq->header.size == sizeof(VMMDevSharedModuleCheckRequest),
2388	("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2389	return PGMR3SharedModuleCheckAll(PDMDevHlpGetVM(pThis->pDevIns));
2390	}
2391
2392	/**
2393	* Handles VMMDevReq_GetPageSharingStatus.
2394	*
2395	* @returns VBox status code that the guest should see.
2396	* @param pThis The VMMDev instance data.
2397	* @param pReqHdr The header of the request to handle.
2398	*/
2399	static int vmmdevReqHandler_GetPageSharingStatus(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2400	{
2401	VMMDevPageSharingStatusRequest pReq = (VMMDevPageSharingStatusRequest )pReqHdr;
2402	AssertMsgReturn(pReq->header.size == sizeof(VMMDevPageSharingStatusRequest),
2403	("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2404
2405	pReq->fEnabled = false;
2406	int rc = pThis->pDrv->pfnIsPageFusionEnabled(pThis->pDrv, &pReq->fEnabled);
2407	if (RT_FAILURE(rc))
2408	pReq->fEnabled = false;
2409	return VINF_SUCCESS;
2410	}
2411
2412
2413	/**
2414	* Handles VMMDevReq_DebugIsPageShared.
2415	*
2416	* @returns VBox status code that the guest should see.
2417	* @param pThis The VMMDev instance data.
2418	* @param pReqHdr The header of the request to handle.
2419	*/
2420	static int vmmdevReqHandler_DebugIsPageShared(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2421	{
2422	VMMDevPageIsSharedRequest pReq = (VMMDevPageIsSharedRequest )pReqHdr;
2423	AssertMsgReturn(pReq->header.size == sizeof(VMMDevPageIsSharedRequest),
2424	("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2425
2426	# ifdef DEBUG
2427	return PGMR3SharedModuleGetPageState(PDMDevHlpGetVM(pThis->pDevIns), pReq->GCPtrPage, &pReq->fShared, &pReq->uPageFlags);
2428	# else
2429	RT_NOREF1(pThis);
2430	return VERR_NOT_IMPLEMENTED;
2431	# endif
2432	}
2433
2434	#endif /* VBOX_WITH_PAGE_SHARING */
2435
2436
2437	/**
2438	* Handles VMMDevReq_WriteCoreDumpe
2439	*
2440	* @returns VBox status code that the guest should see.
2441	* @param pThis The VMMDev instance data.
2442	* @param pReqHdr Pointer to the request header.
2443	*/
2444	static int vmmdevReqHandler_WriteCoreDump(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
2445	{
2446	VMMDevReqWriteCoreDump pReq = (VMMDevReqWriteCoreDump )pReqHdr;
2447	AssertMsgReturn(pReq->header.size == sizeof(VMMDevReqWriteCoreDump), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
2448
2449	/*
2450	* Only available if explicitly enabled by the user.
2451	*/
2452	if (!pThis->fGuestCoreDumpEnabled)
2453	return VERR_ACCESS_DENIED;
2454
2455	/*
2456	* User makes sure the directory exists before composing the path.
2457	*/
2458	if (!RTDirExists(pThis->szGuestCoreDumpDir))
2459	return VERR_PATH_NOT_FOUND;
2460
2461	char szCorePath[RTPATH_MAX];
2462	RTStrCopy(szCorePath, sizeof(szCorePath), pThis->szGuestCoreDumpDir);
2463	RTPathAppend(szCorePath, sizeof(szCorePath), "VBox.core");
2464
2465	/*
2466	* Rotate existing cores based on number of additional cores to keep around.
2467	*/
2468	if (pThis->cGuestCoreDumps > 0)
2469	for (int64_t i = pThis->cGuestCoreDumps - 1; i >= 0; i--)
2470	{
2471	char szFilePathOld[RTPATH_MAX];
2472	if (i == 0)
2473	RTStrCopy(szFilePathOld, sizeof(szFilePathOld), szCorePath);
2474	else
2475	RTStrPrintf(szFilePathOld, sizeof(szFilePathOld), "%s.%lld", szCorePath, i);
2476
2477	char szFilePathNew[RTPATH_MAX];
2478	RTStrPrintf(szFilePathNew, sizeof(szFilePathNew), "%s.%lld", szCorePath, i + 1);
2479	int vrc = RTFileMove(szFilePathOld, szFilePathNew, RTFILEMOVE_FLAGS_REPLACE);
2480	if (vrc == VERR_FILE_NOT_FOUND)
2481	RTFileDelete(szFilePathNew);
2482	}
2483
2484	/*
2485	* Write the core file.
2486	*/
2487	PUVM pUVM = PDMDevHlpGetUVM(pThis->pDevIns);
2488	return DBGFR3CoreWrite(pUVM, szCorePath, true /fReplaceFile/);
2489	}
2490
2491
2492	/**
2493	* Dispatch the request to the appropriate handler function.
2494	*
2495	* @returns Port I/O handler exit code.
2496	* @param pThis The VMM device instance data.
2497	* @param pReqHdr The request header (cached in host memory).
2498	* @param GCPhysReqHdr The guest physical address of the request (for
2499	* HGCM).
2500	* @param pfDelayedUnlock Where to indicate whether the critical section exit
2501	* needs to be delayed till after the request has been
2502	* written back. This is a HGCM kludge, see critsect
2503	* work in hgcmCompletedWorker for more details.
2504	*/
2505	static int vmmdevReqDispatcher(PVMMDEV pThis, VMMDevRequestHeader pReqHdr, RTGCPHYS GCPhysReqHdr, bool pfDelayedUnlock)
2506	{
2507	int rcRet = VINF_SUCCESS;
2508	*pfDelayedUnlock = false;
2509
2510	switch (pReqHdr->requestType)
2511	{
2512	case VMMDevReq_ReportGuestInfo:
2513	pReqHdr->rc = vmmdevReqHandler_ReportGuestInfo(pThis, pReqHdr);
2514	break;
2515
2516	case VMMDevReq_ReportGuestInfo2:
2517	pReqHdr->rc = vmmdevReqHandler_ReportGuestInfo2(pThis, pReqHdr);
2518	break;
2519
2520	case VMMDevReq_ReportGuestStatus:
2521	pReqHdr->rc = vmmdevReqHandler_ReportGuestStatus(pThis, pReqHdr);
2522	break;
2523
2524	case VMMDevReq_ReportGuestUserState:
2525	pReqHdr->rc = vmmdevReqHandler_ReportGuestUserState(pThis, pReqHdr);
2526	break;
2527
2528	case VMMDevReq_ReportGuestCapabilities:
2529	pReqHdr->rc = vmmdevReqHandler_ReportGuestCapabilities(pThis, pReqHdr);
2530	break;
2531
2532	case VMMDevReq_SetGuestCapabilities:
2533	pReqHdr->rc = vmmdevReqHandler_SetGuestCapabilities(pThis, pReqHdr);
2534	break;
2535
2536	case VMMDevReq_WriteCoreDump:
2537	pReqHdr->rc = vmmdevReqHandler_WriteCoreDump(pThis, pReqHdr);
2538	break;
2539
2540	case VMMDevReq_GetMouseStatus:
2541	pReqHdr->rc = vmmdevReqHandler_GetMouseStatus(pThis, pReqHdr);
2542	break;
2543
2544	case VMMDevReq_SetMouseStatus:
2545	pReqHdr->rc = vmmdevReqHandler_SetMouseStatus(pThis, pReqHdr);
2546	break;
2547
2548	case VMMDevReq_SetPointerShape:
2549	pReqHdr->rc = vmmdevReqHandler_SetPointerShape(pThis, pReqHdr);
2550	break;
2551
2552	case VMMDevReq_GetHostTime:
2553	pReqHdr->rc = vmmdevReqHandler_GetHostTime(pThis, pReqHdr);
2554	break;
2555
2556	case VMMDevReq_GetHypervisorInfo:
2557	pReqHdr->rc = vmmdevReqHandler_GetHypervisorInfo(pThis, pReqHdr);
2558	break;
2559
2560	case VMMDevReq_SetHypervisorInfo:
2561	pReqHdr->rc = vmmdevReqHandler_SetHypervisorInfo(pThis, pReqHdr);
2562	break;
2563
2564	case VMMDevReq_RegisterPatchMemory:
2565	pReqHdr->rc = vmmdevReqHandler_RegisterPatchMemory(pThis, pReqHdr);
2566	break;
2567
2568	case VMMDevReq_DeregisterPatchMemory:
2569	pReqHdr->rc = vmmdevReqHandler_DeregisterPatchMemory(pThis, pReqHdr);
2570	break;
2571
2572	case VMMDevReq_SetPowerStatus:
2573	{
2574	int rc = pReqHdr->rc = vmmdevReqHandler_SetPowerStatus(pThis, pReqHdr);
2575	if (rc != VINF_SUCCESS && RT_SUCCESS(rc))
2576	rcRet = rc;
2577	break;
2578	}
2579
2580	case VMMDevReq_GetDisplayChangeRequest:
2581	pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequest(pThis, pReqHdr);
2582	break;
2583
2584	case VMMDevReq_GetDisplayChangeRequest2:
2585	pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequest2(pThis, pReqHdr);
2586	break;
2587
2588	case VMMDevReq_GetDisplayChangeRequestEx:
2589	pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequestEx(pThis, pReqHdr);
2590	break;
2591
2592	case VMMDevReq_VideoModeSupported:
2593	pReqHdr->rc = vmmdevReqHandler_VideoModeSupported(pThis, pReqHdr);
2594	break;
2595
2596	case VMMDevReq_VideoModeSupported2:
2597	pReqHdr->rc = vmmdevReqHandler_VideoModeSupported2(pThis, pReqHdr);
2598	break;
2599
2600	case VMMDevReq_GetHeightReduction:
2601	pReqHdr->rc = vmmdevReqHandler_GetHeightReduction(pThis, pReqHdr);
2602	break;
2603
2604	case VMMDevReq_AcknowledgeEvents:
2605	pReqHdr->rc = vmmdevReqHandler_AcknowledgeEvents(pThis, pReqHdr);
2606	break;
2607
2608	case VMMDevReq_CtlGuestFilterMask:
2609	pReqHdr->rc = vmmdevReqHandler_CtlGuestFilterMask(pThis, pReqHdr);
2610	break;
2611
2612	#ifdef VBOX_WITH_HGCM
2613	case VMMDevReq_HGCMConnect:
2614	pReqHdr->rc = vmmdevReqHandler_HGCMConnect(pThis, pReqHdr, GCPhysReqHdr);
2615	*pfDelayedUnlock = true;
2616	break;
2617
2618	case VMMDevReq_HGCMDisconnect:
2619	pReqHdr->rc = vmmdevReqHandler_HGCMDisconnect(pThis, pReqHdr, GCPhysReqHdr);
2620	*pfDelayedUnlock = true;
2621	break;
2622
2623	# ifdef VBOX_WITH_64_BITS_GUESTS
2624	case VMMDevReq_HGCMCall32:
2625	case VMMDevReq_HGCMCall64:
2626	# else
2627	case VMMDevReq_HGCMCall:
2628	# endif /* VBOX_WITH_64_BITS_GUESTS */
2629	pReqHdr->rc = vmmdevReqHandler_HGCMCall(pThis, pReqHdr, GCPhysReqHdr);
2630	*pfDelayedUnlock = true;
2631	break;
2632
2633	case VMMDevReq_HGCMCancel:
2634	pReqHdr->rc = vmmdevReqHandler_HGCMCancel(pThis, pReqHdr, GCPhysReqHdr);
2635	*pfDelayedUnlock = true;
2636	break;
2637
2638	case VMMDevReq_HGCMCancel2:
2639	pReqHdr->rc = vmmdevReqHandler_HGCMCancel2(pThis, pReqHdr);
2640	break;
2641	#endif /* VBOX_WITH_HGCM */
2642
2643	case VMMDevReq_VideoAccelEnable:
2644	pReqHdr->rc = vmmdevReqHandler_VideoAccelEnable(pThis, pReqHdr);
2645	break;
2646
2647	case VMMDevReq_VideoAccelFlush:
2648	pReqHdr->rc = vmmdevReqHandler_VideoAccelFlush(pThis, pReqHdr);
2649	break;
2650
2651	case VMMDevReq_VideoSetVisibleRegion:
2652	pReqHdr->rc = vmmdevReqHandler_VideoSetVisibleRegion(pThis, pReqHdr);
2653	break;
2654
2655	case VMMDevReq_GetSeamlessChangeRequest:
2656	pReqHdr->rc = vmmdevReqHandler_GetSeamlessChangeRequest(pThis, pReqHdr);
2657	break;
2658
2659	case VMMDevReq_GetVRDPChangeRequest:
2660	pReqHdr->rc = vmmdevReqHandler_GetVRDPChangeRequest(pThis, pReqHdr);
2661	break;
2662
2663	case VMMDevReq_GetMemBalloonChangeRequest:
2664	pReqHdr->rc = vmmdevReqHandler_GetMemBalloonChangeRequest(pThis, pReqHdr);
2665	break;
2666
2667	case VMMDevReq_ChangeMemBalloon:
2668	pReqHdr->rc = vmmdevReqHandler_ChangeMemBalloon(pThis, pReqHdr);
2669	break;
2670
2671	case VMMDevReq_GetStatisticsChangeRequest:
2672	pReqHdr->rc = vmmdevReqHandler_GetStatisticsChangeRequest(pThis, pReqHdr);
2673	break;
2674
2675	case VMMDevReq_ReportGuestStats:
2676	pReqHdr->rc = vmmdevReqHandler_ReportGuestStats(pThis, pReqHdr);
2677	break;
2678
2679	case VMMDevReq_QueryCredentials:
2680	pReqHdr->rc = vmmdevReqHandler_QueryCredentials(pThis, pReqHdr);
2681	break;
2682
2683	case VMMDevReq_ReportCredentialsJudgement:
2684	pReqHdr->rc = vmmdevReqHandler_ReportCredentialsJudgement(pThis, pReqHdr);
2685	break;
2686
2687	case VMMDevReq_GetHostVersion:
2688	pReqHdr->rc = vmmdevReqHandler_GetHostVersion(pReqHdr);
2689	break;
2690
2691	case VMMDevReq_GetCpuHotPlugRequest:
2692	pReqHdr->rc = vmmdevReqHandler_GetCpuHotPlugRequest(pThis, pReqHdr);
2693	break;
2694
2695	case VMMDevReq_SetCpuHotPlugStatus:
2696	pReqHdr->rc = vmmdevReqHandler_SetCpuHotPlugStatus(pThis, pReqHdr);
2697	break;
2698
2699	#ifdef VBOX_WITH_PAGE_SHARING
2700	case VMMDevReq_RegisterSharedModule:
2701	pReqHdr->rc = vmmdevReqHandler_RegisterSharedModule(pThis, pReqHdr);
2702	break;
2703
2704	case VMMDevReq_UnregisterSharedModule:
2705	pReqHdr->rc = vmmdevReqHandler_UnregisterSharedModule(pThis, pReqHdr);
2706	break;
2707
2708	case VMMDevReq_CheckSharedModules:
2709	pReqHdr->rc = vmmdevReqHandler_CheckSharedModules(pThis, pReqHdr);
2710	break;
2711
2712	case VMMDevReq_GetPageSharingStatus:
2713	pReqHdr->rc = vmmdevReqHandler_GetPageSharingStatus(pThis, pReqHdr);
2714	break;
2715
2716	case VMMDevReq_DebugIsPageShared:
2717	pReqHdr->rc = vmmdevReqHandler_DebugIsPageShared(pThis, pReqHdr);
2718	break;
2719
2720	#endif /* VBOX_WITH_PAGE_SHARING */
2721
2722	#ifdef DEBUG
2723	case VMMDevReq_LogString:
2724	pReqHdr->rc = vmmdevReqHandler_LogString(pReqHdr);
2725	break;
2726	#endif
2727
2728	case VMMDevReq_GetSessionId:
2729	pReqHdr->rc = vmmdevReqHandler_GetSessionId(pThis, pReqHdr);
2730	break;
2731
2732	/*
2733	* Guest wants to give up a timeslice.
2734	* Note! This was only ever used by experimental GAs!
2735	*/
2736	/** @todo maybe we could just remove this? */
2737	case VMMDevReq_Idle:
2738	{
2739	/* just return to EMT telling it that we want to halt */
2740	rcRet = VINF_EM_HALT;
2741	break;
2742	}
2743
2744	case VMMDevReq_GuestHeartbeat:
2745	pReqHdr->rc = vmmDevReqHandler_GuestHeartbeat(pThis);
2746	break;
2747
2748	case VMMDevReq_HeartbeatConfigure:
2749	pReqHdr->rc = vmmDevReqHandler_HeartbeatConfigure(pThis, pReqHdr);
2750	break;
2751
2752	default:
2753	{
2754	pReqHdr->rc = VERR_NOT_IMPLEMENTED;
2755	Log(("VMMDev unknown request type %d\n", pReqHdr->requestType));
2756	break;
2757	}
2758	}
2759	return rcRet;
2760	}
2761
2762
2763	/**
2764	* @callback_method_impl{FNIOMIOPORTOUT, Port I/O Handler for the generic
2765	* request interface.}
2766	*/
2767	static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2768	{
2769	RT_NOREF2(Port, cb);
2770	PVMMDEV pThis = (VMMDevState*)pvUser;
2771
2772	/*
2773	* The caller has passed the guest context physical address of the request
2774	* structure. We'll copy all of it into a heap buffer eventually, but we
2775	* will have to start off with the header.
2776	*/
2777	VMMDevRequestHeader requestHeader;
2778	RT_ZERO(requestHeader);
2779	PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
2780
2781	/* The structure size must be greater or equal to the header size. */
2782	if (requestHeader.size < sizeof(VMMDevRequestHeader))
2783	{
2784	Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
2785	return VINF_SUCCESS;
2786	}
2787
2788	/* Check the version of the header structure. */
2789	if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
2790	{
2791	Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
2792	return VINF_SUCCESS;
2793	}
2794
2795	Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
2796
2797	int rcRet = VINF_SUCCESS;
2798	bool fDelayedUnlock = false;
2799	VMMDevRequestHeader *pRequestHeader = NULL;
2800
2801	/* Check that is doesn't exceed the max packet size. */
2802	if (requestHeader.size <= VMMDEV_MAX_VMMDEVREQ_SIZE)
2803	{
2804	/*
2805	* We require the GAs to report it's information before we let it have
2806	* access to all the functions. The VMMDevReq_ReportGuestInfo request
2807	* is the one which unlocks the access. Newer additions will first
2808	* issue VMMDevReq_ReportGuestInfo2, older ones doesn't know this one.
2809	* Two exceptions: VMMDevReq_GetHostVersion and VMMDevReq_WriteCoreDump.
2810	*/
2811	if ( pThis->fu32AdditionsOk
2812	\|\| requestHeader.requestType == VMMDevReq_ReportGuestInfo2
2813	\|\| requestHeader.requestType == VMMDevReq_ReportGuestInfo
2814	\|\| requestHeader.requestType == VMMDevReq_WriteCoreDump
2815	\|\| requestHeader.requestType == VMMDevReq_GetHostVersion
2816	)
2817	{
2818	/*
2819	* The request looks fine. Allocate a heap block for it, read the
2820	* entire package from guest memory and feed it to the dispatcher.
2821	*/
2822	pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
2823	if (pRequestHeader)
2824	{
2825	memcpy(pRequestHeader, &requestHeader, sizeof(VMMDevRequestHeader));
2826	size_t cbLeft = requestHeader.size - sizeof(VMMDevRequestHeader);
2827	if (cbLeft)
2828	PDMDevHlpPhysRead(pDevIns,
2829	(RTGCPHYS)u32 + sizeof(VMMDevRequestHeader),
2830	(uint8_t *)pRequestHeader + sizeof(VMMDevRequestHeader),
2831	cbLeft);
2832
2833	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
2834	rcRet = vmmdevReqDispatcher(pThis, pRequestHeader, u32, &fDelayedUnlock);
2835	if (!fDelayedUnlock)
2836	PDMCritSectLeave(&pThis->CritSect);
2837	}
2838	else
2839	{
2840	Log(("VMMDev: RTMemAlloc failed!\n"));
2841	requestHeader.rc = VERR_NO_MEMORY;
2842	}
2843	}
2844	else
2845	{
2846	LogRelMax(10, ("VMMDev: Guest has not yet reported to us -- refusing operation of request #%d\n",
2847	requestHeader.requestType));
2848	requestHeader.rc = VERR_NOT_SUPPORTED;
2849	}
2850	}
2851	else
2852	{
2853	LogRelMax(50, ("VMMDev: Request packet too big (%x), refusing operation\n", requestHeader.size));
2854	requestHeader.rc = VERR_NOT_SUPPORTED;
2855	}
2856
2857	/*
2858	* Write the result back to guest memory
2859	*/
2860	if (pRequestHeader)
2861	{
2862	PDMDevHlpPhysWrite(pDevIns, u32, pRequestHeader, pRequestHeader->size);
2863	if (fDelayedUnlock)
2864	PDMCritSectLeave(&pThis->CritSect);
2865	RTMemFree(pRequestHeader);
2866	}
2867	else
2868	{
2869	/* early error case; write back header only */
2870	PDMDevHlpPhysWrite(pDevIns, u32, &requestHeader, sizeof(requestHeader));
2871	Assert(!fDelayedUnlock);
2872	}
2873
2874	return rcRet;
2875	}
2876
2877
2878	/* -=-=-=-=-=- PCI Device -=-=-=-=-=- */
2879
2880
2881	/**
2882	* @callback_method_impl{FNPCIIOREGIONMAP,MMIO/MMIO2 regions}
2883	*/
2884	static DECLCALLBACK(int) vmmdevIORAMRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2885	RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2886	{
2887	RT_NOREF1(cb);
2888	LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%RGp enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
2889	PVMMDEV pThis = RT_FROM_MEMBER(pPciDev, VMMDEV, PciDev);
2890	int rc;
2891
2892	if (iRegion == 1)
2893	{
2894	AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
2895	Assert(pThis->pVMMDevRAMR3 != NULL);
2896	if (GCPhysAddress != NIL_RTGCPHYS)
2897	{
2898	/*
2899	* Map the MMIO2 memory.
2900	*/
2901	pThis->GCPhysVMMDevRAM = GCPhysAddress;
2902	Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
2903	rc = PDMDevHlpMMIOExMap(pDevIns, pPciDev, iRegion, GCPhysAddress);
2904	}
2905	else
2906	{
2907	/*
2908	* It is about to be unmapped, just clean up.
2909	*/
2910	pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
2911	rc = VINF_SUCCESS;
2912	}
2913	}
2914	else if (iRegion == 2)
2915	{
2916	AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
2917	Assert(pThis->pVMMDevHeapR3 != NULL);
2918	if (GCPhysAddress != NIL_RTGCPHYS)
2919	{
2920	/*
2921	* Map the MMIO2 memory.
2922	*/
2923	pThis->GCPhysVMMDevHeap = GCPhysAddress;
2924	Assert(pThis->GCPhysVMMDevHeap == GCPhysAddress);
2925	rc = PDMDevHlpMMIOExMap(pDevIns, pPciDev, iRegion, GCPhysAddress);
2926	if (RT_SUCCESS(rc))
2927	rc = PDMDevHlpRegisterVMMDevHeap(pDevIns, GCPhysAddress, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
2928	}
2929	else
2930	{
2931	/*
2932	* It is about to be unmapped, just clean up.
2933	*/
2934	PDMDevHlpRegisterVMMDevHeap(pDevIns, NIL_RTGCPHYS, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
2935	pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
2936	rc = VINF_SUCCESS;
2937	}
2938	}
2939	else
2940	{
2941	AssertMsgFailed(("%d\n", iRegion));
2942	rc = VERR_INVALID_PARAMETER;
2943	}
2944
2945	return rc;
2946	}
2947
2948
2949	/**
2950	* @callback_method_impl{FNPCIIOREGIONMAP,I/O Port Region}
2951	*/
2952	static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
2953	RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
2954	{
2955	RT_NOREF3(iRegion, cb, enmType);
2956	PVMMDEV pThis = RT_FROM_MEMBER(pPciDev, VMMDEV, PciDev);
2957
2958	Assert(enmType == PCI_ADDRESS_SPACE_IO);
2959	Assert(iRegion == 0);
2960	AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
2961
2962	/*
2963	* Register our port IO handlers.
2964	*/
2965	int rc = PDMDevHlpIOPortRegister(pDevIns, (RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
2966	pThis, vmmdevRequestHandler, NULL, NULL, NULL, "VMMDev Request Handler");
2967	AssertRC(rc);
2968	return rc;
2969	}
2970
2971
2972
2973	/* -=-=-=-=-=- Backdoor Logging and Time Sync. -=-=-=-=-=- */
2974
2975	/**
2976	* @callback_method_impl{FNIOMIOPORTOUT, Backdoor Logging.}
2977	*/
2978	static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
2979	{
2980	RT_NOREF1(pvUser);
2981	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
2982
2983	if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
2984	{
2985
2986	/* The raw version. */
2987	switch (u32)
2988	{
2989	case '\r': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
2990	case '\n': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
2991	case '\t': LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
2992	default: LogIt(RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
2993	}
2994
2995	/* The readable, buffered version. */
2996	if (u32 == '\n' \|\| u32 == '\r')
2997	{
2998	pThis->szMsg[pThis->iMsg] = '\0';
2999	if (pThis->iMsg)
3000	LogRelIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
3001	pThis->iMsg = 0;
3002	}
3003	else
3004	{
3005	if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
3006	{
3007	pThis->szMsg[pThis->iMsg] = '\0';
3008	LogRelIt(RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("VMMDev: Guest Log: %s\n", pThis->szMsg));
3009	pThis->iMsg = 0;
3010	}
3011	pThis->szMsg[pThis->iMsg] = (char )u32;
3012	pThis->szMsg[++pThis->iMsg] = '\0';
3013	}
3014	}
3015	return VINF_SUCCESS;
3016	}
3017
3018	#ifdef VMMDEV_WITH_ALT_TIMESYNC
3019
3020	/**
3021	* @callback_method_impl{FNIOMIOPORTOUT, Alternative time synchronization.}
3022	*/
3023	static DECLCALLBACK(int) vmmdevAltTimeSyncWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
3024	{
3025	RT_NOREF2(pvUser, Port);
3026	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
3027	if (cb == 4)
3028	{
3029	/* Selects high (0) or low (1) DWORD. The high has to be read first. */
3030	switch (u32)
3031	{
3032	case 0:
3033	pThis->fTimesyncBackdoorLo = false;
3034	break;
3035	case 1:
3036	pThis->fTimesyncBackdoorLo = true;
3037	break;
3038	default:
3039	Log(("vmmdevAltTimeSyncWrite: Invalid access cb=%#x u32=%#x\n", cb, u32));
3040	break;
3041	}
3042	}
3043	else
3044	Log(("vmmdevAltTimeSyncWrite: Invalid access cb=%#x u32=%#x\n", cb, u32));
3045	return VINF_SUCCESS;
3046	}
3047
3048	/**
3049	* @callback_method_impl{FNIOMIOPORTOUT, Alternative time synchronization.}
3050	*/
3051	static DECLCALLBACK(int) vmmdevAltTimeSyncRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
3052	{
3053	RT_NOREF2(pvUser, Port);
3054	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, VMMDevState *);
3055	int rc;
3056	if (cb == 4)
3057	{
3058	if (pThis->fTimesyncBackdoorLo)
3059	*pu32 = (uint32_t)pThis->hostTime;
3060	else
3061	{
3062	/* Reading the high dword gets and saves the current time. */
3063	RTTIMESPEC Now;
3064	pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &Now));
3065	*pu32 = (uint32_t)(pThis->hostTime >> 32);
3066	}
3067	rc = VINF_SUCCESS;
3068	}
3069	else
3070	{
3071	Log(("vmmdevAltTimeSyncRead: Invalid access cb=%#x\n", cb));
3072	rc = VERR_IOM_IOPORT_UNUSED;
3073	}
3074	return rc;
3075	}
3076
3077	#endif /* VMMDEV_WITH_ALT_TIMESYNC */
3078
3079
3080	/* -=-=-=-=-=- IBase -=-=-=-=-=- */
3081
3082	/**
3083	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
3084	*/
3085	static DECLCALLBACK(void ) vmmdevPortQueryInterface(PPDMIBASE pInterface, const char pszIID)
3086	{
3087	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IBase);
3088
3089	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
3090	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIVMMDEVPORT, &pThis->IPort);
3091	#ifdef VBOX_WITH_HGCM
3092	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHGCMPORT, &pThis->IHGCMPort);
3093	#endif
3094	/* Currently only for shared folders. */
3095	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->SharedFolders.ILeds);
3096	return NULL;
3097	}
3098
3099
3100	/* -=-=-=-=-=- ILeds -=-=-=-=-=- */
3101
3102	/**
3103	* Gets the pointer to the status LED of a unit.
3104	*
3105	* @returns VBox status code.
3106	* @param pInterface Pointer to the interface structure containing the called function pointer.
3107	* @param iLUN The unit which status LED we desire.
3108	* @param ppLed Where to store the LED pointer.
3109	*/
3110	static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
3111	{
3112	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, SharedFolders.ILeds);
3113	if (iLUN == 0) /* LUN 0 is shared folders */
3114	{
3115	*ppLed = &pThis->SharedFolders.Led;
3116	return VINF_SUCCESS;
3117	}
3118	return VERR_PDM_LUN_NOT_FOUND;
3119	}
3120
3121
3122	/* -=-=-=-=-=- PDMIVMMDEVPORT (VMMDEV::IPort) -=-=-=-=-=- */
3123
3124	/**
3125	* @interface_method_impl{PDMIVMMDEVPORT,pfnQueryAbsoluteMouse}
3126	*/
3127	static DECLCALLBACK(int) vmmdevIPort_QueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, int32_t pxAbs, int32_t pyAbs)
3128	{
3129	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3130
3131	/** @todo at the first sign of trouble in this area, just enter the critsect.
3132	* As indicated by the comment below, the atomic reads serves no real purpose
3133	* here since we can assume cache coherency protocoles and int32_t alignment
3134	* rules making sure we won't see a halfwritten value. */
3135	if (pxAbs)
3136	pxAbs = ASMAtomicReadS32(&pThis->mouseXAbs); / why the atomic read? */
3137	if (pyAbs)
3138	*pyAbs = ASMAtomicReadS32(&pThis->mouseYAbs);
3139
3140	return VINF_SUCCESS;
3141	}
3142
3143	/**
3144	* @interface_method_impl{PDMIVMMDEVPORT,pfnSetAbsoluteMouse}
3145	*/
3146	static DECLCALLBACK(int) vmmdevIPort_SetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, int32_t xAbs, int32_t yAbs)
3147	{
3148	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3149	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3150
3151	if ( pThis->mouseXAbs != xAbs
3152	\|\| pThis->mouseYAbs != yAbs)
3153	{
3154	Log2(("vmmdevIPort_SetAbsoluteMouse : settings absolute position to x = %d, y = %d\n", xAbs, yAbs));
3155	pThis->mouseXAbs = xAbs;
3156	pThis->mouseYAbs = yAbs;
3157	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
3158	}
3159
3160	PDMCritSectLeave(&pThis->CritSect);
3161	return VINF_SUCCESS;
3162	}
3163
3164	/**
3165	* @interface_method_impl{PDMIVMMDEVPORT,pfnQueryMouseCapabilities}
3166	*/
3167	static DECLCALLBACK(int) vmmdevIPort_QueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pfCapabilities)
3168	{
3169	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3170	AssertPtrReturn(pfCapabilities, VERR_INVALID_PARAMETER);
3171
3172	*pfCapabilities = pThis->mouseCapabilities;
3173	return VINF_SUCCESS;
3174	}
3175
3176	/**
3177	* @interface_method_impl{PDMIVMMDEVPORT,pfnUpdateMouseCapabilities}
3178	*/
3179	static DECLCALLBACK(int)
3180	vmmdevIPort_UpdateMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t fCapsAdded, uint32_t fCapsRemoved)
3181	{
3182	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3183	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3184
3185	uint32_t fOldCaps = pThis->mouseCapabilities;
3186	pThis->mouseCapabilities &= ~(fCapsRemoved & VMMDEV_MOUSE_HOST_MASK);
3187	pThis->mouseCapabilities \|= (fCapsAdded & VMMDEV_MOUSE_HOST_MASK)
3188	\| VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
3189	bool fNotify = fOldCaps != pThis->mouseCapabilities;
3190
3191	LogRelFlow(("VMMDev: vmmdevIPort_UpdateMouseCapabilities: fCapsAdded=0x%x, fCapsRemoved=0x%x, fNotify=%RTbool\n", fCapsAdded,
3192	fCapsRemoved, fNotify));
3193
3194	if (fNotify)
3195	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
3196
3197	PDMCritSectLeave(&pThis->CritSect);
3198	return VINF_SUCCESS;
3199	}
3200
3201	/**
3202	* @interface_method_impl{PDMIVMMDEVPORT,pfnRequestDisplayChange}
3203	*/
3204	static DECLCALLBACK(int)
3205	vmmdevIPort_RequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBits, uint32_t idxDisplay,
3206	int32_t xOrigin, int32_t yOrigin, bool fEnabled, bool fChangeOrigin)
3207	{
3208	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3209
3210	if (idxDisplay >= RT_ELEMENTS(pThis->displayChangeData.aRequests))
3211	return VERR_INVALID_PARAMETER;
3212
3213	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3214
3215	DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[idxDisplay];
3216
3217	/* Verify that the new resolution is different and that guest does not yet know about it. */
3218	bool fSameResolution = (!cx \|\| pRequest->lastReadDisplayChangeRequest.xres == cx)
3219	&& (!cy \|\| pRequest->lastReadDisplayChangeRequest.yres == cy)
3220	&& (!cBits \|\| pRequest->lastReadDisplayChangeRequest.bpp == cBits)
3221	&& pRequest->lastReadDisplayChangeRequest.xOrigin == xOrigin
3222	&& pRequest->lastReadDisplayChangeRequest.yOrigin == yOrigin
3223	&& pRequest->lastReadDisplayChangeRequest.fEnabled == fEnabled
3224	&& pRequest->lastReadDisplayChangeRequest.display == idxDisplay;
3225
3226	if (!cx && !cy && !cBits)
3227	{
3228	/* Special case of reset video mode. */
3229	fSameResolution = false;
3230	}
3231
3232	Log3(("vmmdevIPort_RequestDisplayChange: same=%d. new: cx=%d, cy=%d, cBits=%d, idxDisplay=%d.\
3233	old: cx=%d, cy=%d, cBits=%d, idxDisplay=%d. \n \
3234	,OriginX = %d , OriginY=%d, Enabled=%d, ChangeOrigin=%d\n",
3235	fSameResolution, cx, cy, cBits, idxDisplay, pRequest->lastReadDisplayChangeRequest.xres,
3236	pRequest->lastReadDisplayChangeRequest.yres, pRequest->lastReadDisplayChangeRequest.bpp,
3237	pRequest->lastReadDisplayChangeRequest.display,
3238	xOrigin, yOrigin, fEnabled, fChangeOrigin));
3239
3240	/* we could validate the information here but hey, the guest can do that as well! */
3241	pRequest->displayChangeRequest.xres = cx;
3242	pRequest->displayChangeRequest.yres = cy;
3243	pRequest->displayChangeRequest.bpp = cBits;
3244	pRequest->displayChangeRequest.display = idxDisplay;
3245	pRequest->displayChangeRequest.xOrigin = xOrigin;
3246	pRequest->displayChangeRequest.yOrigin = yOrigin;
3247	pRequest->displayChangeRequest.fEnabled = fEnabled;
3248	pRequest->displayChangeRequest.fChangeOrigin = fChangeOrigin;
3249
3250	pRequest->fPending = !fSameResolution;
3251
3252	if (!fSameResolution)
3253	{
3254	LogRel(("VMMDev: SetVideoModeHint: Got a video mode hint (%dx%dx%d)@(%dx%d),(%d;%d) at %d\n",
3255	cx, cy, cBits, xOrigin, yOrigin, fEnabled, fChangeOrigin, idxDisplay));
3256
3257	/* IRQ so the guest knows what's going on */
3258	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
3259	}
3260
3261	PDMCritSectLeave(&pThis->CritSect);
3262	return VINF_SUCCESS;
3263	}
3264
3265	/**
3266	* @interface_method_impl{PDMIVMMDEVPORT,pfnRequestSeamlessChange}
3267	*/
3268	static DECLCALLBACK(int) vmmdevIPort_RequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
3269	{
3270	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3271	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3272
3273	/* Verify that the new resolution is different and that guest does not yet know about it. */
3274	bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
3275
3276	Log(("vmmdevIPort_RequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
3277
3278	if (!fSameMode)
3279	{
3280	/* we could validate the information here but hey, the guest can do that as well! */
3281	pThis->fSeamlessEnabled = fEnabled;
3282
3283	/* IRQ so the guest knows what's going on */
3284	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
3285	}
3286
3287	PDMCritSectLeave(&pThis->CritSect);
3288	return VINF_SUCCESS;
3289	}
3290
3291	/**
3292	* @interface_method_impl{PDMIVMMDEVPORT,pfnSetMemoryBalloon}
3293	*/
3294	static DECLCALLBACK(int) vmmdevIPort_SetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t cMbBalloon)
3295	{
3296	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3297	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3298
3299	/* Verify that the new resolution is different and that guest does not yet know about it. */
3300	Log(("vmmdevIPort_SetMemoryBalloon: old=%u new=%u\n", pThis->cMbMemoryBalloonLast, cMbBalloon));
3301	if (pThis->cMbMemoryBalloonLast != cMbBalloon)
3302	{
3303	/* we could validate the information here but hey, the guest can do that as well! */
3304	pThis->cMbMemoryBalloon = cMbBalloon;
3305
3306	/* IRQ so the guest knows what's going on */
3307	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
3308	}
3309
3310	PDMCritSectLeave(&pThis->CritSect);
3311	return VINF_SUCCESS;
3312	}
3313
3314	/**
3315	* @interface_method_impl{PDMIVMMDEVPORT,pfnVRDPChange}
3316	*/
3317	static DECLCALLBACK(int) vmmdevIPort_VRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t uVRDPExperienceLevel)
3318	{
3319	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3320	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3321
3322	bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
3323
3324	Log(("vmmdevIPort_VRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
3325
3326	if (!fSame)
3327	{
3328	pThis->fVRDPEnabled = fVRDPEnabled;
3329	pThis->uVRDPExperienceLevel = uVRDPExperienceLevel;
3330
3331	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_VRDP);
3332	}
3333
3334	PDMCritSectLeave(&pThis->CritSect);
3335	return VINF_SUCCESS;
3336	}
3337
3338	/**
3339	* @interface_method_impl{PDMIVMMDEVPORT,pfnSetStatisticsInterval}
3340	*/
3341	static DECLCALLBACK(int) vmmdevIPort_SetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t cSecsStatInterval)
3342	{
3343	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3344	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3345
3346	/* Verify that the new resolution is different and that guest does not yet know about it. */
3347	bool fSame = (pThis->u32LastStatIntervalSize == cSecsStatInterval);
3348
3349	Log(("vmmdevIPort_SetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, cSecsStatInterval));
3350
3351	if (!fSame)
3352	{
3353	/* we could validate the information here but hey, the guest can do that as well! */
3354	pThis->u32StatIntervalSize = cSecsStatInterval;
3355
3356	/* IRQ so the guest knows what's going on */
3357	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
3358	}
3359
3360	PDMCritSectLeave(&pThis->CritSect);
3361	return VINF_SUCCESS;
3362	}
3363
3364	/**
3365	* @interface_method_impl{PDMIVMMDEVPORT,pfnSetCredentials}
3366	*/
3367	static DECLCALLBACK(int) vmmdevIPort_SetCredentials(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
3368	const char pszPassword, const char pszDomain, uint32_t fFlags)
3369	{
3370	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3371	AssertReturn(fFlags & (VMMDEV_SETCREDENTIALS_GUESTLOGON \| VMMDEV_SETCREDENTIALS_JUDGE), VERR_INVALID_PARAMETER);
3372
3373	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3374
3375	/*
3376	* Logon mode
3377	*/
3378	if (fFlags & VMMDEV_SETCREDENTIALS_GUESTLOGON)
3379	{
3380	/* memorize the data */
3381	strcpy(pThis->pCredentials->Logon.szUserName, pszUsername);
3382	strcpy(pThis->pCredentials->Logon.szPassword, pszPassword);
3383	strcpy(pThis->pCredentials->Logon.szDomain, pszDomain);
3384	pThis->pCredentials->Logon.fAllowInteractiveLogon = !(fFlags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
3385	}
3386	/*
3387	* Credentials verification mode?
3388	*/
3389	else
3390	{
3391	/* memorize the data */
3392	strcpy(pThis->pCredentials->Judge.szUserName, pszUsername);
3393	strcpy(pThis->pCredentials->Judge.szPassword, pszPassword);
3394	strcpy(pThis->pCredentials->Judge.szDomain, pszDomain);
3395
3396	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
3397	}
3398
3399	PDMCritSectLeave(&pThis->CritSect);
3400	return VINF_SUCCESS;
3401	}
3402
3403	/**
3404	* @interface_method_impl{PDMIVMMDEVPORT,pfnVBVAChange}
3405	*
3406	* Notification from the Display. Especially useful when acceleration is
3407	* disabled after a video mode change.
3408	*/
3409	static DECLCALLBACK(void) vmmdevIPort_VBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
3410	{
3411	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3412	Log(("vmmdevIPort_VBVAChange: fEnabled = %d\n", fEnabled));
3413
3414	/* Only used by saved state, which I guess is why we don't bother with locking here. */
3415	pThis->u32VideoAccelEnabled = fEnabled;
3416	}
3417
3418	/**
3419	* @interface_method_impl{PDMIVMMDEVPORT,pfnCpuHotUnplug}
3420	*/
3421	static DECLCALLBACK(int) vmmdevIPort_CpuHotUnplug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
3422	{
3423	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3424	int rc = VINF_SUCCESS;
3425
3426	Log(("vmmdevIPort_CpuHotUnplug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
3427
3428	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3429
3430	if (pThis->fCpuHotPlugEventsEnabled)
3431	{
3432	pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Unplug;
3433	pThis->idCpuCore = idCpuCore;
3434	pThis->idCpuPackage = idCpuPackage;
3435	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_CPU_HOTPLUG);
3436	}
3437	else
3438	rc = VERR_VMMDEV_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
3439
3440	PDMCritSectLeave(&pThis->CritSect);
3441	return rc;
3442	}
3443
3444	/**
3445	* @interface_method_impl{PDMIVMMDEVPORT,pfnCpuHotPlug}
3446	*/
3447	static DECLCALLBACK(int) vmmdevIPort_CpuHotPlug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
3448	{
3449	PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
3450	int rc = VINF_SUCCESS;
3451
3452	Log(("vmmdevCpuPlug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
3453
3454	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3455
3456	if (pThis->fCpuHotPlugEventsEnabled)
3457	{
3458	pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Plug;
3459	pThis->idCpuCore = idCpuCore;
3460	pThis->idCpuPackage = idCpuPackage;
3461	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_CPU_HOTPLUG);
3462	}
3463	else
3464	rc = VERR_VMMDEV_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
3465
3466	PDMCritSectLeave(&pThis->CritSect);
3467	return rc;
3468	}
3469
3470
3471	/* -=-=-=-=-=- Saved State -=-=-=-=-=- */
3472
3473	/**
3474	* @callback_method_impl{FNSSMDEVLIVEEXEC}
3475	*/
3476	static DECLCALLBACK(int) vmmdevLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
3477	{
3478	RT_NOREF1(uPass);
3479	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3480
3481	SSMR3PutBool(pSSM, pThis->fGetHostTimeDisabled);
3482	SSMR3PutBool(pSSM, pThis->fBackdoorLogDisabled);
3483	SSMR3PutBool(pSSM, pThis->fKeepCredentials);
3484	SSMR3PutBool(pSSM, pThis->fHeapEnabled);
3485
3486	return VINF_SSM_DONT_CALL_AGAIN;
3487	}
3488
3489
3490	/**
3491	* @callback_method_impl{FNSSMDEVSAVEEXEC}
3492	*/
3493	static DECLCALLBACK(int) vmmdevSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
3494	{
3495	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3496	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3497
3498	vmmdevLiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
3499
3500	SSMR3PutU32(pSSM, pThis->hypervisorSize);
3501	SSMR3PutU32(pSSM, pThis->mouseCapabilities);
3502	SSMR3PutS32(pSSM, pThis->mouseXAbs);
3503	SSMR3PutS32(pSSM, pThis->mouseYAbs);
3504
3505	SSMR3PutBool(pSSM, pThis->fNewGuestFilterMask);
3506	SSMR3PutU32(pSSM, pThis->u32NewGuestFilterMask);
3507	SSMR3PutU32(pSSM, pThis->u32GuestFilterMask);
3508	SSMR3PutU32(pSSM, pThis->u32HostEventFlags);
3509	/* The following is not strictly necessary as PGM restores MMIO2, keeping it for historical reasons. */
3510	SSMR3PutMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof(pThis->pVMMDevRAMR3->V));
3511
3512	SSMR3PutMem(pSSM, &pThis->guestInfo, sizeof(pThis->guestInfo));
3513	SSMR3PutU32(pSSM, pThis->fu32AdditionsOk);
3514	SSMR3PutU32(pSSM, pThis->u32VideoAccelEnabled);
3515	SSMR3PutBool(pSSM, pThis->displayChangeData.fGuestSentChangeEventAck);
3516
3517	SSMR3PutU32(pSSM, pThis->guestCaps);
3518
3519	#ifdef VBOX_WITH_HGCM
3520	vmmdevHGCMSaveState(pThis, pSSM);
3521	#endif /* VBOX_WITH_HGCM */
3522
3523	SSMR3PutU32(pSSM, pThis->fHostCursorRequested);
3524
3525	SSMR3PutU32(pSSM, pThis->guestInfo2.uFullVersion);
3526	SSMR3PutU32(pSSM, pThis->guestInfo2.uRevision);
3527	SSMR3PutU32(pSSM, pThis->guestInfo2.fFeatures);
3528	SSMR3PutStrZ(pSSM, pThis->guestInfo2.szName);
3529	SSMR3PutU32(pSSM, pThis->cFacilityStatuses);
3530	for (uint32_t i = 0; i < pThis->cFacilityStatuses; i++)
3531	{
3532	SSMR3PutU32(pSSM, pThis->aFacilityStatuses[i].enmFacility);
3533	SSMR3PutU32(pSSM, pThis->aFacilityStatuses[i].fFlags);
3534	SSMR3PutU16(pSSM, (uint16_t)pThis->aFacilityStatuses[i].enmStatus);
3535	SSMR3PutS64(pSSM, RTTimeSpecGetNano(&pThis->aFacilityStatuses[i].TimeSpecTS));
3536	}
3537
3538	/* Heartbeat: */
3539	SSMR3PutBool(pSSM, pThis->fHeartbeatActive);
3540	SSMR3PutBool(pSSM, pThis->fFlatlined);
3541	SSMR3PutU64(pSSM, pThis->nsLastHeartbeatTS);
3542	TMR3TimerSave(pThis->pFlatlinedTimer, pSSM);
3543
3544	PDMCritSectLeave(&pThis->CritSect);
3545	return VINF_SUCCESS;
3546	}
3547
3548	/**
3549	* @callback_method_impl{FNSSMDEVLOADEXEC}
3550	*/
3551	static DECLCALLBACK(int) vmmdevLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
3552	{
3553	/** @todo The code load code is assuming we're always loaded into a freshly
3554	* constructed VM. */
3555	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3556	int rc;
3557
3558	if ( uVersion > VMMDEV_SAVED_STATE_VERSION
3559	\|\| uVersion < 6)
3560	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
3561
3562	/* config */
3563	if (uVersion > VMMDEV_SAVED_STATE_VERSION_VBOX_30)
3564	{
3565	bool f;
3566	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3567	if (pThis->fGetHostTimeDisabled != f)
3568	LogRel(("VMMDev: Config mismatch - fGetHostTimeDisabled: config=%RTbool saved=%RTbool\n", pThis->fGetHostTimeDisabled, f));
3569
3570	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3571	if (pThis->fBackdoorLogDisabled != f)
3572	LogRel(("VMMDev: Config mismatch - fBackdoorLogDisabled: config=%RTbool saved=%RTbool\n", pThis->fBackdoorLogDisabled, f));
3573
3574	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3575	if (pThis->fKeepCredentials != f)
3576	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fKeepCredentials: config=%RTbool saved=%RTbool"),
3577	pThis->fKeepCredentials, f);
3578	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
3579	if (pThis->fHeapEnabled != f)
3580	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fHeapEnabled: config=%RTbool saved=%RTbool"),
3581	pThis->fHeapEnabled, f);
3582	}
3583
3584	if (uPass != SSM_PASS_FINAL)
3585	return VINF_SUCCESS;
3586
3587	/* state */
3588	SSMR3GetU32(pSSM, &pThis->hypervisorSize);
3589	SSMR3GetU32(pSSM, &pThis->mouseCapabilities);
3590	SSMR3GetS32(pSSM, &pThis->mouseXAbs);
3591	SSMR3GetS32(pSSM, &pThis->mouseYAbs);
3592
3593	SSMR3GetBool(pSSM, &pThis->fNewGuestFilterMask);
3594	SSMR3GetU32(pSSM, &pThis->u32NewGuestFilterMask);
3595	SSMR3GetU32(pSSM, &pThis->u32GuestFilterMask);
3596	SSMR3GetU32(pSSM, &pThis->u32HostEventFlags);
3597
3598	//SSMR3GetBool(pSSM, &pThis->pVMMDevRAMR3->fHaveEvents);
3599	// here be dragons (probably)
3600	SSMR3GetMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
3601
3602	SSMR3GetMem(pSSM, &pThis->guestInfo, sizeof (pThis->guestInfo));
3603	SSMR3GetU32(pSSM, &pThis->fu32AdditionsOk);
3604	SSMR3GetU32(pSSM, &pThis->u32VideoAccelEnabled);
3605	if (uVersion > 10)
3606	SSMR3GetBool(pSSM, &pThis->displayChangeData.fGuestSentChangeEventAck);
3607
3608	rc = SSMR3GetU32(pSSM, &pThis->guestCaps);
3609
3610	/* Attributes which were temporarily introduced in r30072 */
3611	if (uVersion == 7)
3612	{
3613	uint32_t temp;
3614	SSMR3GetU32(pSSM, &temp);
3615	rc = SSMR3GetU32(pSSM, &temp);
3616	}
3617	AssertRCReturn(rc, rc);
3618
3619	#ifdef VBOX_WITH_HGCM
3620	rc = vmmdevHGCMLoadState(pThis, pSSM, uVersion);
3621	AssertRCReturn(rc, rc);
3622	#endif /* VBOX_WITH_HGCM */
3623
3624	if (uVersion >= 10)
3625	rc = SSMR3GetU32(pSSM, &pThis->fHostCursorRequested);
3626	AssertRCReturn(rc, rc);
3627
3628	if (uVersion > VMMDEV_SAVED_STATE_VERSION_MISSING_GUEST_INFO_2)
3629	{
3630	SSMR3GetU32(pSSM, &pThis->guestInfo2.uFullVersion);
3631	SSMR3GetU32(pSSM, &pThis->guestInfo2.uRevision);
3632	SSMR3GetU32(pSSM, &pThis->guestInfo2.fFeatures);
3633	rc = SSMR3GetStrZ(pSSM, &pThis->guestInfo2.szName[0], sizeof(pThis->guestInfo2.szName));
3634	AssertRCReturn(rc, rc);
3635	}
3636
3637	if (uVersion > VMMDEV_SAVED_STATE_VERSION_MISSING_FACILITY_STATUSES)
3638	{
3639	uint32_t cFacilityStatuses;
3640	rc = SSMR3GetU32(pSSM, &cFacilityStatuses);
3641	AssertRCReturn(rc, rc);
3642
3643	for (uint32_t i = 0; i < cFacilityStatuses; i++)
3644	{
3645	uint32_t uFacility, fFlags;
3646	uint16_t uStatus;
3647	int64_t iTimeStampNano;
3648
3649	SSMR3GetU32(pSSM, &uFacility);
3650	SSMR3GetU32(pSSM, &fFlags);
3651	SSMR3GetU16(pSSM, &uStatus);
3652	rc = SSMR3GetS64(pSSM, &iTimeStampNano);
3653	AssertRCReturn(rc, rc);
3654
3655	PVMMDEVFACILITYSTATUSENTRY pEntry = vmmdevGetFacilityStatusEntry(pThis, (VBoxGuestFacilityType)uFacility);
3656	AssertLogRelMsgReturn(pEntry,
3657	("VMMDev: Ran out of entries restoring the guest facility statuses. Saved state has %u.\n", cFacilityStatuses),
3658	VERR_OUT_OF_RESOURCES);
3659	pEntry->enmStatus = (VBoxGuestFacilityStatus)uStatus;
3660	pEntry->fFlags = fFlags;
3661	RTTimeSpecSetNano(&pEntry->TimeSpecTS, iTimeStampNano);
3662	}
3663	}
3664
3665	/*
3666	* Heartbeat.
3667	*/
3668	if (uVersion >= VMMDEV_SAVED_STATE_VERSION_HEARTBEAT)
3669	{
3670	SSMR3GetBool(pSSM, (bool *)&pThis->fHeartbeatActive);
3671	SSMR3GetBool(pSSM, (bool *)&pThis->fFlatlined);
3672	SSMR3GetU64(pSSM, (uint64_t *)&pThis->nsLastHeartbeatTS);
3673	rc = TMR3TimerLoad(pThis->pFlatlinedTimer, pSSM);
3674	AssertRCReturn(rc, rc);
3675	if (pThis->fFlatlined)
3676	LogRel(("vmmdevLoadState: Guest has flatlined. Last heartbeat %'RU64 ns before state was saved.\n",
3677	TMTimerGetNano(pThis->pFlatlinedTimer) - pThis->nsLastHeartbeatTS));
3678	}
3679
3680	/*
3681	* On a resume, we send the capabilities changed message so
3682	* that listeners can sync their state again
3683	*/
3684	Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
3685	if (pThis->pDrv)
3686	{
3687	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
3688	if (uVersion >= 10)
3689	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
3690	/fVisible=/!!pThis->fHostCursorRequested,
3691	/fAlpha=/false,
3692	/xHot=/0, /yHot=/0,
3693	/cx=/0, /cy=/0,
3694	/pvShape=/NULL);
3695	}
3696
3697	if (pThis->fu32AdditionsOk)
3698	{
3699	vmmdevLogGuestOsInfo(&pThis->guestInfo);
3700	if (pThis->pDrv)
3701	{
3702	if (pThis->guestInfo2.uFullVersion && pThis->pDrv->pfnUpdateGuestInfo2)
3703	pThis->pDrv->pfnUpdateGuestInfo2(pThis->pDrv, pThis->guestInfo2.uFullVersion, pThis->guestInfo2.szName,
3704	pThis->guestInfo2.uRevision, pThis->guestInfo2.fFeatures);
3705	if (pThis->pDrv->pfnUpdateGuestInfo)
3706	pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
3707
3708	if (pThis->pDrv->pfnUpdateGuestStatus)
3709	{
3710	for (uint32_t i = 0; i < pThis->cFacilityStatuses; i++) /* ascending order! */
3711	if ( pThis->aFacilityStatuses[i].enmStatus != VBoxGuestFacilityStatus_Inactive
3712	\|\| !pThis->aFacilityStatuses[i].fFixed)
3713	pThis->pDrv->pfnUpdateGuestStatus(pThis->pDrv,
3714	pThis->aFacilityStatuses[i].enmFacility,
3715	(uint16_t)pThis->aFacilityStatuses[i].enmStatus,
3716	pThis->aFacilityStatuses[i].fFlags,
3717	&pThis->aFacilityStatuses[i].TimeSpecTS);
3718	}
3719	}
3720	}
3721	if (pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
3722	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
3723
3724	return VINF_SUCCESS;
3725	}
3726
3727	/**
3728	* Load state done callback. Notify guest of restore event.
3729	*
3730	* @returns VBox status code.
3731	* @param pDevIns The device instance.
3732	* @param pSSM The handle to the saved state.
3733	*/
3734	static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
3735	{
3736	RT_NOREF1(pSSM);
3737	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3738
3739	#ifdef VBOX_WITH_HGCM
3740	int rc = vmmdevHGCMLoadStateDone(pThis);
3741	AssertLogRelRCReturn(rc, rc);
3742	#endif /* VBOX_WITH_HGCM */
3743
3744	/* Reestablish the acceleration status. */
3745	if ( pThis->u32VideoAccelEnabled
3746	&& pThis->pDrv)
3747	{
3748	pThis->pDrv->pfnVideoAccelEnable(pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMR3->vbvaMemory);
3749	}
3750
3751	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_RESTORED);
3752
3753	return VINF_SUCCESS;
3754	}
3755
3756
3757	/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
3758
3759	/**
3760	* (Re-)initializes the MMIO2 data.
3761	*
3762	* @param pThis Pointer to the VMMDev instance data.
3763	*/
3764	static void vmmdevInitRam(PVMMDEV pThis)
3765	{
3766	memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
3767	pThis->pVMMDevRAMR3->u32Size = sizeof(VMMDevMemory);
3768	pThis->pVMMDevRAMR3->u32Version = VMMDEV_MEMORY_VERSION;
3769	}
3770
3771
3772	/**
3773	* @interface_method_impl{PDMDEVREG,pfnReset}
3774	*/
3775	static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
3776	{
3777	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3778	PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
3779
3780	/*
3781	* Reset the mouse integration feature bits
3782	*/
3783	if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_MASK)
3784	{
3785	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
3786	/* notify the connector */
3787	Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
3788	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
3789	}
3790	pThis->fHostCursorRequested = false;
3791
3792	pThis->hypervisorSize = 0;
3793
3794	/* re-initialize the VMMDev memory */
3795	if (pThis->pVMMDevRAMR3)
3796	vmmdevInitRam(pThis);
3797
3798	/* credentials have to go away (by default) */
3799	if (!pThis->fKeepCredentials)
3800	{
3801	memset(pThis->pCredentials->Logon.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3802	memset(pThis->pCredentials->Logon.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3803	memset(pThis->pCredentials->Logon.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3804	}
3805	memset(pThis->pCredentials->Judge.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3806	memset(pThis->pCredentials->Judge.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3807	memset(pThis->pCredentials->Judge.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
3808
3809	/* Reset means that additions will report again. */
3810	const bool fVersionChanged = pThis->fu32AdditionsOk
3811	\|\| pThis->guestInfo.interfaceVersion
3812	\|\| pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
3813	if (fVersionChanged)
3814	Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
3815	pThis->fu32AdditionsOk, pThis->guestInfo.interfaceVersion, pThis->guestInfo.osType));
3816	pThis->fu32AdditionsOk = false;
3817	memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
3818	RT_ZERO(pThis->guestInfo2);
3819	const bool fCapsChanged = pThis->guestCaps != 0; /* Report transition to 0. */
3820	pThis->guestCaps = 0;
3821
3822	/* Clear facilities. No need to tell Main as it will get a
3823	pfnUpdateGuestInfo callback. */
3824	RTTIMESPEC TimeStampNow;
3825	RTTimeNow(&TimeStampNow);
3826	uint32_t iFacility = pThis->cFacilityStatuses;
3827	while (iFacility-- > 0)
3828	{
3829	pThis->aFacilityStatuses[iFacility].enmStatus = VBoxGuestFacilityStatus_Inactive;
3830	pThis->aFacilityStatuses[iFacility].TimeSpecTS = TimeStampNow;
3831	}
3832
3833	/* clear pending display change request. */
3834	for (unsigned i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
3835	{
3836	DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[i];
3837	memset (&pRequest->lastReadDisplayChangeRequest, 0, sizeof (pRequest->lastReadDisplayChangeRequest));
3838	}
3839	pThis->displayChangeData.iCurrentMonitor = 0;
3840	pThis->displayChangeData.fGuestSentChangeEventAck = false;
3841
3842	/* disable seamless mode */
3843	pThis->fLastSeamlessEnabled = false;
3844
3845	/* disabled memory ballooning */
3846	pThis->cMbMemoryBalloonLast = 0;
3847
3848	/* disabled statistics updating */
3849	pThis->u32LastStatIntervalSize = 0;
3850
3851	#ifdef VBOX_WITH_HGCM
3852	/* Clear the "HGCM event enabled" flag so the event can be automatically reenabled. */
3853	pThis->u32HGCMEnabled = 0;
3854	#endif
3855
3856	/*
3857	* Deactive heartbeat.
3858	*/
3859	if (pThis->fHeartbeatActive)
3860	{
3861	TMTimerStop(pThis->pFlatlinedTimer);
3862	pThis->fFlatlined = false;
3863	pThis->fHeartbeatActive = true;
3864	}
3865
3866	/*
3867	* Clear the event variables.
3868	*
3869	* XXX By design we should NOT clear pThis->u32HostEventFlags because it is designed
3870	* that way so host events do not depend on guest resets. However, the pending
3871	* event flags actually _were_ cleared since ages so we mask out events from
3872	* clearing which we really need to survive the reset. See xtracker 5767.
3873	*/
3874	pThis->u32HostEventFlags &= VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
3875	pThis->u32GuestFilterMask = 0;
3876	pThis->u32NewGuestFilterMask = 0;
3877	pThis->fNewGuestFilterMask = 0;
3878
3879	/*
3880	* Call the update functions as required.
3881	*/
3882	if (fVersionChanged && pThis->pDrv && pThis->pDrv->pfnUpdateGuestInfo)
3883	pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
3884	if (fCapsChanged && pThis->pDrv && pThis->pDrv->pfnUpdateGuestCapabilities)
3885	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
3886
3887	/*
3888	* Generate a unique session id for this VM; it will be changed for each start, reset or restore.
3889	* This can be used for restore detection inside the guest.
3890	*/
3891	pThis->idSession = ASMReadTSC();
3892
3893	PDMCritSectLeave(&pThis->CritSect);
3894	}
3895
3896
3897	/**
3898	* @interface_method_impl{PDMDEVREG,pfnRelocate}
3899	*/
3900	static DECLCALLBACK(void) vmmdevRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
3901	{
3902	NOREF(pDevIns);
3903	NOREF(offDelta);
3904	}
3905
3906
3907	/**
3908	* @interface_method_impl{PDMDEVREG,pfnDestruct}
3909	*/
3910	static DECLCALLBACK(int) vmmdevDestruct(PPDMDEVINS pDevIns)
3911	{
3912	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3913	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
3914
3915	/*
3916	* Wipe and free the credentials.
3917	*/
3918	if (pThis->pCredentials)
3919	{
3920	RTMemWipeThoroughly(pThis->pCredentials, sizeof(*pThis->pCredentials), 10);
3921	RTMemFree(pThis->pCredentials);
3922	pThis->pCredentials = NULL;
3923	}
3924
3925	#ifdef VBOX_WITH_HGCM
3926	vmmdevHGCMDestroy(pThis);
3927	RTCritSectDelete(&pThis->critsectHGCMCmdList);
3928	#endif
3929
3930	#ifndef VBOX_WITHOUT_TESTING_FEATURES
3931	/*
3932	* Clean up the testing device.
3933	*/
3934	vmmdevTestingTerminate(pDevIns);
3935	#endif
3936
3937	return VINF_SUCCESS;
3938	}
3939
3940
3941	/**
3942	* @interface_method_impl{PDMDEVREG,pfnConstruct}
3943	*/
3944	static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
3945	{
3946	PVMMDEV pThis = PDMINS_2_DATA(pDevIns, PVMMDEV);
3947	int rc;
3948
3949	Assert(iInstance == 0);
3950	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
3951
3952	/*
3953	* Initialize data (most of it anyway).
3954	*/
3955	/* Save PDM device instance data for future reference. */
3956	pThis->pDevIns = pDevIns;
3957
3958	/* PCI vendor, just a free bogus value */
3959	PCIDevSetVendorId(&pThis->PciDev, 0x80ee);
3960	/* device ID */
3961	PCIDevSetDeviceId(&pThis->PciDev, 0xcafe);
3962	/* class sub code (other type of system peripheral) */
3963	PCIDevSetClassSub(&pThis->PciDev, 0x80);
3964	/* class base code (base system peripheral) */
3965	PCIDevSetClassBase(&pThis->PciDev, 0x08);
3966	/* header type */
3967	PCIDevSetHeaderType(&pThis->PciDev, 0x00);
3968	/* interrupt on pin 0 */
3969	PCIDevSetInterruptPin(&pThis->PciDev, 0x01);
3970
3971	RTTIMESPEC TimeStampNow;
3972	RTTimeNow(&TimeStampNow);
3973	vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_VBoxGuestDriver, true /fFixed/, &TimeStampNow);
3974	vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_VBoxService, true /fFixed/, &TimeStampNow);
3975	vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_VBoxTrayClient, true /fFixed/, &TimeStampNow);
3976	vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_Seamless, true /fFixed/, &TimeStampNow);
3977	vmmdevAllocFacilityStatusEntry(pThis, VBoxGuestFacilityType_Graphics, true /fFixed/, &TimeStampNow);
3978	Assert(pThis->cFacilityStatuses == 5);
3979
3980	/*
3981	* Interfaces
3982	*/
3983	/* IBase */
3984	pThis->IBase.pfnQueryInterface = vmmdevPortQueryInterface;
3985
3986	/* VMMDev port */
3987	pThis->IPort.pfnQueryAbsoluteMouse = vmmdevIPort_QueryAbsoluteMouse;
3988	pThis->IPort.pfnSetAbsoluteMouse = vmmdevIPort_SetAbsoluteMouse ;
3989	pThis->IPort.pfnQueryMouseCapabilities = vmmdevIPort_QueryMouseCapabilities;
3990	pThis->IPort.pfnUpdateMouseCapabilities = vmmdevIPort_UpdateMouseCapabilities;
3991	pThis->IPort.pfnRequestDisplayChange = vmmdevIPort_RequestDisplayChange;
3992	pThis->IPort.pfnSetCredentials = vmmdevIPort_SetCredentials;
3993	pThis->IPort.pfnVBVAChange = vmmdevIPort_VBVAChange;
3994	pThis->IPort.pfnRequestSeamlessChange = vmmdevIPort_RequestSeamlessChange;
3995	pThis->IPort.pfnSetMemoryBalloon = vmmdevIPort_SetMemoryBalloon;
3996	pThis->IPort.pfnSetStatisticsInterval = vmmdevIPort_SetStatisticsInterval;
3997	pThis->IPort.pfnVRDPChange = vmmdevIPort_VRDPChange;
3998	pThis->IPort.pfnCpuHotUnplug = vmmdevIPort_CpuHotUnplug;
3999	pThis->IPort.pfnCpuHotPlug = vmmdevIPort_CpuHotPlug;
4000
4001	/* Shared folder LED */
4002	pThis->SharedFolders.Led.u32Magic = PDMLED_MAGIC;
4003	pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
4004
4005	#ifdef VBOX_WITH_HGCM
4006	/* HGCM port */
4007	pThis->IHGCMPort.pfnCompleted = hgcmCompleted;
4008	#endif
4009
4010	pThis->pCredentials = (VMMDEVCREDS )RTMemAllocZ(sizeof(pThis->pCredentials));
4011	if (!pThis->pCredentials)
4012	return VERR_NO_MEMORY;
4013
4014
4015	/*
4016	* Validate and read the configuration.
4017	*/
4018	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns,
4019	"GetHostTimeDisabled\|"
4020	"BackdoorLogDisabled\|"
4021	"KeepCredentials\|"
4022	"HeapEnabled\|"
4023	"RZEnabled\|"
4024	"GuestCoreDumpEnabled\|"
4025	"GuestCoreDumpDir\|"
4026	"GuestCoreDumpCount\|"
4027	"HeartbeatInterval\|"
4028	"HeartbeatTimeout\|"
4029	"TestingEnabled\|"
4030	"TestingMMIO\|"
4031	"TestintXmlOutputFile"
4032	,
4033	"");
4034
4035	rc = CFGMR3QueryBoolDef(pCfg, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled, false);
4036	if (RT_FAILURE(rc))
4037	return PDMDEV_SET_ERROR(pDevIns, rc,
4038	N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
4039
4040	rc = CFGMR3QueryBoolDef(pCfg, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled, false);
4041	if (RT_FAILURE(rc))
4042	return PDMDEV_SET_ERROR(pDevIns, rc,
4043	N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
4044
4045	rc = CFGMR3QueryBoolDef(pCfg, "KeepCredentials", &pThis->fKeepCredentials, false);
4046	if (RT_FAILURE(rc))
4047	return PDMDEV_SET_ERROR(pDevIns, rc,
4048	N_("Configuration error: Failed querying \"KeepCredentials\" as a boolean"));
4049
4050	rc = CFGMR3QueryBoolDef(pCfg, "HeapEnabled", &pThis->fHeapEnabled, true);
4051	if (RT_FAILURE(rc))
4052	return PDMDEV_SET_ERROR(pDevIns, rc,
4053	N_("Configuration error: Failed querying \"HeapEnabled\" as a boolean"));
4054
4055	rc = CFGMR3QueryBoolDef(pCfg, "RZEnabled", &pThis->fRZEnabled, true);
4056	if (RT_FAILURE(rc))
4057	return PDMDEV_SET_ERROR(pDevIns, rc,
4058	N_("Configuration error: Failed querying \"RZEnabled\" as a boolean"));
4059
4060	rc = CFGMR3QueryBoolDef(pCfg, "GuestCoreDumpEnabled", &pThis->fGuestCoreDumpEnabled, false);
4061	if (RT_FAILURE(rc))
4062	return PDMDEV_SET_ERROR(pDevIns, rc,
4063	N_("Configuration error: Failed querying \"GuestCoreDumpEnabled\" as a boolean"));
4064
4065	char *pszGuestCoreDumpDir = NULL;
4066	rc = CFGMR3QueryStringAllocDef(pCfg, "GuestCoreDumpDir", &pszGuestCoreDumpDir, "");
4067	if (RT_FAILURE(rc))
4068	return PDMDEV_SET_ERROR(pDevIns, rc,
4069	N_("Configuration error: Failed querying \"GuestCoreDumpDir\" as a string"));
4070
4071	RTStrCopy(pThis->szGuestCoreDumpDir, sizeof(pThis->szGuestCoreDumpDir), pszGuestCoreDumpDir);
4072	MMR3HeapFree(pszGuestCoreDumpDir);
4073
4074	rc = CFGMR3QueryU32Def(pCfg, "GuestCoreDumpCount", &pThis->cGuestCoreDumps, 3);
4075	if (RT_FAILURE(rc))
4076	return PDMDEV_SET_ERROR(pDevIns, rc,
4077	N_("Configuration error: Failed querying \"GuestCoreDumpCount\" as a 32-bit unsigned integer"));
4078
4079	rc = CFGMR3QueryU64Def(pCfg, "HeartbeatInterval", &pThis->cNsHeartbeatInterval, VMMDEV_HEARTBEAT_DEFAULT_INTERVAL);
4080	if (RT_FAILURE(rc))
4081	return PDMDEV_SET_ERROR(pDevIns, rc,
4082	N_("Configuration error: Failed querying \"HeartbeatInterval\" as a 64-bit unsigned integer"));
4083	if (pThis->cNsHeartbeatInterval < RT_NS_100MS / 2)
4084	return PDMDEV_SET_ERROR(pDevIns, rc,
4085	N_("Configuration error: Heartbeat interval \"HeartbeatInterval\" too small"));
4086
4087	rc = CFGMR3QueryU64Def(pCfg, "HeartbeatTimeout", &pThis->cNsHeartbeatTimeout, pThis->cNsHeartbeatInterval * 2);
4088	if (RT_FAILURE(rc))
4089	return PDMDEV_SET_ERROR(pDevIns, rc,
4090	N_("Configuration error: Failed querying \"HeartbeatTimeout\" as a 64-bit unsigned integer"));
4091	if (pThis->cNsHeartbeatTimeout < RT_NS_100MS)
4092	return PDMDEV_SET_ERROR(pDevIns, rc,
4093	N_("Configuration error: Heartbeat timeout \"HeartbeatTimeout\" too small"));
4094	if (pThis->cNsHeartbeatTimeout <= pThis->cNsHeartbeatInterval + RT_NS_10MS)
4095	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4096	N_("Configuration error: Heartbeat timeout \"HeartbeatTimeout\" value (%'ull ns) is too close to the interval (%'ull ns)"),
4097	pThis->cNsHeartbeatTimeout, pThis->cNsHeartbeatInterval);
4098
4099	#ifndef VBOX_WITHOUT_TESTING_FEATURES
4100	rc = CFGMR3QueryBoolDef(pCfg, "TestingEnabled", &pThis->fTestingEnabled, false);
4101	if (RT_FAILURE(rc))
4102	return PDMDEV_SET_ERROR(pDevIns, rc,
4103	N_("Configuration error: Failed querying \"TestingEnabled\" as a boolean"));
4104	rc = CFGMR3QueryBoolDef(pCfg, "TestingMMIO", &pThis->fTestingMMIO, false);
4105	if (RT_FAILURE(rc))
4106	return PDMDEV_SET_ERROR(pDevIns, rc,
4107	N_("Configuration error: Failed querying \"TestingMMIO\" as a boolean"));
4108	rc = CFGMR3QueryStringAllocDef(pCfg, "TestintXmlOutputFile", &pThis->pszTestingXmlOutput, NULL);
4109	if (RT_FAILURE(rc))
4110	return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed querying \"TestintXmlOutputFile\" as a string"));
4111
4112	/** @todo image-to-load-filename? */
4113	#endif
4114
4115	pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
4116
4117	/*
4118	* We do our own locking entirely. So, install NOP critsect for the device
4119	* and create our own critsect for use where it really matters (++).
4120	*/
4121	rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
4122	AssertRCReturn(rc, rc);
4123	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "VMMDev#%u", iInstance);
4124	AssertRCReturn(rc, rc);
4125
4126	/*
4127	* Register the backdoor logging port
4128	*/
4129	rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog,
4130	NULL, NULL, NULL, "VMMDev backdoor logging");
4131	AssertRCReturn(rc, rc);
4132
4133	#ifdef VMMDEV_WITH_ALT_TIMESYNC
4134	/*
4135	* Alternative timesync source.
4136	*
4137	* This was orignally added for creating a simple time sync service in an
4138	* OpenBSD guest without requiring VBoxGuest and VBoxService to be ported
4139	* first. We keep it in case it comes in handy.
4140	*/
4141	rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL,
4142	vmmdevAltTimeSyncWrite, vmmdevAltTimeSyncRead,
4143	NULL, NULL, "VMMDev timesync backdoor");
4144	AssertRCReturn(rc, rc);
4145	#endif
4146
4147	/*
4148	* Register the PCI device.
4149	*/
4150	rc = PDMDevHlpPCIRegister(pDevIns, &pThis->PciDev);
4151	if (RT_FAILURE(rc))
4152	return rc;
4153	if (pThis->PciDev.uDevFn != 32 \|\| iInstance != 0)
4154	Log(("!!WARNING!!: pThis->PciDev.uDevFn=%d (ignore if testcase or no started by Main)\n", pThis->PciDev.uDevFn));
4155	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
4156	if (RT_FAILURE(rc))
4157	return rc;
4158	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, VMMDEV_RAM_SIZE, PCI_ADDRESS_SPACE_MEM, vmmdevIORAMRegionMap);
4159	if (RT_FAILURE(rc))
4160	return rc;
4161	if (pThis->fHeapEnabled)
4162	{
4163	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, VMMDEV_HEAP_SIZE, PCI_ADDRESS_SPACE_MEM_PREFETCH, vmmdevIORAMRegionMap);
4164	if (RT_FAILURE(rc))
4165	return rc;
4166	}
4167
4168	/*
4169	* Allocate and initialize the MMIO2 memory.
4170	*/
4171	rc = PDMDevHlpMMIO2Register(pDevIns, &pThis->PciDev, 1 /iRegion/, VMMDEV_RAM_SIZE, 0 /fFlags/,
4172	(void **)&pThis->pVMMDevRAMR3, "VMMDev");
4173	if (RT_FAILURE(rc))
4174	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4175	N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
4176	vmmdevInitRam(pThis);
4177
4178	if (pThis->fHeapEnabled)
4179	{
4180	rc = PDMDevHlpMMIO2Register(pDevIns, &pThis->PciDev, 2 /iRegion/, VMMDEV_HEAP_SIZE, 0 /fFlags/,
4181	(void **)&pThis->pVMMDevHeapR3, "VMMDev Heap");
4182	if (RT_FAILURE(rc))
4183	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
4184	N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
4185
4186	/* Register the memory area with PDM so HM can access it before it's mapped. */
4187	rc = PDMDevHlpRegisterVMMDevHeap(pDevIns, NIL_RTGCPHYS, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
4188	AssertLogRelRCReturn(rc, rc);
4189	}
4190
4191	#ifndef VBOX_WITHOUT_TESTING_FEATURES
4192	/*
4193	* Initialize testing.
4194	*/
4195	rc = vmmdevTestingInitialize(pDevIns);
4196	if (RT_FAILURE(rc))
4197	return rc;
4198	#endif
4199
4200	/*
4201	* Get the corresponding connector interface
4202	*/
4203	rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "VMM Driver Port");
4204	if (RT_SUCCESS(rc))
4205	{
4206	pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIVMMDEVCONNECTOR);
4207	AssertMsgReturn(pThis->pDrv, ("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
4208	#ifdef VBOX_WITH_HGCM
4209	pThis->pHGCMDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIHGCMCONNECTOR);
4210	if (!pThis->pHGCMDrv)
4211	{
4212	Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Rrc\n", rc));
4213	/* this is not actually an error, just means that there is no support for HGCM */
4214	}
4215	#endif
4216	/* Query the initial balloon size. */
4217	AssertPtr(pThis->pDrv->pfnQueryBalloonSize);
4218	rc = pThis->pDrv->pfnQueryBalloonSize(pThis->pDrv, &pThis->cMbMemoryBalloon);
4219	AssertRC(rc);
4220
4221	Log(("Initial balloon size %x\n", pThis->cMbMemoryBalloon));
4222	}
4223	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
4224	{
4225	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
4226	rc = VINF_SUCCESS;
4227	}
4228	else
4229	AssertMsgFailedReturn(("Failed to attach LUN #0! rc=%Rrc\n", rc), rc);
4230
4231	/*
4232	* Attach status driver for shared folders (optional).
4233	*/
4234	PPDMIBASE pBase;
4235	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
4236	if (RT_SUCCESS(rc))
4237	pThis->SharedFolders.pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
4238	else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
4239	{
4240	AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
4241	return rc;
4242	}
4243
4244	/*
4245	* Register saved state and init the HGCM CmdList critsect.
4246	*/
4247	rc = PDMDevHlpSSMRegisterEx(pDevIns, VMMDEV_SAVED_STATE_VERSION, sizeof(*pThis), NULL,
4248	NULL, vmmdevLiveExec, NULL,
4249	NULL, vmmdevSaveExec, NULL,
4250	NULL, vmmdevLoadExec, vmmdevLoadStateDone);
4251	AssertRCReturn(rc, rc);
4252
4253	/*
4254	* Create heartbeat checking timer.
4255	*/
4256	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vmmDevHeartbeatFlatlinedTimer, pThis,
4257	TMTIMER_FLAGS_NO_CRIT_SECT, "Heartbeat flatlined", &pThis->pFlatlinedTimer);
4258	AssertRCReturn(rc, rc);
4259
4260	#ifdef VBOX_WITH_HGCM
4261	pThis->pHGCMCmdList = NULL;
4262	rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
4263	AssertRCReturn(rc, rc);
4264	pThis->u32HGCMEnabled = 0;
4265	#endif /* VBOX_WITH_HGCM */
4266
4267	/*
4268	* In this version of VirtualBox the GUI checks whether "needs host cursor"
4269	* changes.
4270	*/
4271	pThis->mouseCapabilities \|= VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
4272
4273	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMemBalloonChunks, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Memory balloon size", "/Devices/VMMDev/BalloonChunks");
4274
4275	/*
4276	* Generate a unique session id for this VM; it will be changed for each
4277	* start, reset or restore. This can be used for restore detection inside
4278	* the guest.
4279	*/
4280	pThis->idSession = ASMReadTSC();
4281	return rc;
4282	}
4283
4284	/**
4285	* The device registration structure.
4286	*/
4287	extern "C" const PDMDEVREG g_DeviceVMMDev =
4288	{
4289	/* u32Version */
4290	PDM_DEVREG_VERSION,
4291	/* szName */
4292	"VMMDev",
4293	/* szRCMod */
4294	"VBoxDDRC.rc",
4295	/* szR0Mod */
4296	"VBoxDDR0.r0",
4297	/* pszDescription */
4298	"VirtualBox VMM Device\n",
4299	/* fFlags */
4300	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0,
4301	/* fClass */
4302	PDM_DEVREG_CLASS_VMM_DEV,
4303	/* cMaxInstances */
4304	1,
4305	/* cbInstance */
4306	sizeof(VMMDevState),
4307	/* pfnConstruct */
4308	vmmdevConstruct,
4309	/* pfnDestruct */
4310	vmmdevDestruct,
4311	/* pfnRelocate */
4312	vmmdevRelocate,
4313	/* pfnMemSetup */
4314	NULL,
4315	/* pfnPowerOn */
4316	NULL,
4317	/* pfnReset */
4318	vmmdevReset,
4319	/* pfnSuspend */
4320	NULL,
4321	/* pfnResume */
4322	NULL,
4323	/* pfnAttach */
4324	NULL,
4325	/* pfnDetach */
4326	NULL,
4327	/* pfnQueryInterface. */
4328	NULL,
4329	/* pfnInitComplete */
4330	NULL,
4331	/* pfnPowerOff */
4332	NULL,
4333	/* pfnSoftReset */
4334	NULL,
4335	/* u32VersionEnd */
4336	PDM_DEVREG_VERSION
4337	};
4338	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
4339

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

source: vbox/trunk/src/VBox/Devices/VMMDev/VMMDev.cpp@ 69304

Download in other formats: