VMMDev.cpp@ 39823

Last change on this file since 39823 was 39823, checked in by vboxsync, 13 years ago
VMMDevReq_ReportGuestInfo2: Validate szName length.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 124.3 KB

Line
1	/* $Id: VMMDev.cpp 39823 2012-01-20 21:13:51Z vboxsync $ */
2	/** @file
3	* VMMDev - Guest <-> VMM/Host communication device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2011 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
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22
23	/* Enable dev_vmm Log3 statements to get IRQ-related logging. */
24
25	#define LOG_GROUP LOG_GROUP_DEV_VMM
26	#include <VBox/VMMDev.h>
27	#include <VBox/vmm/mm.h>
28	#include <VBox/log.h>
29	#include <VBox/param.h>
30	#include <iprt/path.h>
31	#include <iprt/dir.h>
32	#include <iprt/file.h>
33	#include <VBox/vmm/pgm.h>
34	#include <VBox/err.h>
35	#include <VBox/vmm/vm.h> /* for VM_IS_EMT */
36	#include <VBox/dbg.h>
37
38	#include <iprt/asm.h>
39	#include <iprt/asm-amd64-x86.h>
40	#include <iprt/assert.h>
41	#include <iprt/buildconfig.h>
42	#include <iprt/string.h>
43	#include <iprt/time.h>
44	#ifndef IN_RC
45	# include <iprt/mem.h>
46	#endif
47	#ifdef IN_RING3
48	# include <iprt/uuid.h>
49	#endif
50
51	#include "VMMDevState.h"
52	#ifdef VBOX_WITH_HGCM
53	# include "VMMDevHGCM.h"
54	#endif
55	#ifndef VBOX_WITHOUT_TESTING_FEATURES
56	# include "VMMDevTesting.h"
57	#endif
58
59
60	/*******************************************************************************
61	* Defined Constants And Macros *
62	*******************************************************************************/
63	#define PCIDEV_2_VMMDEVSTATE(pPciDev) ( (VMMDevState *)(pPciDev) )
64	#define VMMDEVSTATE_2_DEVINS(pVMMDevState) ( (pVMMDevState)->pDevIns )
65
66	#define VBOX_GUEST_INTERFACE_VERSION_1_03(s) \
67	( RT_HIWORD((s)->guestInfo.interfaceVersion) == 1 \
68	&& RT_LOWORD((s)->guestInfo.interfaceVersion) == 3 )
69
70	#define VBOX_GUEST_INTERFACE_VERSION_OK(additionsVersion) \
71	( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
72	&& RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) )
73
74	#define VBOX_GUEST_INTERFACE_VERSION_OLD(additionsVersion) \
75	( (RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) \
76	\|\| ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
77	&& RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION) ) )
78
79	#define VBOX_GUEST_INTERFACE_VERSION_TOO_OLD(additionsVersion) \
80	( RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) )
81
82	#define VBOX_GUEST_INTERFACE_VERSION_NEW(additionsVersion) \
83	( RT_HIWORD(additionsVersion) > RT_HIWORD(VMMDEV_VERSION) \
84	\|\| ( RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
85	&& RT_LOWORD(additionsVersion) > RT_LOWORD(VMMDEV_VERSION) ) )
86
87	/** The saved state version. */
88	#define VMMDEV_SAVED_STATE_VERSION 13
89	/** The saved state version used by VirtualBox 3.0.
90	* This doesn't have the config part. */
91	#define VMMDEV_SAVED_STATE_VERSION_VBOX_30 11
92
93
94	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
95
96	/* Whenever host wants to inform guest about something
97	* an IRQ notification will be raised.
98	*
99	* VMMDev PDM interface will contain the guest notification method.
100	*
101	* There is a 32 bit event mask which will be read
102	* by guest on an interrupt. A non zero bit in the mask
103	* means that the specific event occurred and requires
104	* processing on guest side.
105	*
106	* After reading the event mask guest must issue a
107	* generic request AcknowlegdeEvents.
108	*
109	* IRQ line is set to 1 (request) if there are unprocessed
110	* events, that is the event mask is not zero.
111	*
112	* After receiving an interrupt and checking event mask,
113	* the guest must process events using the event specific
114	* mechanism.
115	*
116	* That is if mouse capabilities were changed,
117	* guest will use VMMDev_GetMouseStatus generic request.
118	*
119	* Event mask is only a set of flags indicating that guest
120	* must proceed with a procedure.
121	*
122	* Unsupported events are therefore ignored.
123	* The guest additions must inform host which events they
124	* want to receive, to avoid unnecessary IRQ processing.
125	* By default no events are signalled to guest.
126	*
127	* This seems to be fast method. It requires
128	* only one context switch for an event processing.
129	*
130	*/
131
132	static void vmmdevSetIRQ_Legacy_EMT (VMMDevState *pVMMDevState)
133	{
134	if (!pVMMDevState->fu32AdditionsOk)
135	{
136	Log(("vmmdevSetIRQ: IRQ is not generated, guest has not yet reported to us.\n"));
137	return;
138	}
139
140	uint32_t u32IRQLevel = 0;
141
142	/* Filter unsupported events */
143	uint32_t u32EventFlags =
144	pVMMDevState->u32HostEventFlags
145	& pVMMDevState->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
146
147	Log(("vmmdevSetIRQ: u32EventFlags = 0x%08X, "
148	"pVMMDevState->u32HostEventFlags = 0x%08X, "
149	"pVMMDevState->pVMMDevRAMR3->u32GuestEventMask = 0x%08X\n",
150	u32EventFlags,
151	pVMMDevState->u32HostEventFlags,
152	pVMMDevState->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
153
154	/* Move event flags to VMMDev RAM */
155	pVMMDevState->pVMMDevRAMR3->V.V1_03.u32HostEvents = u32EventFlags;
156
157	if (u32EventFlags)
158	{
159	/* Clear host flags which will be delivered to guest. */
160	pVMMDevState->u32HostEventFlags &= ~u32EventFlags;
161	Log(("vmmdevSetIRQ: pVMMDevState->u32HostEventFlags = 0x%08X\n",
162	pVMMDevState->u32HostEventFlags));
163	u32IRQLevel = 1;
164	}
165
166	/* Set IRQ level for pin 0 */
167	/** @todo make IRQ pin configurable, at least a symbolic constant */
168	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
169	PDMDevHlpPCISetIrqNoWait(pDevIns, 0, u32IRQLevel);
170	Log(("vmmdevSetIRQ: IRQ set %d\n", u32IRQLevel));
171	}
172
173	static void vmmdevMaybeSetIRQ_EMT (VMMDevState *pVMMDevState)
174	{
175	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS (pVMMDevState);
176
177	Log3(("vmmdevMaybeSetIRQ_EMT: u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
178	pVMMDevState->u32HostEventFlags, pVMMDevState->u32GuestFilterMask));
179
180	if (pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask)
181	{
182	pVMMDevState->pVMMDevRAMR3->V.V1_04.fHaveEvents = true;
183	PDMDevHlpPCISetIrqNoWait (pDevIns, 0, 1);
184	Log3(("vmmdevMaybeSetIRQ_EMT: IRQ set.\n"));
185	}
186	}
187
188	static void vmmdevNotifyGuest_EMT (VMMDevState *pVMMDevState, uint32_t u32EventMask)
189	{
190	Log3(("VMMDevNotifyGuest_EMT: u32EventMask = 0x%08X.\n", u32EventMask));
191
192	if (VBOX_GUEST_INTERFACE_VERSION_1_03 (pVMMDevState))
193	{
194	Log3(("VMMDevNotifyGuest_EMT: Old additions detected.\n"));
195
196	pVMMDevState->u32HostEventFlags \|= u32EventMask;
197	vmmdevSetIRQ_Legacy_EMT (pVMMDevState);
198	}
199	else
200	{
201	Log3(("VMMDevNotifyGuest_EMT: New additions detected.\n"));
202
203	if (!pVMMDevState->fu32AdditionsOk)
204	{
205	pVMMDevState->u32HostEventFlags \|= u32EventMask;
206	Log(("vmmdevNotifyGuest_EMT: IRQ is not generated, guest has not yet reported to us.\n"));
207	return;
208	}
209
210	const bool fHadEvents =
211	(pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask) != 0;
212
213	Log3(("VMMDevNotifyGuest_EMT: fHadEvents = %d, u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
214	fHadEvents, pVMMDevState->u32HostEventFlags, pVMMDevState->u32GuestFilterMask));
215
216	pVMMDevState->u32HostEventFlags \|= u32EventMask;
217
218	if (!fHadEvents)
219	vmmdevMaybeSetIRQ_EMT (pVMMDevState);
220	}
221	}
222
223	void VMMDevCtlSetGuestFilterMask (VMMDevState *pVMMDevState,
224	uint32_t u32OrMask,
225	uint32_t u32NotMask)
226	{
227	PDMCritSectEnter(&pVMMDevState->CritSect, VERR_SEM_BUSY);
228
229	const bool fHadEvents =
230	(pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask) != 0;
231
232	Log(("VMMDevCtlSetGuestFilterMask: u32OrMask = 0x%08X, u32NotMask = 0x%08X, fHadEvents = %d.\n", u32OrMask, u32NotMask, fHadEvents));
233	if (fHadEvents)
234	{
235	if (!pVMMDevState->fNewGuestFilterMask)
236	pVMMDevState->u32NewGuestFilterMask = pVMMDevState->u32GuestFilterMask;
237
238	pVMMDevState->u32NewGuestFilterMask \|= u32OrMask;
239	pVMMDevState->u32NewGuestFilterMask &= ~u32NotMask;
240	pVMMDevState->fNewGuestFilterMask = true;
241	}
242	else
243	{
244	pVMMDevState->u32GuestFilterMask \|= u32OrMask;
245	pVMMDevState->u32GuestFilterMask &= ~u32NotMask;
246	vmmdevMaybeSetIRQ_EMT (pVMMDevState);
247	}
248	PDMCritSectLeave(&pVMMDevState->CritSect);
249	}
250
251	void VMMDevNotifyGuest (VMMDevState *pVMMDevState, uint32_t u32EventMask)
252	{
253	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
254
255	Log3(("VMMDevNotifyGuest: u32EventMask = 0x%08X.\n", u32EventMask));
256
257	/*
258	* Drop notifications if the VM is not running yet/anymore.
259	*/
260	VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
261	if ( enmVMState != VMSTATE_RUNNING
262	&& enmVMState != VMSTATE_RUNNING_LS)
263	return;
264
265	PDMCritSectEnter(&pVMMDevState->CritSect, VERR_SEM_BUSY);
266	/* No need to wait for the completion of this request. It is a notification
267	* about something, which has already happened.
268	*/
269	vmmdevNotifyGuest_EMT(pVMMDevState, u32EventMask);
270	PDMCritSectLeave(&pVMMDevState->CritSect);
271	}
272
273	/**
274	* Port I/O Handler for OUT operations.
275	*
276	* @returns VBox status code.
277	*
278	* @param pDevIns The device instance.
279	* @param pvUser User argument - ignored.
280	* @param uPort Port number used for the IN operation.
281	* @param u32 The value to output.
282	* @param cb The value size in bytes.
283	*/
284	static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
285	{
286	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
287
288	if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
289	{
290
291	/* The raw version. */
292	switch (u32)
293	{
294	case '\r': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
295	case '\n': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
296	case '\t': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
297	default: LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
298	}
299
300	/* The readable, buffered version. */
301	if (u32 == '\n' \|\| u32 == '\r')
302	{
303	pThis->szMsg[pThis->iMsg] = '\0';
304	if (pThis->iMsg)
305	LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
306	pThis->iMsg = 0;
307	}
308	else
309	{
310	if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
311	{
312	pThis->szMsg[pThis->iMsg] = '\0';
313	LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
314	pThis->iMsg = 0;
315	}
316	pThis->szMsg[pThis->iMsg] = (char )u32;
317	pThis->szMsg[++pThis->iMsg] = '\0';
318	}
319	}
320	return VINF_SUCCESS;
321	}
322
323	#ifdef TIMESYNC_BACKDOOR
324	/**
325	* Port I/O Handler for OUT operations.
326	*
327	* @returns VBox status code.
328	*
329	* @param pDevIns The device instance.
330	* @param pvUser User argument - ignored.
331	* @param uPort Port number used for the IN operation.
332	* @param u32 The value to output.
333	* @param cb The value size in bytes.
334	*/
335	static DECLCALLBACK(int) vmmdevTimesyncBackdoorWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
336	{
337	NOREF(pvUser);
338	if (cb == 4)
339	{
340	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
341	switch (u32)
342	{
343	case 0:
344	pThis->fTimesyncBackdoorLo = false;
345	break;
346	case 1:
347	pThis->fTimesyncBackdoorLo = true;
348	}
349	return VINF_SUCCESS;
350
351	}
352	return VINF_SUCCESS;
353	}
354
355	/**
356	* Port I/O Handler for backdoor timesync IN operations.
357	*
358	* @returns VBox status code.
359	*
360	* @param pDevIns The device instance.
361	* @param pvUser User argument - ignored.
362	* @param uPort Port number used for the IN operation.
363	* @param pu32 Where to store the result.
364	* @param cb Number of bytes read.
365	*/
366	static DECLCALLBACK(int) vmmdevTimesyncBackdoorRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
367	{
368	int rc;
369	NOREF(pvUser);
370	if (cb == 4)
371	{
372	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
373	RTTIMESPEC now;
374
375	if (pThis->fTimesyncBackdoorLo)
376	*pu32 = (uint32_t)pThis->hostTime;
377	else
378	{
379	pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &now));
380	*pu32 = (uint32_t)(pThis->hostTime >> 32);
381	}
382	rc = VINF_SUCCESS;
383	}
384	else
385	rc = VERR_IOM_IOPORT_UNUSED;
386	return rc;
387	}
388	#endif /* TIMESYNC_BACKDOOR */
389
390
391	/**
392	* Port I/O Handler for the generic request interface
393	* @see FNIOMIOPORTOUT for details.
394	*
395	* @todo Too long, suggest doing the request copying here and moving the
396	* switch into a different function (or better case -> functions), and
397	* looing the gotos.
398	*/
399	static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
400	{
401	VMMDevState pThis = (VMMDevState)pvUser;
402	int rcRet = VINF_SUCCESS;
403	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
404
405	/*
406	* The caller has passed the guest context physical address
407	* of the request structure. Copy the request packet.
408	*/
409	VMMDevRequestHeader *pRequestHeader = NULL;
410	VMMDevRequestHeader requestHeader;
411	RT_ZERO(requestHeader);
412
413	PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
414
415	/* the structure size must be greater or equal to the header size */
416	if (requestHeader.size < sizeof(VMMDevRequestHeader))
417	{
418	Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
419	rcRet = VINF_SUCCESS;
420	goto l_end; /** @todo shouldn't (/ no need to) write back.*/
421	}
422
423	/* check the version of the header structure */
424	if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
425	{
426	Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
427	rcRet = VINF_SUCCESS;
428	goto l_end; /** @todo shouldn't (/ no need to) write back.*/
429	}
430
431	Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
432
433	/* Newer additions starts with VMMDevReq_ReportGuestInfo2, older additions
434	started with VMMDevReq_ReportGuestInfo. */
435	if ( !pThis->fu32AdditionsOk
436	&& requestHeader.requestType != VMMDevReq_ReportGuestInfo2
437	&& requestHeader.requestType != VMMDevReq_ReportGuestInfo
438	&& requestHeader.requestType != VMMDevReq_WriteCoreDump
439	&& requestHeader.requestType != VMMDevReq_GetHostVersion) /* Always allow the guest to query the host capabilities. */
440	{
441	Log(("VMMDev: guest has not yet reported to us. Refusing operation of request #%d!\n",
442	requestHeader.requestType));
443	requestHeader.rc = VERR_NOT_SUPPORTED;
444	static int cRelWarn;
445	if (cRelWarn < 10)
446	{
447	cRelWarn++;
448	LogRel(("VMMDev: the guest has not yet reported to us -- refusing operation of request #%d\n",
449	requestHeader.requestType));
450	}
451	rcRet = VINF_SUCCESS;
452	goto l_end;
453	}
454
455	/* Check upper limit */
456	if (requestHeader.size > VMMDEV_MAX_VMMDEVREQ_SIZE)
457	{
458	static int cRelWarn;
459	if (cRelWarn < 50)
460	{
461	cRelWarn++;
462	LogRel(("VMMDev: request packet too big (%x). Refusing operation.\n", requestHeader.size));
463	}
464	requestHeader.rc = VERR_NOT_SUPPORTED;
465	rcRet = VINF_SUCCESS;
466	goto l_end;
467	}
468
469	/* Read the entire request packet */
470	pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
471	if (!pRequestHeader)
472	{
473	Log(("VMMDev: RTMemAlloc failed!\n"));
474	rcRet = VINF_SUCCESS;
475	requestHeader.rc = VERR_NO_MEMORY;
476	goto l_end;
477	}
478	PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, pRequestHeader, requestHeader.size);
479
480	/* which request was sent? */
481	switch (pRequestHeader->requestType)
482	{
483	/*
484	* Guest wants to give up a timeslice
485	*/
486	case VMMDevReq_Idle:
487	{
488	/* just return to EMT telling it that we want to halt */
489	rcRet = VINF_EM_HALT;
490	break;
491	}
492
493	/*
494	* Guest is reporting its information
495	*/
496	case VMMDevReq_ReportGuestInfo:
497	{
498	AssertMsgBreakStmt(pRequestHeader->size == sizeof(VMMDevReportGuestInfo), ("%u\n", pRequestHeader->size),
499	pRequestHeader->rc = VERR_INVALID_PARAMETER);
500	VBoxGuestInfo pGuestInfo = &((VMMDevReportGuestInfo)pRequestHeader)->guestInfo;
501
502	if (memcmp(&pThis->guestInfo, pGuestInfo, sizeof(*pGuestInfo)) != 0)
503	{
504	/* make a copy of supplied information */
505	pThis->guestInfo = *pGuestInfo;
506
507	/* Check additions version */
508	pThis->fu32AdditionsOk = VBOX_GUEST_INTERFACE_VERSION_OK(pThis->guestInfo.interfaceVersion);
509
510	LogRel(("Guest Additions information report: Interface = 0x%08X osType = 0x%08X\n",
511	pThis->guestInfo.interfaceVersion,
512	pThis->guestInfo.osType));
513	pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
514	}
515
516	if (pThis->fu32AdditionsOk)
517	pRequestHeader->rc = VINF_SUCCESS;
518	else
519	pRequestHeader->rc = VERR_VERSION_MISMATCH;
520	break;
521	}
522
523	case VMMDevReq_ReportGuestInfo2:
524	{
525	AssertMsgBreakStmt(pRequestHeader->size == sizeof(VMMDevReportGuestInfo2), ("%u\n", pRequestHeader->size),
526	pRequestHeader->rc = VERR_INVALID_PARAMETER);
527	VBoxGuestInfo2 pGuestInfo2 = &((VMMDevReportGuestInfo2 )pRequestHeader)->guestInfo;
528	LogRel(("Guest Additions information report: Version %d.%d.%d r%d '%.*s'\n",
529	pGuestInfo2->additionsMajor, pGuestInfo2->additionsMinor, pGuestInfo2->additionsBuild,
530	pGuestInfo2->additionsRevision, sizeof(pGuestInfo2->szName), pGuestInfo2->szName));
531	AssertBreakStmt(memchr(pGuestInfo2->szName, '\0', sizeof(pGuestInfo2->szName)) != NULL,
532	pRequestHeader->rc = VERR_INVALID_PARAMETER);
533
534	pThis->pDrv->pfnUpdateGuestInfo2(pThis->pDrv, pGuestInfo2);
535	pRequestHeader->rc = VINF_SUCCESS;
536	break;
537	}
538
539	case VMMDevReq_WriteCoreDump:
540	{
541	if (pRequestHeader->size != sizeof(VMMDevReqWriteCoreDump))
542	{
543	AssertMsgFailed(("VMMDev WriteCoreDump structure has an invalid size!\n"));
544	pRequestHeader->rc = VERR_INVALID_PARAMETER;
545	}
546	else
547	{
548	if (pThis->fGuestCoreDumpEnabled)
549	{
550	/*
551	* User makes sure the directory exists.
552	*/
553	if (!RTDirExists(pThis->szGuestCoreDumpDir))
554	return VERR_PATH_NOT_FOUND;
555
556	char szCorePath[RTPATH_MAX];
557	RTStrCopy(szCorePath, sizeof(szCorePath), pThis->szGuestCoreDumpDir);
558	RTPathAppend(szCorePath, sizeof(szCorePath), "VBox.core");
559
560	/*
561	* Rotate existing cores based on number of additional cores to keep around.
562	*/
563	if (pThis->cGuestCoreDumps > 0)
564	for (int64_t i = pThis->cGuestCoreDumps - 1; i >= 0; i--)
565	{
566	char szFilePathOld[RTPATH_MAX];
567	if (i == 0)
568	RTStrCopy(szFilePathOld, sizeof(szFilePathOld), szCorePath);
569	else
570	RTStrPrintf(szFilePathOld, sizeof(szFilePathOld), "%s.%d", szCorePath, i);
571
572	char szFilePathNew[RTPATH_MAX];
573	RTStrPrintf(szFilePathNew, sizeof(szFilePathNew), "%s.%d", szCorePath, i + 1);
574	int vrc = RTFileMove(szFilePathOld, szFilePathNew, RTFILEMOVE_FLAGS_REPLACE);
575	if (vrc == VERR_FILE_NOT_FOUND)
576	RTFileDelete(szFilePathNew);
577	}
578
579	/*
580	* Write the core file.
581	*/
582	PVM pVM = PDMDevHlpGetVM(pDevIns);
583	pRequestHeader->rc = DBGFR3CoreWrite(pVM, szCorePath, true /fReplaceFile/);
584	}
585	else
586	pRequestHeader->rc = VERR_ACCESS_DENIED;
587	}
588	break;
589	}
590
591	case VMMDevReq_ReportGuestStatus:
592	{
593	if (pRequestHeader->size != sizeof(VMMDevReportGuestStatus))
594	{
595	AssertMsgFailed(("VMMDev guest status structure has an invalid size!\n"));
596	pRequestHeader->rc = VERR_INVALID_PARAMETER;
597	}
598	else
599	{
600	VBoxGuestStatus guestStatus = &((VMMDevReportGuestStatus)pRequestHeader)->guestStatus;
601	pThis->pDrv->pfnUpdateGuestStatus(pThis->pDrv, guestStatus);
602
603	pRequestHeader->rc = VINF_SUCCESS;
604	}
605	break;
606	}
607
608	/* Report guest capabilities */
609	case VMMDevReq_ReportGuestCapabilities:
610	{
611	if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities))
612	{
613	AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
614	pRequestHeader->rc = VERR_INVALID_PARAMETER;
615	}
616	else
617	{
618	VMMDevReqGuestCapabilities guestCaps = (VMMDevReqGuestCapabilities)pRequestHeader;
619
620	/* Enable this automatically for guests using the old
621	request to report their capabilities. */
622	/** @todo change this when we next bump the interface version */
623	guestCaps->caps \|= VMMDEV_GUEST_SUPPORTS_GRAPHICS;
624	if (pThis->guestCaps != guestCaps->caps)
625	{
626	/* make a copy of supplied information */
627	pThis->guestCaps = guestCaps->caps;
628
629	LogRel(("Guest Additions capability report: (0x%x) "
630	"seamless: %s, "
631	"hostWindowMapping: %s, "
632	"graphics: %s\n",
633	guestCaps->caps,
634	guestCaps->caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
635	guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
636	guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
637
638	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, guestCaps->caps);
639	}
640	pRequestHeader->rc = VINF_SUCCESS;
641	}
642	break;
643	}
644
645	/* Change guest capabilities */
646	case VMMDevReq_SetGuestCapabilities:
647	{
648	if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities2))
649	{
650	AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
651	pRequestHeader->rc = VERR_INVALID_PARAMETER;
652	}
653	else
654	{
655	VMMDevReqGuestCapabilities2 guestCaps = (VMMDevReqGuestCapabilities2)pRequestHeader;
656
657	pThis->guestCaps \|= guestCaps->u32OrMask;
658	pThis->guestCaps &= ~guestCaps->u32NotMask;
659
660	LogRel(("Guest Additions capability report: (0x%x) "
661	"seamless: %s, "
662	"hostWindowMapping: %s, "
663	"graphics: %s\n",
664	pThis->guestCaps,
665	pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
666	pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
667	pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
668
669	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
670	pRequestHeader->rc = VINF_SUCCESS;
671	}
672	break;
673	}
674
675	/*
676	* Retrieve mouse information
677	*/
678	case VMMDevReq_GetMouseStatus:
679	{
680	if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
681	{
682	AssertMsgFailed(("VMMDev mouse status structure has invalid size!\n"));
683	pRequestHeader->rc = VERR_INVALID_PARAMETER;
684	}
685	else
686	{
687	VMMDevReqMouseStatus mouseStatus = (VMMDevReqMouseStatus)pRequestHeader;
688	mouseStatus->mouseFeatures = pThis->mouseCapabilities
689	& VMMDEV_MOUSE_MASK;
690	mouseStatus->pointerXPos = pThis->mouseXAbs;
691	mouseStatus->pointerYPos = pThis->mouseYAbs;
692	LogRel2(("%s: VMMDevReq_GetMouseStatus: features = 0x%x, absX = %d, absY = %d\n",
693	__PRETTY_FUNCTION__,
694	mouseStatus->mouseFeatures,
695	mouseStatus->pointerXPos,
696	mouseStatus->pointerYPos));
697	pRequestHeader->rc = VINF_SUCCESS;
698	}
699	break;
700	}
701
702	/*
703	* Set mouse information
704	*/
705	case VMMDevReq_SetMouseStatus:
706	{
707	if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
708	{
709	AssertMsgFailed(("VMMDev mouse status structure has invalid size %d (%#x) version=%d!\n",
710	pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
711	pRequestHeader->rc = VERR_INVALID_PARAMETER;
712	}
713	else
714	{
715	bool fNotify = false;
716
717	uint32_t fFeatures =
718	((VMMDevReqMouseStatus*)pRequestHeader)->mouseFeatures;
719
720	LogRelFlowFunc(("VMMDevReqMouseStatus: mouseFeatures = 0x%x\n",
721	fFeatures));
722
723	if ( (fFeatures & VMMDEV_MOUSE_NOTIFY_HOST_MASK)
724	!= ( pThis->mouseCapabilities
725	& VMMDEV_MOUSE_NOTIFY_HOST_MASK))
726	fNotify = true;
727	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
728	pThis->mouseCapabilities \|=
729	(fFeatures & VMMDEV_MOUSE_GUEST_MASK);
730	LogRelFlowFunc(("VMMDevReq_SetMouseStatus: new host capabilities: 0x%x\n",
731	pThis->mouseCapabilities));
732
733	/*
734	* Notify connector if something has changed
735	*/
736	if (fNotify)
737	{
738	LogRelFlowFunc(("VMMDevReq_SetMouseStatus: notifying connector\n"));
739	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
740	}
741	pRequestHeader->rc = VINF_SUCCESS;
742	}
743
744	break;
745	}
746
747	/*
748	* Set a new mouse pointer shape
749	*/
750	case VMMDevReq_SetPointerShape:
751	{
752	if (pRequestHeader->size < sizeof(VMMDevReqMousePointer))
753	{
754	AssertMsg(pRequestHeader->size == 0x10028 && pRequestHeader->version == 10000, /* don't complain about legacy!!! */
755	("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
756	pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
757	pRequestHeader->rc = VERR_INVALID_PARAMETER;
758	}
759	else
760	{
761	VMMDevReqMousePointer pointerShape = (VMMDevReqMousePointer)pRequestHeader;
762
763	bool fVisible = (pointerShape->fFlags & VBOX_MOUSE_POINTER_VISIBLE) != 0;
764	bool fAlpha = (pointerShape->fFlags & VBOX_MOUSE_POINTER_ALPHA) != 0;
765	bool fShape = (pointerShape->fFlags & VBOX_MOUSE_POINTER_SHAPE) != 0;
766
767	Log(("VMMDevReq_SetPointerShape: visible: %d, alpha: %d, shape = %d, width: %d, height: %d\n",
768	fVisible, fAlpha, fShape, pointerShape->width, pointerShape->height));
769
770	if (pRequestHeader->size == sizeof(VMMDevReqMousePointer))
771	{
772	/* The guest did not provide the shape actually. */
773	fShape = false;
774	}
775
776	/* forward call to driver */
777	if (fShape)
778	{
779	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
780	fVisible,
781	fAlpha,
782	pointerShape->xHot, pointerShape->yHot,
783	pointerShape->width, pointerShape->height,
784	pointerShape->pointerData);
785	}
786	else
787	{
788	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
789	fVisible,
790	0,
791	0, 0,
792	0, 0,
793	NULL);
794	}
795	pThis->fHostCursorRequested = fVisible;
796	pRequestHeader->rc = VINF_SUCCESS;
797	}
798	break;
799	}
800
801	/*
802	* Query the system time from the host
803	*/
804	case VMMDevReq_GetHostTime:
805	{
806	if (pRequestHeader->size != sizeof(VMMDevReqHostTime))
807	{
808	AssertMsgFailed(("VMMDev host time structure has invalid size!\n"));
809	pRequestHeader->rc = VERR_INVALID_PARAMETER;
810	}
811	else if (RT_UNLIKELY(pThis->fGetHostTimeDisabled))
812	pRequestHeader->rc = VERR_NOT_SUPPORTED;
813	else
814	{
815	VMMDevReqHostTime hostTimeReq = (VMMDevReqHostTime)pRequestHeader;
816	RTTIMESPEC now;
817	hostTimeReq->time = RTTimeSpecGetMilli(PDMDevHlpTMUtcNow(pDevIns, &now));
818	pRequestHeader->rc = VINF_SUCCESS;
819	}
820	break;
821	}
822
823	/*
824	* Query information about the hypervisor
825	*/
826	case VMMDevReq_GetHypervisorInfo:
827	{
828	if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
829	{
830	AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
831	pRequestHeader->rc = VERR_INVALID_PARAMETER;
832	}
833	else
834	{
835	VMMDevReqHypervisorInfo hypervisorInfo = (VMMDevReqHypervisorInfo)pRequestHeader;
836	PVM pVM = PDMDevHlpGetVM(pDevIns);
837	pRequestHeader->rc = PGMR3MappingsSize(pVM, &hypervisorInfo->hypervisorSize);
838	}
839	break;
840	}
841
842	/*
843	* Set hypervisor information
844	*/
845	case VMMDevReq_SetHypervisorInfo:
846	{
847	if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
848	{
849	AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
850	pRequestHeader->rc = VERR_INVALID_PARAMETER;
851	}
852	else
853	{
854	VMMDevReqHypervisorInfo hypervisorInfo = (VMMDevReqHypervisorInfo)pRequestHeader;
855	PVM pVM = PDMDevHlpGetVM(pDevIns);
856	if (hypervisorInfo->hypervisorStart == 0)
857	pRequestHeader->rc = PGMR3MappingsUnfix(pVM);
858	else
859	{
860	/* only if the client has queried the size before! */
861	uint32_t mappingsSize;
862	pRequestHeader->rc = PGMR3MappingsSize(pVM, &mappingsSize);
863	if (RT_SUCCESS(pRequestHeader->rc) && hypervisorInfo->hypervisorSize == mappingsSize)
864	{
865	/* new reservation */
866	pRequestHeader->rc = PGMR3MappingsFix(pVM, hypervisorInfo->hypervisorStart,
867	hypervisorInfo->hypervisorSize);
868	LogRel(("Guest reported fixed hypervisor window at 0x%p (size = 0x%x, rc = %Rrc)\n",
869	(uintptr_t)hypervisorInfo->hypervisorStart,
870	hypervisorInfo->hypervisorSize,
871	pRequestHeader->rc));
872	}
873	}
874	}
875	break;
876	}
877
878	case VMMDevReq_RegisterPatchMemory:
879	{
880	if (pRequestHeader->size != sizeof(VMMDevReqPatchMemory))
881	{
882	AssertMsgFailed(("VMMDevReq_RegisterPatchMemory structure has invalid size!\n"));
883	pRequestHeader->rc = VERR_INVALID_PARAMETER;
884	}
885	else
886	{
887	VMMDevReqPatchMemory pPatchRequest = (VMMDevReqPatchMemory)pRequestHeader;
888
889	pRequestHeader->rc = VMMR3RegisterPatchMemory(PDMDevHlpGetVM(pDevIns), pPatchRequest->pPatchMem, pPatchRequest->cbPatchMem);
890	}
891	break;
892	}
893
894	case VMMDevReq_DeregisterPatchMemory:
895	{
896	if (pRequestHeader->size != sizeof(VMMDevReqPatchMemory))
897	{
898	AssertMsgFailed(("VMMDevReq_DeregisterPatchMemory structure has invalid size!\n"));
899	pRequestHeader->rc = VERR_INVALID_PARAMETER;
900	}
901	else
902	{
903	VMMDevReqPatchMemory pPatchRequest = (VMMDevReqPatchMemory)pRequestHeader;
904
905	pRequestHeader->rc = VMMR3DeregisterPatchMemory(PDMDevHlpGetVM(pDevIns), pPatchRequest->pPatchMem, pPatchRequest->cbPatchMem);
906	}
907	break;
908	}
909
910	/*
911	* Set the system power status
912	*/
913	case VMMDevReq_SetPowerStatus:
914	{
915	if (pRequestHeader->size != sizeof(VMMDevPowerStateRequest))
916	{
917	AssertMsgFailed(("VMMDev power state request structure has invalid size!\n"));
918	pRequestHeader->rc = VERR_INVALID_PARAMETER;
919	}
920	else
921	{
922	VMMDevPowerStateRequest powerStateRequest = (VMMDevPowerStateRequest)pRequestHeader;
923	switch(powerStateRequest->powerState)
924	{
925	case VMMDevPowerState_Pause:
926	{
927	LogRel(("Guest requests the VM to be suspended (paused)\n"));
928	pRequestHeader->rc = rcRet = PDMDevHlpVMSuspend(pDevIns);
929	break;
930	}
931
932	case VMMDevPowerState_PowerOff:
933	{
934	LogRel(("Guest requests the VM to be turned off\n"));
935	pRequestHeader->rc = rcRet = PDMDevHlpVMPowerOff(pDevIns);
936	break;
937	}
938
939	case VMMDevPowerState_SaveState:
940	{
941	if (true /pThis->fAllowGuestToSaveState/)
942	{
943	LogRel(("Guest requests the VM to be saved and powered off\n"));
944	pRequestHeader->rc = rcRet = PDMDevHlpVMSuspendSaveAndPowerOff(pDevIns);
945	}
946	else
947	{
948	LogRel(("Guest requests the VM to be saved and powered off, declined\n"));
949	pRequestHeader->rc = VERR_ACCESS_DENIED;
950	}
951	break;
952	}
953
954	default:
955	AssertMsgFailed(("VMMDev invalid power state request: %d\n", powerStateRequest->powerState));
956	pRequestHeader->rc = VERR_INVALID_PARAMETER;
957	break;
958	}
959	}
960	break;
961	}
962
963	/*
964	* Retrieve a display resize request sent by the host using
965	* @a IDisplay:setVideoModeHint. Deprecated.
966	* See documentation in VMMDev.h.
967	*/
968	/**
969	* @todo It looks like a multi-monitor guest which only uses
970	* @a VMMDevReq_GetDisplayChangeRequest (not the *2 version)
971	* will get into a @a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST event
972	* loop if it tries to acknowlege host requests for additional
973	* monitors. Should the loop which checks for those requests
974	* be removed?
975	*/
976	case VMMDevReq_GetDisplayChangeRequest:
977	{
978	if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest))
979	{
980	/* Assert only if the size also not equal to a previous version size to prevent
981	* assertion with old additions.
982	*/
983	AssertMsg(pRequestHeader->size == sizeof(VMMDevDisplayChangeRequest) - sizeof (uint32_t),
984	("VMMDev display change request structure has invalid size!\n"));
985	pRequestHeader->rc = VERR_INVALID_PARAMETER;
986	}
987	else
988	{
989	VMMDevDisplayChangeRequest displayChangeRequest = (VMMDevDisplayChangeRequest)pRequestHeader;
990
991	DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[0];
992
993	if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
994	{
995	/* Current request has been read at least once. */
996	pRequest->fPending = false;
997
998	/* Check if there are more pending requests. */
999	for (unsigned i = 1; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1000	{
1001	if (pThis->displayChangeData.aRequests[i].fPending)
1002	{
1003	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1004	break;
1005	}
1006	}
1007
1008	/* Remember which resolution the client has queried, subsequent reads
1009	* will return the same values. */
1010	pRequest->lastReadDisplayChangeRequest = pRequest->displayChangeRequest;
1011	pThis->displayChangeData.fGuestSentChangeEventAck = true;
1012	}
1013
1014	if (pThis->displayChangeData.fGuestSentChangeEventAck)
1015	{
1016	displayChangeRequest->xres = pRequest->lastReadDisplayChangeRequest.xres;
1017	displayChangeRequest->yres = pRequest->lastReadDisplayChangeRequest.yres;
1018	displayChangeRequest->bpp = pRequest->lastReadDisplayChangeRequest.bpp;
1019	}
1020	else
1021	{
1022	/* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1023	* read the last valid video mode hint. This happens when the guest X server
1024	* determines the initial mode. */
1025	displayChangeRequest->xres = pRequest->displayChangeRequest.xres;
1026	displayChangeRequest->yres = pRequest->displayChangeRequest.yres;
1027	displayChangeRequest->bpp = pRequest->displayChangeRequest.bpp;
1028	}
1029	Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n",
1030	displayChangeRequest->xres, displayChangeRequest->yres, displayChangeRequest->bpp));
1031
1032	pRequestHeader->rc = VINF_SUCCESS;
1033	}
1034	break;
1035	}
1036
1037	/*
1038	* Retrieve a display resize request sent by the host using
1039	* @a IDisplay:setVideoModeHint.
1040	* See documentation in VMMDev.h.
1041	*/
1042	case VMMDevReq_GetDisplayChangeRequest2:
1043	{
1044	if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest2))
1045	{
1046	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1047	}
1048	else
1049	{
1050	VMMDevDisplayChangeRequest2 displayChangeRequest = (VMMDevDisplayChangeRequest2)pRequestHeader;
1051
1052	DISPLAYCHANGEREQUEST *pRequest = NULL;
1053
1054	if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
1055	{
1056	/* Select a pending request to report. */
1057	unsigned i;
1058	for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1059	{
1060	if (pThis->displayChangeData.aRequests[i].fPending)
1061	{
1062	pRequest = &pThis->displayChangeData.aRequests[i];
1063	/* Remember which request should be reported. */
1064	pThis->displayChangeData.iCurrentMonitor = i;
1065	Log3(("VMMDev: will report pending request for %d\n",
1066	i));
1067	break;
1068	}
1069	}
1070
1071	/* Check if there are more pending requests. */
1072	i++;
1073	for (; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
1074	{
1075	if (pThis->displayChangeData.aRequests[i].fPending)
1076	{
1077	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1078	Log3(("VMMDev: another pending at %d\n",
1079	i));
1080	break;
1081	}
1082	}
1083
1084	if (pRequest)
1085	{
1086	/* Current request has been read at least once. */
1087	pRequest->fPending = false;
1088
1089	/* Remember which resolution the client has queried, subsequent reads
1090	* will return the same values. */
1091	pRequest->lastReadDisplayChangeRequest = pRequest->displayChangeRequest;
1092	pThis->displayChangeData.fGuestSentChangeEventAck = true;
1093	}
1094	else
1095	{
1096	Log3(("VMMDev: no pending request!!!\n"));
1097	}
1098	}
1099
1100	if (!pRequest)
1101	{
1102	Log3(("VMMDev: default to %d\n",
1103	pThis->displayChangeData.iCurrentMonitor));
1104	pRequest = &pThis->displayChangeData.aRequests[pThis->displayChangeData.iCurrentMonitor];
1105	}
1106
1107	if (pThis->displayChangeData.fGuestSentChangeEventAck)
1108	{
1109	displayChangeRequest->xres = pRequest->lastReadDisplayChangeRequest.xres;
1110	displayChangeRequest->yres = pRequest->lastReadDisplayChangeRequest.yres;
1111	displayChangeRequest->bpp = pRequest->lastReadDisplayChangeRequest.bpp;
1112	displayChangeRequest->display = pRequest->lastReadDisplayChangeRequest.display;
1113	}
1114	else
1115	{
1116	/* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
1117	* read the last valid video mode hint. This happens when the guest X server
1118	* determines the initial video mode. */
1119	displayChangeRequest->xres = pRequest->displayChangeRequest.xres;
1120	displayChangeRequest->yres = pRequest->displayChangeRequest.yres;
1121	displayChangeRequest->bpp = pRequest->displayChangeRequest.bpp;
1122	displayChangeRequest->display = pRequest->displayChangeRequest.display;
1123	}
1124	Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
1125	displayChangeRequest->xres, displayChangeRequest->yres, displayChangeRequest->bpp, displayChangeRequest->display));
1126
1127	pRequestHeader->rc = VINF_SUCCESS;
1128	}
1129	break;
1130	}
1131
1132	/*
1133	* Query whether the given video mode is supported
1134	*/
1135	case VMMDevReq_VideoModeSupported:
1136	{
1137	if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest))
1138	{
1139	AssertMsgFailed(("VMMDev video mode supported request structure has invalid size!\n"));
1140	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1141	}
1142	else
1143	{
1144	VMMDevVideoModeSupportedRequest videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest)pRequestHeader;
1145	/* forward the call */
1146	pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1147	0, /* primary screen. */
1148	videoModeSupportedRequest->width,
1149	videoModeSupportedRequest->height,
1150	videoModeSupportedRequest->bpp,
1151	&videoModeSupportedRequest->fSupported);
1152	}
1153	break;
1154	}
1155
1156	/*
1157	* Query whether the given video mode is supported for a specific display
1158	*/
1159	case VMMDevReq_VideoModeSupported2:
1160	{
1161	if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest2))
1162	{
1163	AssertMsgFailed(("VMMDev video mode supported request 2 structure has invalid size!\n"));
1164	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1165	}
1166	else
1167	{
1168	VMMDevVideoModeSupportedRequest2 videoModeSupportedRequest2 = (VMMDevVideoModeSupportedRequest2)pRequestHeader;
1169	/* forward the call */
1170	pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
1171	videoModeSupportedRequest2->display,
1172	videoModeSupportedRequest2->width,
1173	videoModeSupportedRequest2->height,
1174	videoModeSupportedRequest2->bpp,
1175	&videoModeSupportedRequest2->fSupported);
1176	}
1177	break;
1178	}
1179
1180	/*
1181	* Query the height reduction in pixels
1182	*/
1183	case VMMDevReq_GetHeightReduction:
1184	{
1185	if (pRequestHeader->size != sizeof(VMMDevGetHeightReductionRequest))
1186	{
1187	AssertMsgFailed(("VMMDev height reduction request structure has invalid size!\n"));
1188	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1189	}
1190	else
1191	{
1192	VMMDevGetHeightReductionRequest heightReductionRequest = (VMMDevGetHeightReductionRequest)pRequestHeader;
1193	/* forward the call */
1194	pRequestHeader->rc = pThis->pDrv->pfnGetHeightReduction(pThis->pDrv,
1195	&heightReductionRequest->heightReduction);
1196	}
1197	break;
1198	}
1199
1200	/*
1201	* Acknowledge VMMDev events
1202	*/
1203	case VMMDevReq_AcknowledgeEvents:
1204	{
1205	if (pRequestHeader->size != sizeof(VMMDevEvents))
1206	{
1207	AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
1208	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1209	}
1210	else
1211	{
1212	if (VBOX_GUEST_INTERFACE_VERSION_1_03 (pThis))
1213	{
1214	vmmdevSetIRQ_Legacy_EMT (pThis);
1215	}
1216	else
1217	{
1218	VMMDevEvents *pAckRequest;
1219
1220	if (pThis->fNewGuestFilterMask)
1221	{
1222	pThis->fNewGuestFilterMask = false;
1223	pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
1224	}
1225
1226	pAckRequest = (VMMDevEvents *)pRequestHeader;
1227	pAckRequest->events =
1228	pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
1229
1230	pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
1231	pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = false;
1232	PDMDevHlpPCISetIrqNoWait (pThis->pDevIns, 0, 0);
1233	}
1234	pRequestHeader->rc = VINF_SUCCESS;
1235	}
1236	break;
1237	}
1238
1239	/*
1240	* Change guest filter mask
1241	*/
1242	case VMMDevReq_CtlGuestFilterMask:
1243	{
1244	if (pRequestHeader->size != sizeof(VMMDevCtlGuestFilterMask))
1245	{
1246	AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
1247	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1248	}
1249	else
1250	{
1251	VMMDevCtlGuestFilterMask *pCtlMaskRequest;
1252
1253	pCtlMaskRequest = (VMMDevCtlGuestFilterMask *)pRequestHeader;
1254	LogRelFlowFunc(("VMMDevCtlGuestFilterMask: or mask: 0x%x, not mask: 0x%x\n",
1255	pCtlMaskRequest->u32OrMask,
1256	pCtlMaskRequest->u32NotMask));
1257	/* HGCM event notification is enabled by the VMMDev device
1258	* automatically when any HGCM command is issued. The guest
1259	* cannot disable these notifications.
1260	*/
1261	VMMDevCtlSetGuestFilterMask (pThis,
1262	pCtlMaskRequest->u32OrMask,
1263	pCtlMaskRequest->u32NotMask & ~VMMDEV_EVENT_HGCM);
1264	pRequestHeader->rc = VINF_SUCCESS;
1265
1266	}
1267	break;
1268	}
1269
1270	#ifdef VBOX_WITH_HGCM
1271	/*
1272	* Process HGCM request
1273	*/
1274	case VMMDevReq_HGCMConnect:
1275	{
1276	if (pRequestHeader->size < sizeof(VMMDevHGCMConnect))
1277	{
1278	AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
1279	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1280	}
1281	else if (!pThis->pHGCMDrv)
1282	{
1283	Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
1284	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1285	}
1286	else
1287	{
1288	VMMDevHGCMConnect pHGCMConnect = (VMMDevHGCMConnect )pRequestHeader;
1289
1290	Log(("VMMDevReq_HGCMConnect\n"));
1291
1292	pRequestHeader->rc = vmmdevHGCMConnect (pThis, pHGCMConnect, (RTGCPHYS)u32);
1293	}
1294	break;
1295	}
1296
1297	case VMMDevReq_HGCMDisconnect:
1298	{
1299	if (pRequestHeader->size < sizeof(VMMDevHGCMDisconnect))
1300	{
1301	AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
1302	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1303	}
1304	else if (!pThis->pHGCMDrv)
1305	{
1306	Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
1307	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1308	}
1309	else
1310	{
1311	VMMDevHGCMDisconnect pHGCMDisconnect = (VMMDevHGCMDisconnect )pRequestHeader;
1312
1313	Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
1314	pRequestHeader->rc = vmmdevHGCMDisconnect (pThis, pHGCMDisconnect, (RTGCPHYS)u32);
1315	}
1316	break;
1317	}
1318
1319	#ifdef VBOX_WITH_64_BITS_GUESTS
1320	case VMMDevReq_HGCMCall32:
1321	case VMMDevReq_HGCMCall64:
1322	#else
1323	case VMMDevReq_HGCMCall:
1324	#endif /* VBOX_WITH_64_BITS_GUESTS */
1325	{
1326	if (pRequestHeader->size < sizeof(VMMDevHGCMCall))
1327	{
1328	AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
1329	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1330	}
1331	else if (!pThis->pHGCMDrv)
1332	{
1333	Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
1334	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1335	}
1336	else
1337	{
1338	VMMDevHGCMCall pHGCMCall = (VMMDevHGCMCall )pRequestHeader;
1339
1340	Log2(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
1341	Log2(("%.*Rhxd\n", pRequestHeader->size, pRequestHeader));
1342
1343	#ifdef VBOX_WITH_64_BITS_GUESTS
1344	bool f64Bits = (pRequestHeader->requestType == VMMDevReq_HGCMCall64);
1345	#else
1346	bool f64Bits = false;
1347	#endif /* VBOX_WITH_64_BITS_GUESTS */
1348
1349	pRequestHeader->rc = vmmdevHGCMCall (pThis, pHGCMCall, requestHeader.size, (RTGCPHYS)u32, f64Bits);
1350	}
1351	break;
1352	}
1353	#endif /* VBOX_WITH_HGCM */
1354
1355	case VMMDevReq_HGCMCancel:
1356	{
1357	if (pRequestHeader->size < sizeof(VMMDevHGCMCancel))
1358	{
1359	AssertMsgFailed(("VMMDevReq_HGCMCancel structure has invalid size!\n"));
1360	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1361	}
1362	else if (!pThis->pHGCMDrv)
1363	{
1364	Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
1365	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1366	}
1367	else
1368	{
1369	VMMDevHGCMCancel pHGCMCancel = (VMMDevHGCMCancel )pRequestHeader;
1370
1371	Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1372	pRequestHeader->rc = vmmdevHGCMCancel (pThis, pHGCMCancel, (RTGCPHYS)u32);
1373	}
1374	break;
1375	}
1376
1377	case VMMDevReq_HGCMCancel2:
1378	{
1379	if (pRequestHeader->size != sizeof(VMMDevHGCMCancel2))
1380	{
1381	AssertMsgFailed(("VMMDevReq_HGCMCancel structure has invalid size!\n"));
1382	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1383	}
1384	else if (!pThis->pHGCMDrv)
1385	{
1386	Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
1387	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1388	}
1389	else
1390	{
1391	VMMDevHGCMCancel2 pHGCMCancel2 = (VMMDevHGCMCancel2 )pRequestHeader;
1392
1393	Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1394	pRequestHeader->rc = vmmdevHGCMCancel2 (pThis, pHGCMCancel2->physReqToCancel);
1395	}
1396	break;
1397	}
1398
1399	case VMMDevReq_VideoAccelEnable:
1400	{
1401	if (pRequestHeader->size < sizeof(VMMDevVideoAccelEnable))
1402	{
1403	Log(("VMMDevReq_VideoAccelEnable request size too small!!!\n"));
1404	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1405	}
1406	else if (!pThis->pDrv)
1407	{
1408	Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!!\n"));
1409	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1410	}
1411	else
1412	{
1413	VMMDevVideoAccelEnable ptr = (VMMDevVideoAccelEnable )pRequestHeader;
1414
1415	if (ptr->cbRingBuffer != VBVA_RING_BUFFER_SIZE)
1416	{
1417	/* The guest driver seems compiled with another headers. */
1418	Log(("VMMDevReq_VideoAccelEnable guest ring buffer size %d, should be %d!!!\n", ptr->cbRingBuffer, VBVA_RING_BUFFER_SIZE));
1419	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1420	}
1421	else
1422	{
1423	/* The request is correct. */
1424	ptr->fu32Status \|= VBVA_F_STATUS_ACCEPTED;
1425
1426	LogFlow(("VMMDevReq_VideoAccelEnable ptr->u32Enable = %d\n", ptr->u32Enable));
1427
1428	pRequestHeader->rc = ptr->u32Enable?
1429	pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, true, &pThis->pVMMDevRAMR3->vbvaMemory):
1430	pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, false, NULL);
1431
1432	if ( ptr->u32Enable
1433	&& RT_SUCCESS (pRequestHeader->rc))
1434	{
1435	ptr->fu32Status \|= VBVA_F_STATUS_ENABLED;
1436
1437	/* Remember that guest successfully enabled acceleration.
1438	* We need to reestablish it on restoring the VM from saved state.
1439	*/
1440	pThis->u32VideoAccelEnabled = 1;
1441	}
1442	else
1443	{
1444	/* The acceleration was not enabled. Remember that. */
1445	pThis->u32VideoAccelEnabled = 0;
1446	}
1447	}
1448	}
1449	break;
1450	}
1451
1452	case VMMDevReq_VideoAccelFlush:
1453	{
1454	if (pRequestHeader->size < sizeof(VMMDevVideoAccelFlush))
1455	{
1456	AssertMsgFailed(("VMMDevReq_VideoAccelFlush request size too small.\n"));
1457	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1458	}
1459	else if (!pThis->pDrv)
1460	{
1461	Log(("VMMDevReq_VideoAccelFlush Connector is NULL!\n"));
1462	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1463	}
1464	else
1465	{
1466	pThis->pDrv->pfnVideoAccelFlush (pThis->pDrv);
1467
1468	pRequestHeader->rc = VINF_SUCCESS;
1469	}
1470	break;
1471	}
1472
1473	case VMMDevReq_VideoSetVisibleRegion:
1474	{
1475	if ( pRequestHeader->size + sizeof(RTRECT)
1476	< sizeof(VMMDevVideoSetVisibleRegion))
1477	{
1478	Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1479	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1480	}
1481	else if (!pThis->pDrv)
1482	{
1483	Log(("VMMDevReq_VideoSetVisibleRegion Connector is NULL!!!\n"));
1484	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1485	}
1486	else
1487	{
1488	VMMDevVideoSetVisibleRegion ptr = (VMMDevVideoSetVisibleRegion )pRequestHeader;
1489
1490	if ( ptr->cRect > _1M /* restrict to sane range */
1491	\|\| pRequestHeader->size != sizeof(VMMDevVideoSetVisibleRegion) + ptr->cRect * sizeof(RTRECT) - sizeof(RTRECT))
1492	{
1493	Log(("VMMDevReq_VideoSetVisibleRegion: cRects=%#x doesn't match size=%#x or is out of bounds\n",
1494	ptr->cRect, pRequestHeader->size));
1495	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1496	}
1497	else
1498	{
1499	Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", ptr->cRect));
1500	/* forward the call */
1501	pRequestHeader->rc = pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, ptr->cRect, &ptr->Rect);
1502	}
1503	}
1504	break;
1505	}
1506
1507	case VMMDevReq_GetSeamlessChangeRequest:
1508	{
1509	if (pRequestHeader->size != sizeof(VMMDevSeamlessChangeRequest))
1510	{
1511	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1512	}
1513	else
1514	{
1515	VMMDevSeamlessChangeRequest seamlessChangeRequest = (VMMDevSeamlessChangeRequest)pRequestHeader;
1516	/* just pass on the information */
1517	Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
1518	if (pThis->fSeamlessEnabled)
1519	seamlessChangeRequest->mode = VMMDev_Seamless_Visible_Region;
1520	else
1521	seamlessChangeRequest->mode = VMMDev_Seamless_Disabled;
1522
1523	if (seamlessChangeRequest->eventAck == VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
1524	{
1525	/* Remember which mode the client has queried. */
1526	pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
1527	}
1528
1529	pRequestHeader->rc = VINF_SUCCESS;
1530	}
1531	break;
1532	}
1533
1534	case VMMDevReq_GetVRDPChangeRequest:
1535	{
1536	if (pRequestHeader->size != sizeof(VMMDevVRDPChangeRequest))
1537	{
1538	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1539	}
1540	else
1541	{
1542	VMMDevVRDPChangeRequest vrdpChangeRequest = (VMMDevVRDPChangeRequest)pRequestHeader;
1543	/* just pass on the information */
1544	Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->u32VRDPExperienceLevel));
1545
1546	vrdpChangeRequest->u8VRDPActive = pThis->fVRDPEnabled;
1547	vrdpChangeRequest->u32VRDPExperienceLevel = pThis->u32VRDPExperienceLevel;
1548
1549	pRequestHeader->rc = VINF_SUCCESS;
1550	}
1551	break;
1552	}
1553
1554	case VMMDevReq_GetMemBalloonChangeRequest:
1555	{
1556	Log(("VMMDevReq_GetMemBalloonChangeRequest\n"));
1557	if (pRequestHeader->size != sizeof(VMMDevGetMemBalloonChangeRequest))
1558	{
1559	AssertFailed();
1560	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1561	}
1562	else
1563	{
1564	VMMDevGetMemBalloonChangeRequest memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest)pRequestHeader;
1565	/* just pass on the information */
1566	Log(("VMMDev: returning memory balloon size =%d\n", pThis->u32MemoryBalloonSize));
1567	memBalloonChangeRequest->cBalloonChunks = pThis->u32MemoryBalloonSize;
1568	memBalloonChangeRequest->cPhysMemChunks = pThis->cbGuestRAM / (uint64_t)_1M;
1569
1570	if (memBalloonChangeRequest->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
1571	{
1572	/* Remember which mode the client has queried. */
1573	pThis->u32LastMemoryBalloonSize = pThis->u32MemoryBalloonSize;
1574	}
1575
1576	pRequestHeader->rc = VINF_SUCCESS;
1577	}
1578	break;
1579	}
1580
1581	case VMMDevReq_ChangeMemBalloon:
1582	{
1583	VMMDevChangeMemBalloon memBalloonChange = (VMMDevChangeMemBalloon)pRequestHeader;
1584
1585	Log(("VMMDevReq_ChangeMemBalloon\n"));
1586	if ( pRequestHeader->size < sizeof(VMMDevChangeMemBalloon)
1587	\|\| memBalloonChange->cPages != VMMDEV_MEMORY_BALLOON_CHUNK_PAGES
1588	\|\| pRequestHeader->size != (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[memBalloonChange->cPages]))
1589	{
1590	AssertFailed();
1591	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1592	}
1593	else
1594	{
1595	pRequestHeader->rc = PGMR3PhysChangeMemBalloon(PDMDevHlpGetVM(pDevIns), !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
1596	if (memBalloonChange->fInflate)
1597	STAM_REL_U32_INC(&pThis->StatMemBalloonChunks);
1598	else
1599	STAM_REL_U32_DEC(&pThis->StatMemBalloonChunks);
1600	}
1601	break;
1602	}
1603
1604	case VMMDevReq_GetStatisticsChangeRequest:
1605	{
1606	Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
1607	if (pRequestHeader->size != sizeof(VMMDevGetStatisticsChangeRequest))
1608	{
1609	AssertFailed();
1610	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1611	}
1612	else
1613	{
1614	VMMDevGetStatisticsChangeRequest statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest)pRequestHeader;
1615	/* just pass on the information */
1616	Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
1617	statIntervalChangeRequest->u32StatInterval = pThis->u32StatIntervalSize;
1618
1619	if (statIntervalChangeRequest->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
1620	{
1621	/* Remember which mode the client has queried. */
1622	pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
1623	}
1624
1625	pRequestHeader->rc = VINF_SUCCESS;
1626	}
1627	break;
1628	}
1629
1630	case VMMDevReq_ReportGuestStats:
1631	{
1632	Log(("VMMDevReq_ReportGuestStats\n"));
1633	if (pRequestHeader->size != sizeof(VMMDevReportGuestStats))
1634	{
1635	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1636	}
1637	else
1638	{
1639	VMMDevReportGuestStats stats = (VMMDevReportGuestStats)pRequestHeader;
1640
1641	#ifdef DEBUG
1642	VBoxGuestStatistics *pGuestStats = &stats->guestStats;
1643
1644	Log(("Current statistics:\n"));
1645	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_IDLE)
1646	Log(("CPU%d: CPU Load Idle %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Idle));
1647
1648	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_KERNEL)
1649	Log(("CPU%d: CPU Load Kernel %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Kernel));
1650
1651	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_USER)
1652	Log(("CPU%d: CPU Load User %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_User));
1653
1654	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_THREADS)
1655	Log(("CPU%d: Thread %d\n", pGuestStats->u32CpuId, pGuestStats->u32Threads));
1656
1657	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PROCESSES)
1658	Log(("CPU%d: Processes %d\n", pGuestStats->u32CpuId, pGuestStats->u32Processes));
1659
1660	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_HANDLES)
1661	Log(("CPU%d: Handles %d\n", pGuestStats->u32CpuId, pGuestStats->u32Handles));
1662
1663	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEMORY_LOAD)
1664	Log(("CPU%d: Memory Load %d%%\n", pGuestStats->u32CpuId, pGuestStats->u32MemoryLoad));
1665
1666	/* Note that reported values are in pages; upper layers expect them in megabytes */
1667	Log(("CPU%d: Page size %-4d bytes\n", pGuestStats->u32CpuId, pGuestStats->u32PageSize));
1668	Assert(pGuestStats->u32PageSize == 4096);
1669
1670	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)
1671	Log(("CPU%d: Total physical memory %-4d MB\n", pGuestStats->u32CpuId, (pGuestStats->u32PhysMemTotal + (_1M/_4K)-1) / (_1M/_4K)));
1672
1673	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_AVAIL)
1674	Log(("CPU%d: Free physical memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemAvail / (_1M/_4K)));
1675
1676	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_BALLOON)
1677	Log(("CPU%d: Memory balloon size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemBalloon / (_1M/_4K)));
1678
1679	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_COMMIT_TOTAL)
1680	Log(("CPU%d: Committed memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemCommitTotal / (_1M/_4K)));
1681
1682	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_TOTAL)
1683	Log(("CPU%d: Total kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelTotal / (_1M/_4K)));
1684
1685	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_PAGED)
1686	Log(("CPU%d: Paged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelPaged / (_1M/_4K)));
1687
1688	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED)
1689	Log(("CPU%d: Nonpaged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelNonPaged / (_1M/_4K)));
1690
1691	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_SYSTEM_CACHE)
1692	Log(("CPU%d: System cache size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemSystemCache / (_1M/_4K)));
1693
1694	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PAGE_FILE_SIZE)
1695	Log(("CPU%d: Page file size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PageFileSize / (_1M/_4K)));
1696	Log(("Statistics end *******************\n"));
1697	#endif
1698
1699	/* forward the call */
1700	pRequestHeader->rc = pThis->pDrv->pfnReportStatistics(pThis->pDrv, &stats->guestStats);
1701	}
1702	break;
1703	}
1704
1705	case VMMDevReq_QueryCredentials:
1706	{
1707	if (pRequestHeader->size != sizeof(VMMDevCredentials))
1708	{
1709	AssertMsgFailed(("VMMDevReq_QueryCredentials request size too small.\n"));
1710	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1711	}
1712	else
1713	{
1714	VMMDevCredentials credentials = (VMMDevCredentials)pRequestHeader;
1715
1716	/* let's start by nulling out the data */
1717	memset(credentials->szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1718	memset(credentials->szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1719	memset(credentials->szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1720
1721	/* should we return whether we got credentials for a logon? */
1722	if (credentials->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
1723	{
1724	if ( pThis->pCredentials->Logon.szUserName[0]
1725	\|\| pThis->pCredentials->Logon.szPassword[0]
1726	\|\| pThis->pCredentials->Logon.szDomain[0])
1727	{
1728	credentials->u32Flags \|= VMMDEV_CREDENTIALS_PRESENT;
1729	}
1730	else
1731	{
1732	credentials->u32Flags &= ~VMMDEV_CREDENTIALS_PRESENT;
1733	}
1734	}
1735
1736	/* does the guest want to read logon credentials? */
1737	if (credentials->u32Flags & VMMDEV_CREDENTIALS_READ)
1738	{
1739	if (pThis->pCredentials->Logon.szUserName[0])
1740	strcpy(credentials->szUserName, pThis->pCredentials->Logon.szUserName);
1741	if (pThis->pCredentials->Logon.szPassword[0])
1742	strcpy(credentials->szPassword, pThis->pCredentials->Logon.szPassword);
1743	if (pThis->pCredentials->Logon.szDomain[0])
1744	strcpy(credentials->szDomain, pThis->pCredentials->Logon.szDomain);
1745	if (!pThis->pCredentials->Logon.fAllowInteractiveLogon)
1746	credentials->u32Flags \|= VMMDEV_CREDENTIALS_NOLOCALLOGON;
1747	else
1748	credentials->u32Flags &= ~VMMDEV_CREDENTIALS_NOLOCALLOGON;
1749	}
1750
1751	if (!pThis->fKeepCredentials)
1752	{
1753	/* does the caller want us to destroy the logon credentials? */
1754	if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
1755	{
1756	memset(pThis->pCredentials->Logon.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1757	memset(pThis->pCredentials->Logon.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1758	memset(pThis->pCredentials->Logon.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1759	}
1760	}
1761
1762	/* does the guest want to read credentials for verification? */
1763	if (credentials->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
1764	{
1765	if (pThis->pCredentials->Judge.szUserName[0])
1766	strcpy(credentials->szUserName, pThis->pCredentials->Judge.szUserName);
1767	if (pThis->pCredentials->Judge.szPassword[0])
1768	strcpy(credentials->szPassword, pThis->pCredentials->Judge.szPassword);
1769	if (pThis->pCredentials->Judge.szDomain[0])
1770	strcpy(credentials->szDomain, pThis->pCredentials->Judge.szDomain);
1771	}
1772
1773	/* does the caller want us to destroy the judgement credentials? */
1774	if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
1775	{
1776	memset(pThis->pCredentials->Judge.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1777	memset(pThis->pCredentials->Judge.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1778	memset(pThis->pCredentials->Judge.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
1779	}
1780
1781	pRequestHeader->rc = VINF_SUCCESS;
1782	}
1783	break;
1784	}
1785
1786	case VMMDevReq_ReportCredentialsJudgement:
1787	{
1788	if (pRequestHeader->size != sizeof(VMMDevCredentials))
1789	{
1790	AssertMsgFailed(("VMMDevReq_ReportCredentialsJudgement request size too small.\n"));
1791	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1792	}
1793	else
1794	{
1795	VMMDevCredentials credentials = (VMMDevCredentials)pRequestHeader;
1796
1797	/* what does the guest think about the credentials? (note: the order is important here!) */
1798	if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
1799	{
1800	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
1801	}
1802	else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
1803	{
1804	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
1805	}
1806	else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
1807	{
1808	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
1809	}
1810	else
1811	Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", credentials->u32Flags));
1812
1813	pRequestHeader->rc = VINF_SUCCESS;
1814	}
1815	break;
1816	}
1817
1818	/*
1819	* Implemented in 3.1.0.
1820	*
1821	* Note! The ring-0 VBoxGuestLib uses this to check whether
1822	* VMMDevHGCMParmType_PageList is supported.
1823	*/
1824	case VMMDevReq_GetHostVersion:
1825	{
1826	AssertMsgBreakStmt(pRequestHeader->size == sizeof(VMMDevReqHostVersion),
1827	("%#x < %#x\n", pRequestHeader->size, sizeof(VMMDevReqLogString)),
1828	pRequestHeader->rc = VERR_INVALID_PARAMETER);
1829	VMMDevReqHostVersion pReqHostVer = (VMMDevReqHostVersion)pRequestHeader;
1830	pReqHostVer->major = RTBldCfgVersionMajor();
1831	pReqHostVer->minor = RTBldCfgVersionMinor();
1832	pReqHostVer->build = RTBldCfgVersionBuild();
1833	pReqHostVer->revision = RTBldCfgRevision();
1834	pReqHostVer->features = VMMDEV_HVF_HGCM_PHYS_PAGE_LIST;
1835	pReqHostVer->header.rc = VINF_SUCCESS;
1836	break;
1837	}
1838
1839	case VMMDevReq_GetCpuHotPlugRequest:
1840	{
1841	VMMDevGetCpuHotPlugRequest pReqCpuHotPlug = (VMMDevGetCpuHotPlugRequest )pRequestHeader;
1842
1843	if (pRequestHeader->size != sizeof(VMMDevGetCpuHotPlugRequest))
1844	{
1845	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1846	}
1847	else
1848	{
1849	pReqCpuHotPlug->enmEventType = pThis->enmCpuHotPlugEvent;
1850	pReqCpuHotPlug->idCpuCore = pThis->idCpuCore;
1851	pReqCpuHotPlug->idCpuPackage = pThis->idCpuPackage;
1852	pReqCpuHotPlug->header.rc = VINF_SUCCESS;
1853
1854	/* Clear the event */
1855	pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_None;
1856	pThis->idCpuCore = UINT32_MAX;
1857	pThis->idCpuPackage = UINT32_MAX;
1858	}
1859	break;
1860	}
1861
1862	case VMMDevReq_SetCpuHotPlugStatus:
1863	{
1864	VMMDevCpuHotPlugStatusRequest pReqCpuHotPlugStatus = (VMMDevCpuHotPlugStatusRequest )pRequestHeader;
1865
1866	if (pRequestHeader->size != sizeof(VMMDevCpuHotPlugStatusRequest))
1867	{
1868	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1869	}
1870	else
1871	{
1872	pRequestHeader->rc = VINF_SUCCESS;
1873
1874	if (pReqCpuHotPlugStatus->enmStatusType == VMMDevCpuStatusType_Disable)
1875	pThis->fCpuHotPlugEventsEnabled = false;
1876	else if (pReqCpuHotPlugStatus->enmStatusType == VMMDevCpuStatusType_Enable)
1877	pThis->fCpuHotPlugEventsEnabled = true;
1878	else
1879	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1880	}
1881	break;
1882	}
1883
1884	#ifdef VBOX_WITH_PAGE_SHARING
1885	case VMMDevReq_RegisterSharedModule:
1886	{
1887	VMMDevSharedModuleRegistrationRequest pReqModule = (VMMDevSharedModuleRegistrationRequest )pRequestHeader;
1888
1889	if ( pRequestHeader->size < sizeof(VMMDevSharedModuleRegistrationRequest)
1890	\|\| pRequestHeader->size != RT_UOFFSETOF(VMMDevSharedModuleRegistrationRequest, aRegions[pReqModule->cRegions]))
1891	{
1892	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1893	}
1894	else
1895	{
1896	pRequestHeader->rc = PGMR3SharedModuleRegister(PDMDevHlpGetVM(pDevIns), pReqModule->enmGuestOS, pReqModule->szName, pReqModule->szVersion,
1897	pReqModule->GCBaseAddr, pReqModule->cbModule,
1898	pReqModule->cRegions, pReqModule->aRegions);
1899	}
1900	break;
1901	}
1902
1903	case VMMDevReq_UnregisterSharedModule:
1904	{
1905	VMMDevSharedModuleUnregistrationRequest pReqModule = (VMMDevSharedModuleUnregistrationRequest )pRequestHeader;
1906
1907	if (pRequestHeader->size != sizeof(VMMDevSharedModuleUnregistrationRequest))
1908	{
1909	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1910	}
1911	else
1912	{
1913	pRequestHeader->rc = PGMR3SharedModuleUnregister(PDMDevHlpGetVM(pDevIns), pReqModule->szName, pReqModule->szVersion,
1914	pReqModule->GCBaseAddr, pReqModule->cbModule);
1915	}
1916	break;
1917	}
1918
1919	case VMMDevReq_CheckSharedModules:
1920	{
1921	VMMDevSharedModuleCheckRequest pReqModule = (VMMDevSharedModuleCheckRequest )pRequestHeader;
1922
1923	if (pRequestHeader->size != sizeof(VMMDevSharedModuleCheckRequest))
1924	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1925	else
1926	pRequestHeader->rc = PGMR3SharedModuleCheckAll(PDMDevHlpGetVM(pDevIns));
1927	break;
1928	}
1929
1930	case VMMDevReq_GetPageSharingStatus:
1931	{
1932	VMMDevPageSharingStatusRequest pReqStatus = (VMMDevPageSharingStatusRequest )pRequestHeader;
1933
1934	if (pRequestHeader->size != sizeof(VMMDevPageSharingStatusRequest))
1935	{
1936	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1937	}
1938	else
1939	{
1940	pReqStatus->fEnabled = false;
1941	pThis->pDrv->pfnIsPageFusionEnabled(pThis->pDrv, &pReqStatus->fEnabled);
1942	pRequestHeader->rc = VINF_SUCCESS;
1943	}
1944	break;
1945	}
1946
1947	case VMMDevReq_DebugIsPageShared:
1948	{
1949	# ifdef DEBUG
1950	VMMDevPageIsSharedRequest pReq = (VMMDevPageIsSharedRequest )pRequestHeader;
1951
1952	if (pRequestHeader->size != sizeof(VMMDevPageIsSharedRequest))
1953	{
1954	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1955	}
1956	else
1957	{
1958	pRequestHeader->rc = PGMR3SharedModuleGetPageState(PDMDevHlpGetVM(pDevIns), pReq->GCPtrPage, &pReq->fShared, &pReq->uPageFlags);
1959	}
1960	# else
1961	pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
1962	# endif
1963	break;
1964	}
1965
1966	#endif
1967
1968	#ifdef DEBUG
1969	case VMMDevReq_LogString:
1970	{
1971	if (pRequestHeader->size < sizeof(VMMDevReqLogString))
1972	{
1973	AssertMsgFailed(("VMMDevReq_LogString request size too small.\n"));
1974	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1975	}
1976	else
1977	{
1978	VMMDevReqLogString pReqLogString = (VMMDevReqLogString )pRequestHeader;
1979	LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR,
1980	("DEBUG LOG: %s", pReqLogString->szString));
1981	pRequestHeader->rc = VINF_SUCCESS;
1982	}
1983	break;
1984	}
1985	#endif
1986
1987	/*
1988	* Get a unique session id for this VM; the id will be different after each start, reset or restore of the VM
1989	* This can be used for restore detection inside the guest.
1990	*/
1991	case VMMDevReq_GetSessionId:
1992	{
1993	if (pRequestHeader->size != sizeof(VMMDevReqSessionId))
1994	{
1995	AssertMsgFailed(("VMMDevReq_GetSessionId request size too small.\n"));
1996	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1997	}
1998	else
1999	{
2000	VMMDevReqSessionId pReq = (VMMDevReqSessionId )pRequestHeader;
2001	pReq->idSession = pThis->idSession;
2002	pRequestHeader->rc = VINF_SUCCESS;
2003	}
2004	break;
2005	}
2006
2007	default:
2008	{
2009	pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
2010	Log(("VMMDev unknown request type %d\n", pRequestHeader->requestType));
2011	break;
2012	}
2013	}
2014
2015	l_end:
2016	/* Write the result back to guest memory */
2017	if (pRequestHeader)
2018	{
2019	PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, pRequestHeader, pRequestHeader->size);
2020	RTMemFree(pRequestHeader);
2021	}
2022	else
2023	{
2024	/* early error case; write back header only */
2025	PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
2026	}
2027
2028	PDMCritSectLeave(&pThis->CritSect);
2029	return rcRet;
2030	}
2031
2032	/**
2033	* Callback function for mapping an PCI I/O region.
2034	*
2035	* @return VBox status code.
2036	* @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
2037	* @param iRegion The region number.
2038	* @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
2039	* I/O port, else it's a physical address.
2040	* This address is NOT relative to pci_mem_base like earlier!
2041	* @param enmType One of the PCI_ADDRESS_SPACE_* values.
2042	*/
2043	static DECLCALLBACK(int) vmmdevIORAMRegionMap(PPCIDEVICE pPciDev, /unsigned/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
2044	{
2045	LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
2046	VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
2047	int rc;
2048
2049	if (iRegion == 1)
2050	{
2051	AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
2052	Assert(pThis->pVMMDevRAMR3 != NULL);
2053	if (GCPhysAddress != NIL_RTGCPHYS)
2054	{
2055	/*
2056	* Map the MMIO2 memory.
2057	*/
2058	pThis->GCPhysVMMDevRAM = GCPhysAddress;
2059	Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
2060	rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
2061	}
2062	else
2063	{
2064	/*
2065	* It is about to be unmapped, just clean up.
2066	*/
2067	pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
2068	rc = VINF_SUCCESS;
2069	}
2070	}
2071	else if (iRegion == 2)
2072	{
2073	AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
2074	Assert(pThis->pVMMDevHeapR3 != NULL);
2075	if (GCPhysAddress != NIL_RTGCPHYS)
2076	{
2077	/*
2078	* Map the MMIO2 memory.
2079	*/
2080	pThis->GCPhysVMMDevHeap = GCPhysAddress;
2081	Assert(pThis->GCPhysVMMDevHeap == GCPhysAddress);
2082	rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
2083	if (RT_SUCCESS(rc))
2084	rc = PDMDevHlpRegisterVMMDevHeap(pPciDev->pDevIns, GCPhysAddress, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
2085	}
2086	else
2087	{
2088	/*
2089	* It is about to be unmapped, just clean up.
2090	*/
2091	PDMDevHlpUnregisterVMMDevHeap(pPciDev->pDevIns, pThis->GCPhysVMMDevHeap);
2092	pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
2093	rc = VINF_SUCCESS;
2094	}
2095	}
2096	else
2097	{
2098	AssertMsgFailed(("%d\n", iRegion));
2099	rc = VERR_INVALID_PARAMETER;
2100	}
2101
2102	return rc;
2103	}
2104
2105
2106	/**
2107	* Callback function for mapping a PCI I/O region.
2108	*
2109	* @return VBox status code.
2110	* @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
2111	* @param iRegion The region number.
2112	* @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
2113	* I/O port, else it's a physical address.
2114	* This address is NOT relative to pci_mem_base like earlier!
2115	* @param enmType One of the PCI_ADDRESS_SPACE_* values.
2116	*/
2117	static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPCIDEVICE pPciDev, /unsigned/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
2118	{
2119	VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
2120	int rc = VINF_SUCCESS;
2121
2122	Assert(enmType == PCI_ADDRESS_SPACE_IO);
2123	Assert(iRegion == 0);
2124	AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
2125
2126	/*
2127	* Save the base port address to simplify Port offset calculations.
2128	*/
2129	pThis->PortBase = (RTIOPORT)GCPhysAddress;
2130
2131	/*
2132	* Register our port IO handlers.
2133	*/
2134	rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns,
2135	(RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
2136	(void*)pThis, vmmdevRequestHandler,
2137	NULL, NULL, NULL, "VMMDev Request Handler");
2138	AssertRC(rc);
2139	return rc;
2140	}
2141
2142	/**
2143	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
2144	*/
2145	static DECLCALLBACK(void ) vmmdevPortQueryInterface(PPDMIBASE pInterface, const char pszIID)
2146	{
2147	VMMDevState *pThis = RT_FROM_MEMBER(pInterface, VMMDevState, IBase);
2148
2149	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2150	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIVMMDEVPORT, &pThis->IPort);
2151	#ifdef VBOX_WITH_HGCM
2152	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHGCMPORT, &pThis->IHGCMPort);
2153	#endif
2154	/* Currently only for shared folders. */
2155	PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->SharedFolders.ILeds);
2156	return NULL;
2157	}
2158
2159	/**
2160	* Gets the pointer to the status LED of a unit.
2161	*
2162	* @returns VBox status code.
2163	* @param pInterface Pointer to the interface structure containing the called function pointer.
2164	* @param iLUN The unit which status LED we desire.
2165	* @param ppLed Where to store the LED pointer.
2166	*/
2167	static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
2168	{
2169	VMMDevState pThis = (VMMDevState )( (uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, SharedFolders.ILeds) );
2170	if (iLUN == 0) /* LUN 0 is shared folders */
2171	{
2172	*ppLed = &pThis->SharedFolders.Led;
2173	return VINF_SUCCESS;
2174	}
2175	return VERR_PDM_LUN_NOT_FOUND;
2176	}
2177
2178	/* -=-=-=-=-=- IVMMDevPort -=-=-=-=-=- */
2179
2180	/** Converts a VMMDev port interface pointer to a VMMDev state pointer. */
2181	#define IVMMDEVPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, IPort)) )
2182
2183
2184	/**
2185	* Return the current absolute mouse position in pixels
2186	*
2187	* @returns VBox status code
2188	* @param pAbsX Pointer of result value, can be NULL
2189	* @param pAbsY Pointer of result value, can be NULL
2190	*/
2191	static DECLCALLBACK(int) vmmdevQueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, int32_t pAbsX, int32_t pAbsY)
2192	{
2193	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2194	if (pAbsX)
2195	pAbsX = ASMAtomicReadS32(&pThis->mouseXAbs); / why the atomic read? */
2196	if (pAbsY)
2197	*pAbsY = ASMAtomicReadS32(&pThis->mouseYAbs);
2198	return VINF_SUCCESS;
2199	}
2200
2201	/**
2202	* Set the new absolute mouse position in pixels
2203	*
2204	* @returns VBox status code
2205	* @param absX New absolute X position
2206	* @param absY New absolute Y position
2207	*/
2208	static DECLCALLBACK(int) vmmdevSetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, int32_t absX, int32_t absY)
2209	{
2210	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2211	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2212
2213	if (pThis->mouseXAbs == absX && pThis->mouseYAbs == absY)
2214	{
2215	PDMCritSectLeave(&pThis->CritSect);
2216	return VINF_SUCCESS;
2217	}
2218	Log2(("vmmdevSetAbsoluteMouse: settings absolute position to x = %d, y = %d\n", absX, absY));
2219	pThis->mouseXAbs = absX;
2220	pThis->mouseYAbs = absY;
2221	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
2222	PDMCritSectLeave(&pThis->CritSect);
2223	return VINF_SUCCESS;
2224	}
2225
2226	/**
2227	* Return the current mouse capability flags
2228	*
2229	* @returns VBox status code
2230	* @param pCapabilities Pointer of result value
2231	*/
2232	static DECLCALLBACK(int) vmmdevQueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pfCaps)
2233	{
2234	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2235	if (!pfCaps)
2236	return VERR_INVALID_PARAMETER;
2237	*pfCaps = pThis->mouseCapabilities;
2238	return VINF_SUCCESS;
2239	}
2240
2241	/**
2242	* Set the current mouse capability flag (host side)
2243	*
2244	* @returns VBox status code
2245	* @param capabilities Capability mask
2246	*/
2247	static DECLCALLBACK(int) vmmdevUpdateMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t fCapsAdded, uint32_t fCapsRemoved)
2248	{
2249	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2250	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2251
2252	uint32_t fOldCaps = pThis->mouseCapabilities;
2253	pThis->mouseCapabilities &= ~(fCapsRemoved & VMMDEV_MOUSE_HOST_MASK);
2254	pThis->mouseCapabilities \|= (fCapsAdded & VMMDEV_MOUSE_HOST_MASK)
2255	\| VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
2256	bool fNotify = fOldCaps != pThis->mouseCapabilities;
2257
2258	LogRelFlowFunc(("fCapsAdded=0x%x, fCapsRemoved=0x%x, fNotify %s\n",
2259	fCapsAdded, fCapsRemoved, fNotify ? "TRUE" : "FALSE"));
2260
2261	if (fNotify)
2262	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
2263
2264	PDMCritSectLeave(&pThis->CritSect);
2265	return VINF_SUCCESS;
2266	}
2267
2268
2269	static DECLCALLBACK(int) vmmdevRequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t xres, uint32_t yres, uint32_t bpp, uint32_t display)
2270	{
2271	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2272
2273	if (display >= RT_ELEMENTS(pThis->displayChangeData.aRequests))
2274	{
2275	return VERR_INVALID_PARAMETER;
2276	}
2277
2278	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2279
2280	DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[display];
2281
2282	/* Verify that the new resolution is different and that guest does not yet know about it. */
2283	bool fSameResolution = (!xres \|\| (pRequest->lastReadDisplayChangeRequest.xres == xres)) &&
2284	(!yres \|\| (pRequest->lastReadDisplayChangeRequest.yres == yres)) &&
2285	(!bpp \|\| (pRequest->lastReadDisplayChangeRequest.bpp == bpp)) &&
2286	pRequest->lastReadDisplayChangeRequest.display == display;
2287
2288	if (!xres && !yres && !bpp)
2289	{
2290	/* Special case of reset video mode. */
2291	fSameResolution = false;
2292	}
2293
2294	Log3(("vmmdevRequestDisplayChange: same=%d. new: xres=%d, yres=%d, bpp=%d, display=%d. old: xres=%d, yres=%d, bpp=%d, display=%d.\n",
2295	fSameResolution, xres, yres, bpp, display, pRequest->lastReadDisplayChangeRequest.xres, pRequest->lastReadDisplayChangeRequest.yres, pRequest->lastReadDisplayChangeRequest.bpp, pRequest->lastReadDisplayChangeRequest.display));
2296
2297	if (!fSameResolution)
2298	{
2299	LogRel(("VMMDev::SetVideoModeHint: got a video mode hint (%dx%dx%d) at %d\n",
2300	xres, yres, bpp, display));
2301
2302	/* we could validate the information here but hey, the guest can do that as well! */
2303	pRequest->displayChangeRequest.xres = xres;
2304	pRequest->displayChangeRequest.yres = yres;
2305	pRequest->displayChangeRequest.bpp = bpp;
2306	pRequest->displayChangeRequest.display = display;
2307	pRequest->fPending = true;
2308
2309	/* IRQ so the guest knows what's going on */
2310	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
2311	}
2312
2313	PDMCritSectLeave(&pThis->CritSect);
2314	return VINF_SUCCESS;
2315	}
2316
2317	static DECLCALLBACK(int) vmmdevRequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
2318	{
2319	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2320	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2321
2322	/* Verify that the new resolution is different and that guest does not yet know about it. */
2323	bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
2324
2325	Log(("vmmdevRequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
2326
2327	if (!fSameMode)
2328	{
2329	/* we could validate the information here but hey, the guest can do that as well! */
2330	pThis->fSeamlessEnabled = fEnabled;
2331
2332	/* IRQ so the guest knows what's going on */
2333	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
2334	}
2335
2336	PDMCritSectLeave(&pThis->CritSect);
2337	return VINF_SUCCESS;
2338	}
2339
2340	static DECLCALLBACK(int) vmmdevSetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t ulBalloonSize)
2341	{
2342	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2343	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2344
2345	/* Verify that the new resolution is different and that guest does not yet know about it. */
2346	bool fSame = (pThis->u32LastMemoryBalloonSize == ulBalloonSize);
2347
2348	Log(("vmmdevSetMemoryBalloon: old=%d. new=%d\n", pThis->u32LastMemoryBalloonSize, ulBalloonSize));
2349
2350	if (!fSame)
2351	{
2352	/* we could validate the information here but hey, the guest can do that as well! */
2353	pThis->u32MemoryBalloonSize = ulBalloonSize;
2354
2355	/* IRQ so the guest knows what's going on */
2356	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
2357	}
2358
2359	PDMCritSectLeave(&pThis->CritSect);
2360	return VINF_SUCCESS;
2361	}
2362
2363	static DECLCALLBACK(int) vmmdevVRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t u32VRDPExperienceLevel)
2364	{
2365	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2366	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2367
2368	bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
2369
2370	Log(("vmmdevVRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
2371
2372	if (!fSame)
2373	{
2374	pThis->fVRDPEnabled = fVRDPEnabled;
2375	pThis->u32VRDPExperienceLevel = u32VRDPExperienceLevel;
2376
2377	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_VRDP);
2378	}
2379
2380	PDMCritSectLeave(&pThis->CritSect);
2381	return VINF_SUCCESS;
2382	}
2383
2384	static DECLCALLBACK(int) vmmdevSetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t ulStatInterval)
2385	{
2386	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2387	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2388
2389	/* Verify that the new resolution is different and that guest does not yet know about it. */
2390	bool fSame = (pThis->u32LastStatIntervalSize == ulStatInterval);
2391
2392	Log(("vmmdevSetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, ulStatInterval));
2393
2394	if (!fSame)
2395	{
2396	/* we could validate the information here but hey, the guest can do that as well! */
2397	pThis->u32StatIntervalSize = ulStatInterval;
2398
2399	/* IRQ so the guest knows what's going on */
2400	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
2401	}
2402
2403	PDMCritSectLeave(&pThis->CritSect);
2404	return VINF_SUCCESS;
2405	}
2406
2407
2408	static DECLCALLBACK(int) vmmdevSetCredentials(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
2409	const char pszPassword, const char pszDomain,
2410	uint32_t u32Flags)
2411	{
2412	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2413	int rc = VINF_SUCCESS;
2414
2415	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2416
2417	/* logon mode? */
2418	if (u32Flags & VMMDEV_SETCREDENTIALS_GUESTLOGON)
2419	{
2420	/* memorize the data */
2421	strcpy(pThis->pCredentials->Logon.szUserName, pszUsername);
2422	strcpy(pThis->pCredentials->Logon.szPassword, pszPassword);
2423	strcpy(pThis->pCredentials->Logon.szDomain, pszDomain);
2424	pThis->pCredentials->Logon.fAllowInteractiveLogon = !(u32Flags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
2425	}
2426	/* credentials verification mode? */
2427	else if (u32Flags & VMMDEV_SETCREDENTIALS_JUDGE)
2428	{
2429	/* memorize the data */
2430	strcpy(pThis->pCredentials->Judge.szUserName, pszUsername);
2431	strcpy(pThis->pCredentials->Judge.szPassword, pszPassword);
2432	strcpy(pThis->pCredentials->Judge.szDomain, pszDomain);
2433
2434	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
2435	}
2436	else
2437	rc = VERR_INVALID_PARAMETER;
2438
2439	PDMCritSectLeave(&pThis->CritSect);
2440	return rc;
2441	}
2442
2443	/**
2444	* Notification from the Display. Especially useful when
2445	* acceleration is disabled after a video mode change.
2446	*
2447	* @param fEnable Current acceleration status.
2448	*/
2449	static DECLCALLBACK(void) vmmdevVBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
2450	{
2451	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2452
2453	Log(("vmmdevVBVAChange: fEnabled = %d\n", fEnabled));
2454
2455	if (pThis)
2456	{
2457	pThis->u32VideoAccelEnabled = fEnabled;
2458	}
2459	return;
2460	}
2461
2462	/**
2463	* Notification that a CPU is about to be unplugged from the VM.
2464	* The guest has to eject the CPU.
2465	*
2466	* @returns VBox status code.
2467	* @param idCpu The id of the CPU.
2468	* @param idCpuCore The core id of the CPU to remove.
2469	* @param idCpuPackage The package id of the CPU to remove.
2470	*/
2471	static DECLCALLBACK(int) vmmdevCpuHotUnplug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
2472	{
2473	int rc = VINF_SUCCESS;
2474	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2475
2476	Log(("vmmdevCpuHotUnplug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
2477
2478	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2479
2480	if (pThis->fCpuHotPlugEventsEnabled)
2481	{
2482	pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Unplug;
2483	pThis->idCpuCore = idCpuCore;
2484	pThis->idCpuPackage = idCpuPackage;
2485	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_CPU_HOTPLUG);
2486	}
2487	else
2488	rc = VERR_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
2489
2490	PDMCritSectLeave(&pThis->CritSect);
2491	return rc;
2492	}
2493
2494	/**
2495	* Notification that a CPU was attached to the VM
2496	* The guest may use it now.
2497	*
2498	* @returns VBox status code.
2499	* @param idCpuCore The core id of the CPU to add.
2500	* @param idCpuPackage The package id of the CPU to add.
2501	*/
2502	static DECLCALLBACK(int) vmmdevCpuHotPlug(PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage)
2503	{
2504	int rc = VINF_SUCCESS;
2505	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2506
2507	Log(("vmmdevCpuPlug: idCpuCore=%u idCpuPackage=%u\n", idCpuCore, idCpuPackage));
2508
2509	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
2510
2511	if (pThis->fCpuHotPlugEventsEnabled)
2512	{
2513	pThis->enmCpuHotPlugEvent = VMMDevCpuEventType_Plug;
2514	pThis->idCpuCore = idCpuCore;
2515	pThis->idCpuPackage = idCpuPackage;
2516	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_CPU_HOTPLUG);
2517	}
2518	else
2519	rc = VERR_CPU_HOTPLUG_NOT_MONITORED_BY_GUEST;
2520
2521	PDMCritSectLeave(&pThis->CritSect);
2522	return rc;
2523	}
2524
2525	/* -=-=-=-=-=- Saved State -=-=-=-=-=- */
2526
2527	/**
2528	* @copydoc FNSSMDEVLIVEEXEC
2529	*/
2530	static DECLCALLBACK(int) vmmdevLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
2531	{
2532	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2533
2534	SSMR3PutBool(pSSM, pThis->fGetHostTimeDisabled);
2535	SSMR3PutBool(pSSM, pThis->fBackdoorLogDisabled);
2536	SSMR3PutBool(pSSM, pThis->fKeepCredentials);
2537	SSMR3PutBool(pSSM, pThis->fHeapEnabled);
2538
2539	return VINF_SSM_DONT_CALL_AGAIN;
2540	}
2541
2542
2543	/**
2544	* @copydoc FNSSMDEVSAVEEXEC
2545	*
2546	*/
2547	static DECLCALLBACK(int) vmmdevSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2548	{
2549	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2550
2551	vmmdevLiveExec(pDevIns, pSSM, SSM_PASS_FINAL);
2552
2553	SSMR3PutU32(pSSM, pThis->hypervisorSize);
2554	SSMR3PutU32(pSSM, pThis->mouseCapabilities);
2555	SSMR3PutS32(pSSM, pThis->mouseXAbs);
2556	SSMR3PutS32(pSSM, pThis->mouseYAbs);
2557
2558	SSMR3PutBool(pSSM, pThis->fNewGuestFilterMask);
2559	SSMR3PutU32(pSSM, pThis->u32NewGuestFilterMask);
2560	SSMR3PutU32(pSSM, pThis->u32GuestFilterMask);
2561	SSMR3PutU32(pSSM, pThis->u32HostEventFlags);
2562	/* The following is not strictly necessary as PGM restores MMIO2, keeping it for historical reasons. */
2563	SSMR3PutMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof(pThis->pVMMDevRAMR3->V));
2564
2565	SSMR3PutMem(pSSM, &pThis->guestInfo, sizeof (pThis->guestInfo));
2566	SSMR3PutU32(pSSM, pThis->fu32AdditionsOk);
2567	SSMR3PutU32(pSSM, pThis->u32VideoAccelEnabled);
2568	SSMR3PutBool(pSSM, pThis->displayChangeData.fGuestSentChangeEventAck);
2569
2570	SSMR3PutU32(pSSM, pThis->guestCaps);
2571
2572	#ifdef VBOX_WITH_HGCM
2573	vmmdevHGCMSaveState(pThis, pSSM);
2574	#endif /* VBOX_WITH_HGCM */
2575
2576	SSMR3PutU32(pSSM, pThis->fHostCursorRequested);
2577
2578	return VINF_SUCCESS;
2579	}
2580
2581	/**
2582	* @copydoc FNSSMDEVLOADEXEC
2583	*/
2584	static DECLCALLBACK(int) vmmdevLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2585	{
2586	/** @todo The code load code is assuming we're always loaded into a freshly
2587	* constructed VM. */
2588	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2589	int rc;
2590
2591	if ( uVersion > VMMDEV_SAVED_STATE_VERSION
2592	\|\| uVersion < 6)
2593	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2594
2595	/* config */
2596	if (uVersion > VMMDEV_SAVED_STATE_VERSION_VBOX_30)
2597	{
2598	bool f;
2599	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2600	if (pThis->fGetHostTimeDisabled != f)
2601	LogRel(("VMMDev: Config mismatch - fGetHostTimeDisabled: config=%RTbool saved=%RTbool\n", pThis->fGetHostTimeDisabled, f));
2602
2603	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2604	if (pThis->fBackdoorLogDisabled != f)
2605	LogRel(("VMMDev: Config mismatch - fBackdoorLogDisabled: config=%RTbool saved=%RTbool\n", pThis->fBackdoorLogDisabled, f));
2606
2607	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2608	if (pThis->fKeepCredentials != f)
2609	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fKeepCredentials: config=%RTbool saved=%RTbool"),
2610	pThis->fKeepCredentials, f);
2611	rc = SSMR3GetBool(pSSM, &f); AssertRCReturn(rc, rc);
2612	if (pThis->fHeapEnabled != f)
2613	return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Config mismatch - fHeapEnabled: config=%RTbool saved=%RTbool"),
2614	pThis->fHeapEnabled, f);
2615	}
2616
2617	if (uPass != SSM_PASS_FINAL)
2618	return VINF_SUCCESS;
2619
2620	/* state */
2621	SSMR3GetU32(pSSM, &pThis->hypervisorSize);
2622	SSMR3GetU32(pSSM, &pThis->mouseCapabilities);
2623	SSMR3GetS32(pSSM, &pThis->mouseXAbs);
2624	SSMR3GetS32(pSSM, &pThis->mouseYAbs);
2625
2626	SSMR3GetBool(pSSM, &pThis->fNewGuestFilterMask);
2627	SSMR3GetU32(pSSM, &pThis->u32NewGuestFilterMask);
2628	SSMR3GetU32(pSSM, &pThis->u32GuestFilterMask);
2629	SSMR3GetU32(pSSM, &pThis->u32HostEventFlags);
2630
2631	// SSMR3GetBool(pSSM, &pThis->pVMMDevRAMR3->fHaveEvents);
2632	// here be dragons (probably)
2633	SSMR3GetMem(pSSM, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
2634
2635	SSMR3GetMem(pSSM, &pThis->guestInfo, sizeof (pThis->guestInfo));
2636	SSMR3GetU32(pSSM, &pThis->fu32AdditionsOk);
2637	SSMR3GetU32(pSSM, &pThis->u32VideoAccelEnabled);
2638	if (uVersion > 10)
2639	SSMR3GetBool(pSSM, &pThis->displayChangeData.fGuestSentChangeEventAck);
2640
2641	rc = SSMR3GetU32(pSSM, &pThis->guestCaps);
2642
2643	/* Attributes which were temporarily introduced in r30072 */
2644	if (uVersion == 7)
2645	{
2646	uint32_t temp;
2647	SSMR3GetU32(pSSM, &temp);
2648	rc = SSMR3GetU32(pSSM, &temp);
2649	}
2650	AssertRCReturn(rc, rc);
2651
2652	#ifdef VBOX_WITH_HGCM
2653	rc = vmmdevHGCMLoadState(pThis, pSSM, uVersion);
2654	AssertRCReturn(rc, rc);
2655	#endif /* VBOX_WITH_HGCM */
2656
2657	if (uVersion >= 10)
2658	rc = SSMR3GetU32(pSSM, &pThis->fHostCursorRequested);
2659	AssertRCReturn(rc, rc);
2660
2661	/*
2662	* On a resume, we send the capabilities changed message so
2663	* that listeners can sync their state again
2664	*/
2665	Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2666	if (pThis->pDrv)
2667	{
2668	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2669	if (uVersion >= 10)
2670	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
2671	/fVisible=/!!pThis->fHostCursorRequested,
2672	/fAlpha=/false,
2673	/xHot=/0, /yHot=/0,
2674	/cx=/0, /cy=/0,
2675	/pvShape=/NULL);
2676	}
2677
2678	/* Reestablish the acceleration status. */
2679	if ( pThis->u32VideoAccelEnabled
2680	&& pThis->pDrv)
2681	{
2682	pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMR3->vbvaMemory);
2683	}
2684
2685	if (pThis->fu32AdditionsOk)
2686	{
2687	LogRel(("Guest Additions information report: additionsVersion = 0x%08X, osType = 0x%08X\n",
2688	pThis->guestInfo.interfaceVersion,
2689	pThis->guestInfo.osType));
2690	if (pThis->pDrv)
2691	pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
2692	/** @todo Missing pfnUpdateGuestInfo2 */
2693	}
2694	if (pThis->pDrv)
2695	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2696
2697	return VINF_SUCCESS;
2698	}
2699
2700	/**
2701	* Load state done callback. Notify guest of restore event.
2702	*
2703	* @returns VBox status code.
2704	* @param pDevIns The device instance.
2705	* @param pSSM The handle to the saved state.
2706	*/
2707	static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2708	{
2709	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2710
2711	#ifdef VBOX_WITH_HGCM
2712	int rc = vmmdevHGCMLoadStateDone(pThis, pSSM);
2713	AssertLogRelRCReturn(rc, rc);
2714	#endif /* VBOX_WITH_HGCM */
2715
2716	VMMDevNotifyGuest(pThis, VMMDEV_EVENT_RESTORED);
2717
2718	return VINF_SUCCESS;
2719	}
2720
2721	/* -=-=-=-=- PDMDEVREG -=-=-=-=- */
2722
2723	/**
2724	* (Re-)initializes the MMIO2 data.
2725	*
2726	* @param pThis Pointer to the VMMDev instance data.
2727	*/
2728	static void vmmdevInitRam(VMMDevState *pThis)
2729	{
2730	memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
2731	pThis->pVMMDevRAMR3->u32Size = sizeof(VMMDevMemory);
2732	pThis->pVMMDevRAMR3->u32Version = VMMDEV_MEMORY_VERSION;
2733	}
2734
2735	/**
2736	* Reset notification.
2737	*
2738	* @returns VBox status.
2739	* @param pDrvIns The driver instance data.
2740	*/
2741	static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
2742	{
2743	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2744
2745	/*
2746	* Reset the mouse integration feature bits
2747	*/
2748	if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_MASK)
2749	{
2750	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_MASK;
2751	/* notify the connector */
2752	Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2753	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2754	}
2755	pThis->fHostCursorRequested = false;
2756
2757	pThis->hypervisorSize = 0;
2758
2759	/* re-initialize the VMMDev memory */
2760	if (pThis->pVMMDevRAMR3)
2761	vmmdevInitRam(pThis);
2762
2763	/* credentials have to go away (by default) */
2764	if (!pThis->fKeepCredentials)
2765	{
2766	memset(pThis->pCredentials->Logon.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2767	memset(pThis->pCredentials->Logon.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2768	memset(pThis->pCredentials->Logon.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2769	}
2770	memset(pThis->pCredentials->Judge.szUserName, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2771	memset(pThis->pCredentials->Judge.szPassword, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2772	memset(pThis->pCredentials->Judge.szDomain, '\0', VMMDEV_CREDENTIALS_SZ_SIZE);
2773
2774	/* Reset means that additions will report again. */
2775	const bool fVersionChanged = pThis->fu32AdditionsOk
2776	\|\| pThis->guestInfo.interfaceVersion
2777	\|\| pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
2778	if (fVersionChanged)
2779	Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
2780	pThis->fu32AdditionsOk, pThis->guestInfo.interfaceVersion, pThis->guestInfo.osType));
2781	pThis->fu32AdditionsOk = false;
2782	memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
2783
2784	/* clear pending display change request. */
2785	for (unsigned i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); i++)
2786	{
2787	DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[i];
2788	memset (&pRequest->lastReadDisplayChangeRequest, 0, sizeof (pRequest->lastReadDisplayChangeRequest));
2789	}
2790	pThis->displayChangeData.iCurrentMonitor = 0;
2791	pThis->displayChangeData.fGuestSentChangeEventAck = false;
2792
2793	/* disable seamless mode */
2794	pThis->fLastSeamlessEnabled = false;
2795
2796	/* disabled memory ballooning */
2797	pThis->u32LastMemoryBalloonSize = 0;
2798
2799	/* disabled statistics updating */
2800	pThis->u32LastStatIntervalSize = 0;
2801
2802	/* Clear the "HGCM event enabled" flag so the event can be automatically reenabled. */
2803	pThis->u32HGCMEnabled = 0;
2804
2805	/*
2806	* Clear the event variables.
2807	*
2808	* XXX By design we should NOT clear pThis->u32HostEventFlags because it is designed
2809	* that way so host events do not depend on guest resets. However, the pending
2810	* event flags actually _were_ cleared since ages so we mask out events from
2811	* clearing which we really need to survive the reset. See xtracker 5767.
2812	*/
2813	pThis->u32HostEventFlags &= VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
2814	pThis->u32GuestFilterMask = 0;
2815	pThis->u32NewGuestFilterMask = 0;
2816	pThis->fNewGuestFilterMask = 0;
2817
2818	/* This is the default, as Windows and OS/2 guests take this for granted. (Actually, neither does...) */
2819	/** @todo change this when we next bump the interface version */
2820	const bool fCapsChanged = pThis->guestCaps != VMMDEV_GUEST_SUPPORTS_GRAPHICS;
2821	if (fCapsChanged)
2822	Log(("vmmdevReset: fCapsChanged=%#x -> %#x\n", pThis->guestCaps, VMMDEV_GUEST_SUPPORTS_GRAPHICS));
2823	pThis->guestCaps = VMMDEV_GUEST_SUPPORTS_GRAPHICS; /** @todo r=bird: why? I cannot see this being done at construction?*/
2824
2825	/*
2826	* Call the update functions as required.
2827	*/
2828	if (fVersionChanged)
2829	pThis->pDrv->pfnUpdateGuestInfo(pThis->pDrv, &pThis->guestInfo);
2830	if (fCapsChanged)
2831	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2832
2833	/* Generate a unique session id for this VM; it will be changed for each start, reset or restore.
2834	* This can be used for restore detection inside the guest.
2835	*/
2836	pThis->idSession = ASMReadTSC();
2837	}
2838
2839
2840	/**
2841	* @interface_method_impl{PDMDEVREG,pfnRelocate}
2842	*/
2843	static DECLCALLBACK(void) vmmdevRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
2844	{
2845	NOREF(pDevIns);
2846	NOREF(offDelta);
2847	}
2848
2849
2850	/**
2851	* @interface_method_impl{PDMDEVREG,pfnDestruct}
2852	*/
2853	static DECLCALLBACK(int) vmmdevDestroy(PPDMDEVINS pDevIns)
2854	{
2855	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2856	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
2857
2858	/*
2859	* Wipe and free the credentials.
2860	*/
2861	if (pThis->pCredentials)
2862	{
2863	RTMemWipeThoroughly(pThis->pCredentials, sizeof(*pThis->pCredentials), 10);
2864	RTMemFree(pThis->pCredentials);
2865	pThis->pCredentials = NULL;
2866	}
2867
2868	return VINF_SUCCESS;
2869	}
2870
2871
2872	/**
2873	* @interface_method_impl{PDMDEVREG,pfnConstruct}
2874	*/
2875	static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
2876	{
2877	int rc;
2878	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
2879
2880	Assert(iInstance == 0);
2881	PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
2882
2883	/*
2884	* Initialize data (most of it anyway).
2885	*/
2886	/* Save PDM device instance data for future reference. */
2887	pThis->pDevIns = pDevIns;
2888
2889	/* PCI vendor, just a free bogus value */
2890	PCIDevSetVendorId(&pThis->dev, 0x80ee);
2891	/* device ID */
2892	PCIDevSetDeviceId(&pThis->dev, 0xcafe);
2893	/* class sub code (other type of system peripheral) */
2894	PCIDevSetClassSub(&pThis->dev, 0x80);
2895	/* class base code (base system peripheral) */
2896	PCIDevSetClassBase(&pThis->dev, 0x08);
2897	/* header type */
2898	PCIDevSetHeaderType(&pThis->dev, 0x00);
2899	/* interrupt on pin 0 */
2900	PCIDevSetInterruptPin(&pThis->dev, 0x01);
2901
2902	/*
2903	* Interfaces
2904	*/
2905	/* IBase */
2906	pThis->IBase.pfnQueryInterface = vmmdevPortQueryInterface;
2907
2908	/* VMMDev port */
2909	pThis->IPort.pfnQueryAbsoluteMouse = vmmdevQueryAbsoluteMouse;
2910	pThis->IPort.pfnSetAbsoluteMouse = vmmdevSetAbsoluteMouse;
2911	pThis->IPort.pfnQueryMouseCapabilities = vmmdevQueryMouseCapabilities;
2912	pThis->IPort.pfnUpdateMouseCapabilities = vmmdevUpdateMouseCapabilities;
2913	pThis->IPort.pfnRequestDisplayChange = vmmdevRequestDisplayChange;
2914	pThis->IPort.pfnSetCredentials = vmmdevSetCredentials;
2915	pThis->IPort.pfnVBVAChange = vmmdevVBVAChange;
2916	pThis->IPort.pfnRequestSeamlessChange = vmmdevRequestSeamlessChange;
2917	pThis->IPort.pfnSetMemoryBalloon = vmmdevSetMemoryBalloon;
2918	pThis->IPort.pfnSetStatisticsInterval = vmmdevSetStatisticsInterval;
2919	pThis->IPort.pfnVRDPChange = vmmdevVRDPChange;
2920	pThis->IPort.pfnCpuHotUnplug = vmmdevCpuHotUnplug;
2921	pThis->IPort.pfnCpuHotPlug = vmmdevCpuHotPlug;
2922
2923	/* Shared folder LED */
2924	pThis->SharedFolders.Led.u32Magic = PDMLED_MAGIC;
2925	pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
2926
2927	#ifdef VBOX_WITH_HGCM
2928	/* HGCM port */
2929	pThis->IHGCMPort.pfnCompleted = hgcmCompleted;
2930	#endif
2931
2932	pThis->pCredentials = (VMMDEVCREDS )RTMemAllocZ(sizeof(pThis->pCredentials));
2933	if (!pThis->pCredentials)
2934	return VERR_NO_MEMORY;
2935
2936
2937	/*
2938	* Validate and read the configuration.
2939	*/
2940	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns,
2941	"GetHostTimeDisabled\|"
2942	"BackdoorLogDisabled\|"
2943	"KeepCredentials\|"
2944	"HeapEnabled\|"
2945	"RamSize\|"
2946	"RZEnabled\|"
2947	"GuestCoreDumpEnabled\|"
2948	"GuestCoreDumpDir\|"
2949	"GuestCoreDumpCount\|"
2950	"TestingEnabled"
2951	,
2952	"");
2953
2954	rc = CFGMR3QueryU64(pCfg, "RamSize", &pThis->cbGuestRAM);
2955	if (RT_FAILURE(rc))
2956	return PDMDEV_SET_ERROR(pDevIns, rc,
2957	N_("Configuration error: Failed querying \"RamSize\" as a 64-bit unsigned integer"));
2958
2959	rc = CFGMR3QueryBoolDef(pCfg, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled, false);
2960	if (RT_FAILURE(rc))
2961	return PDMDEV_SET_ERROR(pDevIns, rc,
2962	N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
2963
2964	rc = CFGMR3QueryBoolDef(pCfg, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled, false);
2965	if (RT_FAILURE(rc))
2966	return PDMDEV_SET_ERROR(pDevIns, rc,
2967	N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
2968
2969	rc = CFGMR3QueryBoolDef(pCfg, "KeepCredentials", &pThis->fKeepCredentials, false);
2970	if (RT_FAILURE(rc))
2971	return PDMDEV_SET_ERROR(pDevIns, rc,
2972	N_("Configuration error: Failed querying \"KeepCredentials\" as a boolean"));
2973
2974	rc = CFGMR3QueryBoolDef(pCfg, "HeapEnabled", &pThis->fHeapEnabled, true);
2975	if (RT_FAILURE(rc))
2976	return PDMDEV_SET_ERROR(pDevIns, rc,
2977	N_("Configuration error: Failed querying \"HeapEnabled\" as a boolean"));
2978
2979	rc = CFGMR3QueryBoolDef(pCfg, "RZEnabled", &pThis->fRZEnabled, true);
2980	if (RT_FAILURE(rc))
2981	return PDMDEV_SET_ERROR(pDevIns, rc,
2982	N_("Configuration error: Failed querying \"RZEnabled\" as a boolean"));
2983
2984	rc = CFGMR3QueryBoolDef(pCfg, "GuestCoreDumpEnabled", &pThis->fGuestCoreDumpEnabled, false);
2985	if (RT_FAILURE(rc))
2986	return PDMDEV_SET_ERROR(pDevIns, rc,
2987	N_("Configuration error: Failed querying \"GuestCoreDumpEnabled\" as a boolean"));
2988
2989	char *pszGuestCoreDumpDir = NULL;
2990	rc = CFGMR3QueryStringAllocDef(pCfg, "GuestCoreDumpDir", &pszGuestCoreDumpDir, "");
2991	if (RT_FAILURE(rc))
2992	return PDMDEV_SET_ERROR(pDevIns, rc,
2993	N_("Configuration error: Failed querying \"GuestCoreDumpDir\" as a string"));
2994
2995	RTStrCopy(pThis->szGuestCoreDumpDir, sizeof(pThis->szGuestCoreDumpDir), pszGuestCoreDumpDir);
2996	MMR3HeapFree(pszGuestCoreDumpDir);
2997
2998	rc = CFGMR3QueryU32Def(pCfg, "GuestCoreDumpCount", &pThis->cGuestCoreDumps, 3);
2999	if (RT_FAILURE(rc))
3000	return PDMDEV_SET_ERROR(pDevIns, rc,
3001	N_("Configuration error: Failed querying \"GuestCoreDumpCount\" as a 32-bit unsigned integer"));
3002
3003	#ifndef VBOX_WITHOUT_TESTING_FEATURES
3004	rc = CFGMR3QueryBoolDef(pCfg, "TestingEnabled", &pThis->fTestingEnabled, false);
3005	if (RT_FAILURE(rc))
3006	return PDMDEV_SET_ERROR(pDevIns, rc,
3007	N_("Configuration error: Failed querying \"TestingEnabled\" as a boolean"));
3008	/** @todo image-to-load-filename? */
3009	#endif
3010
3011	/*
3012	* Create the critical section for the device.
3013	*/
3014	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "VMMDev#u", iInstance);
3015	AssertRCReturn(rc, rc);
3016	/* Later: pDevIns->pCritSectR3 = &pThis->CritSect; */
3017
3018	/*
3019	* Register the backdoor logging port
3020	*/
3021	rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog, NULL, NULL, NULL, "VMMDev backdoor logging");
3022	AssertRCReturn(rc, rc);
3023
3024	#ifdef TIMESYNC_BACKDOOR
3025	/*
3026	* Alternative timesync source (temporary!)
3027	*/
3028	rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL, vmmdevTimesyncBackdoorWrite, vmmdevTimesyncBackdoorRead, NULL, NULL, "VMMDev timesync backdoor");
3029	AssertRCReturn(rc, rc);
3030	#endif
3031
3032	/*
3033	* Allocate and initialize the MMIO2 memory.
3034	*/
3035	rc = PDMDevHlpMMIO2Register(pDevIns, 1 /iRegion/, VMMDEV_RAM_SIZE, 0 /fFlags/, (void **)&pThis->pVMMDevRAMR3, "VMMDev");
3036	if (RT_FAILURE(rc))
3037	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
3038	N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
3039	vmmdevInitRam(pThis);
3040
3041	if (pThis->fHeapEnabled)
3042	{
3043	rc = PDMDevHlpMMIO2Register(pDevIns, 2 /iRegion/, VMMDEV_HEAP_SIZE, 0 /fFlags/, (void **)&pThis->pVMMDevHeapR3, "VMMDev Heap");
3044	if (RT_FAILURE(rc))
3045	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
3046	N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
3047	}
3048
3049	/*
3050	* Register the PCI device.
3051	*/
3052	rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
3053	if (RT_FAILURE(rc))
3054	return rc;
3055	if (pThis->dev.devfn != 32 \|\| iInstance != 0)
3056	Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or no started by Main)\n", pThis->dev.devfn));
3057	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
3058	if (RT_FAILURE(rc))
3059	return rc;
3060	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, VMMDEV_RAM_SIZE, PCI_ADDRESS_SPACE_MEM, vmmdevIORAMRegionMap);
3061	if (RT_FAILURE(rc))
3062	return rc;
3063	if (pThis->fHeapEnabled)
3064	{
3065	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, VMMDEV_HEAP_SIZE, PCI_ADDRESS_SPACE_MEM_PREFETCH, vmmdevIORAMRegionMap);
3066	if (RT_FAILURE(rc))
3067	return rc;
3068	}
3069
3070	#ifndef VBOX_WITHOUT_TESTING_FEATURES
3071	/*
3072	* Initialize testing.
3073	*/
3074	rc = vmmdevTestingInitialize(pDevIns);
3075	if (RT_FAILURE(rc))
3076	return rc;
3077	#endif
3078
3079	/*
3080	* Get the corresponding connector interface
3081	*/
3082	rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "VMM Driver Port");
3083	if (RT_SUCCESS(rc))
3084	{
3085	pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIVMMDEVCONNECTOR);
3086	AssertMsgReturn(pThis->pDrv, ("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
3087	#ifdef VBOX_WITH_HGCM
3088	pThis->pHGCMDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIHGCMCONNECTOR);
3089	if (!pThis->pHGCMDrv)
3090	{
3091	Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Rrc\n", rc));
3092	/* this is not actually an error, just means that there is no support for HGCM */
3093	}
3094	#endif
3095	/* Query the initial balloon size. */
3096	AssertPtr(pThis->pDrv->pfnQueryBalloonSize);
3097	rc = pThis->pDrv->pfnQueryBalloonSize(pThis->pDrv, &pThis->u32MemoryBalloonSize);
3098	AssertRC(rc);
3099
3100	Log(("Initial balloon size %x\n", pThis->u32MemoryBalloonSize));
3101	}
3102	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
3103	{
3104	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
3105	rc = VINF_SUCCESS;
3106	}
3107	else
3108	AssertMsgFailedReturn(("Failed to attach LUN #0! rc=%Rrc\n", rc), rc);
3109
3110	/*
3111	* Attach status driver for shared folders (optional).
3112	*/
3113	PPDMIBASE pBase;
3114	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->IBase, &pBase, "Status Port");
3115	if (RT_SUCCESS(rc))
3116	pThis->SharedFolders.pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
3117	else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
3118	{
3119	AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
3120	return rc;
3121	}
3122
3123	/*
3124	* Register saved state and init the HGCM CmdList critsect.
3125	*/
3126	rc = PDMDevHlpSSMRegisterEx(pDevIns, VMMDEV_SAVED_STATE_VERSION, sizeof(*pThis), NULL,
3127	NULL, vmmdevLiveExec, NULL,
3128	NULL, vmmdevSaveExec, NULL,
3129	NULL, vmmdevLoadExec, vmmdevLoadStateDone);
3130	AssertRCReturn(rc, rc);
3131
3132	#ifdef VBOX_WITH_HGCM
3133	pThis->pHGCMCmdList = NULL;
3134	rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
3135	AssertRCReturn(rc, rc);
3136	pThis->u32HGCMEnabled = 0;
3137	#endif /* VBOX_WITH_HGCM */
3138
3139	/* In this version of VirtualBox the GUI checks whether "needs host cursor"
3140	* changes. */
3141	pThis->mouseCapabilities \|= VMMDEV_MOUSE_HOST_RECHECKS_NEEDS_HOST_CURSOR;
3142
3143	PDMDevHlpSTAMRegisterF(pDevIns, &pThis->StatMemBalloonChunks, STAMTYPE_U32, STAMVISIBILITY_ALWAYS, STAMUNIT_COUNT, "Memory balloon size", "/Devices/VMMDev/BalloonChunks");
3144
3145	/* Generate a unique session id for this VM; it will be changed for each start, reset or restore.
3146	* This can be used for restore detection inside the guest.
3147	*/
3148	pThis->idSession = ASMReadTSC();
3149	return rc;
3150	}
3151
3152	/**
3153	* The device registration structure.
3154	*/
3155	extern "C" const PDMDEVREG g_DeviceVMMDev =
3156	{
3157	/* u32Version */
3158	PDM_DEVREG_VERSION,
3159	/* szName */
3160	"VMMDev",
3161	/* szRCMod */
3162	"VBoxDDGC.gc",
3163	/* szR0Mod */
3164	"VBoxDDR0.r0",
3165	/* pszDescription */
3166	"VirtualBox VMM Device\n",
3167	/* fFlags */
3168	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0,
3169	/* fClass */
3170	PDM_DEVREG_CLASS_VMM_DEV,
3171	/* cMaxInstances */
3172	1,
3173	/* cbInstance */
3174	sizeof(VMMDevState),
3175	/* pfnConstruct */
3176	vmmdevConstruct,
3177	/* pfnDestruct */
3178	NULL,
3179	/* pfnRelocate */
3180	vmmdevRelocate,
3181	/* pfnIOCtl */
3182	NULL,
3183	/* pfnPowerOn */
3184	NULL,
3185	/* pfnReset */
3186	vmmdevReset,
3187	/* pfnSuspend */
3188	NULL,
3189	/* pfnResume */
3190	NULL,
3191	/* pfnAttach */
3192	NULL,
3193	/* pfnDetach */
3194	NULL,
3195	/* pfnQueryInterface. */
3196	NULL,
3197	/* pfnInitComplete */
3198	NULL,
3199	/* pfnPowerOff */
3200	NULL,
3201	/* pfnSoftReset */
3202	NULL,
3203	/* u32VersionEnd */
3204	PDM_DEVREG_VERSION
3205	};
3206	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */

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

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

Download in other formats: