VMMDev.cpp@ 26994

Last change on this file since 26994 was 26350, checked in by vboxsync, 15 years ago
Removed the balloon interface from Main's VMM device. Directly call PGMR3PhysFreeRamPages in VMMDev.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 106.4 KB

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

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

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

Download in other formats: