VMMDev.cpp@ 21231

Last change on this file since 21231 was 21231, checked in by vboxsync, 16 years ago
VMMDev/VBoxDev.cpp -> VMMDev/VMMDev.cpp
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 97.7 KB

Line
1	/* $Id: VMMDev.cpp 21231 2009-07-05 20:04:13Z vboxsync $ */
2	/** @file
3	* VMMDev - Guest <-> VMM/Host communication device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	/* #define LOG_ENABLED */
27	/* Enable dev_vmm Log3 statements to get IRQ-related logging. */
28
29	#define LOG_GROUP LOG_GROUP_DEV_VMM
30	#include <VBox/VMMDev.h>
31	#include <VBox/log.h>
32	#include <VBox/param.h>
33	#include <VBox/mm.h>
34	#include <VBox/pgm.h>
35	#include <VBox/err.h>
36	#include <VBox/vm.h> /* for VM_IS_EMT */
37
38	#include <iprt/assert.h>
39	#include <iprt/string.h>
40	#include <iprt/time.h>
41	#ifndef IN_RC
42	# include <iprt/mem.h>
43	#endif
44
45	#include "VMMDevState.h"
46	#ifdef VBOX_WITH_HGCM
47	# include "VMMDevHGCM.h"
48	#endif
49
50
51	/*******************************************************************************
52	* Defined Constants And Macros *
53	*******************************************************************************/
54	#define PCIDEV_2_VMMDEVSTATE(pPciDev) ( (VMMDevState *)(pPciDev) )
55	#define VMMDEVSTATE_2_DEVINS(pVMMDevState) ( (pVMMDevState)->pDevIns )
56
57	#define VBOX_GUEST_ADDITIONS_VERSION_1_03(s) \
58	((RT_HIWORD ((s)->guestInfo.additionsVersion) == 1) && \
59	(RT_LOWORD ((s)->guestInfo.additionsVersion) == 3))
60
61	#define VBOX_GUEST_ADDITIONS_VERSION_OK(additionsVersion) \
62	(RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
63	&& RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION))
64
65	#define VBOX_GUEST_ADDITIONS_VERSION_OLD(additionsVersion) \
66	((RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION) \
67	\|\| ((RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
68	&& RT_LOWORD(additionsVersion) <= RT_LOWORD(VMMDEV_VERSION))
69
70	#define VBOX_GUEST_ADDITIONS_VERSION_TOO_OLD(additionsVersion) \
71	(RT_HIWORD(additionsVersion) < RT_HIWORD(VMMDEV_VERSION))
72
73	#define VBOX_GUEST_ADDITIONS_VERSION_NEW(additionsVersion) \
74	((RT_HIWORD(additionsVersion) > RT_HIWORD(VMMDEV_VERSION) \
75	\|\| ((RT_HIWORD(additionsVersion) == RT_HIWORD(VMMDEV_VERSION) \
76	&& RT_LOWORD(additionsVersion) > RT_LOWORD(VMMDEV_VERSION))
77
78	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
79
80	/* Whenever host wants to inform guest about something
81	* an IRQ notification will be raised.
82	*
83	* VMMDev PDM interface will contain the guest notification method.
84	*
85	* There is a 32 bit event mask which will be read
86	* by guest on an interrupt. A non zero bit in the mask
87	* means that the specific event occurred and requires
88	* processing on guest side.
89	*
90	* After reading the event mask guest must issue a
91	* generic request AcknowlegdeEvents.
92	*
93	* IRQ line is set to 1 (request) if there are unprocessed
94	* events, that is the event mask is not zero.
95	*
96	* After receiving an interrupt and checking event mask,
97	* the guest must process events using the event specific
98	* mechanism.
99	*
100	* That is if mouse capabilities were changed,
101	* guest will use VMMDev_GetMouseStatus generic request.
102	*
103	* Event mask is only a set of flags indicating that guest
104	* must proceed with a procedure.
105	*
106	* Unsupported events are therefore ignored.
107	* The guest additions must inform host which events they
108	* want to receive, to avoid unnecessary IRQ processing.
109	* By default no events are signalled to guest.
110	*
111	* This seems to be fast method. It requires
112	* only one context switch for an event processing.
113	*
114	*/
115
116	static void vmmdevSetIRQ_Legacy_EMT (VMMDevState *pVMMDevState)
117	{
118	if (!pVMMDevState->fu32AdditionsOk)
119	{
120	Log(("vmmdevSetIRQ: IRQ is not generated, guest has not yet reported to us.\n"));
121	return;
122	}
123
124	uint32_t u32IRQLevel = 0;
125
126	/* Filter unsupported events */
127	uint32_t u32EventFlags =
128	pVMMDevState->u32HostEventFlags
129	& pVMMDevState->pVMMDevRAMR3->V.V1_03.u32GuestEventMask;
130
131	Log(("vmmdevSetIRQ: u32EventFlags = 0x%08X, "
132	"pVMMDevState->u32HostEventFlags = 0x%08X, "
133	"pVMMDevState->pVMMDevRAMR3->u32GuestEventMask = 0x%08X\n",
134	u32EventFlags,
135	pVMMDevState->u32HostEventFlags,
136	pVMMDevState->pVMMDevRAMR3->V.V1_03.u32GuestEventMask));
137
138	/* Move event flags to VMMDev RAM */
139	pVMMDevState->pVMMDevRAMR3->V.V1_03.u32HostEvents = u32EventFlags;
140
141	if (u32EventFlags)
142	{
143	/* Clear host flags which will be delivered to guest. */
144	pVMMDevState->u32HostEventFlags &= ~u32EventFlags;
145	Log(("vmmdevSetIRQ: pVMMDevState->u32HostEventFlags = 0x%08X\n",
146	pVMMDevState->u32HostEventFlags));
147	u32IRQLevel = 1;
148	}
149
150	/* Set IRQ level for pin 0 */
151	/** @todo make IRQ pin configurable, at least a symbolic constant */
152	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
153	PDMDevHlpPCISetIrqNoWait(pDevIns, 0, u32IRQLevel);
154	Log(("vmmdevSetIRQ: IRQ set %d\n", u32IRQLevel));
155	}
156
157	static void vmmdevMaybeSetIRQ_EMT (VMMDevState *pVMMDevState)
158	{
159	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS (pVMMDevState);
160
161	Log3(("vmmdevMaybeSetIRQ_EMT: u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
162	pVMMDevState->u32HostEventFlags, pVMMDevState->u32GuestFilterMask));
163
164	if (pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask)
165	{
166	pVMMDevState->pVMMDevRAMR3->V.V1_04.fHaveEvents = true;
167	PDMDevHlpPCISetIrqNoWait (pDevIns, 0, 1);
168	Log3(("vmmdevMaybeSetIRQ_EMT: IRQ set.\n"));
169	}
170	}
171
172	static void vmmdevNotifyGuest_EMT (VMMDevState *pVMMDevState, uint32_t u32EventMask)
173	{
174	Log3(("VMMDevNotifyGuest_EMT: u32EventMask = 0x%08X.\n", u32EventMask));
175
176	if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pVMMDevState))
177	{
178	Log3(("VMMDevNotifyGuest_EMT: Old additions detected.\n"));
179
180	pVMMDevState->u32HostEventFlags \|= u32EventMask;
181	vmmdevSetIRQ_Legacy_EMT (pVMMDevState);
182	}
183	else
184	{
185	Log3(("VMMDevNotifyGuest_EMT: New additions detected.\n"));
186
187	if (!pVMMDevState->fu32AdditionsOk)
188	{
189	pVMMDevState->u32HostEventFlags \|= u32EventMask;
190	Log(("vmmdevNotifyGuest_EMT: IRQ is not generated, guest has not yet reported to us.\n"));
191	return;
192	}
193
194	const bool fHadEvents =
195	(pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask) != 0;
196
197	Log3(("VMMDevNotifyGuest_EMT: fHadEvents = %d, u32HostEventFlags = 0x%08X, u32GuestFilterMask = 0x%08X.\n",
198	fHadEvents, pVMMDevState->u32HostEventFlags, pVMMDevState->u32GuestFilterMask));
199
200	pVMMDevState->u32HostEventFlags \|= u32EventMask;
201
202	if (!fHadEvents)
203	vmmdevMaybeSetIRQ_EMT (pVMMDevState);
204	}
205	}
206
207	static void vmmdevCtlGuestFilterMask_EMT (VMMDevState *pVMMDevState,
208	uint32_t u32OrMask,
209	uint32_t u32NotMask)
210	{
211	const bool fHadEvents =
212	(pVMMDevState->u32HostEventFlags & pVMMDevState->u32GuestFilterMask) != 0;
213
214	Log(("vmmdevCtlGuestFilterMask_EMT: u32OrMask = 0x%08X, u32NotMask = 0x%08X, fHadEvents = %d.\n", u32OrMask, u32NotMask, fHadEvents));
215	if (fHadEvents)
216	{
217	if (!pVMMDevState->fNewGuestFilterMask)
218	pVMMDevState->u32NewGuestFilterMask = pVMMDevState->u32GuestFilterMask;
219
220	pVMMDevState->u32NewGuestFilterMask \|= u32OrMask;
221	pVMMDevState->u32NewGuestFilterMask &= ~u32NotMask;
222	pVMMDevState->fNewGuestFilterMask = true;
223	}
224	else
225	{
226	pVMMDevState->u32GuestFilterMask \|= u32OrMask;
227	pVMMDevState->u32GuestFilterMask &= ~u32NotMask;
228	vmmdevMaybeSetIRQ_EMT (pVMMDevState);
229	}
230	}
231
232	void VMMDevCtlSetGuestFilterMask (VMMDevState *pVMMDevState,
233	uint32_t u32OrMask,
234	uint32_t u32NotMask)
235	{
236	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
237	PVM pVM = PDMDevHlpGetVM(pDevIns);
238
239	Log(("VMMDevCtlSetGuestFilterMask: u32OrMask = 0x%08X, u32NotMask = 0x%08X.\n", u32OrMask, u32NotMask));
240
241	if (VM_IS_EMT(pVM))
242	{
243	vmmdevCtlGuestFilterMask_EMT (pVMMDevState, u32OrMask, u32NotMask);
244	}
245	else
246	{
247	int rc;
248	PVMREQ pReq;
249
250	rc = VMR3ReqCallVoid (pVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT,
251	(PFNRT) vmmdevCtlGuestFilterMask_EMT,
252	3, pVMMDevState, u32OrMask, u32NotMask);
253	AssertReleaseRC (rc);
254	VMR3ReqFree (pReq);
255	}
256	}
257
258	void VMMDevNotifyGuest (VMMDevState *pVMMDevState, uint32_t u32EventMask)
259	{
260	PPDMDEVINS pDevIns = VMMDEVSTATE_2_DEVINS(pVMMDevState);
261	PVM pVM = PDMDevHlpGetVM(pDevIns);
262	int rc;
263
264	Log3(("VMMDevNotifyGuest: u32EventMask = 0x%08X.\n", u32EventMask));
265
266	/*
267	* Drop notifications if the VM is not running yet/anymore.
268	*/
269	if (PDMDevHlpVMState(pDevIns) != VMSTATE_RUNNING)
270	return;
271
272	/* No need to wait for the completion of this request. It is a notification
273	* about something, which has already happened.
274	*/
275	rc = VMR3ReqCallEx(pVM, VMCPUID_ANY, NULL, 0, VMREQFLAGS_NO_WAIT \| VMREQFLAGS_VOID,
276	(PFNRT) vmmdevNotifyGuest_EMT,
277	2, pVMMDevState, u32EventMask);
278	AssertRC(rc);
279	}
280
281	/**
282	* Port I/O Handler for OUT operations.
283	*
284	* @returns VBox status code.
285	*
286	* @param pDevIns The device instance.
287	* @param pvUser User argument - ignored.
288	* @param uPort Port number used for the IN operation.
289	* @param u32 The value to output.
290	* @param cb The value size in bytes.
291	*/
292	static DECLCALLBACK(int) vmmdevBackdoorLog(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
293	{
294	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
295
296	if (!pThis->fBackdoorLogDisabled && cb == 1 && Port == RTLOG_DEBUG_PORT)
297	{
298
299	/* The raw version. */
300	switch (u32)
301	{
302	case '\r': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <return>\n")); break;
303	case '\n': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <newline>\n")); break;
304	case '\t': LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: <tab>\n")); break;
305	default: LogIt(LOG_INSTANCE, RTLOGGRPFLAGS_LEVEL_2, LOG_GROUP_DEV_VMM_BACKDOOR, ("vmmdev: %c (%02x)\n", u32, u32)); break;
306	}
307
308	/* The readable, buffered version. */
309	if (u32 == '\n' \|\| u32 == '\r')
310	{
311	pThis->szMsg[pThis->iMsg] = '\0';
312	if (pThis->iMsg)
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	else
317	{
318	if (pThis->iMsg >= sizeof(pThis->szMsg)-1)
319	{
320	pThis->szMsg[pThis->iMsg] = '\0';
321	LogRelIt(LOG_REL_INSTANCE, RTLOGGRPFLAGS_LEVEL_1, LOG_GROUP_DEV_VMM_BACKDOOR, ("Guest Log: %s\n", pThis->szMsg));
322	pThis->iMsg = 0;
323	}
324	pThis->szMsg[pThis->iMsg] = (char )u32;
325	pThis->szMsg[++pThis->iMsg] = '\0';
326	}
327	}
328	return VINF_SUCCESS;
329	}
330
331	#ifdef TIMESYNC_BACKDOOR
332	/**
333	* Port I/O Handler for OUT operations.
334	*
335	* @returns VBox status code.
336	*
337	* @param pDevIns The device instance.
338	* @param pvUser User argument - ignored.
339	* @param uPort Port number used for the IN operation.
340	* @param u32 The value to output.
341	* @param cb The value size in bytes.
342	*/
343	static DECLCALLBACK(int) vmmdevTimesyncBackdoorWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
344	{
345	NOREF(pvUser);
346	if (cb == 4)
347	{
348	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
349	switch (u32)
350	{
351	case 0:
352	pThis->fTimesyncBackdoorLo = false;
353	break;
354	case 1:
355	pThis->fTimesyncBackdoorLo = true;
356	}
357	return VINF_SUCCESS;
358
359	}
360	return VINF_SUCCESS;
361	}
362
363	/**
364	* Port I/O Handler for backdoor timesync IN operations.
365	*
366	* @returns VBox status code.
367	*
368	* @param pDevIns The device instance.
369	* @param pvUser User argument - ignored.
370	* @param uPort Port number used for the IN operation.
371	* @param pu32 Where to store the result.
372	* @param cb Number of bytes read.
373	*/
374	static DECLCALLBACK(int) vmmdevTimesyncBackdoorRead(PPDMDEVINS pDevIns, void pvUser, RTIOPORT Port, uint32_t pu32, unsigned cb)
375	{
376	int rc;
377	NOREF(pvUser);
378	if (cb == 4)
379	{
380	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
381	RTTIMESPEC now;
382
383	if (pThis->fTimesyncBackdoorLo)
384	*pu32 = (uint32_t)pThis->hostTime;
385	else
386	{
387	pThis->hostTime = RTTimeSpecGetMilli(PDMDevHlpUTCNow(pDevIns, &now));
388	*pu32 = (uint32_t)(pThis->hostTime >> 32);
389	}
390	rc = VINF_SUCCESS;
391	}
392	else
393	rc = VERR_IOM_IOPORT_UNUSED;
394	return rc;
395	}
396	#endif /* TIMESYNC_BACKDOOR */
397
398	/**
399	* Port I/O Handler for the generic request interface
400	* @see FNIOMIOPORTOUT for details.
401	*
402	* @todo Too long, suggest doing the request copying here and moving the
403	* switch into a different function (or better case -> functions), and
404	* looing the gotos.
405	*/
406	static DECLCALLBACK(int) vmmdevRequestHandler(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
407	{
408	VMMDevState pThis = (VMMDevState)pvUser;
409	int rcRet = VINF_SUCCESS;
410	PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
411
412	/*
413	* The caller has passed the guest context physical address
414	* of the request structure. Copy the request packet.
415	*/
416	VMMDevRequestHeader requestHeader = {0};
417	VMMDevRequestHeader *pRequestHeader = NULL;
418
419	PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
420
421	/* the structure size must be greater or equal to the header size */
422	if (requestHeader.size < sizeof(VMMDevRequestHeader))
423	{
424	Log(("VMMDev request header size too small! size = %d\n", requestHeader.size));
425	rcRet = VINF_SUCCESS;
426	goto end; /** @todo shouldn't (/ no need to) write back.*/
427	}
428
429	/* check the version of the header structure */
430	if (requestHeader.version != VMMDEV_REQUEST_HEADER_VERSION)
431	{
432	Log(("VMMDev: guest header version (0x%08X) differs from ours (0x%08X)\n", requestHeader.version, VMMDEV_REQUEST_HEADER_VERSION));
433	rcRet = VINF_SUCCESS;
434	goto end; /** @todo shouldn't (/ no need to) write back.*/
435	}
436
437	Log2(("VMMDev request issued: %d\n", requestHeader.requestType));
438
439	if ( requestHeader.requestType != VMMDevReq_ReportGuestInfo
440	&& !pThis->fu32AdditionsOk)
441	{
442	Log(("VMMDev: guest has not yet reported to us. Refusing operation.\n"));
443	requestHeader.rc = VERR_NOT_SUPPORTED;
444	rcRet = VINF_SUCCESS;
445	goto end;
446	}
447
448	/* Check upper limit */
449	if (requestHeader.size > VMMDEV_MAX_VMMDEVREQ_SIZE)
450	{
451	LogRel(("VMMDev: request packet too big (%x). Refusing operation.\n", requestHeader.size));
452	requestHeader.rc = VERR_NOT_SUPPORTED;
453	rcRet = VINF_SUCCESS;
454	goto end;
455	}
456
457	/* Read the entire request packet */
458	pRequestHeader = (VMMDevRequestHeader *)RTMemAlloc(requestHeader.size);
459	if (!pRequestHeader)
460	{
461	Log(("VMMDev: RTMemAlloc failed!\n"));
462	rcRet = VINF_SUCCESS;
463	requestHeader.rc = VERR_NO_MEMORY;
464	goto end;
465	}
466	PDMDevHlpPhysRead(pDevIns, (RTGCPHYS)u32, pRequestHeader, requestHeader.size);
467
468	/* which request was sent? */
469	switch (pRequestHeader->requestType)
470	{
471	/*
472	* Guest wants to give up a timeslice
473	*/
474	case VMMDevReq_Idle:
475	{
476	/* just return to EMT telling it that we want to halt */
477	rcRet = VINF_EM_HALT;
478	break;
479	}
480
481	/*
482	* Guest is reporting its information
483	*/
484	case VMMDevReq_ReportGuestInfo:
485	{
486	if (pRequestHeader->size < sizeof(VMMDevReportGuestInfo))
487	{
488	AssertMsgFailed(("VMMDev guest information structure has invalid size!\n"));
489	pRequestHeader->rc = VERR_INVALID_PARAMETER;
490	}
491	else
492	{
493	VMMDevReportGuestInfo guestInfo = (VMMDevReportGuestInfo)pRequestHeader;
494
495	if (memcmp (&pThis->guestInfo, &guestInfo->guestInfo, sizeof (guestInfo->guestInfo)) != 0)
496	{
497	/* make a copy of supplied information */
498	pThis->guestInfo = guestInfo->guestInfo;
499
500	/* Check additions version */
501	pThis->fu32AdditionsOk = VBOX_GUEST_ADDITIONS_VERSION_OK(pThis->guestInfo.additionsVersion);
502
503	LogRel(("Guest Additions information report: additionsVersion = 0x%08X osType = 0x%08X\n",
504	pThis->guestInfo.additionsVersion,
505	pThis->guestInfo.osType));
506	pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
507	}
508
509	if (pThis->fu32AdditionsOk)
510	{
511	pRequestHeader->rc = VINF_SUCCESS;
512	}
513	else
514	{
515	pRequestHeader->rc = VERR_VERSION_MISMATCH;
516	}
517	}
518	break;
519	}
520
521	/* Report guest capabilities */
522	case VMMDevReq_ReportGuestCapabilities:
523	{
524	if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities))
525	{
526	AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
527	pRequestHeader->rc = VERR_INVALID_PARAMETER;
528	}
529	else
530	{
531	VMMDevReqGuestCapabilities guestCaps = (VMMDevReqGuestCapabilities)pRequestHeader;
532
533	/* Enable this automatically for guests using the old
534	request to report their capabilities. */
535	/** @todo change this when we next bump the interface version */
536	guestCaps->caps \|= VMMDEV_GUEST_SUPPORTS_GRAPHICS;
537	if (pThis->guestCaps != guestCaps->caps)
538	{
539	/* make a copy of supplied information */
540	pThis->guestCaps = guestCaps->caps;
541
542	LogRel(("Guest Additions capability report: (0x%x) "
543	"seamless: %s, "
544	"hostWindowMapping: %s, "
545	"graphics: %s\n",
546	guestCaps->caps,
547	guestCaps->caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
548	guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
549	guestCaps->caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
550
551	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, guestCaps->caps);
552	}
553	pRequestHeader->rc = VINF_SUCCESS;
554	}
555	break;
556	}
557
558	/* Change guest capabilities */
559	case VMMDevReq_SetGuestCapabilities:
560	{
561	if (pRequestHeader->size != sizeof(VMMDevReqGuestCapabilities2))
562	{
563	AssertMsgFailed(("VMMDev guest caps structure has invalid size!\n"));
564	pRequestHeader->rc = VERR_INVALID_PARAMETER;
565	}
566	else
567	{
568	VMMDevReqGuestCapabilities2 guestCaps = (VMMDevReqGuestCapabilities2)pRequestHeader;
569
570	pThis->guestCaps \|= guestCaps->u32OrMask;
571	pThis->guestCaps &= ~guestCaps->u32NotMask;
572
573	LogRel(("Guest Additions capability report: (0x%x) "
574	"seamless: %s, "
575	"hostWindowMapping: %s, "
576	"graphics: %s\n",
577	pThis->guestCaps,
578	pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS ? "yes" : "no",
579	pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING ? "yes" : "no",
580	pThis->guestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS ? "yes" : "no"));
581
582	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
583	pRequestHeader->rc = VINF_SUCCESS;
584	}
585	break;
586	}
587
588	/*
589	* Retrieve mouse information
590	*/
591	case VMMDevReq_GetMouseStatus:
592	{
593	if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
594	{
595	AssertMsgFailed(("VMMDev mouse status structure has invalid size!\n"));
596	pRequestHeader->rc = VERR_INVALID_PARAMETER;
597	}
598	else
599	{
600	VMMDevReqMouseStatus mouseStatus = (VMMDevReqMouseStatus)pRequestHeader;
601	mouseStatus->mouseFeatures = 0;
602	if (pThis->mouseCapabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
603	{
604	mouseStatus->mouseFeatures \|= VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
605	}
606	if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
607	{
608	mouseStatus->mouseFeatures \|= VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
609	}
610	if (pThis->mouseCapabilities & VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER)
611	{
612	mouseStatus->mouseFeatures \|= VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
613	}
614	mouseStatus->pointerXPos = pThis->mouseXAbs;
615	mouseStatus->pointerYPos = pThis->mouseYAbs;
616	Log2(("returning mouse status: features = %d, absX = %d, absY = %d\n", mouseStatus->mouseFeatures,
617	mouseStatus->pointerXPos, mouseStatus->pointerYPos));
618	pRequestHeader->rc = VINF_SUCCESS;
619	}
620	break;
621	}
622
623	/*
624	* Set mouse information
625	*/
626	case VMMDevReq_SetMouseStatus:
627	{
628	if (pRequestHeader->size != sizeof(VMMDevReqMouseStatus))
629	{
630	AssertMsgFailed(("VMMDev mouse status structure has invalid size %d (%#x) version=%d!\n",
631	pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
632	pRequestHeader->rc = VERR_INVALID_PARAMETER;
633	}
634	else
635	{
636	bool bCapsChanged = false;
637
638	VMMDevReqMouseStatus mouseStatus = (VMMDevReqMouseStatus)pRequestHeader;
639
640	/* check if the guest wants absolute coordinates */
641	if (mouseStatus->mouseFeatures & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
642	{
643	/* set the capability flag and the changed flag if it's actually a change */
644	if (!(pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE))
645	{
646	pThis->mouseCapabilities \|= VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
647	bCapsChanged = true;
648	LogRel(("Guest requests mouse pointer integration\n"));
649	}
650	} else
651	{
652	if (pThis->mouseCapabilities & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
653	{
654	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
655	bCapsChanged = true;
656	LogRel(("Guest disables mouse pointer integration\n"));
657	}
658	}
659	if (mouseStatus->mouseFeatures & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR)
660	pThis->mouseCapabilities \|= VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR;
661	else
662	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR;
663	if (mouseStatus->mouseFeatures & VMMDEV_MOUSE_GUEST_USES_VMMDEV)
664	pThis->mouseCapabilities \|= VMMDEV_MOUSE_GUEST_USES_VMMDEV;
665	else
666	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_USES_VMMDEV;
667
668	/*
669	* Notify connector if something has changed
670	*/
671	if (bCapsChanged)
672	{
673	Log(("VMMDevReq_SetMouseStatus: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
674	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
675	}
676	pRequestHeader->rc = VINF_SUCCESS;
677	}
678
679	break;
680	}
681
682	/*
683	* Set a new mouse pointer shape
684	*/
685	case VMMDevReq_SetPointerShape:
686	{
687	if (pRequestHeader->size < sizeof(VMMDevReqMousePointer))
688	{
689	AssertMsg(pRequestHeader->size == 0x10028 && pRequestHeader->version == 10000, /* don't bitch about legacy!!! */
690	("VMMDev mouse shape structure has invalid size %d (%#x) version=%d!\n",
691	pRequestHeader->size, pRequestHeader->size, pRequestHeader->size, pRequestHeader->version));
692	pRequestHeader->rc = VERR_INVALID_PARAMETER;
693	}
694	else
695	{
696	VMMDevReqMousePointer pointerShape = (VMMDevReqMousePointer)pRequestHeader;
697
698	bool fVisible = (pointerShape->fFlags & VBOX_MOUSE_POINTER_VISIBLE) != 0;
699	bool fAlpha = (pointerShape->fFlags & VBOX_MOUSE_POINTER_ALPHA) != 0;
700	bool fShape = (pointerShape->fFlags & VBOX_MOUSE_POINTER_SHAPE) != 0;
701
702	Log(("VMMDevReq_SetPointerShape: visible: %d, alpha: %d, shape = %d, width: %d, height: %d\n",
703	fVisible, fAlpha, fShape, pointerShape->width, pointerShape->height));
704
705	if (pRequestHeader->size == sizeof(VMMDevReqMousePointer))
706	{
707	/* The guest did not provide the shape actually. */
708	fShape = false;
709	}
710
711	/* forward call to driver */
712	if (fShape)
713	{
714	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
715	fVisible,
716	fAlpha,
717	pointerShape->xHot, pointerShape->yHot,
718	pointerShape->width, pointerShape->height,
719	pointerShape->pointerData);
720	}
721	else
722	{
723	pThis->pDrv->pfnUpdatePointerShape(pThis->pDrv,
724	fVisible,
725	0,
726	0, 0,
727	0, 0,
728	NULL);
729	}
730	pRequestHeader->rc = VINF_SUCCESS;
731	}
732	break;
733	}
734
735	/*
736	* Query the system time from the host
737	*/
738	case VMMDevReq_GetHostTime:
739	{
740	if (pRequestHeader->size != sizeof(VMMDevReqHostTime))
741	{
742	AssertMsgFailed(("VMMDev host time structure has invalid size!\n"));
743	pRequestHeader->rc = VERR_INVALID_PARAMETER;
744	}
745	else if (RT_UNLIKELY(pThis->fGetHostTimeDisabled))
746	pRequestHeader->rc = VERR_NOT_SUPPORTED;
747	else
748	{
749	VMMDevReqHostTime hostTimeReq = (VMMDevReqHostTime)pRequestHeader;
750	RTTIMESPEC now;
751	hostTimeReq->time = RTTimeSpecGetMilli(PDMDevHlpUTCNow(pDevIns, &now));
752	pRequestHeader->rc = VINF_SUCCESS;
753	}
754	break;
755	}
756
757	/*
758	* Query information about the hypervisor
759	*/
760	case VMMDevReq_GetHypervisorInfo:
761	{
762	if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
763	{
764	AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
765	pRequestHeader->rc = VERR_INVALID_PARAMETER;
766	}
767	else
768	{
769	VMMDevReqHypervisorInfo hypervisorInfo = (VMMDevReqHypervisorInfo)pRequestHeader;
770	PVM pVM = PDMDevHlpGetVM(pDevIns);
771	pRequestHeader->rc = PGMR3MappingsSize(pVM, &hypervisorInfo->hypervisorSize);
772	}
773	break;
774	}
775
776	/*
777	* Set hypervisor information
778	*/
779	case VMMDevReq_SetHypervisorInfo:
780	{
781	if (pRequestHeader->size != sizeof(VMMDevReqHypervisorInfo))
782	{
783	AssertMsgFailed(("VMMDev hypervisor info structure has invalid size!\n"));
784	pRequestHeader->rc = VERR_INVALID_PARAMETER;
785	}
786	else
787	{
788	VMMDevReqHypervisorInfo hypervisorInfo = (VMMDevReqHypervisorInfo)pRequestHeader;
789	PVM pVM = PDMDevHlpGetVM(pDevIns);
790	if (hypervisorInfo->hypervisorStart == 0)
791	pRequestHeader->rc = PGMR3MappingsUnfix(pVM);
792	else
793	{
794	/* only if the client has queried the size before! */
795	uint32_t mappingsSize;
796	pRequestHeader->rc = PGMR3MappingsSize(pVM, &mappingsSize);
797	if (RT_SUCCESS(pRequestHeader->rc) && hypervisorInfo->hypervisorSize == mappingsSize)
798	{
799	/* new reservation */
800	pRequestHeader->rc = PGMR3MappingsFix(pVM, hypervisorInfo->hypervisorStart,
801	hypervisorInfo->hypervisorSize);
802	LogRel(("Guest reported fixed hypervisor window at 0x%p (size = 0x%x, rc = %Rrc)\n",
803	(uintptr_t)hypervisorInfo->hypervisorStart,
804	hypervisorInfo->hypervisorSize,
805	pRequestHeader->rc));
806	}
807	}
808	}
809	break;
810	}
811
812	/*
813	* Set the system power status
814	*/
815	case VMMDevReq_SetPowerStatus:
816	{
817	if (pRequestHeader->size != sizeof(VMMDevPowerStateRequest))
818	{
819	AssertMsgFailed(("VMMDev power state request structure has invalid size!\n"));
820	pRequestHeader->rc = VERR_INVALID_PARAMETER;
821	}
822	else
823	{
824	VMMDevPowerStateRequest powerStateRequest = (VMMDevPowerStateRequest)pRequestHeader;
825	switch(powerStateRequest->powerState)
826	{
827	case VMMDevPowerState_Pause:
828	{
829	LogRel(("Guest requests the VM to be suspended (paused)\n"));
830	pRequestHeader->rc = rcRet = PDMDevHlpVMSuspend(pDevIns);
831	break;
832	}
833
834	case VMMDevPowerState_PowerOff:
835	{
836	LogRel(("Guest requests the VM to be turned off\n"));
837	pRequestHeader->rc = rcRet = PDMDevHlpVMPowerOff(pDevIns);
838	break;
839	}
840
841	case VMMDevPowerState_SaveState:
842	{
843	/** @todo no API for that yet */
844	pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
845	break;
846	}
847
848	default:
849	AssertMsgFailed(("VMMDev invalid power state request: %d\n", powerStateRequest->powerState));
850	pRequestHeader->rc = VERR_INVALID_PARAMETER;
851	break;
852	}
853	}
854	break;
855	}
856
857	/*
858	* Get display change request
859	*/
860	case VMMDevReq_GetDisplayChangeRequest:
861	{
862	if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest))
863	{
864	/* Assert only if the size also not equal to a previous version size to prevent
865	* assertion with old additions.
866	*/
867	AssertMsg(pRequestHeader->size == sizeof(VMMDevDisplayChangeRequest) - sizeof (uint32_t),
868	("VMMDev display change request structure has invalid size!\n"));
869	pRequestHeader->rc = VERR_INVALID_PARAMETER;
870	}
871	else
872	{
873	VMMDevDisplayChangeRequest displayChangeRequest = (VMMDevDisplayChangeRequest)pRequestHeader;
874
875	if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
876	{
877	/* Remember which resolution the client has queried, subsequent reads will return the same values. */
878	pThis->lastReadDisplayChangeRequest = pThis->displayChangeRequest;
879	}
880
881	/* just pass on the information */
882	Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n",
883	pThis->displayChangeRequest.xres, pThis->displayChangeRequest.yres, pThis->displayChangeRequest.bpp));
884	displayChangeRequest->xres = pThis->lastReadDisplayChangeRequest.xres;
885	displayChangeRequest->yres = pThis->lastReadDisplayChangeRequest.yres;
886	displayChangeRequest->bpp = pThis->lastReadDisplayChangeRequest.bpp;
887
888	pRequestHeader->rc = VINF_SUCCESS;
889	}
890	break;
891	}
892
893	case VMMDevReq_GetDisplayChangeRequest2:
894	{
895	if (pRequestHeader->size != sizeof(VMMDevDisplayChangeRequest2))
896	{
897	pRequestHeader->rc = VERR_INVALID_PARAMETER;
898	}
899	else
900	{
901	VMMDevDisplayChangeRequest2 displayChangeRequest = (VMMDevDisplayChangeRequest2)pRequestHeader;
902
903	if (displayChangeRequest->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
904	{
905	/* Remember which resolution the client has queried, subsequent reads will return the same values. */
906	pThis->lastReadDisplayChangeRequest = pThis->displayChangeRequest;
907	}
908
909	/* just pass on the information */
910	Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
911	pThis->displayChangeRequest.xres, pThis->displayChangeRequest.yres, pThis->displayChangeRequest.bpp, pThis->displayChangeRequest.display));
912	displayChangeRequest->xres = pThis->lastReadDisplayChangeRequest.xres;
913	displayChangeRequest->yres = pThis->lastReadDisplayChangeRequest.yres;
914	displayChangeRequest->bpp = pThis->lastReadDisplayChangeRequest.bpp;
915	displayChangeRequest->display = pThis->lastReadDisplayChangeRequest.display;
916
917	pRequestHeader->rc = VINF_SUCCESS;
918	}
919	break;
920	}
921
922	/*
923	* Query whether the given video mode is supported
924	*/
925	case VMMDevReq_VideoModeSupported:
926	{
927	if (pRequestHeader->size != sizeof(VMMDevVideoModeSupportedRequest))
928	{
929	AssertMsgFailed(("VMMDev video mode supported request structure has invalid size!\n"));
930	pRequestHeader->rc = VERR_INVALID_PARAMETER;
931	}
932	else
933	{
934	VMMDevVideoModeSupportedRequest videoModeSupportedRequest = (VMMDevVideoModeSupportedRequest)pRequestHeader;
935	/* forward the call */
936	pRequestHeader->rc = pThis->pDrv->pfnVideoModeSupported(pThis->pDrv,
937	videoModeSupportedRequest->width,
938	videoModeSupportedRequest->height,
939	videoModeSupportedRequest->bpp,
940	&videoModeSupportedRequest->fSupported);
941	}
942	break;
943	}
944
945	/*
946	* Query the height reduction in pixels
947	*/
948	case VMMDevReq_GetHeightReduction:
949	{
950	if (pRequestHeader->size != sizeof(VMMDevGetHeightReductionRequest))
951	{
952	AssertMsgFailed(("VMMDev height reduction request structure has invalid size!\n"));
953	pRequestHeader->rc = VERR_INVALID_PARAMETER;
954	}
955	else
956	{
957	VMMDevGetHeightReductionRequest heightReductionRequest = (VMMDevGetHeightReductionRequest)pRequestHeader;
958	/* forward the call */
959	pRequestHeader->rc = pThis->pDrv->pfnGetHeightReduction(pThis->pDrv,
960	&heightReductionRequest->heightReduction);
961	}
962	break;
963	}
964
965	/*
966	* Acknowledge VMMDev events
967	*/
968	case VMMDevReq_AcknowledgeEvents:
969	{
970	if (pRequestHeader->size != sizeof(VMMDevEvents))
971	{
972	AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
973	pRequestHeader->rc = VERR_INVALID_PARAMETER;
974	}
975	else
976	{
977	if (VBOX_GUEST_ADDITIONS_VERSION_1_03 (pThis))
978	{
979	vmmdevSetIRQ_Legacy_EMT (pThis);
980	}
981	else
982	{
983	VMMDevEvents *pAckRequest;
984
985	if (pThis->fNewGuestFilterMask)
986	{
987	pThis->fNewGuestFilterMask = false;
988	pThis->u32GuestFilterMask = pThis->u32NewGuestFilterMask;
989	}
990
991	pAckRequest = (VMMDevEvents *)pRequestHeader;
992	pAckRequest->events =
993	pThis->u32HostEventFlags & pThis->u32GuestFilterMask;
994
995	pThis->u32HostEventFlags &= ~pThis->u32GuestFilterMask;
996	pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents = false;
997	PDMDevHlpPCISetIrqNoWait (pThis->pDevIns, 0, 0);
998	}
999	pRequestHeader->rc = VINF_SUCCESS;
1000	}
1001	break;
1002	}
1003
1004	/*
1005	* Change guest filter mask
1006	*/
1007	case VMMDevReq_CtlGuestFilterMask:
1008	{
1009	if (pRequestHeader->size != sizeof(VMMDevCtlGuestFilterMask))
1010	{
1011	AssertMsgFailed(("VMMDevReq_AcknowledgeEvents structure has invalid size!\n"));
1012	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1013	}
1014	else
1015	{
1016	VMMDevCtlGuestFilterMask *pCtlMaskRequest;
1017
1018	pCtlMaskRequest = (VMMDevCtlGuestFilterMask *)pRequestHeader;
1019	/* The HGCM events are enabled by the VMMDev device automatically when any
1020	* HGCM command is issued. The guest then can not disable these events.
1021	*/
1022	vmmdevCtlGuestFilterMask_EMT (pThis,
1023	pCtlMaskRequest->u32OrMask,
1024	pCtlMaskRequest->u32NotMask & ~VMMDEV_EVENT_HGCM);
1025	pRequestHeader->rc = VINF_SUCCESS;
1026
1027	}
1028	break;
1029	}
1030
1031	#ifdef VBOX_WITH_HGCM
1032	/*
1033	* Process HGCM request
1034	*/
1035	case VMMDevReq_HGCMConnect:
1036	{
1037	if (pRequestHeader->size < sizeof(VMMDevHGCMConnect))
1038	{
1039	AssertMsgFailed(("VMMDevReq_HGCMConnect structure has invalid size!\n"));
1040	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1041	}
1042	else if (!pThis->pHGCMDrv)
1043	{
1044	Log(("VMMDevReq_HGCMConnect HGCM Connector is NULL!\n"));
1045	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1046	}
1047	else
1048	{
1049	VMMDevHGCMConnect pHGCMConnect = (VMMDevHGCMConnect )pRequestHeader;
1050
1051	Log(("VMMDevReq_HGCMConnect\n"));
1052
1053	pRequestHeader->rc = vmmdevHGCMConnect (pThis, pHGCMConnect, (RTGCPHYS)u32);
1054	}
1055	break;
1056	}
1057
1058	case VMMDevReq_HGCMDisconnect:
1059	{
1060	if (pRequestHeader->size < sizeof(VMMDevHGCMDisconnect))
1061	{
1062	AssertMsgFailed(("VMMDevReq_HGCMDisconnect structure has invalid size!\n"));
1063	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1064	}
1065	else if (!pThis->pHGCMDrv)
1066	{
1067	Log(("VMMDevReq_HGCMDisconnect HGCM Connector is NULL!\n"));
1068	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1069	}
1070	else
1071	{
1072	VMMDevHGCMDisconnect pHGCMDisconnect = (VMMDevHGCMDisconnect )pRequestHeader;
1073
1074	Log(("VMMDevReq_VMMDevHGCMDisconnect\n"));
1075	pRequestHeader->rc = vmmdevHGCMDisconnect (pThis, pHGCMDisconnect, (RTGCPHYS)u32);
1076	}
1077	break;
1078	}
1079
1080	#ifdef VBOX_WITH_64_BITS_GUESTS
1081	case VMMDevReq_HGCMCall32:
1082	case VMMDevReq_HGCMCall64:
1083	#else
1084	case VMMDevReq_HGCMCall:
1085	#endif /* VBOX_WITH_64_BITS_GUESTS */
1086	{
1087	if (pRequestHeader->size < sizeof(VMMDevHGCMCall))
1088	{
1089	AssertMsgFailed(("VMMDevReq_HGCMCall structure has invalid size!\n"));
1090	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1091	}
1092	else if (!pThis->pHGCMDrv)
1093	{
1094	Log(("VMMDevReq_HGCMCall HGCM Connector is NULL!\n"));
1095	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1096	}
1097	else
1098	{
1099	VMMDevHGCMCall pHGCMCall = (VMMDevHGCMCall )pRequestHeader;
1100
1101	Log2(("VMMDevReq_HGCMCall: sizeof (VMMDevHGCMRequest) = %04X\n", sizeof (VMMDevHGCMCall)));
1102	Log2(("%.*Rhxd\n", pRequestHeader->size, pRequestHeader));
1103
1104	#ifdef VBOX_WITH_64_BITS_GUESTS
1105	bool f64Bits = (pRequestHeader->requestType == VMMDevReq_HGCMCall64);
1106	#else
1107	bool f64Bits = false;
1108	#endif /* VBOX_WITH_64_BITS_GUESTS */
1109
1110	pRequestHeader->rc = vmmdevHGCMCall (pThis, pHGCMCall, (RTGCPHYS)u32, f64Bits);
1111	}
1112	break;
1113	}
1114	#endif /* VBOX_WITH_HGCM */
1115
1116	case VMMDevReq_HGCMCancel:
1117	{
1118	if (pRequestHeader->size < sizeof(VMMDevHGCMCancel))
1119	{
1120	AssertMsgFailed(("VMMDevReq_HGCMCancel structure has invalid size!\n"));
1121	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1122	}
1123	else if (!pThis->pHGCMDrv)
1124	{
1125	Log(("VMMDevReq_HGCMCancel HGCM Connector is NULL!\n"));
1126	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1127	}
1128	else
1129	{
1130	VMMDevHGCMCancel pHGCMCancel = (VMMDevHGCMCancel )pRequestHeader;
1131
1132	Log(("VMMDevReq_VMMDevHGCMCancel\n"));
1133	pRequestHeader->rc = vmmdevHGCMCancel (pThis, pHGCMCancel, (RTGCPHYS)u32);
1134	}
1135	break;
1136	}
1137
1138	case VMMDevReq_VideoAccelEnable:
1139	{
1140	if (pRequestHeader->size < sizeof(VMMDevVideoAccelEnable))
1141	{
1142	Log(("VMMDevReq_VideoAccelEnable request size too small!!!\n"));
1143	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1144	}
1145	else if (!pThis->pDrv)
1146	{
1147	Log(("VMMDevReq_VideoAccelEnable Connector is NULL!!!\n"));
1148	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1149	}
1150	else
1151	{
1152	VMMDevVideoAccelEnable ptr = (VMMDevVideoAccelEnable )pRequestHeader;
1153
1154	if (ptr->cbRingBuffer != VBVA_RING_BUFFER_SIZE)
1155	{
1156	/* The guest driver seems compiled with another headers. */
1157	Log(("VMMDevReq_VideoAccelEnable guest ring buffer size %d, should be %d!!!\n", ptr->cbRingBuffer, VBVA_RING_BUFFER_SIZE));
1158	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1159	}
1160	else
1161	{
1162	/* The request is correct. */
1163	ptr->fu32Status \|= VBVA_F_STATUS_ACCEPTED;
1164
1165	LogFlow(("VMMDevReq_VideoAccelEnable ptr->u32Enable = %d\n", ptr->u32Enable));
1166
1167	pRequestHeader->rc = ptr->u32Enable?
1168	pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, true, &pThis->pVMMDevRAMR3->vbvaMemory):
1169	pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, false, NULL);
1170
1171	if ( ptr->u32Enable
1172	&& RT_SUCCESS (pRequestHeader->rc))
1173	{
1174	ptr->fu32Status \|= VBVA_F_STATUS_ENABLED;
1175
1176	/* Remember that guest successfully enabled acceleration.
1177	* We need to reestablish it on restoring the VM from saved state.
1178	*/
1179	pThis->u32VideoAccelEnabled = 1;
1180	}
1181	else
1182	{
1183	/* The acceleration was not enabled. Remember that. */
1184	pThis->u32VideoAccelEnabled = 0;
1185	}
1186	}
1187	}
1188	break;
1189	}
1190
1191	case VMMDevReq_VideoAccelFlush:
1192	{
1193	if (pRequestHeader->size < sizeof(VMMDevVideoAccelFlush))
1194	{
1195	AssertMsgFailed(("VMMDevReq_VideoAccelFlush request size too small.\n"));
1196	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1197	}
1198	else if (!pThis->pDrv)
1199	{
1200	Log(("VMMDevReq_VideoAccelFlush Connector is NULL!\n"));
1201	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1202	}
1203	else
1204	{
1205	pThis->pDrv->pfnVideoAccelFlush (pThis->pDrv);
1206
1207	pRequestHeader->rc = VINF_SUCCESS;
1208	}
1209	break;
1210	}
1211
1212	case VMMDevReq_VideoSetVisibleRegion:
1213	{
1214	if (pRequestHeader->size < sizeof(VMMDevVideoSetVisibleRegion))
1215	{
1216	Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1217	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1218	}
1219	else if (!pThis->pDrv)
1220	{
1221	Log(("VMMDevReq_VideoSetVisibleRegion Connector is NULL!!!\n"));
1222	pRequestHeader->rc = VERR_NOT_SUPPORTED;
1223	}
1224	else
1225	{
1226	VMMDevVideoSetVisibleRegion ptr = (VMMDevVideoSetVisibleRegion )pRequestHeader;
1227
1228	if (!ptr->cRect)
1229	{
1230	Log(("VMMDevReq_VideoSetVisibleRegion no rectangles!!!\n"));
1231	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1232	}
1233	else
1234	if (pRequestHeader->size != sizeof(VMMDevVideoSetVisibleRegion) + (ptr->cRect-1)*sizeof(RTRECT))
1235	{
1236	Log(("VMMDevReq_VideoSetVisibleRegion request size too small!!!\n"));
1237	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1238	}
1239	else
1240	{
1241	Log(("VMMDevReq_VideoSetVisibleRegion %d rectangles\n", ptr->cRect));
1242	/* forward the call */
1243	pRequestHeader->rc = pThis->pDrv->pfnSetVisibleRegion(pThis->pDrv, ptr->cRect, &ptr->Rect);
1244	}
1245	}
1246	break;
1247	}
1248
1249	case VMMDevReq_GetSeamlessChangeRequest:
1250	{
1251	if (pRequestHeader->size != sizeof(VMMDevSeamlessChangeRequest))
1252	{
1253	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1254	}
1255	else
1256	{
1257	VMMDevSeamlessChangeRequest seamlessChangeRequest = (VMMDevSeamlessChangeRequest)pRequestHeader;
1258	/* just pass on the information */
1259	Log(("VMMDev: returning seamless change request mode=%d\n", pThis->fSeamlessEnabled));
1260	if (pThis->fSeamlessEnabled)
1261	seamlessChangeRequest->mode = VMMDev_Seamless_Visible_Region;
1262	else
1263	seamlessChangeRequest->mode = VMMDev_Seamless_Disabled;
1264
1265	if (seamlessChangeRequest->eventAck == VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
1266	{
1267	/* Remember which mode the client has queried. */
1268	pThis->fLastSeamlessEnabled = pThis->fSeamlessEnabled;
1269	}
1270
1271	pRequestHeader->rc = VINF_SUCCESS;
1272	}
1273	break;
1274	}
1275
1276	case VMMDevReq_GetVRDPChangeRequest:
1277	{
1278	if (pRequestHeader->size != sizeof(VMMDevVRDPChangeRequest))
1279	{
1280	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1281	}
1282	else
1283	{
1284	VMMDevVRDPChangeRequest vrdpChangeRequest = (VMMDevVRDPChangeRequest)pRequestHeader;
1285	/* just pass on the information */
1286	Log(("VMMDev: returning VRDP status %d level %d\n", pThis->fVRDPEnabled, pThis->u32VRDPExperienceLevel));
1287
1288	vrdpChangeRequest->u8VRDPActive = pThis->fVRDPEnabled;
1289	vrdpChangeRequest->u32VRDPExperienceLevel = pThis->u32VRDPExperienceLevel;
1290
1291	pRequestHeader->rc = VINF_SUCCESS;
1292	}
1293	break;
1294	}
1295
1296	case VMMDevReq_GetMemBalloonChangeRequest:
1297	{
1298	Log(("VMMDevReq_GetMemBalloonChangeRequest\n"));
1299	if (pRequestHeader->size != sizeof(VMMDevGetMemBalloonChangeRequest))
1300	{
1301	AssertFailed();
1302	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1303	}
1304	else
1305	{
1306	VMMDevGetMemBalloonChangeRequest memBalloonChangeRequest = (VMMDevGetMemBalloonChangeRequest)pRequestHeader;
1307	/* just pass on the information */
1308	Log(("VMMDev: returning memory balloon size =%d\n", pThis->u32MemoryBalloonSize));
1309	memBalloonChangeRequest->u32BalloonSize = pThis->u32MemoryBalloonSize;
1310	memBalloonChangeRequest->u32PhysMemSize = pThis->cbGuestRAM / (uint64_t)_1M;
1311
1312	if (memBalloonChangeRequest->eventAck == VMMDEV_EVENT_BALLOON_CHANGE_REQUEST)
1313	{
1314	/* Remember which mode the client has queried. */
1315	pThis->u32LastMemoryBalloonSize = pThis->u32MemoryBalloonSize;
1316	}
1317
1318	pRequestHeader->rc = VINF_SUCCESS;
1319	}
1320	break;
1321	}
1322
1323	case VMMDevReq_ChangeMemBalloon:
1324	{
1325	VMMDevChangeMemBalloon memBalloonChange = (VMMDevChangeMemBalloon)pRequestHeader;
1326
1327	Log(("VMMDevReq_ChangeMemBalloon\n"));
1328	if ( pRequestHeader->size < sizeof(VMMDevChangeMemBalloon)
1329	\|\| memBalloonChange->cPages != VMMDEV_MEMORY_BALLOON_CHUNK_PAGES
1330	\|\| pRequestHeader->size != (uint32_t)RT_OFFSETOF(VMMDevChangeMemBalloon, aPhysPage[memBalloonChange->cPages]))
1331	{
1332	AssertFailed();
1333	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1334	}
1335	else
1336	{
1337	pRequestHeader->rc = pThis->pDrv->pfnChangeMemoryBalloon(pThis->pDrv, !!memBalloonChange->fInflate, memBalloonChange->cPages, memBalloonChange->aPhysPage);
1338	}
1339	break;
1340	}
1341
1342	case VMMDevReq_GetStatisticsChangeRequest:
1343	{
1344	Log(("VMMDevReq_GetStatisticsChangeRequest\n"));
1345	if (pRequestHeader->size != sizeof(VMMDevGetStatisticsChangeRequest))
1346	{
1347	AssertFailed();
1348	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1349	}
1350	else
1351	{
1352	VMMDevGetStatisticsChangeRequest statIntervalChangeRequest = (VMMDevGetStatisticsChangeRequest)pRequestHeader;
1353	/* just pass on the information */
1354	Log(("VMMDev: returning statistics interval %d seconds\n", pThis->u32StatIntervalSize));
1355	statIntervalChangeRequest->u32StatInterval = pThis->u32StatIntervalSize;
1356
1357	if (statIntervalChangeRequest->eventAck == VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST)
1358	{
1359	/* Remember which mode the client has queried. */
1360	pThis->u32LastStatIntervalSize= pThis->u32StatIntervalSize;
1361	}
1362
1363	pRequestHeader->rc = VINF_SUCCESS;
1364	}
1365	break;
1366	}
1367
1368	case VMMDevReq_ReportGuestStats:
1369	{
1370	Log(("VMMDevReq_ReportGuestStats\n"));
1371	if (pRequestHeader->size != sizeof(VMMDevReportGuestStats))
1372	{
1373	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1374	}
1375	else
1376	{
1377	VMMDevReportGuestStats stats = (VMMDevReportGuestStats)pRequestHeader;
1378
1379	#ifdef DEBUG
1380	VBoxGuestStatistics *pGuestStats = &stats->guestStats;
1381
1382	Log(("Current statistics:\n"));
1383	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_IDLE)
1384	Log(("CPU%d: CPU Load Idle %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Idle));
1385
1386	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_KERNEL)
1387	Log(("CPU%d: CPU Load Kernel %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_Kernel));
1388
1389	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_CPU_LOAD_USER)
1390	Log(("CPU%d: CPU Load User %-3d%%\n", pGuestStats->u32CpuId, pGuestStats->u32CpuLoad_User));
1391
1392	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_THREADS)
1393	Log(("CPU%d: Thread %d\n", pGuestStats->u32CpuId, pGuestStats->u32Threads));
1394
1395	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PROCESSES)
1396	Log(("CPU%d: Processes %d\n", pGuestStats->u32CpuId, pGuestStats->u32Processes));
1397
1398	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_HANDLES)
1399	Log(("CPU%d: Handles %d\n", pGuestStats->u32CpuId, pGuestStats->u32Handles));
1400
1401	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEMORY_LOAD)
1402	Log(("CPU%d: Memory Load %d%%\n", pGuestStats->u32CpuId, pGuestStats->u32MemoryLoad));
1403
1404	/* Note that reported values are in pages; upper layers expect them in megabytes */
1405	Assert(pGuestStats->u32PageSize == 4096);
1406	if (pGuestStats->u32PageSize != 4096)
1407	pGuestStats->u32PageSize = 4096;
1408
1409	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_TOTAL)
1410	Log(("CPU%d: Total physical memory %-4d MB\n", pGuestStats->u32CpuId, (pGuestStats->u32PhysMemTotal + (_1M/pGuestStats->u32PageSize)-1)/ (_1M/pGuestStats->u32PageSize)));
1411
1412	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_AVAIL)
1413	Log(("CPU%d: Free physical memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemAvail / (_1M/pGuestStats->u32PageSize)));
1414
1415	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PHYS_MEM_BALLOON)
1416	Log(("CPU%d: Memory balloon size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PhysMemBalloon / (_1M/pGuestStats->u32PageSize)));
1417
1418	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_COMMIT_TOTAL)
1419	Log(("CPU%d: Committed memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemCommitTotal / (_1M/pGuestStats->u32PageSize)));
1420
1421	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_TOTAL)
1422	Log(("CPU%d: Total kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelTotal / (_1M/pGuestStats->u32PageSize)));
1423
1424	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_PAGED)
1425	Log(("CPU%d: Paged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelPaged / (_1M/pGuestStats->u32PageSize)));
1426
1427	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_KERNEL_NONPAGED)
1428	Log(("CPU%d: Nonpaged kernel memory %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemKernelNonPaged / (_1M/pGuestStats->u32PageSize)));
1429
1430	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_MEM_SYSTEM_CACHE)
1431	Log(("CPU%d: System cache size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32MemSystemCache / (_1M/pGuestStats->u32PageSize)));
1432
1433	if (pGuestStats->u32StatCaps & VBOX_GUEST_STAT_PAGE_FILE_SIZE)
1434	Log(("CPU%d: Page file size %-4d MB\n", pGuestStats->u32CpuId, pGuestStats->u32PageFileSize / (_1M/pGuestStats->u32PageSize)));
1435	Log(("Statistics end *******************\n"));
1436	#endif
1437
1438	/* forward the call */
1439	pRequestHeader->rc = pThis->pDrv->pfnReportStatistics(pThis->pDrv, &stats->guestStats);
1440	}
1441	break;
1442	}
1443
1444	case VMMDevReq_QueryCredentials:
1445	{
1446	if (pRequestHeader->size != sizeof(VMMDevCredentials))
1447	{
1448	AssertMsgFailed(("VMMDevReq_QueryCredentials request size too small.\n"));
1449	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1450	}
1451	else
1452	{
1453	VMMDevCredentials credentials = (VMMDevCredentials)pRequestHeader;
1454
1455	/* let's start by nulling out the data */
1456	memset(credentials->szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1457	memset(credentials->szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1458	memset(credentials->szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1459
1460	/* should we return whether we got credentials for a logon? */
1461	if (credentials->u32Flags & VMMDEV_CREDENTIALS_QUERYPRESENCE)
1462	{
1463	if ( pThis->credentialsLogon.szUserName[0]
1464	\|\| pThis->credentialsLogon.szPassword[0]
1465	\|\| pThis->credentialsLogon.szDomain[0])
1466	{
1467	credentials->u32Flags \|= VMMDEV_CREDENTIALS_PRESENT;
1468	}
1469	else
1470	{
1471	credentials->u32Flags &= ~VMMDEV_CREDENTIALS_PRESENT;
1472	}
1473	}
1474
1475	/* does the guest want to read logon credentials? */
1476	if (credentials->u32Flags & VMMDEV_CREDENTIALS_READ)
1477	{
1478	if (pThis->credentialsLogon.szUserName[0])
1479	strcpy(credentials->szUserName, pThis->credentialsLogon.szUserName);
1480	if (pThis->credentialsLogon.szPassword[0])
1481	strcpy(credentials->szPassword, pThis->credentialsLogon.szPassword);
1482	if (pThis->credentialsLogon.szDomain[0])
1483	strcpy(credentials->szDomain, pThis->credentialsLogon.szDomain);
1484	if (!pThis->credentialsLogon.fAllowInteractiveLogon)
1485	credentials->u32Flags \|= VMMDEV_CREDENTIALS_NOLOCALLOGON;
1486	else
1487	credentials->u32Flags &= ~VMMDEV_CREDENTIALS_NOLOCALLOGON;
1488	}
1489
1490	if (!pThis->fKeepCredentials)
1491	{
1492	/* does the caller want us to destroy the logon credentials? */
1493	if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEAR)
1494	{
1495	memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1496	memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1497	memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1498	}
1499	}
1500
1501	/* does the guest want to read credentials for verification? */
1502	if (credentials->u32Flags & VMMDEV_CREDENTIALS_READJUDGE)
1503	{
1504	if (pThis->credentialsJudge.szUserName[0])
1505	strcpy(credentials->szUserName, pThis->credentialsJudge.szUserName);
1506	if (pThis->credentialsJudge.szPassword[0])
1507	strcpy(credentials->szPassword, pThis->credentialsJudge.szPassword);
1508	if (pThis->credentialsJudge.szDomain[0])
1509	strcpy(credentials->szDomain, pThis->credentialsJudge.szDomain);
1510	}
1511
1512	/* does the caller want us to destroy the judgement credentials? */
1513	if (credentials->u32Flags & VMMDEV_CREDENTIALS_CLEARJUDGE)
1514	{
1515	memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
1516	memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
1517	memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
1518	}
1519
1520	pRequestHeader->rc = VINF_SUCCESS;
1521	}
1522	break;
1523	}
1524
1525	case VMMDevReq_ReportCredentialsJudgement:
1526	{
1527	if (pRequestHeader->size != sizeof(VMMDevCredentials))
1528	{
1529	AssertMsgFailed(("VMMDevReq_ReportCredentialsJudgement request size too small.\n"));
1530	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1531	}
1532	else
1533	{
1534	VMMDevCredentials credentials = (VMMDevCredentials)pRequestHeader;
1535
1536	/* what does the guest think about the credentials? (note: the order is important here!) */
1537	if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_DENY)
1538	{
1539	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_DENY);
1540	}
1541	else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT)
1542	{
1543	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_NOJUDGEMENT);
1544	}
1545	else if (credentials->u32Flags & VMMDEV_CREDENTIALS_JUDGE_OK)
1546	{
1547	pThis->pDrv->pfnSetCredentialsJudgementResult(pThis->pDrv, VMMDEV_CREDENTIALS_JUDGE_OK);
1548	}
1549	else
1550	Log(("VMMDevReq_ReportCredentialsJudgement: invalid flags: %d!!!\n", credentials->u32Flags));
1551
1552	pRequestHeader->rc = VINF_SUCCESS;
1553	}
1554	break;
1555	}
1556
1557	#ifdef DEBUG
1558	case VMMDevReq_LogString:
1559	{
1560	if (pRequestHeader->size < sizeof(VMMDevReqLogString))
1561	{
1562	AssertMsgFailed(("VMMDevReq_LogString request size too small.\n"));
1563	pRequestHeader->rc = VERR_INVALID_PARAMETER;
1564	}
1565	else
1566	{
1567	VMMDevReqLogString pReqLogString = (VMMDevReqLogString)pRequestHeader;
1568	#undef LOG_GROUP
1569	#define LOG_GROUP LOG_GROUP_DEV_VMM_BACKDOOR
1570	// Log(("Guest Log: %s", pReqLogString->szString));
1571	Log(("DEBUG LOG: %s", pReqLogString->szString));
1572
1573	#undef LOG_GROUP
1574	#define LOG_GROUP LOG_GROUP_DEV_VMM
1575	pRequestHeader->rc = VINF_SUCCESS;
1576	}
1577	break;
1578	}
1579	#endif
1580	default:
1581	{
1582	pRequestHeader->rc = VERR_NOT_IMPLEMENTED;
1583
1584	Log(("VMMDev unknown request type %d\n", pRequestHeader->requestType));
1585
1586	break;
1587	}
1588	}
1589
1590	end:
1591	/* Write the result back to guest memory */
1592	if (pRequestHeader)
1593	{
1594	PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, pRequestHeader, pRequestHeader->size);
1595	RTMemFree(pRequestHeader);
1596	}
1597	else
1598	{
1599	/* early error case; write back header only */
1600	PDMDevHlpPhysWrite(pDevIns, (RTGCPHYS)u32, &requestHeader, sizeof(requestHeader));
1601	}
1602
1603	PDMCritSectLeave(&pThis->CritSect);
1604	return rcRet;
1605	}
1606
1607	/**
1608	* Callback function for mapping an PCI I/O region.
1609	*
1610	* @return VBox status code.
1611	* @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1612	* @param iRegion The region number.
1613	* @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1614	* I/O port, else it's a physical address.
1615	* This address is NOT relative to pci_mem_base like earlier!
1616	* @param enmType One of the PCI_ADDRESS_SPACE_* values.
1617	*/
1618	static DECLCALLBACK(int) vmmdevIORAMRegionMap(PPCIDEVICE pPciDev, /unsigned/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1619	{
1620	LogFlow(("vmmdevR3IORAMRegionMap: iRegion=%d GCPhysAddress=%RGp cb=%#x enmType=%d\n", iRegion, GCPhysAddress, cb, enmType));
1621	VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
1622	int rc;
1623
1624	if (iRegion == 1)
1625	{
1626	AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM, VERR_INTERNAL_ERROR);
1627	Assert(pThis->pVMMDevRAMR3 != NULL);
1628	if (GCPhysAddress != NIL_RTGCPHYS)
1629	{
1630	/*
1631	* Map the MMIO2 memory.
1632	*/
1633	pThis->GCPhysVMMDevRAM = GCPhysAddress;
1634	Assert(pThis->GCPhysVMMDevRAM == GCPhysAddress);
1635	rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
1636	}
1637	else
1638	{
1639	/*
1640	* It is about to be unmapped, just clean up.
1641	*/
1642	pThis->GCPhysVMMDevRAM = NIL_RTGCPHYS32;
1643	rc = VINF_SUCCESS;
1644	}
1645	}
1646	else if (iRegion == 2)
1647	{
1648	AssertReturn(enmType == PCI_ADDRESS_SPACE_MEM_PREFETCH, VERR_INTERNAL_ERROR);
1649	Assert(pThis->pVMMDevHeapR3 != NULL);
1650	if (GCPhysAddress != NIL_RTGCPHYS)
1651	{
1652	/*
1653	* Map the MMIO2 memory.
1654	*/
1655	pThis->GCPhysVMMDevHeap = GCPhysAddress;
1656	Assert(pThis->GCPhysVMMDevHeap == GCPhysAddress);
1657	rc = PDMDevHlpMMIO2Map(pPciDev->pDevIns, iRegion, GCPhysAddress);
1658	if (RT_SUCCESS(rc))
1659	rc = PDMDevHlpRegisterVMMDevHeap(pPciDev->pDevIns, GCPhysAddress, pThis->pVMMDevHeapR3, VMMDEV_HEAP_SIZE);
1660	}
1661	else
1662	{
1663	/*
1664	* It is about to be unmapped, just clean up.
1665	*/
1666	PDMDevHlpUnregisterVMMDevHeap(pPciDev->pDevIns, pThis->GCPhysVMMDevHeap);
1667	pThis->GCPhysVMMDevHeap = NIL_RTGCPHYS32;
1668	rc = VINF_SUCCESS;
1669	}
1670	}
1671	else
1672	{
1673	AssertMsgFailed(("%d\n", iRegion));
1674	rc = VERR_INVALID_PARAMETER;
1675	}
1676
1677	return rc;
1678	}
1679
1680
1681	/**
1682	* Callback function for mapping a PCI I/O region.
1683	*
1684	* @return VBox status code.
1685	* @param pPciDev Pointer to PCI device. Use pPciDev->pDevIns to get the device instance.
1686	* @param iRegion The region number.
1687	* @param GCPhysAddress Physical address of the region. If iType is PCI_ADDRESS_SPACE_IO, this is an
1688	* I/O port, else it's a physical address.
1689	* This address is NOT relative to pci_mem_base like earlier!
1690	* @param enmType One of the PCI_ADDRESS_SPACE_* values.
1691	*/
1692	static DECLCALLBACK(int) vmmdevIOPortRegionMap(PPCIDEVICE pPciDev, /unsigned/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
1693	{
1694	VMMDevState *pThis = PCIDEV_2_VMMDEVSTATE(pPciDev);
1695	int rc = VINF_SUCCESS;
1696
1697	Assert(enmType == PCI_ADDRESS_SPACE_IO);
1698	Assert(iRegion == 0);
1699	AssertMsg(RT_ALIGN(GCPhysAddress, 8) == GCPhysAddress, ("Expected 8 byte alignment. GCPhysAddress=%#x\n", GCPhysAddress));
1700
1701	/*
1702	* Save the base port address to simplify Port offset calculations.
1703	*/
1704	pThis->PortBase = (RTIOPORT)GCPhysAddress;
1705
1706	/*
1707	* Register our port IO handlers.
1708	*/
1709	rc = PDMDevHlpIOPortRegister(pPciDev->pDevIns,
1710	(RTIOPORT)GCPhysAddress + VMMDEV_PORT_OFF_REQUEST, 1,
1711	(void*)pThis, vmmdevRequestHandler,
1712	NULL, NULL, NULL, "VMMDev Request Handler");
1713	AssertRC(rc);
1714	return rc;
1715	}
1716
1717	/**
1718	* Queries an interface to the driver.
1719	*
1720	* @returns Pointer to interface.
1721	* @returns NULL if the interface was not supported by the driver.
1722	* @param pInterface Pointer to this interface structure.
1723	* @param enmInterface The requested interface identification.
1724	* @thread Any thread.
1725	*/
1726	static DECLCALLBACK(void *) vmmdevPortQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
1727	{
1728	VMMDevState pThis = (VMMDevState)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, Base));
1729	switch (enmInterface)
1730	{
1731	case PDMINTERFACE_BASE:
1732	return &pThis->Base;
1733	case PDMINTERFACE_VMMDEV_PORT:
1734	return &pThis->Port;
1735	#ifdef VBOX_WITH_HGCM
1736	case PDMINTERFACE_HGCM_PORT:
1737	return &pThis->HGCMPort;
1738	#endif
1739	case PDMINTERFACE_LED_PORTS:
1740	/* Currently only for shared folders */
1741	return &pThis->SharedFolders.ILeds;
1742	default:
1743	return NULL;
1744	}
1745	}
1746
1747	/**
1748	* Gets the pointer to the status LED of a unit.
1749	*
1750	* @returns VBox status code.
1751	* @param pInterface Pointer to the interface structure containing the called function pointer.
1752	* @param iLUN The unit which status LED we desire.
1753	* @param ppLed Where to store the LED pointer.
1754	*/
1755	static DECLCALLBACK(int) vmmdevQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
1756	{
1757	VMMDevState pThis = (VMMDevState )( (uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, SharedFolders.ILeds) );
1758	if (iLUN == 0) /* LUN 0 is shared folders */
1759	{
1760	*ppLed = &pThis->SharedFolders.Led;
1761	return VINF_SUCCESS;
1762	}
1763	return VERR_PDM_LUN_NOT_FOUND;
1764	}
1765
1766	/* -=-=-=-=-=- IVMMDevPort -=-=-=-=-=- */
1767
1768	/** Converts a VMMDev port interface pointer to a VMMDev state pointer. */
1769	#define IVMMDEVPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, Port)) )
1770
1771
1772	/**
1773	* Return the current absolute mouse position in pixels
1774	*
1775	* @returns VBox status code
1776	* @param pAbsX Pointer of result value, can be NULL
1777	* @param pAbsY Pointer of result value, can be NULL
1778	*/
1779	static DECLCALLBACK(int) vmmdevQueryAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t pAbsX, uint32_t pAbsY)
1780	{
1781	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1782	if (pAbsX)
1783	*pAbsX = pThis->mouseXAbs;
1784	if (pAbsY)
1785	*pAbsY = pThis->mouseYAbs;
1786	return VINF_SUCCESS;
1787	}
1788
1789	/**
1790	* Set the new absolute mouse position in pixels
1791	*
1792	* @returns VBox status code
1793	* @param absX New absolute X position
1794	* @param absY New absolute Y position
1795	*/
1796	static DECLCALLBACK(int) vmmdevSetAbsoluteMouse(PPDMIVMMDEVPORT pInterface, uint32_t absX, uint32_t absY)
1797	{
1798	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1799	if ((pThis->mouseXAbs == absX) && (pThis->mouseYAbs == absY))
1800	return VINF_SUCCESS;
1801	Log2(("vmmdevSetAbsoluteMouse: settings absolute position to x = %d, y = %d\n", absX, absY));
1802	pThis->mouseXAbs = absX;
1803	pThis->mouseYAbs = absY;
1804	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
1805	return VINF_SUCCESS;
1806	}
1807
1808	/**
1809	* Return the current mouse capability flags
1810	*
1811	* @returns VBox status code
1812	* @param pCapabilities Pointer of result value
1813	*/
1814	static DECLCALLBACK(int) vmmdevQueryMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t *pCapabilities)
1815	{
1816	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1817	if (!pCapabilities)
1818	return VERR_INVALID_PARAMETER;
1819	*pCapabilities = pThis->mouseCapabilities;
1820	return VINF_SUCCESS;
1821	}
1822
1823	/**
1824	* Set the current mouse capability flag (host side)
1825	*
1826	* @returns VBox status code
1827	* @param capabilities Capability mask
1828	*/
1829	static DECLCALLBACK(int) vmmdevSetMouseCapabilities(PPDMIVMMDEVPORT pInterface, uint32_t capabilities)
1830	{
1831	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1832
1833	bool bCapsChanged = ((capabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
1834	!= (pThis->mouseCapabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE));
1835
1836	Log(("vmmdevSetMouseCapabilities: bCapsChanged %d\n", bCapsChanged));
1837
1838	if (capabilities & VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER)
1839	pThis->mouseCapabilities \|= VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
1840	else
1841	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_HOST_CANNOT_HWPOINTER;
1842
1843	if (capabilities & VMMDEV_MOUSE_HOST_CAN_ABSOLUTE)
1844	pThis->mouseCapabilities \|= VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
1845	else
1846	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_HOST_CAN_ABSOLUTE;
1847
1848	if (bCapsChanged)
1849	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
1850
1851	return VINF_SUCCESS;
1852	}
1853
1854
1855	static DECLCALLBACK(int) vmmdevRequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t xres, uint32_t yres, uint32_t bpp, uint32_t display)
1856	{
1857	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1858
1859	/* Verify that the new resolution is different and that guest does not yet know about it. */
1860	bool fSameResolution = (!xres \|\| (pThis->lastReadDisplayChangeRequest.xres == xres)) &&
1861	(!yres \|\| (pThis->lastReadDisplayChangeRequest.yres == yres)) &&
1862	(!bpp \|\| (pThis->lastReadDisplayChangeRequest.bpp == bpp)) &&
1863	pThis->lastReadDisplayChangeRequest.display == display;
1864
1865	if (!xres && !yres && !bpp)
1866	{
1867	/* Special case of reset video mode. */
1868	fSameResolution = false;
1869	}
1870
1871	Log3(("vmmdevRequestDisplayChange: same=%d. new: xres=%d, yres=%d, bpp=%d, display=%d. old: xres=%d, yres=%d, bpp=%d, display=%d.\n",
1872	fSameResolution, xres, yres, bpp, display, pThis->lastReadDisplayChangeRequest.xres, pThis->lastReadDisplayChangeRequest.yres, pThis->lastReadDisplayChangeRequest.bpp, pThis->lastReadDisplayChangeRequest.display));
1873
1874	if (!fSameResolution)
1875	{
1876	LogRel(("VMMDev::SetVideoModeHint: got a video mode hint (%dx%dx%d) at %d\n",
1877	xres, yres, bpp, display));
1878
1879	/* we could validate the information here but hey, the guest can do that as well! */
1880	pThis->displayChangeRequest.xres = xres;
1881	pThis->displayChangeRequest.yres = yres;
1882	pThis->displayChangeRequest.bpp = bpp;
1883	pThis->displayChangeRequest.display = display;
1884
1885	/* IRQ so the guest knows what's going on */
1886	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
1887	}
1888
1889	return VINF_SUCCESS;
1890	}
1891
1892	static DECLCALLBACK(int) vmmdevRequestSeamlessChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
1893	{
1894	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1895
1896	/* Verify that the new resolution is different and that guest does not yet know about it. */
1897	bool fSameMode = (pThis->fLastSeamlessEnabled == fEnabled);
1898
1899	Log(("vmmdevRequestSeamlessChange: same=%d. new=%d\n", fSameMode, fEnabled));
1900
1901	if (!fSameMode)
1902	{
1903	/* we could validate the information here but hey, the guest can do that as well! */
1904	pThis->fSeamlessEnabled = fEnabled;
1905
1906	/* IRQ so the guest knows what's going on */
1907	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
1908	}
1909
1910	return VINF_SUCCESS;
1911	}
1912
1913	static DECLCALLBACK(int) vmmdevSetMemoryBalloon(PPDMIVMMDEVPORT pInterface, uint32_t ulBalloonSize)
1914	{
1915	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1916
1917	/* Verify that the new resolution is different and that guest does not yet know about it. */
1918	bool fSame = (pThis->u32LastMemoryBalloonSize == ulBalloonSize);
1919
1920	Log(("vmmdevSetMemoryBalloon: old=%d. new=%d\n", pThis->u32LastMemoryBalloonSize, ulBalloonSize));
1921
1922	if (!fSame)
1923	{
1924	/* we could validate the information here but hey, the guest can do that as well! */
1925	pThis->u32MemoryBalloonSize = ulBalloonSize;
1926
1927	/* IRQ so the guest knows what's going on */
1928	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_BALLOON_CHANGE_REQUEST);
1929	}
1930
1931	return VINF_SUCCESS;
1932	}
1933
1934	static DECLCALLBACK(int) vmmdevVRDPChange(PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t u32VRDPExperienceLevel)
1935	{
1936	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1937
1938	bool fSame = (pThis->fVRDPEnabled == fVRDPEnabled);
1939
1940	Log(("vmmdevVRDPChange: old=%d. new=%d\n", pThis->fVRDPEnabled, fVRDPEnabled));
1941
1942	if (!fSame)
1943	{
1944	pThis->fVRDPEnabled = fVRDPEnabled;
1945	pThis->u32VRDPExperienceLevel = u32VRDPExperienceLevel;
1946
1947	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_VRDP);
1948	}
1949
1950	return VINF_SUCCESS;
1951	}
1952
1953	static DECLCALLBACK(int) vmmdevSetStatisticsInterval(PPDMIVMMDEVPORT pInterface, uint32_t ulStatInterval)
1954	{
1955	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1956
1957	/* Verify that the new resolution is different and that guest does not yet know about it. */
1958	bool fSame = (pThis->u32LastStatIntervalSize == ulStatInterval);
1959
1960	Log(("vmmdevSetStatisticsInterval: old=%d. new=%d\n", pThis->u32LastStatIntervalSize, ulStatInterval));
1961
1962	if (!fSame)
1963	{
1964	/* we could validate the information here but hey, the guest can do that as well! */
1965	pThis->u32StatIntervalSize = ulStatInterval;
1966
1967	/* IRQ so the guest knows what's going on */
1968	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_STATISTICS_INTERVAL_CHANGE_REQUEST);
1969	}
1970
1971	return VINF_SUCCESS;
1972	}
1973
1974
1975	static DECLCALLBACK(int) vmmdevSetCredentials(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
1976	const char pszPassword, const char pszDomain,
1977	uint32_t u32Flags)
1978	{
1979	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
1980
1981	/* logon mode? */
1982	if (u32Flags & VMMDEV_SETCREDENTIALS_GUESTLOGON)
1983	{
1984	/* memorize the data */
1985	strcpy(pThis->credentialsLogon.szUserName, pszUsername);
1986	strcpy(pThis->credentialsLogon.szPassword, pszPassword);
1987	strcpy(pThis->credentialsLogon.szDomain, pszDomain);
1988	pThis->credentialsLogon.fAllowInteractiveLogon = !(u32Flags & VMMDEV_SETCREDENTIALS_NOLOCALLOGON);
1989	}
1990	/* credentials verification mode? */
1991	else if (u32Flags & VMMDEV_SETCREDENTIALS_JUDGE)
1992	{
1993	/* memorize the data */
1994	strcpy(pThis->credentialsJudge.szUserName, pszUsername);
1995	strcpy(pThis->credentialsJudge.szPassword, pszPassword);
1996	strcpy(pThis->credentialsJudge.szDomain, pszDomain);
1997
1998	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_JUDGE_CREDENTIALS);
1999	}
2000	else
2001	return VERR_INVALID_PARAMETER;
2002
2003	return VINF_SUCCESS;
2004	}
2005
2006	/**
2007	* Notification from the Display. Especially useful when
2008	* acceleration is disabled after a video mode change.
2009	*
2010	* @param fEnable Current acceleration status.
2011	*/
2012	static DECLCALLBACK(void) vmmdevVBVAChange(PPDMIVMMDEVPORT pInterface, bool fEnabled)
2013	{
2014	VMMDevState *pThis = IVMMDEVPORT_2_VMMDEVSTATE(pInterface);
2015
2016	Log(("vmmdevVBVAChange: fEnabled = %d\n", fEnabled));
2017
2018	if (pThis)
2019	{
2020	pThis->u32VideoAccelEnabled = fEnabled;
2021	}
2022
2023	return;
2024	}
2025
2026
2027	/* -=-=-=-=-=- IHGCMPort -=-=-=-=-=- */
2028
2029	/** Converts a VMMDev port interface pointer to a VMMDev state pointer. */
2030	#define IHGCMPORT_2_VMMDEVSTATE(pInterface) ( (VMMDevState*)((uintptr_t)pInterface - RT_OFFSETOF(VMMDevState, HGCMPort)) )
2031
2032
2033
2034	#define VMMDEV_SSM_VERSION 9
2035
2036	/**
2037	* Saves a state of the VMM device.
2038	*
2039	* @returns VBox status code.
2040	* @param pDevIns The device instance.
2041	* @param pSSMHandle The handle to save the state to.
2042	*/
2043	static DECLCALLBACK(int) vmmdevSaveState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
2044	{
2045	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2046	SSMR3PutU32(pSSMHandle, pThis->hypervisorSize);
2047	SSMR3PutU32(pSSMHandle, pThis->mouseCapabilities);
2048	SSMR3PutU32(pSSMHandle, pThis->mouseXAbs);
2049	SSMR3PutU32(pSSMHandle, pThis->mouseYAbs);
2050
2051	SSMR3PutBool(pSSMHandle, pThis->fNewGuestFilterMask);
2052	SSMR3PutU32(pSSMHandle, pThis->u32NewGuestFilterMask);
2053	SSMR3PutU32(pSSMHandle, pThis->u32GuestFilterMask);
2054	SSMR3PutU32(pSSMHandle, pThis->u32HostEventFlags);
2055	// here be dragons (probably)
2056	// SSMR3PutBool(pSSMHandle, pThis->pVMMDevRAMR3->V.V1_04.fHaveEvents);
2057	SSMR3PutMem(pSSMHandle, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
2058
2059	SSMR3PutMem(pSSMHandle, &pThis->guestInfo, sizeof (pThis->guestInfo));
2060	SSMR3PutU32(pSSMHandle, pThis->fu32AdditionsOk);
2061	SSMR3PutU32(pSSMHandle, pThis->u32VideoAccelEnabled);
2062
2063	SSMR3PutU32(pSSMHandle, pThis->guestCaps);
2064
2065	#ifdef VBOX_WITH_HGCM
2066	vmmdevHGCMSaveState (pThis, pSSMHandle);
2067	#endif /* VBOX_WITH_HGCM */
2068
2069	return VINF_SUCCESS;
2070	}
2071
2072	/**
2073	* Loads the saved VMM device state.
2074	*
2075	* @returns VBox status code.
2076	* @param pDevIns The device instance.
2077	* @param pSSMHandle The handle to the saved state.
2078	* @param u32Version The data unit version number.
2079	*/
2080	static DECLCALLBACK(int) vmmdevLoadState(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
2081	{
2082	/** @todo The code load code is assuming we're always loaded into a fresh VM. */
2083	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2084	if ( SSM_VERSION_MAJOR_CHANGED(u32Version, VMMDEV_SSM_VERSION)
2085	\|\| (SSM_VERSION_MINOR(u32Version) < 6))
2086	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2087
2088	SSMR3GetU32(pSSMHandle, &pThis->hypervisorSize);
2089	SSMR3GetU32(pSSMHandle, &pThis->mouseCapabilities);
2090	SSMR3GetU32(pSSMHandle, &pThis->mouseXAbs);
2091	SSMR3GetU32(pSSMHandle, &pThis->mouseYAbs);
2092
2093	SSMR3GetBool(pSSMHandle, &pThis->fNewGuestFilterMask);
2094	SSMR3GetU32(pSSMHandle, &pThis->u32NewGuestFilterMask);
2095	SSMR3GetU32(pSSMHandle, &pThis->u32GuestFilterMask);
2096	SSMR3GetU32(pSSMHandle, &pThis->u32HostEventFlags);
2097	// SSMR3GetBool(pSSMHandle, &pThis->pVMMDevRAMR3->fHaveEvents);
2098	// here be dragons (probably)
2099	SSMR3GetMem(pSSMHandle, &pThis->pVMMDevRAMR3->V, sizeof (pThis->pVMMDevRAMR3->V));
2100
2101	SSMR3GetMem(pSSMHandle, &pThis->guestInfo, sizeof (pThis->guestInfo));
2102	SSMR3GetU32(pSSMHandle, &pThis->fu32AdditionsOk);
2103	SSMR3GetU32(pSSMHandle, &pThis->u32VideoAccelEnabled);
2104
2105	SSMR3GetU32(pSSMHandle, &pThis->guestCaps);
2106
2107	/* Attributes which were temporarily introduced in r30072 */
2108	if ( SSM_VERSION_MAJOR(u32Version) == 0
2109	&& SSM_VERSION_MINOR(u32Version) == 7)
2110	{
2111	uint32_t temp;
2112	SSMR3GetU32(pSSMHandle, &temp);
2113	SSMR3GetU32(pSSMHandle, &temp);
2114	}
2115
2116	#ifdef VBOX_WITH_HGCM
2117	vmmdevHGCMLoadState (pThis, pSSMHandle, u32Version);
2118	#endif /* VBOX_WITH_HGCM */
2119
2120	/*
2121	* On a resume, we send the capabilities changed message so
2122	* that listeners can sync their state again
2123	*/
2124	Log(("vmmdevLoadState: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2125	if (pThis->pDrv)
2126	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2127
2128	/* Reestablish the acceleration status. */
2129	if ( pThis->u32VideoAccelEnabled
2130	&& pThis->pDrv)
2131	{
2132	pThis->pDrv->pfnVideoAccelEnable (pThis->pDrv, !!pThis->u32VideoAccelEnabled, &pThis->pVMMDevRAMR3->vbvaMemory);
2133	}
2134
2135	if (pThis->fu32AdditionsOk)
2136	{
2137	LogRel(("Guest Additions information report: additionsVersion = 0x%08X, osType = 0x%08X\n",
2138	pThis->guestInfo.additionsVersion,
2139	pThis->guestInfo.osType));
2140	if (pThis->pDrv)
2141	pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
2142	}
2143	if (pThis->pDrv)
2144	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2145
2146	return VINF_SUCCESS;
2147	}
2148
2149	/**
2150	* Load state done callback. Notify guest of restore event.
2151	*
2152	* @returns VBox status code.
2153	* @param pDevIns The device instance.
2154	* @param pSSMHandle The handle to the saved state.
2155	*/
2156	static DECLCALLBACK(int) vmmdevLoadStateDone(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
2157	{
2158	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2159
2160	#ifdef VBOX_WITH_HGCM
2161	vmmdevHGCMLoadStateDone (pThis, pSSMHandle);
2162	#endif /* VBOX_WITH_HGCM */
2163
2164	VMMDevNotifyGuest (pThis, VMMDEV_EVENT_RESTORED);
2165
2166	return VINF_SUCCESS;
2167	}
2168
2169	/**
2170	* (Re-)initializes the MMIO2 data.
2171	*
2172	* @param pThis Pointer to the VMMDev instance data.
2173	*/
2174	static void vmmdevInitRam(VMMDevState *pThis)
2175	{
2176	memset(pThis->pVMMDevRAMR3, 0, sizeof(VMMDevMemory));
2177	pThis->pVMMDevRAMR3->u32Size = sizeof(VMMDevMemory);
2178	pThis->pVMMDevRAMR3->u32Version = VMMDEV_MEMORY_VERSION;
2179	}
2180
2181	/**
2182	* Construct a device instance for a VM.
2183	*
2184	* @returns VBox status.
2185	* @param pDevIns The device instance data.
2186	* If the registration structure is needed, pDevIns->pDevReg points to it.
2187	* @param iInstance Instance number. Use this to figure out which registers and such to use.
2188	* The device number is also found in pDevIns->iInstance, but since it's
2189	* likely to be freqently used PDM passes it as parameter.
2190	* @param pCfgHandle Configuration node handle for the device. Use this to obtain the configuration
2191	* of the device instance. It's also found in pDevIns->pCfgHandle, but like
2192	* iInstance it's expected to be used a bit in this function.
2193	*/
2194	static DECLCALLBACK(int) vmmdevConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
2195	{
2196	int rc;
2197	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState );
2198
2199	Assert(iInstance == 0);
2200
2201	/*
2202	* Validate and read the configuration.
2203	*/
2204	if (!CFGMR3AreValuesValid(pCfgHandle,
2205	"GetHostTimeDisabled\0"
2206	"BackdoorLogDisabled\0"
2207	"KeepCredentials\0"
2208	"HeapEnabled\0"
2209	))
2210	return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
2211
2212	rc = CFGMR3QueryBoolDef(pCfgHandle, "GetHostTimeDisabled", &pThis->fGetHostTimeDisabled, false);
2213	if (RT_FAILURE(rc))
2214	return PDMDEV_SET_ERROR(pDevIns, rc,
2215	N_("Configuration error: Failed querying \"GetHostTimeDisabled\" as a boolean"));
2216
2217	rc = CFGMR3QueryBoolDef(pCfgHandle, "BackdoorLogDisabled", &pThis->fBackdoorLogDisabled, false);
2218	if (RT_FAILURE(rc))
2219	return PDMDEV_SET_ERROR(pDevIns, rc,
2220	N_("Configuration error: Failed querying \"BackdoorLogDisabled\" as a boolean"));
2221
2222	rc = CFGMR3QueryBoolDef(pCfgHandle, "KeepCredentials", &pThis->fKeepCredentials, false);
2223	if (RT_FAILURE(rc))
2224	return PDMDEV_SET_ERROR(pDevIns, rc,
2225	N_("Configuration error: Failed querying \"KeepCredentials\" as a boolean"));
2226
2227	bool fHeapEnabled;
2228	rc = CFGMR3QueryBoolDef(pCfgHandle, "HeapEnabled", &fHeapEnabled, true);
2229	if (RT_FAILURE(rc))
2230	return PDMDEV_SET_ERROR(pDevIns, rc,
2231	N_("Configuration error: Failed querying \"HeapEnabled\" as a boolean"));
2232
2233	/*
2234	* Initialize data (most of it anyway).
2235	*/
2236	/* Save PDM device instance data for future reference. */
2237	pThis->pDevIns = pDevIns;
2238
2239	/* PCI vendor, just a free bogus value */
2240	pThis->dev.config[0x00] = 0xee;
2241	pThis->dev.config[0x01] = 0x80;
2242	/* device ID */
2243	pThis->dev.config[0x02] = 0xfe;
2244	pThis->dev.config[0x03] = 0xca;
2245	/* class sub code (other type of system peripheral) */
2246	pThis->dev.config[0x0a] = 0x80;
2247	/* class base code (base system peripheral) */
2248	pThis->dev.config[0x0b] = 0x08;
2249	/* header type */
2250	pThis->dev.config[0x0e] = 0x00;
2251	/* interrupt on pin 0 */
2252	pThis->dev.config[0x3d] = 0x01;
2253
2254	/*
2255	* Interfaces
2256	*/
2257	/* Base */
2258	pThis->Base.pfnQueryInterface = vmmdevPortQueryInterface;
2259
2260	/* VMMDev port */
2261	pThis->Port.pfnQueryAbsoluteMouse = vmmdevQueryAbsoluteMouse;
2262	pThis->Port.pfnSetAbsoluteMouse = vmmdevSetAbsoluteMouse;
2263	pThis->Port.pfnQueryMouseCapabilities = vmmdevQueryMouseCapabilities;
2264	pThis->Port.pfnSetMouseCapabilities = vmmdevSetMouseCapabilities;
2265	pThis->Port.pfnRequestDisplayChange = vmmdevRequestDisplayChange;
2266	pThis->Port.pfnSetCredentials = vmmdevSetCredentials;
2267	pThis->Port.pfnVBVAChange = vmmdevVBVAChange;
2268	pThis->Port.pfnRequestSeamlessChange = vmmdevRequestSeamlessChange;
2269	pThis->Port.pfnSetMemoryBalloon = vmmdevSetMemoryBalloon;
2270	pThis->Port.pfnSetStatisticsInterval = vmmdevSetStatisticsInterval;
2271	pThis->Port.pfnVRDPChange = vmmdevVRDPChange;
2272
2273	/* Shared folder LED */
2274	pThis->SharedFolders.Led.u32Magic = PDMLED_MAGIC;
2275	pThis->SharedFolders.ILeds.pfnQueryStatusLed = vmmdevQueryStatusLed;
2276
2277	#ifdef VBOX_WITH_HGCM
2278	/* HGCM port */
2279	pThis->HGCMPort.pfnCompleted = hgcmCompleted;
2280	#endif
2281
2282	/** @todo convert this into a config parameter like we do everywhere else! */
2283	pThis->cbGuestRAM = MMR3PhysGetRamSize(PDMDevHlpGetVM(pDevIns));
2284
2285	/*
2286	* Create the critical section for the device.
2287	*/
2288	rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, "VMMDev");
2289	AssertRCReturn(rc, rc);
2290	/* Later: pDevIns->pCritSectR3 = &pThis->CritSect; */
2291
2292	/*
2293	* Register the backdoor logging port
2294	*/
2295	rc = PDMDevHlpIOPortRegister(pDevIns, RTLOG_DEBUG_PORT, 1, NULL, vmmdevBackdoorLog, NULL, NULL, NULL, "VMMDev backdoor logging");
2296	AssertRCReturn(rc, rc);
2297
2298	#ifdef TIMESYNC_BACKDOOR
2299	/*
2300	* Alternative timesync source (temporary!)
2301	*/
2302	rc = PDMDevHlpIOPortRegister(pDevIns, 0x505, 1, NULL, vmmdevTimesyncBackdoorWrite, vmmdevTimesyncBackdoorRead, NULL, NULL, "VMMDev timesync backdoor");
2303	AssertRCReturn(rc, rc);
2304	#endif
2305
2306	/*
2307	* Allocate and initialize the MMIO2 memory.
2308	*/
2309	rc = PDMDevHlpMMIO2Register(pDevIns, 1 /iRegion/, VMMDEV_RAM_SIZE, 0 /fFlags/, (void **)&pThis->pVMMDevRAMR3, "VMMDev");
2310	if (RT_FAILURE(rc))
2311	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2312	N_("Failed to allocate %u bytes of memory for the VMM device"), VMMDEV_RAM_SIZE);
2313	vmmdevInitRam(pThis);
2314
2315	if (fHeapEnabled)
2316	{
2317	rc = PDMDevHlpMMIO2Register(pDevIns, 2 /iRegion/, VMMDEV_HEAP_SIZE, 0 /fFlags/, (void **)&pThis->pVMMDevHeapR3, "VMMDev Heap");
2318	if (RT_FAILURE(rc))
2319	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
2320	N_("Failed to allocate %u bytes of memory for the VMM device heap"), PAGE_SIZE);
2321	}
2322
2323	/*
2324	* Register the PCI device.
2325	*/
2326	rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
2327	if (RT_FAILURE(rc))
2328	return rc;
2329	if (pThis->dev.devfn == 32 \|\| iInstance != 0)
2330	Log(("!!WARNING!!: pThis->dev.devfn=%d (ignore if testcase or no started by Main)\n", pThis->dev.devfn));
2331	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x20, PCI_ADDRESS_SPACE_IO, vmmdevIOPortRegionMap);
2332	if (RT_FAILURE(rc))
2333	return rc;
2334	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 1, VMMDEV_RAM_SIZE, PCI_ADDRESS_SPACE_MEM, vmmdevIORAMRegionMap);
2335	if (RT_FAILURE(rc))
2336	return rc;
2337	if (fHeapEnabled)
2338	{
2339	rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, VMMDEV_HEAP_SIZE, PCI_ADDRESS_SPACE_MEM_PREFETCH, vmmdevIORAMRegionMap);
2340	if (RT_FAILURE(rc))
2341	return rc;
2342	}
2343
2344	/*
2345	* Get the corresponding connector interface
2346	*/
2347	rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->Base, &pThis->pDrvBase, "VMM Driver Port");
2348	if (RT_SUCCESS(rc))
2349	{
2350	pThis->pDrv = (PPDMIVMMDEVCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_VMMDEV_CONNECTOR);
2351	if (!pThis->pDrv)
2352	AssertMsgFailedReturn(("LUN #0 doesn't have a VMMDev connector interface!\n"), VERR_PDM_MISSING_INTERFACE);
2353	#ifdef VBOX_WITH_HGCM
2354	pThis->pHGCMDrv = (PPDMIHGCMCONNECTOR)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_HGCM_CONNECTOR);
2355	if (!pThis->pHGCMDrv)
2356	{
2357	Log(("LUN #0 doesn't have a HGCM connector interface, HGCM is not supported. rc=%Rrc\n", rc));
2358	/* this is not actually an error, just means that there is no support for HGCM */
2359	}
2360	#endif
2361	}
2362	else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
2363	{
2364	Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
2365	rc = VINF_SUCCESS;
2366	}
2367	else
2368	AssertMsgFailedReturn(("Failed to attach LUN #0! rc=%Rrc\n", rc), rc);
2369
2370	/*
2371	* Attach status driver for shared folders (optional).
2372	*/
2373	PPDMIBASE pBase;
2374	rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis->Base, &pBase, "Status Port");
2375	if (RT_SUCCESS(rc))
2376	pThis->SharedFolders.pLedsConnector = (PPDMILEDCONNECTORS)
2377	pBase->pfnQueryInterface(pBase, PDMINTERFACE_LED_CONNECTORS);
2378	else if (rc != VERR_PDM_NO_ATTACHED_DRIVER)
2379	{
2380	AssertMsgFailed(("Failed to attach to status driver. rc=%Rrc\n", rc));
2381	return rc;
2382	}
2383
2384	/*
2385	* Register saved state and init the HGCM CmdList critsect.
2386	*/
2387	rc = PDMDevHlpSSMRegister(pDevIns, "VMMDev", iInstance, VMMDEV_SSM_VERSION, sizeof(*pThis),
2388	NULL, vmmdevSaveState, NULL,
2389	NULL, vmmdevLoadState, vmmdevLoadStateDone);
2390	AssertRCReturn(rc, rc);
2391
2392	#ifdef VBOX_WITH_HGCM
2393	pThis->pHGCMCmdList = NULL;
2394	rc = RTCritSectInit(&pThis->critsectHGCMCmdList);
2395	AssertRCReturn(rc, rc);
2396	pThis->u32HGCMEnabled = 0;
2397	#endif /* VBOX_WITH_HGCM */
2398
2399	return rc;
2400	}
2401
2402	/**
2403	* Reset notification.
2404	*
2405	* @returns VBox status.
2406	* @param pDrvIns The driver instance data.
2407	*/
2408	static DECLCALLBACK(void) vmmdevReset(PPDMDEVINS pDevIns)
2409	{
2410	VMMDevState pThis = PDMINS_2_DATA(pDevIns, VMMDevState);
2411
2412	/*
2413	* Reset the mouse integration feature bit
2414	*/
2415	if (pThis->mouseCapabilities & (VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE\|VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR))
2416	{
2417	pThis->mouseCapabilities &= ~VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE;
2418	/* notify the connector */
2419	Log(("vmmdevReset: capabilities changed (%x), informing connector\n", pThis->mouseCapabilities));
2420	pThis->pDrv->pfnUpdateMouseCapabilities(pThis->pDrv, pThis->mouseCapabilities);
2421	}
2422
2423	pThis->hypervisorSize = 0;
2424
2425	pThis->u32HostEventFlags = 0;
2426
2427	/* re-initialize the VMMDev memory */
2428	if (pThis->pVMMDevRAMR3)
2429	vmmdevInitRam(pThis);
2430
2431	/* credentials have to go away (by default) */
2432	if (!pThis->fKeepCredentials)
2433	{
2434	memset(pThis->credentialsLogon.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
2435	memset(pThis->credentialsLogon.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
2436	memset(pThis->credentialsLogon.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
2437	}
2438	memset(pThis->credentialsJudge.szUserName, '\0', VMMDEV_CREDENTIALS_STRLEN);
2439	memset(pThis->credentialsJudge.szPassword, '\0', VMMDEV_CREDENTIALS_STRLEN);
2440	memset(pThis->credentialsJudge.szDomain, '\0', VMMDEV_CREDENTIALS_STRLEN);
2441
2442	/* Reset means that additions will report again. */
2443	const bool fVersionChanged = pThis->fu32AdditionsOk
2444	\|\| pThis->guestInfo.additionsVersion
2445	\|\| pThis->guestInfo.osType != VBOXOSTYPE_Unknown;
2446	if (fVersionChanged)
2447	Log(("vmmdevReset: fu32AdditionsOk=%d additionsVersion=%x osType=%#x\n",
2448	pThis->fu32AdditionsOk, pThis->guestInfo.additionsVersion, pThis->guestInfo.osType));
2449	pThis->fu32AdditionsOk = false;
2450	memset (&pThis->guestInfo, 0, sizeof (pThis->guestInfo));
2451
2452	/* clear pending display change request. */
2453	memset (&pThis->lastReadDisplayChangeRequest, 0, sizeof (pThis->lastReadDisplayChangeRequest));
2454
2455	/* disable seamless mode */
2456	pThis->fLastSeamlessEnabled = false;
2457
2458	/* disabled memory ballooning */
2459	pThis->u32LastMemoryBalloonSize = 0;
2460
2461	/* disabled statistics updating */
2462	pThis->u32LastStatIntervalSize = 0;
2463
2464	/* Clear the "HGCM event enabled" flag so the event can be automatically reenabled. */
2465	pThis->u32HGCMEnabled = 0;
2466
2467	/*
2468	* Clear the event variables.
2469	*
2470	* Note: The pThis->u32HostEventFlags is not cleared.
2471	* It is designed that way so host events do not
2472	* depend on guest resets.
2473	*/
2474	pThis->u32GuestFilterMask = 0;
2475	pThis->u32NewGuestFilterMask = 0;
2476	pThis->fNewGuestFilterMask = 0;
2477
2478	/* This is the default, as Windows and OS/2 guests take this for granted. (Actually, neither does...) */
2479	/** @todo change this when we next bump the interface version */
2480	const bool fCapsChanged = pThis->guestCaps != VMMDEV_GUEST_SUPPORTS_GRAPHICS;
2481	if (fCapsChanged)
2482	Log(("vmmdevReset: fCapsChanged=%#x -> %#x\n", pThis->guestCaps, VMMDEV_GUEST_SUPPORTS_GRAPHICS));
2483	pThis->guestCaps = VMMDEV_GUEST_SUPPORTS_GRAPHICS; /** @todo r=bird: why? I cannot see this being done at construction?*/
2484
2485	/*
2486	* Call the update functions as required.
2487	*/
2488	if (fVersionChanged)
2489	pThis->pDrv->pfnUpdateGuestVersion(pThis->pDrv, &pThis->guestInfo);
2490	if (fCapsChanged)
2491	pThis->pDrv->pfnUpdateGuestCapabilities(pThis->pDrv, pThis->guestCaps);
2492	}
2493
2494
2495	/**
2496	* The device registration structure.
2497	*/
2498	extern "C" const PDMDEVREG g_DeviceVMMDev =
2499	{
2500	/* u32Version */
2501	PDM_DEVREG_VERSION,
2502	/* szDeviceName */
2503	"VMMDev",
2504	/* szRCMod */
2505	"",
2506	/* szR0Mod */
2507	"",
2508	/* pszDescription */
2509	"VirtualBox VMM Device\n",
2510	/* fFlags */
2511	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32,
2512	/* fClass */
2513	PDM_DEVREG_CLASS_VMM_DEV,
2514	/* cMaxInstances */
2515	1,
2516	/* cbInstance */
2517	sizeof(VMMDevState),
2518	/* pfnConstruct */
2519	vmmdevConstruct,
2520	/* pfnDestruct */
2521	NULL,
2522	/* pfnRelocate */
2523	NULL,
2524	/* pfnIOCtl */
2525	NULL,
2526	/* pfnPowerOn */
2527	NULL,
2528	/* pfnReset */
2529	vmmdevReset,
2530	/* pfnSuspend */
2531	NULL,
2532	/* pfnResume */
2533	NULL,
2534	/* pfnAttach */
2535	NULL,
2536	/* pfnDetach */
2537	NULL,
2538	/* pfnQueryInterface. */
2539	NULL,
2540	/* pfnInitComplete */
2541	NULL,
2542	/* pfnPowerOff */
2543	NULL,
2544	/* pfnSoftReset */
2545	NULL,
2546	/* u32VersionEnd */
2547	PDM_DEVREG_VERSION
2548	};
2549	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
2550

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

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

Download in other formats: