VBoxDev.cpp@ 13756

Last change on this file since 13756 was 13756, checked in by vboxsync, 16 years ago
Compile fixes for the VM request changes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 95.9 KB

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

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

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

Download in other formats: