VBoxGuest.cpp@ 99120

Last change on this file since 99120 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 163.6 KB

Line
1	/* $Id: VBoxGuest.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VBoxGuest - Guest Additions Driver, Common Code.
4	*/
5
6	/*
7	* Copyright (C) 2007-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37	/** @page pg_vbdrv VBoxGuest
38	*
39	* VBoxGuest is the device driver for VMMDev.
40	*
41	* The device driver is shipped as part of the guest additions. It has roots in
42	* the host VMM support driver (usually known as VBoxDrv), so fixes in platform
43	* specific code may apply to both drivers.
44	*
45	* The common code lives in VBoxGuest.cpp and is compiled both as C++ and C.
46	* The VBoxGuest.cpp source file shall not contain platform specific code,
47	* though it must occationally do a few \#ifdef RT_OS_XXX tests to cater for
48	* platform differences. Though, in those cases, it is common that more than
49	* one platform needs special handling.
50	*
51	* On most platforms the device driver should create two device nodes, one for
52	* full (unrestricted) access to the feature set, and one which only provides a
53	* restrict set of functions. These are generally referred to as 'vboxguest'
54	* and 'vboxuser' respectively. Currently, this two device approach is only
55	* implemented on Linux!
56	*
57	*/
58
59
60	/*********************************************************************************************************************************
61	* Header Files *
62	*********************************************************************************************************************************/
63	#define LOG_GROUP LOG_GROUP_DEFAULT
64	#include "VBoxGuestInternal.h"
65	#include <VBox/VMMDev.h> /* for VMMDEV_RAM_SIZE */
66	#include <VBox/err.h>
67	#include <VBox/log.h>
68	#include <VBox/HostServices/GuestPropertySvc.h>
69	#include <iprt/ctype.h>
70	#include <iprt/mem.h>
71	#include <iprt/time.h>
72	#include <iprt/memobj.h>
73	#include <iprt/asm.h>
74	#include <iprt/asm-amd64-x86.h>
75	#include <iprt/string.h>
76	#include <iprt/process.h>
77	#include <iprt/assert.h>
78	#include <iprt/param.h>
79	#include <iprt/timer.h>
80	#ifdef VBOX_WITH_HGCM
81	# include <iprt/thread.h>
82	#endif
83	#include "version-generated.h"
84	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
85	# include "revision-generated.h"
86	#endif
87	#if defined(RT_OS_SOLARIS) \|\| defined(RT_OS_DARWIN)
88	# include <iprt/rand.h>
89	#endif
90
91
92	/*********************************************************************************************************************************
93	* Defined Constants And Macros *
94	*********************************************************************************************************************************/
95	#define VBOXGUEST_ACQUIRE_STYLE_EVENTS (VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST \| VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
96
97
98	/*********************************************************************************************************************************
99	* Internal Functions *
100	*********************************************************************************************************************************/
101	#ifdef VBOX_WITH_HGCM
102	static DECLCALLBACK(int) vgdrvHgcmAsyncWaitCallback(VMMDevHGCMRequestHeader pHdrNonVolatile, void pvUser, uint32_t u32User);
103	#endif
104	static int vgdrvIoCtl_CancelAllWaitEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
105	static void vgdrvBitUsageTrackerClear(PVBOXGUESTBITUSAGETRACER pTracker);
106	static uint32_t vgdrvGetAllowedEventMaskForSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession);
107	static int vgdrvResetEventFilterOnHost(PVBOXGUESTDEVEXT pDevExt, uint32_t fFixedEvents);
108	static int vgdrvResetMouseStatusOnHost(PVBOXGUESTDEVEXT pDevExt);
109	static int vgdrvResetCapabilitiesOnHost(PVBOXGUESTDEVEXT pDevExt);
110	static int vgdrvSetSessionEventFilter(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
111	uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination);
112	static int vgdrvSetSessionMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
113	uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination);
114	static int vgdrvSetSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
115	uint32_t fOrMask, uint32_t fNoMask,
116	uint32_t pfSessionCaps, uint32_t pfGlobalCaps, bool fSessionTermination);
117	static int vgdrvAcquireSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
118	uint32_t fOrMask, uint32_t fNotMask, uint32_t fFlags, bool fSessionTermination);
119	static int vgdrvDispatchEventsLocked(PVBOXGUESTDEVEXT pDevExt, uint32_t fEvents);
120
121
122	/*********************************************************************************************************************************
123	* Global Variables *
124	*********************************************************************************************************************************/
125	static const uint32_t g_cbChangeMemBalloonReq = RT_UOFFSETOF(VMMDevChangeMemBalloon, aPhysPage[VMMDEV_MEMORY_BALLOON_CHUNK_PAGES]);
126
127	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS)
128	/**
129	* Drag in the rest of IRPT since we share it with the
130	* rest of the kernel modules on Solaris.
131	*/
132	struct CLANG11WEIRDNESS { PFNRT pfn; } g_apfnVBoxGuestIPRTDeps[] =
133	{
134	/* VirtioNet */
135	{ (PFNRT)RTRandBytes },
136	/* RTSemMutex* */
137	{ (PFNRT)RTSemMutexCreate },
138	{ (PFNRT)RTSemMutexDestroy },
139	{ (PFNRT)RTSemMutexRequest },
140	{ (PFNRT)RTSemMutexRequestNoResume },
141	{ (PFNRT)RTSemMutexRequestDebug },
142	{ (PFNRT)RTSemMutexRequestNoResumeDebug },
143	{ (PFNRT)RTSemMutexRelease },
144	{ (PFNRT)RTSemMutexIsOwned },
145	{ NULL }
146	};
147	#endif /* RT_OS_DARWIN \|\| RT_OS_SOLARIS */
148
149
150	/**
151	* Reserves memory in which the VMM can relocate any guest mappings
152	* that are floating around.
153	*
154	* This operation is a little bit tricky since the VMM might not accept
155	* just any address because of address clashes between the three contexts
156	* it operates in, so use a small stack to perform this operation.
157	*
158	* @returns VBox status code (ignored).
159	* @param pDevExt The device extension.
160	*/
161	static int vgdrvInitFixateGuestMappings(PVBOXGUESTDEVEXT pDevExt)
162	{
163	/*
164	* Query the required space.
165	*/
166	VMMDevReqHypervisorInfo *pReq;
167	int rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReq, sizeof(VMMDevReqHypervisorInfo), VMMDevReq_GetHypervisorInfo);
168	if (RT_FAILURE(rc))
169	return rc;
170	pReq->hypervisorStart = 0;
171	pReq->hypervisorSize = 0;
172	rc = VbglR0GRPerform(&pReq->header);
173	if (RT_FAILURE(rc)) /* this shouldn't happen! */
174	{
175	VbglR0GRFree(&pReq->header);
176	return rc;
177	}
178
179	/*
180	* The VMM will report back if there is nothing it wants to map, like for
181	* instance in VT-x and AMD-V mode.
182	*/
183	if (pReq->hypervisorSize == 0)
184	Log(("vgdrvInitFixateGuestMappings: nothing to do\n"));
185	else
186	{
187	/*
188	* We have to try several times since the host can be picky
189	* about certain addresses.
190	*/
191	RTR0MEMOBJ hFictive = NIL_RTR0MEMOBJ;
192	uint32_t cbHypervisor = pReq->hypervisorSize;
193	RTR0MEMOBJ ahTries[5];
194	uint32_t iTry;
195	bool fBitched = false;
196	Log(("vgdrvInitFixateGuestMappings: cbHypervisor=%#x\n", cbHypervisor));
197	for (iTry = 0; iTry < RT_ELEMENTS(ahTries); iTry++)
198	{
199	/*
200	* Reserve space, or if that isn't supported, create a object for
201	* some fictive physical memory and map that in to kernel space.
202	*
203	* To make the code a bit uglier, most systems cannot help with
204	* 4MB alignment, so we have to deal with that in addition to
205	* having two ways of getting the memory.
206	*/
207	uint32_t uAlignment = _4M;
208	RTR0MEMOBJ hObj;
209	rc = RTR0MemObjReserveKernel(&hObj, (void *)-1, RT_ALIGN_32(cbHypervisor, _4M), uAlignment);
210	if (rc == VERR_NOT_SUPPORTED)
211	{
212	uAlignment = PAGE_SIZE;
213	rc = RTR0MemObjReserveKernel(&hObj, (void *)-1, RT_ALIGN_32(cbHypervisor, _4M) + _4M, uAlignment);
214	}
215	/*
216	* If both RTR0MemObjReserveKernel calls above failed because either not supported or
217	* not implemented at all at the current platform, try to map the memory object into the
218	* virtual kernel space.
219	*/
220	if (rc == VERR_NOT_SUPPORTED)
221	{
222	if (hFictive == NIL_RTR0MEMOBJ)
223	{
224	rc = RTR0MemObjEnterPhys(&hObj, VBOXGUEST_HYPERVISOR_PHYSICAL_START, cbHypervisor + _4M, RTMEM_CACHE_POLICY_DONT_CARE);
225	if (RT_FAILURE(rc))
226	break;
227	hFictive = hObj;
228	}
229	uAlignment = _4M;
230	rc = RTR0MemObjMapKernel(&hObj, hFictive, (void *)-1, uAlignment, RTMEM_PROT_READ \| RTMEM_PROT_WRITE);
231	if (rc == VERR_NOT_SUPPORTED)
232	{
233	uAlignment = PAGE_SIZE;
234	rc = RTR0MemObjMapKernel(&hObj, hFictive, (void *)-1, uAlignment, RTMEM_PROT_READ \| RTMEM_PROT_WRITE);
235	}
236	}
237	if (RT_FAILURE(rc))
238	{
239	LogRel(("VBoxGuest: Failed to reserve memory for the hypervisor: rc=%Rrc (cbHypervisor=%#x uAlignment=%#x iTry=%u)\n",
240	rc, cbHypervisor, uAlignment, iTry));
241	fBitched = true;
242	break;
243	}
244
245	/*
246	* Try set it.
247	*/
248	pReq->header.requestType = VMMDevReq_SetHypervisorInfo;
249	pReq->header.rc = VERR_INTERNAL_ERROR;
250	pReq->hypervisorSize = cbHypervisor;
251	pReq->hypervisorStart = (RTGCPTR32)(uintptr_t)RTR0MemObjAddress(hObj);
252	if ( uAlignment == PAGE_SIZE
253	&& pReq->hypervisorStart & (_4M - 1))
254	pReq->hypervisorStart = RT_ALIGN_32(pReq->hypervisorStart, _4M);
255	AssertMsg(RT_ALIGN_32(pReq->hypervisorStart, _4M) == pReq->hypervisorStart, ("%#x\n", pReq->hypervisorStart));
256
257	rc = VbglR0GRPerform(&pReq->header);
258	if (RT_SUCCESS(rc))
259	{
260	pDevExt->hGuestMappings = hFictive != NIL_RTR0MEMOBJ ? hFictive : hObj;
261	Log(("VBoxGuest: %p LB %#x; uAlignment=%#x iTry=%u hGuestMappings=%p (%s)\n",
262	RTR0MemObjAddress(pDevExt->hGuestMappings),
263	RTR0MemObjSize(pDevExt->hGuestMappings),
264	uAlignment, iTry, pDevExt->hGuestMappings, hFictive != NIL_RTR0PTR ? "fictive" : "reservation"));
265	break;
266	}
267	ahTries[iTry] = hObj;
268	}
269
270	/*
271	* Cleanup failed attempts.
272	*/
273	while (iTry-- > 0)
274	RTR0MemObjFree(ahTries[iTry], false /* fFreeMappings */);
275	if ( RT_FAILURE(rc)
276	&& hFictive != NIL_RTR0PTR)
277	RTR0MemObjFree(hFictive, false /* fFreeMappings */);
278	if (RT_FAILURE(rc) && !fBitched)
279	LogRel(("VBoxGuest: Warning: failed to reserve %#d of memory for guest mappings.\n", cbHypervisor));
280	}
281	VbglR0GRFree(&pReq->header);
282
283	/*
284	* We ignore failed attempts for now.
285	*/
286	return VINF_SUCCESS;
287	}
288
289
290	/**
291	* Undo what vgdrvInitFixateGuestMappings did.
292	*
293	* @param pDevExt The device extension.
294	*/
295	static void vgdrvTermUnfixGuestMappings(PVBOXGUESTDEVEXT pDevExt)
296	{
297	if (pDevExt->hGuestMappings != NIL_RTR0PTR)
298	{
299	/*
300	* Tell the host that we're going to free the memory we reserved for
301	* it, the free it up. (Leak the memory if anything goes wrong here.)
302	*/
303	VMMDevReqHypervisorInfo *pReq;
304	int rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReq, sizeof(VMMDevReqHypervisorInfo), VMMDevReq_SetHypervisorInfo);
305	if (RT_SUCCESS(rc))
306	{
307	pReq->hypervisorStart = 0;
308	pReq->hypervisorSize = 0;
309	rc = VbglR0GRPerform(&pReq->header);
310	VbglR0GRFree(&pReq->header);
311	}
312	if (RT_SUCCESS(rc))
313	{
314	rc = RTR0MemObjFree(pDevExt->hGuestMappings, true /* fFreeMappings */);
315	AssertRC(rc);
316	}
317	else
318	LogRel(("vgdrvTermUnfixGuestMappings: Failed to unfix the guest mappings! rc=%Rrc\n", rc));
319
320	pDevExt->hGuestMappings = NIL_RTR0MEMOBJ;
321	}
322	}
323
324
325
326	/**
327	* Report the guest information to the host.
328	*
329	* @returns IPRT status code.
330	* @param enmOSType The OS type to report.
331	*/
332	static int vgdrvReportGuestInfo(VBOXOSTYPE enmOSType)
333	{
334	/*
335	* Allocate and fill in the two guest info reports.
336	*/
337	VMMDevReportGuestInfo2 *pReqInfo2 = NULL;
338	VMMDevReportGuestInfo *pReqInfo1 = NULL;
339	int rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReqInfo2, sizeof (VMMDevReportGuestInfo2), VMMDevReq_ReportGuestInfo2);
340	Log(("vgdrvReportGuestInfo: VbglR0GRAlloc VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
341	if (RT_SUCCESS(rc))
342	{
343	pReqInfo2->guestInfo.additionsMajor = VBOX_VERSION_MAJOR;
344	pReqInfo2->guestInfo.additionsMinor = VBOX_VERSION_MINOR;
345	pReqInfo2->guestInfo.additionsBuild = VBOX_VERSION_BUILD;
346	pReqInfo2->guestInfo.additionsRevision = VBOX_SVN_REV;
347	pReqInfo2->guestInfo.additionsFeatures = VBOXGSTINFO2_F_REQUESTOR_INFO;
348	RTStrCopy(pReqInfo2->guestInfo.szName, sizeof(pReqInfo2->guestInfo.szName), VBOX_VERSION_STRING);
349
350	rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReqInfo1, sizeof (VMMDevReportGuestInfo), VMMDevReq_ReportGuestInfo);
351	Log(("vgdrvReportGuestInfo: VbglR0GRAlloc VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
352	if (RT_SUCCESS(rc))
353	{
354	pReqInfo1->guestInfo.interfaceVersion = VMMDEV_VERSION;
355	pReqInfo1->guestInfo.osType = enmOSType;
356
357	/*
358	* There are two protocols here:
359	* 1. Info2 + Info1. Supported by >=3.2.51.
360	* 2. Info1 and optionally Info2. The old protocol.
361	*
362	* We try protocol 1 first. It will fail with VERR_NOT_SUPPORTED
363	* if not supported by the VMMDev (message ordering requirement).
364	*/
365	rc = VbglR0GRPerform(&pReqInfo2->header);
366	Log(("vgdrvReportGuestInfo: VbglR0GRPerform VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
367	if (RT_SUCCESS(rc))
368	{
369	rc = VbglR0GRPerform(&pReqInfo1->header);
370	Log(("vgdrvReportGuestInfo: VbglR0GRPerform VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
371	}
372	else if ( rc == VERR_NOT_SUPPORTED
373	\|\| rc == VERR_NOT_IMPLEMENTED)
374	{
375	rc = VbglR0GRPerform(&pReqInfo1->header);
376	Log(("vgdrvReportGuestInfo: VbglR0GRPerform VMMDevReportGuestInfo completed with rc=%Rrc\n", rc));
377	if (RT_SUCCESS(rc))
378	{
379	rc = VbglR0GRPerform(&pReqInfo2->header);
380	Log(("vgdrvReportGuestInfo: VbglR0GRPerform VMMDevReportGuestInfo2 completed with rc=%Rrc\n", rc));
381	if (rc == VERR_NOT_IMPLEMENTED)
382	rc = VINF_SUCCESS;
383	}
384	}
385	VbglR0GRFree(&pReqInfo1->header);
386	}
387	VbglR0GRFree(&pReqInfo2->header);
388	}
389
390	return rc;
391	}
392
393
394	/**
395	* Report the guest driver status to the host.
396	*
397	* @returns IPRT status code.
398	* @param fActive Flag whether the driver is now active or not.
399	*/
400	static int vgdrvReportDriverStatus(bool fActive)
401	{
402	/*
403	* Report guest status of the VBox driver to the host.
404	*/
405	VMMDevReportGuestStatus *pReq2 = NULL;
406	int rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq2, sizeof(pReq2), VMMDevReq_ReportGuestStatus);
407	Log(("vgdrvReportDriverStatus: VbglR0GRAlloc VMMDevReportGuestStatus completed with rc=%Rrc\n", rc));
408	if (RT_SUCCESS(rc))
409	{
410	pReq2->guestStatus.facility = VBoxGuestFacilityType_VBoxGuestDriver;
411	pReq2->guestStatus.status = fActive ?
412	VBoxGuestFacilityStatus_Active
413	: VBoxGuestFacilityStatus_Inactive;
414	pReq2->guestStatus.flags = 0;
415	rc = VbglR0GRPerform(&pReq2->header);
416	Log(("vgdrvReportDriverStatus: VbglR0GRPerform VMMDevReportGuestStatus completed with fActive=%d, rc=%Rrc\n",
417	fActive ? 1 : 0, rc));
418	if (rc == VERR_NOT_IMPLEMENTED) /* Compatibility with older hosts. */
419	rc = VINF_SUCCESS;
420	VbglR0GRFree(&pReq2->header);
421	}
422
423	return rc;
424	}
425
426
427	/** @name Memory Ballooning
428	* @{
429	*/
430
431	/**
432	* Inflate the balloon by one chunk represented by an R0 memory object.
433	*
434	* The caller owns the balloon mutex.
435	*
436	* @returns IPRT status code.
437	* @param pMemObj Pointer to the R0 memory object.
438	* @param pReq The pre-allocated request for performing the VMMDev call.
439	*/
440	static int vgdrvBalloonInflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
441	{
442	uint32_t iPage;
443	int rc;
444
445	for (iPage = 0; iPage < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; iPage++)
446	{
447	RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(*pMemObj, iPage);
448	pReq->aPhysPage[iPage] = phys;
449	}
450
451	pReq->fInflate = true;
452	pReq->header.size = g_cbChangeMemBalloonReq;
453	pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
454
455	rc = VbglR0GRPerform(&pReq->header);
456	if (RT_FAILURE(rc))
457	LogRel(("vgdrvBalloonInflate: VbglR0GRPerform failed. rc=%Rrc\n", rc));
458	return rc;
459	}
460
461
462	/**
463	* Deflate the balloon by one chunk - info the host and free the memory object.
464	*
465	* The caller owns the balloon mutex.
466	*
467	* @returns IPRT status code.
468	* @param pMemObj Pointer to the R0 memory object.
469	* The memory object will be freed afterwards.
470	* @param pReq The pre-allocated request for performing the VMMDev call.
471	*/
472	static int vgdrvBalloonDeflate(PRTR0MEMOBJ pMemObj, VMMDevChangeMemBalloon *pReq)
473	{
474	uint32_t iPage;
475	int rc;
476
477	for (iPage = 0; iPage < VMMDEV_MEMORY_BALLOON_CHUNK_PAGES; iPage++)
478	{
479	RTHCPHYS phys = RTR0MemObjGetPagePhysAddr(*pMemObj, iPage);
480	pReq->aPhysPage[iPage] = phys;
481	}
482
483	pReq->fInflate = false;
484	pReq->header.size = g_cbChangeMemBalloonReq;
485	pReq->cPages = VMMDEV_MEMORY_BALLOON_CHUNK_PAGES;
486
487	rc = VbglR0GRPerform(&pReq->header);
488	if (RT_FAILURE(rc))
489	{
490	LogRel(("vgdrvBalloonDeflate: VbglR0GRPerform failed. rc=%Rrc\n", rc));
491	return rc;
492	}
493
494	rc = RTR0MemObjFree(*pMemObj, true);
495	if (RT_FAILURE(rc))
496	{
497	LogRel(("vgdrvBalloonDeflate: RTR0MemObjFree(%p,true) -> %Rrc; this is BAD!\n", *pMemObj, rc));
498	return rc;
499	}
500
501	*pMemObj = NIL_RTR0MEMOBJ;
502	return VINF_SUCCESS;
503	}
504
505
506	/**
507	* Inflate/deflate the memory balloon and notify the host.
508	*
509	* This is a worker used by vgdrvIoCtl_CheckMemoryBalloon - it takes the mutex.
510	*
511	* @returns VBox status code.
512	* @param pDevExt The device extension.
513	* @param cBalloonChunks The new size of the balloon in chunks of 1MB.
514	* @param pfHandleInR3 Where to return the handle-in-ring3 indicator
515	* (VINF_SUCCESS if set).
516	*/
517	static int vgdrvSetBalloonSizeKernel(PVBOXGUESTDEVEXT pDevExt, uint32_t cBalloonChunks, bool *pfHandleInR3)
518	{
519	int rc = VINF_SUCCESS;
520
521	if (pDevExt->MemBalloon.fUseKernelAPI)
522	{
523	VMMDevChangeMemBalloon *pReq;
524	uint32_t i;
525
526	if (cBalloonChunks > pDevExt->MemBalloon.cMaxChunks)
527	{
528	LogRel(("vgdrvSetBalloonSizeKernel: illegal balloon size %u (max=%u)\n",
529	cBalloonChunks, pDevExt->MemBalloon.cMaxChunks));
530	return VERR_INVALID_PARAMETER;
531	}
532
533	if (cBalloonChunks == pDevExt->MemBalloon.cMaxChunks)
534	return VINF_SUCCESS; /* nothing to do */
535
536	if ( cBalloonChunks > pDevExt->MemBalloon.cChunks
537	&& !pDevExt->MemBalloon.paMemObj)
538	{
539	pDevExt->MemBalloon.paMemObj = (PRTR0MEMOBJ)RTMemAllocZ(sizeof(RTR0MEMOBJ) * pDevExt->MemBalloon.cMaxChunks);
540	if (!pDevExt->MemBalloon.paMemObj)
541	{
542	LogRel(("vgdrvSetBalloonSizeKernel: no memory for paMemObj!\n"));
543	return VERR_NO_MEMORY;
544	}
545	}
546
547	rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReq, g_cbChangeMemBalloonReq, VMMDevReq_ChangeMemBalloon);
548	if (RT_FAILURE(rc))
549	return rc;
550
551	if (cBalloonChunks > pDevExt->MemBalloon.cChunks)
552	{
553	/* inflate */
554	for (i = pDevExt->MemBalloon.cChunks; i < cBalloonChunks; i++)
555	{
556	rc = RTR0MemObjAllocPhysNC(&pDevExt->MemBalloon.paMemObj[i],
557	VMMDEV_MEMORY_BALLOON_CHUNK_SIZE, NIL_RTHCPHYS);
558	if (RT_FAILURE(rc))
559	{
560	if (rc == VERR_NOT_SUPPORTED)
561	{
562	/* not supported -- fall back to the R3-allocated memory. */
563	rc = VINF_SUCCESS;
564	pDevExt->MemBalloon.fUseKernelAPI = false;
565	Assert(pDevExt->MemBalloon.cChunks == 0);
566	Log(("VBoxGuestSetBalloonSizeKernel: PhysNC allocs not supported, falling back to R3 allocs.\n"));
567	}
568	/* else if (rc == VERR_NO_MEMORY \|\| rc == VERR_NO_PHYS_MEMORY):
569	* cannot allocate more memory => don't try further, just stop here */
570	/* else: XXX what else can fail? VERR_MEMOBJ_INIT_FAILED for instance. just stop. */
571	break;
572	}
573
574	rc = vgdrvBalloonInflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
575	if (RT_FAILURE(rc))
576	{
577	Log(("vboxGuestSetBalloonSize(inflate): failed, rc=%Rrc!\n", rc));
578	RTR0MemObjFree(pDevExt->MemBalloon.paMemObj[i], true);
579	pDevExt->MemBalloon.paMemObj[i] = NIL_RTR0MEMOBJ;
580	break;
581	}
582	pDevExt->MemBalloon.cChunks++;
583	}
584	}
585	else
586	{
587	/* deflate */
588	for (i = pDevExt->MemBalloon.cChunks; i-- > cBalloonChunks;)
589	{
590	rc = vgdrvBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
591	if (RT_FAILURE(rc))
592	{
593	Log(("vboxGuestSetBalloonSize(deflate): failed, rc=%Rrc!\n", rc));
594	break;
595	}
596	pDevExt->MemBalloon.cChunks--;
597	}
598	}
599
600	VbglR0GRFree(&pReq->header);
601	}
602
603	/*
604	* Set the handle-in-ring3 indicator. When set Ring-3 will have to work
605	* the balloon changes via the other API.
606	*/
607	*pfHandleInR3 = pDevExt->MemBalloon.fUseKernelAPI ? false : true;
608
609	return rc;
610	}
611
612
613	/**
614	* Inflate/deflate the balloon by one chunk.
615	*
616	* Worker for vgdrvIoCtl_ChangeMemoryBalloon - it takes the mutex.
617	*
618	* @returns VBox status code.
619	* @param pDevExt The device extension.
620	* @param pSession The session.
621	* @param pvChunk The address of the chunk to add to / remove from the
622	* balloon. (user space address)
623	* @param fInflate Inflate if true, deflate if false.
624	*/
625	static int vgdrvSetBalloonSizeFromUser(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, RTR3PTR pvChunk, bool fInflate)
626	{
627	VMMDevChangeMemBalloon *pReq;
628	PRTR0MEMOBJ pMemObj = NULL;
629	int rc = VINF_SUCCESS;
630	uint32_t i;
631	RT_NOREF1(pSession);
632
633	if (fInflate)
634	{
635	if ( pDevExt->MemBalloon.cChunks > pDevExt->MemBalloon.cMaxChunks - 1
636	\|\| pDevExt->MemBalloon.cMaxChunks == 0 /* If called without first querying. */)
637	{
638	LogRel(("vgdrvSetBalloonSizeFromUser: cannot inflate balloon, already have %u chunks (max=%u)\n",
639	pDevExt->MemBalloon.cChunks, pDevExt->MemBalloon.cMaxChunks));
640	return VERR_INVALID_PARAMETER;
641	}
642
643	if (!pDevExt->MemBalloon.paMemObj)
644	{
645	pDevExt->MemBalloon.paMemObj = (PRTR0MEMOBJ)RTMemAlloc(sizeof(RTR0MEMOBJ) * pDevExt->MemBalloon.cMaxChunks);
646	if (!pDevExt->MemBalloon.paMemObj)
647	{
648	LogRel(("vgdrvSetBalloonSizeFromUser: no memory for paMemObj!\n"));
649	return VERR_NO_MEMORY;
650	}
651	for (i = 0; i < pDevExt->MemBalloon.cMaxChunks; i++)
652	pDevExt->MemBalloon.paMemObj[i] = NIL_RTR0MEMOBJ;
653	}
654	}
655	else
656	{
657	if (pDevExt->MemBalloon.cChunks == 0)
658	{
659	AssertMsgFailed(("vgdrvSetBalloonSizeFromUser: cannot decrease balloon, already at size 0\n"));
660	return VERR_INVALID_PARAMETER;
661	}
662	}
663
664	/*
665	* Enumerate all memory objects and check if the object is already registered.
666	*/
667	for (i = 0; i < pDevExt->MemBalloon.cMaxChunks; i++)
668	{
669	if ( fInflate
670	&& !pMemObj
671	&& pDevExt->MemBalloon.paMemObj[i] == NIL_RTR0MEMOBJ)
672	pMemObj = &pDevExt->MemBalloon.paMemObj[i]; /* found free object pointer */
673	if (RTR0MemObjAddressR3(pDevExt->MemBalloon.paMemObj[i]) == pvChunk)
674	{
675	if (fInflate)
676	return VERR_ALREADY_EXISTS; /* don't provide the same memory twice */
677	pMemObj = &pDevExt->MemBalloon.paMemObj[i];
678	break;
679	}
680	}
681	if (!pMemObj)
682	{
683	if (fInflate)
684	{
685	/* no free object pointer found -- should not happen */
686	return VERR_NO_MEMORY;
687	}
688
689	/* cannot free this memory as it wasn't provided before */
690	return VERR_NOT_FOUND;
691	}
692
693	/*
694	* Try inflate / default the balloon as requested.
695	*/
696	rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReq, g_cbChangeMemBalloonReq, VMMDevReq_ChangeMemBalloon);
697	if (RT_FAILURE(rc))
698	return rc;
699	pReq->header.fRequestor = pSession->fRequestor;
700
701	if (fInflate)
702	{
703	rc = RTR0MemObjLockUser(pMemObj, pvChunk, VMMDEV_MEMORY_BALLOON_CHUNK_SIZE,
704	RTMEM_PROT_READ \| RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
705	if (RT_SUCCESS(rc))
706	{
707	rc = vgdrvBalloonInflate(pMemObj, pReq);
708	if (RT_SUCCESS(rc))
709	pDevExt->MemBalloon.cChunks++;
710	else
711	{
712	Log(("vgdrvSetBalloonSizeFromUser(inflate): failed, rc=%Rrc!\n", rc));
713	RTR0MemObjFree(*pMemObj, true);
714	*pMemObj = NIL_RTR0MEMOBJ;
715	}
716	}
717	}
718	else
719	{
720	rc = vgdrvBalloonDeflate(pMemObj, pReq);
721	if (RT_SUCCESS(rc))
722	pDevExt->MemBalloon.cChunks--;
723	else
724	Log(("vgdrvSetBalloonSizeFromUser(deflate): failed, rc=%Rrc!\n", rc));
725	}
726
727	VbglR0GRFree(&pReq->header);
728	return rc;
729	}
730
731
732	/**
733	* Cleanup the memory balloon of a session.
734	*
735	* Will request the balloon mutex, so it must be valid and the caller must not
736	* own it already.
737	*
738	* @param pDevExt The device extension.
739	* @param pSession The session. Can be NULL at unload.
740	*/
741	static void vgdrvCloseMemBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
742	{
743	RTSemFastMutexRequest(pDevExt->MemBalloon.hMtx);
744	if ( pDevExt->MemBalloon.pOwner == pSession
745	\|\| pSession == NULL /unload/)
746	{
747	if (pDevExt->MemBalloon.paMemObj)
748	{
749	VMMDevChangeMemBalloon *pReq;
750	int rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReq, g_cbChangeMemBalloonReq, VMMDevReq_ChangeMemBalloon);
751	if (RT_SUCCESS(rc))
752	{
753	/* fRequestor is kernel here, as we're cleaning up. */
754
755	uint32_t i;
756	for (i = pDevExt->MemBalloon.cChunks; i-- > 0;)
757	{
758	rc = vgdrvBalloonDeflate(&pDevExt->MemBalloon.paMemObj[i], pReq);
759	if (RT_FAILURE(rc))
760	{
761	LogRel(("vgdrvCloseMemBalloon: Deflate failed with rc=%Rrc. Will leak %u chunks.\n",
762	rc, pDevExt->MemBalloon.cChunks));
763	break;
764	}
765	pDevExt->MemBalloon.paMemObj[i] = NIL_RTR0MEMOBJ;
766	pDevExt->MemBalloon.cChunks--;
767	}
768	VbglR0GRFree(&pReq->header);
769	}
770	else
771	LogRel(("vgdrvCloseMemBalloon: Failed to allocate VMMDev request buffer (rc=%Rrc). Will leak %u chunks.\n",
772	rc, pDevExt->MemBalloon.cChunks));
773	RTMemFree(pDevExt->MemBalloon.paMemObj);
774	pDevExt->MemBalloon.paMemObj = NULL;
775	}
776
777	pDevExt->MemBalloon.pOwner = NULL;
778	}
779	RTSemFastMutexRelease(pDevExt->MemBalloon.hMtx);
780	}
781
782	/** @} */
783
784
785
786	/** @name Heartbeat
787	* @{
788	*/
789
790	/**
791	* Sends heartbeat to host.
792	*
793	* @returns VBox status code.
794	*/
795	static int vgdrvHeartbeatSend(PVBOXGUESTDEVEXT pDevExt)
796	{
797	int rc;
798	if (pDevExt->pReqGuestHeartbeat)
799	{
800	rc = VbglR0GRPerform(pDevExt->pReqGuestHeartbeat);
801	Log3(("vgdrvHeartbeatSend: VbglR0GRPerform vgdrvHeartbeatSend completed with rc=%Rrc\n", rc));
802	}
803	else
804	rc = VERR_INVALID_STATE;
805	return rc;
806	}
807
808
809	/**
810	* Callback for heartbeat timer.
811	*/
812	static DECLCALLBACK(void) vgdrvHeartbeatTimerHandler(PRTTIMER hTimer, void *pvUser, uint64_t iTick)
813	{
814	PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
815	int rc;
816	AssertReturnVoid(pDevExt);
817
818	rc = vgdrvHeartbeatSend(pDevExt);
819	if (RT_FAILURE(rc))
820	Log(("HB Timer: vgdrvHeartbeatSend failed: rc=%Rrc\n", rc));
821
822	NOREF(hTimer); NOREF(iTick);
823	}
824
825
826	/**
827	* Configure the host to check guest's heartbeat
828	* and get heartbeat interval from the host.
829	*
830	* @returns VBox status code.
831	* @param pDevExt The device extension.
832	* @param fEnabled Set true to enable guest heartbeat checks on host.
833	*/
834	static int vgdrvHeartbeatHostConfigure(PVBOXGUESTDEVEXT pDevExt, bool fEnabled)
835	{
836	VMMDevReqHeartbeat *pReq;
837	int rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_HeartbeatConfigure);
838	Log(("vgdrvHeartbeatHostConfigure: VbglR0GRAlloc vgdrvHeartbeatHostConfigure completed with rc=%Rrc\n", rc));
839	if (RT_SUCCESS(rc))
840	{
841	pReq->fEnabled = fEnabled;
842	pReq->cNsInterval = 0;
843	rc = VbglR0GRPerform(&pReq->header);
844	Log(("vgdrvHeartbeatHostConfigure: VbglR0GRPerform vgdrvHeartbeatHostConfigure completed with rc=%Rrc\n", rc));
845	pDevExt->cNsHeartbeatInterval = pReq->cNsInterval;
846	VbglR0GRFree(&pReq->header);
847	}
848	return rc;
849	}
850
851
852	/**
853	* Initializes the heartbeat timer.
854	*
855	* This feature may be disabled by the host.
856	*
857	* @returns VBox status (ignored).
858	* @param pDevExt The device extension.
859	*/
860	static int vgdrvHeartbeatInit(PVBOXGUESTDEVEXT pDevExt)
861	{
862	/*
863	* Make sure that heartbeat checking is disabled.
864	*/
865	int rc = vgdrvHeartbeatHostConfigure(pDevExt, false);
866	if (RT_SUCCESS(rc))
867	{
868	rc = vgdrvHeartbeatHostConfigure(pDevExt, true);
869	if (RT_SUCCESS(rc))
870	{
871	/*
872	* Preallocate the request to use it from the timer callback because:
873	* 1) on Windows VbglR0GRAlloc must be called at IRQL <= APC_LEVEL
874	* and the timer callback runs at DISPATCH_LEVEL;
875	* 2) avoid repeated allocations.
876	*/
877	rc = VbglR0GRAlloc(&pDevExt->pReqGuestHeartbeat, sizeof(*pDevExt->pReqGuestHeartbeat), VMMDevReq_GuestHeartbeat);
878	if (RT_SUCCESS(rc))
879	{
880	LogRel(("vgdrvHeartbeatInit: Setting up heartbeat to trigger every %RU64 milliseconds\n",
881	pDevExt->cNsHeartbeatInterval / RT_NS_1MS));
882	rc = RTTimerCreateEx(&pDevExt->pHeartbeatTimer, pDevExt->cNsHeartbeatInterval, 0 /fFlags/,
883	(PFNRTTIMER)vgdrvHeartbeatTimerHandler, pDevExt);
884	if (RT_SUCCESS(rc))
885	{
886	rc = RTTimerStart(pDevExt->pHeartbeatTimer, 0);
887	if (RT_SUCCESS(rc))
888	return VINF_SUCCESS;
889
890	LogRel(("vgdrvHeartbeatInit: Heartbeat timer failed to start, rc=%Rrc\n", rc));
891	}
892	else
893	LogRel(("vgdrvHeartbeatInit: Failed to create heartbeat timer: %Rrc\n", rc));
894
895	VbglR0GRFree(pDevExt->pReqGuestHeartbeat);
896	pDevExt->pReqGuestHeartbeat = NULL;
897	}
898	else
899	LogRel(("vgdrvHeartbeatInit: VbglR0GRAlloc(VMMDevReq_GuestHeartbeat): %Rrc\n", rc));
900
901	LogRel(("vgdrvHeartbeatInit: Failed to set up the timer, guest heartbeat is disabled\n"));
902	vgdrvHeartbeatHostConfigure(pDevExt, false);
903	}
904	else
905	LogRel(("vgdrvHeartbeatInit: Failed to configure host for heartbeat checking: rc=%Rrc\n", rc));
906	}
907	return rc;
908	}
909
910	/** @} */
911
912
913	/**
914	* Helper to reinit the VMMDev communication after hibernation.
915	*
916	* @returns VBox status code.
917	* @param pDevExt The device extension.
918	* @param enmOSType The OS type.
919	*
920	* @todo Call this on all platforms, not just windows.
921	*/
922	int VGDrvCommonReinitDevExtAfterHibernation(PVBOXGUESTDEVEXT pDevExt, VBOXOSTYPE enmOSType)
923	{
924	int rc = vgdrvReportGuestInfo(enmOSType);
925	if (RT_SUCCESS(rc))
926	{
927	rc = vgdrvReportDriverStatus(true /* Driver is active */);
928	if (RT_FAILURE(rc))
929	Log(("VGDrvCommonReinitDevExtAfterHibernation: could not report guest driver status, rc=%Rrc\n", rc));
930	}
931	else
932	Log(("VGDrvCommonReinitDevExtAfterHibernation: could not report guest information to host, rc=%Rrc\n", rc));
933	LogFlow(("VGDrvCommonReinitDevExtAfterHibernation: returned with rc=%Rrc\n", rc));
934	RT_NOREF1(pDevExt);
935	return rc;
936	}
937
938
939	/**
940	* Initializes the release logger (debug is implicit), if configured.
941	*
942	* @returns IPRT status code.
943	*/
944	int VGDrvCommonInitLoggers(void)
945	{
946	#ifdef VBOX_GUESTDRV_WITH_RELEASE_LOGGER
947	/*
948	* Create the release log.
949	*/
950	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
951	PRTLOGGER pRelLogger;
952	int rc = RTLogCreate(&pRelLogger, 0 /fFlags/, "all", "VBOXGUEST_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
953	RTLOGDEST_STDOUT \| RTLOGDEST_DEBUGGER, NULL);
954	if (RT_SUCCESS(rc))
955	RTLogRelSetDefaultInstance(pRelLogger);
956	/** @todo Add native hook for getting logger config parameters and setting
957	* them. On linux we should use the module parameter stuff... */
958	return rc;
959	#else
960	return VINF_SUCCESS;
961	#endif
962	}
963
964
965	/**
966	* Destroys the loggers.
967	*/
968	void VGDrvCommonDestroyLoggers(void)
969	{
970	#ifdef VBOX_GUESTDRV_WITH_RELEASE_LOGGER
971	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
972	RTLogDestroy(RTLogSetDefaultInstance(NULL));
973	#endif
974	}
975
976
977	/**
978	* Initialize the device extension fundament.
979	*
980	* There are no device resources at this point, VGDrvCommonInitDevExtResources
981	* should be called when they are available.
982	*
983	* @returns VBox status code.
984	* @param pDevExt The device extension to init.
985	*/
986	int VGDrvCommonInitDevExtFundament(PVBOXGUESTDEVEXT pDevExt)
987	{
988	int rc;
989	AssertMsg( pDevExt->uInitState != VBOXGUESTDEVEXT_INIT_STATE_FUNDAMENT
990	&& pDevExt->uInitState != VBOXGUESTDEVEXT_INIT_STATE_RESOURCES, ("uInitState=%#x\n", pDevExt->uInitState));
991
992	/*
993	* Initialize the data.
994	*/
995	pDevExt->IOPortBase = UINT16_MAX;
996	pDevExt->pVMMDevMemory = NULL;
997	pDevExt->hGuestMappings = NIL_RTR0MEMOBJ;
998	pDevExt->EventSpinlock = NIL_RTSPINLOCK;
999	pDevExt->fHostFeatures = 0;
1000	pDevExt->pIrqAckEvents = NULL;
1001	pDevExt->PhysIrqAckEvents = NIL_RTCCPHYS;
1002	RTListInit(&pDevExt->WaitList);
1003	#ifdef VBOX_WITH_HGCM
1004	RTListInit(&pDevExt->HGCMWaitList);
1005	#endif
1006	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
1007	RTListInit(&pDevExt->WakeUpList);
1008	#endif
1009	RTListInit(&pDevExt->WokenUpList);
1010	RTListInit(&pDevExt->FreeList);
1011	RTListInit(&pDevExt->SessionList);
1012	pDevExt->cSessions = 0;
1013	pDevExt->fLoggingEnabled = false;
1014	pDevExt->f32PendingEvents = 0;
1015	pDevExt->u32MousePosChangedSeq = 0;
1016	pDevExt->SessionSpinlock = NIL_RTSPINLOCK;
1017	pDevExt->MemBalloon.hMtx = NIL_RTSEMFASTMUTEX;
1018	pDevExt->MemBalloon.cChunks = 0;
1019	pDevExt->MemBalloon.cMaxChunks = 0;
1020	pDevExt->MemBalloon.fUseKernelAPI = true;
1021	pDevExt->MemBalloon.paMemObj = NULL;
1022	pDevExt->MemBalloon.pOwner = NULL;
1023	pDevExt->pfnMouseNotifyCallback = NULL;
1024	pDevExt->pvMouseNotifyCallbackArg = NULL;
1025	pDevExt->pReqGuestHeartbeat = NULL;
1026
1027	pDevExt->fFixedEvents = 0;
1028	vgdrvBitUsageTrackerClear(&pDevExt->EventFilterTracker);
1029	pDevExt->fEventFilterHost = UINT32_MAX; /* forces a report */
1030
1031	vgdrvBitUsageTrackerClear(&pDevExt->MouseStatusTracker);
1032	pDevExt->fMouseStatusHost = UINT32_MAX; /* forces a report */
1033
1034	pDevExt->fAcquireModeGuestCaps = 0;
1035	pDevExt->fSetModeGuestCaps = 0;
1036	pDevExt->fAcquiredGuestCaps = 0;
1037	vgdrvBitUsageTrackerClear(&pDevExt->SetGuestCapsTracker);
1038	pDevExt->fGuestCapsHost = UINT32_MAX; /* forces a report */
1039
1040	/*
1041	* Create the wait and session spinlocks as well as the ballooning mutex.
1042	*/
1043	rc = RTSpinlockCreate(&pDevExt->EventSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxGuestEvent");
1044	if (RT_SUCCESS(rc))
1045	{
1046	rc = RTSpinlockCreate(&pDevExt->SessionSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxGuestSession");
1047	if (RT_SUCCESS(rc))
1048	{
1049	rc = RTSemFastMutexCreate(&pDevExt->MemBalloon.hMtx);
1050	if (RT_SUCCESS(rc))
1051	{
1052	pDevExt->uInitState = VBOXGUESTDEVEXT_INIT_STATE_FUNDAMENT;
1053	return VINF_SUCCESS;
1054	}
1055
1056	LogRel(("VGDrvCommonInitDevExt: failed to create mutex, rc=%Rrc!\n", rc));
1057	RTSpinlockDestroy(pDevExt->SessionSpinlock);
1058	}
1059	else
1060	LogRel(("VGDrvCommonInitDevExt: failed to create spinlock, rc=%Rrc!\n", rc));
1061	RTSpinlockDestroy(pDevExt->EventSpinlock);
1062	}
1063	else
1064	LogRel(("VGDrvCommonInitDevExt: failed to create spinlock, rc=%Rrc!\n", rc));
1065
1066	pDevExt->uInitState = 0;
1067	return rc;
1068	}
1069
1070
1071	/**
1072	* Counter to VGDrvCommonInitDevExtFundament.
1073	*
1074	* @param pDevExt The device extension.
1075	*/
1076	void VGDrvCommonDeleteDevExtFundament(PVBOXGUESTDEVEXT pDevExt)
1077	{
1078	int rc2;
1079	AssertMsgReturnVoid(pDevExt->uInitState == VBOXGUESTDEVEXT_INIT_STATE_FUNDAMENT, ("uInitState=%#x\n", pDevExt->uInitState));
1080	pDevExt->uInitState = VBOXGUESTDEVEXT_INIT_STATE_DELETED;
1081
1082	rc2 = RTSemFastMutexDestroy(pDevExt->MemBalloon.hMtx); AssertRC(rc2);
1083	rc2 = RTSpinlockDestroy(pDevExt->EventSpinlock); AssertRC(rc2);
1084	rc2 = RTSpinlockDestroy(pDevExt->SessionSpinlock); AssertRC(rc2);
1085	}
1086
1087
1088	/**
1089	* Initializes the VBoxGuest device extension resource parts.
1090	*
1091	* The native code locates the VMMDev on the PCI bus and retrieve the MMIO and
1092	* I/O port ranges, this function will take care of mapping the MMIO memory (if
1093	* present). Upon successful return the native code should set up the interrupt
1094	* handler.
1095	*
1096	* @returns VBox status code.
1097	*
1098	* @param pDevExt The device extension. Allocated by the native code.
1099	* @param IOPortBase The base of the I/O port range.
1100	* @param pvMMIOBase The base of the MMIO memory mapping.
1101	* This is optional, pass NULL if not present.
1102	* @param cbMMIO The size of the MMIO memory mapping.
1103	* This is optional, pass 0 if not present.
1104	* @param enmOSType The guest OS type to report to the VMMDev.
1105	* @param fFixedEvents Events that will be enabled upon init and no client
1106	* will ever be allowed to mask.
1107	*/
1108	int VGDrvCommonInitDevExtResources(PVBOXGUESTDEVEXT pDevExt, uint16_t IOPortBase,
1109	void *pvMMIOBase, uint32_t cbMMIO, VBOXOSTYPE enmOSType, uint32_t fFixedEvents)
1110	{
1111	int rc;
1112	AssertMsgReturn(pDevExt->uInitState == VBOXGUESTDEVEXT_INIT_STATE_FUNDAMENT, ("uInitState=%#x\n", pDevExt->uInitState),
1113	VERR_INVALID_STATE);
1114
1115	/*
1116	* If there is an MMIO region validate the version and size.
1117	*/
1118	if (pvMMIOBase)
1119	{
1120	VMMDevMemory pVMMDev = (VMMDevMemory )pvMMIOBase;
1121	Assert(cbMMIO);
1122	if ( pVMMDev->u32Version == VMMDEV_MEMORY_VERSION
1123	&& pVMMDev->u32Size >= 32
1124	&& pVMMDev->u32Size <= cbMMIO)
1125	{
1126	pDevExt->pVMMDevMemory = pVMMDev;
1127	Log(("VGDrvCommonInitDevExtResources: VMMDevMemory: mapping=%p size=%#RX32 (%#RX32) version=%#RX32\n",
1128	pVMMDev, pVMMDev->u32Size, cbMMIO, pVMMDev->u32Version));
1129	}
1130	else /* try live without it. */
1131	LogRel(("VGDrvCommonInitDevExtResources: Bogus VMMDev memory; u32Version=%RX32 (expected %RX32) u32Size=%RX32 (expected <= %RX32)\n",
1132	pVMMDev->u32Version, VMMDEV_MEMORY_VERSION, pVMMDev->u32Size, cbMMIO));
1133	}
1134
1135	/*
1136	* Initialize the guest library and report the guest info back to VMMDev,
1137	* set the interrupt control filter mask, and fixate the guest mappings
1138	* made by the VMM.
1139	*/
1140	pDevExt->IOPortBase = IOPortBase;
1141	rc = VbglR0InitPrimary(pDevExt->IOPortBase, (VMMDevMemory *)pDevExt->pVMMDevMemory, &pDevExt->fHostFeatures);
1142	if (RT_SUCCESS(rc))
1143	{
1144	VMMDevRequestHeader *pAckReq = NULL;
1145	rc = VbglR0GRAlloc(&pAckReq, sizeof(VMMDevEvents), VMMDevReq_AcknowledgeEvents);
1146	if (RT_SUCCESS(rc))
1147	{
1148	pDevExt->PhysIrqAckEvents = VbglR0PhysHeapGetPhysAddr(pAckReq);
1149	Assert(pDevExt->PhysIrqAckEvents != 0);
1150	ASMCompilerBarrier(); /* linux + solaris already have IRQs hooked up at this point, so take care. */
1151	pDevExt->pIrqAckEvents = (VMMDevEvents *)pAckReq;
1152
1153	rc = vgdrvReportGuestInfo(enmOSType);
1154	if (RT_SUCCESS(rc))
1155	{
1156	/*
1157	* Set the fixed event and make sure the host doesn't have any lingering
1158	* the guest capabilities or mouse status bits set.
1159	*/
1160	#ifdef VBOX_WITH_HGCM
1161	fFixedEvents \|= VMMDEV_EVENT_HGCM;
1162	#endif
1163	pDevExt->fFixedEvents = fFixedEvents;
1164	rc = vgdrvResetEventFilterOnHost(pDevExt, fFixedEvents);
1165	if (RT_SUCCESS(rc))
1166	{
1167	rc = vgdrvResetCapabilitiesOnHost(pDevExt);
1168	if (RT_SUCCESS(rc))
1169	{
1170	rc = vgdrvResetMouseStatusOnHost(pDevExt);
1171	if (RT_SUCCESS(rc))
1172	{
1173	/*
1174	* Initialize stuff which may fail without requiring the driver init to fail.
1175	*/
1176	vgdrvInitFixateGuestMappings(pDevExt);
1177	vgdrvHeartbeatInit(pDevExt);
1178
1179	/*
1180	* Done!
1181	*/
1182	rc = vgdrvReportDriverStatus(true /* Driver is active */);
1183	if (RT_FAILURE(rc))
1184	LogRel(("VGDrvCommonInitDevExtResources: VBoxReportGuestDriverStatus failed, rc=%Rrc\n", rc));
1185
1186	pDevExt->uInitState = VBOXGUESTDEVEXT_INIT_STATE_RESOURCES;
1187	LogFlowFunc(("VGDrvCommonInitDevExtResources: returns success\n"));
1188	return VINF_SUCCESS;
1189	}
1190	LogRel(("VGDrvCommonInitDevExtResources: failed to clear mouse status: rc=%Rrc\n", rc));
1191	}
1192	else
1193	LogRel(("VGDrvCommonInitDevExtResources: failed to clear guest capabilities: rc=%Rrc\n", rc));
1194	}
1195	else
1196	LogRel(("VGDrvCommonInitDevExtResources: failed to set fixed event filter: rc=%Rrc\n", rc));
1197	pDevExt->fFixedEvents = 0;
1198	}
1199	else
1200	LogRel(("VGDrvCommonInitDevExtResources: vgdrvReportGuestInfo failed: rc=%Rrc\n", rc));
1201	VbglR0GRFree((VMMDevRequestHeader *)pDevExt->pIrqAckEvents);
1202	}
1203	else
1204	LogRel(("VGDrvCommonInitDevExtResources: VbglR0GRAlloc failed: rc=%Rrc\n", rc));
1205
1206	VbglR0TerminatePrimary();
1207	}
1208	else
1209	LogRel(("VGDrvCommonInitDevExtResources: VbglR0InitPrimary failed: rc=%Rrc\n", rc));
1210	pDevExt->IOPortBase = UINT16_MAX;
1211	return rc;
1212	}
1213
1214
1215	/**
1216	* Deletes all the items in a wait chain.
1217	* @param pList The head of the chain.
1218	*/
1219	static void vgdrvDeleteWaitList(PRTLISTNODE pList)
1220	{
1221	while (!RTListIsEmpty(pList))
1222	{
1223	int rc2;
1224	PVBOXGUESTWAIT pWait = RTListGetFirst(pList, VBOXGUESTWAIT, ListNode);
1225	RTListNodeRemove(&pWait->ListNode);
1226
1227	rc2 = RTSemEventMultiDestroy(pWait->Event); AssertRC(rc2);
1228	pWait->Event = NIL_RTSEMEVENTMULTI;
1229	pWait->pSession = NULL;
1230	RTMemFree(pWait);
1231	}
1232	}
1233
1234
1235	/**
1236	* Counter to VGDrvCommonInitDevExtResources.
1237	*
1238	* @param pDevExt The device extension.
1239	*/
1240	void VGDrvCommonDeleteDevExtResources(PVBOXGUESTDEVEXT pDevExt)
1241	{
1242	Log(("VGDrvCommonDeleteDevExtResources:\n"));
1243	AssertMsgReturnVoid(pDevExt->uInitState == VBOXGUESTDEVEXT_INIT_STATE_RESOURCES, ("uInitState=%#x\n", pDevExt->uInitState));
1244	pDevExt->uInitState = VBOXGUESTDEVEXT_INIT_STATE_FUNDAMENT;
1245
1246	/*
1247	* Stop and destroy HB timer and disable host heartbeat checking.
1248	*/
1249	if (pDevExt->pHeartbeatTimer)
1250	{
1251	RTTimerDestroy(pDevExt->pHeartbeatTimer);
1252	vgdrvHeartbeatHostConfigure(pDevExt, false);
1253	}
1254
1255	VbglR0GRFree(pDevExt->pReqGuestHeartbeat);
1256	pDevExt->pReqGuestHeartbeat = NULL;
1257
1258	/*
1259	* Clean up the bits that involves the host first.
1260	*/
1261	vgdrvTermUnfixGuestMappings(pDevExt);
1262	if (!RTListIsEmpty(&pDevExt->SessionList))
1263	{
1264	LogRelFunc(("session list not empty!\n"));
1265	RTListInit(&pDevExt->SessionList);
1266	}
1267
1268	/*
1269	* Update the host flags (mouse status etc) not to reflect this session.
1270	*/
1271	pDevExt->fFixedEvents = 0;
1272	vgdrvResetEventFilterOnHost(pDevExt, 0 /fFixedEvents/);
1273	vgdrvResetCapabilitiesOnHost(pDevExt);
1274	vgdrvResetMouseStatusOnHost(pDevExt);
1275
1276	vgdrvCloseMemBalloon(pDevExt, (PVBOXGUESTSESSION)NULL);
1277
1278	/*
1279	* No more IRQs.
1280	*/
1281	pDevExt->pIrqAckEvents = NULL; /* Will be freed by VbglR0TerminatePrimary. */
1282	ASMAtomicWriteU32(&pDevExt->fHostFeatures, 0);
1283
1284	/*
1285	* Cleanup all the other resources.
1286	*/
1287	vgdrvDeleteWaitList(&pDevExt->WaitList);
1288	#ifdef VBOX_WITH_HGCM
1289	vgdrvDeleteWaitList(&pDevExt->HGCMWaitList);
1290	#endif
1291	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
1292	vgdrvDeleteWaitList(&pDevExt->WakeUpList);
1293	#endif
1294	vgdrvDeleteWaitList(&pDevExt->WokenUpList);
1295	vgdrvDeleteWaitList(&pDevExt->FreeList);
1296
1297	VbglR0TerminatePrimary();
1298
1299
1300	pDevExt->pVMMDevMemory = NULL;
1301	pDevExt->IOPortBase = 0;
1302	}
1303
1304
1305	/**
1306	* Initializes the VBoxGuest device extension when the device driver is loaded.
1307	*
1308	* The native code locates the VMMDev on the PCI bus and retrieve the MMIO and
1309	* I/O port ranges, this function will take care of mapping the MMIO memory (if
1310	* present). Upon successful return the native code should set up the interrupt
1311	* handler.
1312	*
1313	* Instead of calling this method, the host specific code choose to perform a
1314	* more granular initialization using:
1315	* 1. VGDrvCommonInitLoggers
1316	* 2. VGDrvCommonInitDevExtFundament
1317	* 3. VGDrvCommonInitDevExtResources
1318	*
1319	* @returns VBox status code.
1320	*
1321	* @param pDevExt The device extension. Allocated by the native code.
1322	* @param IOPortBase The base of the I/O port range.
1323	* @param pvMMIOBase The base of the MMIO memory mapping.
1324	* This is optional, pass NULL if not present.
1325	* @param cbMMIO The size of the MMIO memory mapping.
1326	* This is optional, pass 0 if not present.
1327	* @param enmOSType The guest OS type to report to the VMMDev.
1328	* @param fFixedEvents Events that will be enabled upon init and no client
1329	* will ever be allowed to mask.
1330	*/
1331	int VGDrvCommonInitDevExt(PVBOXGUESTDEVEXT pDevExt, uint16_t IOPortBase,
1332	void *pvMMIOBase, uint32_t cbMMIO, VBOXOSTYPE enmOSType, uint32_t fFixedEvents)
1333	{
1334	int rc;
1335	VGDrvCommonInitLoggers();
1336
1337	rc = VGDrvCommonInitDevExtFundament(pDevExt);
1338	if (RT_SUCCESS(rc))
1339	{
1340	rc = VGDrvCommonInitDevExtResources(pDevExt, IOPortBase, pvMMIOBase, cbMMIO, enmOSType, fFixedEvents);
1341	if (RT_SUCCESS(rc))
1342	return rc;
1343
1344	VGDrvCommonDeleteDevExtFundament(pDevExt);
1345	}
1346	VGDrvCommonDestroyLoggers();
1347	return rc; /* (failed) */
1348	}
1349
1350
1351	/**
1352	* Checks if the given option can be taken to not mean 'false'.
1353	*
1354	* @returns true or false accordingly.
1355	* @param pszValue The value to consider.
1356	*/
1357	bool VBDrvCommonIsOptionValueTrue(const char *pszValue)
1358	{
1359	if (pszValue)
1360	{
1361	char ch;
1362	while ( (ch = *pszValue) != '\0'
1363	&& RT_C_IS_SPACE(ch))
1364	pszValue++;
1365
1366	return ch != '\0'
1367	&& ch != 'n' /* no */
1368	&& ch != 'N' /* NO */
1369	&& ch != 'd' /* disabled */
1370	&& ch != 'f' /* false*/
1371	&& ch != 'F' /* FALSE */
1372	&& ch != 'D' /* DISABLED */
1373	&& ( (ch != 'o' && ch != 'O') /* off, OFF, Off */
1374	\|\| (pszValue[1] != 'f' && pszValue[1] != 'F') )
1375	&& (ch != '0' \|\| pszValue[1] != '\0') /* '0' */
1376	;
1377	}
1378	return false;
1379	}
1380
1381
1382	/**
1383	* Processes a option.
1384	*
1385	* This will let the OS specific code have a go at it too.
1386	*
1387	* @param pDevExt The device extension.
1388	* @param pszName The option name, sans prefix.
1389	* @param pszValue The option value.
1390	*/
1391	void VGDrvCommonProcessOption(PVBOXGUESTDEVEXT pDevExt, const char pszName, const char pszValue)
1392	{
1393	Log(("VGDrvCommonProcessOption: pszName='%s' pszValue='%s'\n", pszName, pszValue));
1394
1395	if ( RTStrICmpAscii(pszName, "r3_log_to_host") == 0
1396	\|\| RTStrICmpAscii(pszName, "LoggingEnabled") == 0 /legacy/ )
1397	pDevExt->fLoggingEnabled = VBDrvCommonIsOptionValueTrue(pszValue);
1398	else if ( RTStrNICmpAscii(pszName, RT_STR_TUPLE("log")) == 0
1399	\|\| RTStrNICmpAscii(pszName, RT_STR_TUPLE("dbg_log")) == 0)
1400	{
1401	bool const fDbgRel = pszName == 'd' \|\| pszName == 'D';
1402	const char *pszSubName = &pszName[fDbgRel ? 4 + 3 : 3];
1403	if ( !*pszSubName
1404	\|\| RTStrICmpAscii(pszSubName, "_flags") == 0
1405	\|\| RTStrICmpAscii(pszSubName, "_dest") == 0)
1406	{
1407	PRTLOGGER pLogger = !fDbgRel ? RTLogRelGetDefaultInstance() : RTLogDefaultInstance();
1408	if (pLogger)
1409	{
1410	if (!*pszSubName)
1411	RTLogGroupSettings(pLogger, pszValue);
1412	else if (RTStrICmpAscii(pszSubName, "_flags"))
1413	RTLogFlags(pLogger, pszValue);
1414	else
1415	RTLogDestinations(pLogger, pszValue);
1416	}
1417	}
1418	else if (!VGDrvNativeProcessOption(pDevExt, pszName, pszValue))
1419	LogRel(("VBoxGuest: Ignoring unknown option '%s' (value '%s')\n", pszName, pszValue));
1420	}
1421	else if (!VGDrvNativeProcessOption(pDevExt, pszName, pszValue))
1422	LogRel(("VBoxGuest: Ignoring unknown option '%s' (value '%s')\n", pszName, pszValue));
1423	}
1424
1425
1426	/**
1427	* Read driver configuration from the host.
1428	*
1429	* This involves connecting to the guest properties service, which means that
1430	* interrupts needs to work and that the calling thread must be able to block.
1431	*
1432	* @param pDevExt The device extension.
1433	*/
1434	void VGDrvCommonProcessOptionsFromHost(PVBOXGUESTDEVEXT pDevExt)
1435	{
1436	/*
1437	* Create a kernel session without our selves, then connect to the HGCM service.
1438	*/
1439	PVBOXGUESTSESSION pSession;
1440	int rc = VGDrvCommonCreateKernelSession(pDevExt, &pSession);
1441	if (RT_SUCCESS(rc))
1442	{
1443	union
1444	{
1445	VBGLIOCHGCMCONNECT Connect;
1446	VBGLIOCHGCMDISCONNECT Disconnect;
1447	GuestPropMsgEnumProperties EnumMsg;
1448	} uBuf;
1449
1450	RT_ZERO(uBuf.Connect);
1451	VBGLREQHDR_INIT(&uBuf.Connect.Hdr, HGCM_CONNECT);
1452	uBuf.Connect.u.In.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
1453	RTStrCopy(uBuf.Connect.u.In.Loc.u.host.achName, sizeof(uBuf.Connect.u.In.Loc.u.host.achName),
1454	"VBoxGuestPropSvc"); /** @todo Add a define to the header for the name. */
1455	rc = VGDrvCommonIoCtl(VBGL_IOCTL_HGCM_CONNECT, pDevExt, pSession, &uBuf.Connect.Hdr, sizeof(uBuf.Connect));
1456	if (RT_SUCCESS(rc))
1457	{
1458	static const char g_szzPattern[] = "/VirtualBox/GuestAdd/VBoxGuest/*\0";
1459	uint32_t const idClient = uBuf.Connect.u.Out.idClient;
1460	char *pszzStrings = NULL;
1461	uint32_t cbStrings;
1462
1463	/*
1464	* Enumerate all the relevant properties. We try with a 1KB buffer, but
1465	* will double it until we get what we want or go beyond 16KB.
1466	*/
1467	for (cbStrings = _1K; cbStrings <= _16K; cbStrings *= 2)
1468	{
1469	pszzStrings = (char *)RTMemAllocZ(cbStrings);
1470	if (pszzStrings)
1471	{
1472	VBGL_HGCM_HDR_INIT(&uBuf.EnumMsg.hdr, idClient, GUEST_PROP_FN_ENUM_PROPS, 3);
1473
1474	uBuf.EnumMsg.patterns.type = VMMDevHGCMParmType_LinAddr;
1475	uBuf.EnumMsg.patterns.u.Pointer.size = sizeof(g_szzPattern);
1476	uBuf.EnumMsg.patterns.u.Pointer.u.linearAddr = (uintptr_t)g_szzPattern;
1477
1478	uBuf.EnumMsg.strings.type = VMMDevHGCMParmType_LinAddr;
1479	uBuf.EnumMsg.strings.u.Pointer.size = cbStrings;
1480	uBuf.EnumMsg.strings.u.Pointer.u.linearAddr = (uintptr_t)pszzStrings;
1481
1482	uBuf.EnumMsg.size.type = VMMDevHGCMParmType_32bit;
1483	uBuf.EnumMsg.size.u.value32 = 0;
1484
1485	rc = VGDrvCommonIoCtl(VBGL_IOCTL_HGCM_CALL(sizeof(uBuf.EnumMsg)), pDevExt, pSession,
1486	&uBuf.EnumMsg.hdr.Hdr, sizeof(uBuf.EnumMsg));
1487	if (RT_SUCCESS(rc))
1488	{
1489	if ( uBuf.EnumMsg.size.type == VMMDevHGCMParmType_32bit
1490	&& uBuf.EnumMsg.size.u.value32 <= cbStrings
1491	&& uBuf.EnumMsg.size.u.value32 > 0)
1492	cbStrings = uBuf.EnumMsg.size.u.value32;
1493	Log(("VGDrvCommonReadConfigurationFromHost: GUEST_PROP_FN_ENUM_PROPS -> %#x bytes (cbStrings=%#x)\n",
1494	uBuf.EnumMsg.size.u.value32, cbStrings));
1495	break;
1496	}
1497
1498	RTMemFree(pszzStrings);
1499	pszzStrings = NULL;
1500	}
1501	else
1502	{
1503	LogRel(("VGDrvCommonReadConfigurationFromHost: failed to allocate %#x bytes\n", cbStrings));
1504	break;
1505	}
1506	}
1507
1508	/*
1509	* Disconnect and destroy the session.
1510	*/
1511	VBGLREQHDR_INIT(&uBuf.Disconnect.Hdr, HGCM_DISCONNECT);
1512	uBuf.Disconnect.u.In.idClient = idClient;
1513	VGDrvCommonIoCtl(VBGL_IOCTL_HGCM_DISCONNECT, pDevExt, pSession, &uBuf.Disconnect.Hdr, sizeof(uBuf.Disconnect));
1514
1515	VGDrvCommonCloseSession(pDevExt, pSession);
1516
1517	/*
1518	* Process the properties if we got any.
1519	*
1520	* The string buffer contains packed strings in groups of four - name, value,
1521	* timestamp (as a decimal string) and flags. It is terminated by four empty
1522	* strings. Layout:
1523	* Name\0Value\0Timestamp\0Flags\0
1524	*/
1525	if (pszzStrings)
1526	{
1527	uint32_t off;
1528	for (off = 0; off < cbStrings; off++)
1529	{
1530	/*
1531	* Parse the four fields, checking that it's all plain ASCII w/o any control characters.
1532	*/
1533	const char *apszFields[4] = { NULL, NULL, NULL, NULL };
1534	bool fValidFields = true;
1535	unsigned iField;
1536	for (iField = 0; iField < RT_ELEMENTS(apszFields); iField++)
1537	{
1538	apszFields[0] = &pszzStrings[off];
1539	while (off < cbStrings)
1540	{
1541	char ch = pszzStrings[off++];
1542	if ((unsigned)ch < 0x20U \|\| (unsigned)ch > 0x7fU)
1543	{
1544	if (!ch)
1545	break;
1546	if (fValidFields)
1547	Log(("VGDrvCommonReadConfigurationFromHost: Invalid char %#x at %#x (field %u)\n",
1548	ch, off - 1, iField));
1549	fValidFields = false;
1550	}
1551	}
1552	}
1553	if ( off <= cbStrings
1554	&& fValidFields
1555	&& *apszFields[0] != '\0')
1556	{
1557	/*
1558	* Validate and convert the flags to integer, then process the option.
1559	*/
1560	uint32_t fFlags = 0;
1561	rc = GuestPropValidateFlags(apszFields[3], &fFlags);
1562	if (RT_SUCCESS(rc))
1563	{
1564	if (fFlags & GUEST_PROP_F_RDONLYGUEST)
1565	{
1566	apszFields[0] += sizeof(g_szzPattern) - 2;
1567	VGDrvCommonProcessOption(pDevExt, apszFields[0], apszFields[1]);
1568	}
1569	else
1570	LogRel(("VBoxGuest: Ignoring '%s' as it does not have RDONLYGUEST set\n", apszFields[0]));
1571	}
1572	else
1573	LogRel(("VBoxGuest: Invalid flags '%s' for '%s': %Rrc\n", apszFields[2], apszFields[0], rc));
1574	}
1575	else if (off < cbStrings)
1576	{
1577	LogRel(("VBoxGuest: Malformed guest properties enum result!\n"));
1578	Log(("VBoxGuest: off=%#x cbStrings=%#x\n%.*Rhxd\n", off, cbStrings, cbStrings, pszzStrings));
1579	break;
1580	}
1581	else if (!fValidFields)
1582	LogRel(("VBoxGuest: Ignoring %.*Rhxs as it has invalid characters in one or more fields\n",
1583	(int)strlen(apszFields[0]), apszFields[0]));
1584	else
1585	break;
1586	}
1587
1588	RTMemFree(pszzStrings);
1589	}
1590	else
1591	LogRel(("VGDrvCommonReadConfigurationFromHost: failed to enumerate '%s': %Rrc\n", g_szzPattern, rc));
1592
1593	}
1594	else
1595	LogRel(("VGDrvCommonReadConfigurationFromHost: failed to connect: %Rrc\n", rc));
1596	}
1597	else
1598	LogRel(("VGDrvCommonReadConfigurationFromHost: failed to connect: %Rrc\n", rc));
1599	}
1600
1601
1602	/**
1603	* Destroys the VBoxGuest device extension.
1604	*
1605	* The native code should call this before the driver is unloaded,
1606	* but don't call this on shutdown.
1607	*
1608	* @param pDevExt The device extension.
1609	*/
1610	void VGDrvCommonDeleteDevExt(PVBOXGUESTDEVEXT pDevExt)
1611	{
1612	Log(("VGDrvCommonDeleteDevExt:\n"));
1613	Log(("VBoxGuest: The additions driver is terminating.\n"));
1614	VGDrvCommonDeleteDevExtResources(pDevExt);
1615	VGDrvCommonDeleteDevExtFundament(pDevExt);
1616	VGDrvCommonDestroyLoggers();
1617	}
1618
1619
1620	/**
1621	* Creates a VBoxGuest user session.
1622	*
1623	* The native code calls this when a ring-3 client opens the device.
1624	* Use VGDrvCommonCreateKernelSession when a ring-0 client connects.
1625	*
1626	* @returns VBox status code.
1627	* @param pDevExt The device extension.
1628	* @param fRequestor VMMDEV_REQUESTOR_XXX.
1629	* @param ppSession Where to store the session on success.
1630	*/
1631	int VGDrvCommonCreateUserSession(PVBOXGUESTDEVEXT pDevExt, uint32_t fRequestor, PVBOXGUESTSESSION *ppSession)
1632	{
1633	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)RTMemAllocZ(sizeof(*pSession));
1634	if (RT_UNLIKELY(!pSession))
1635	{
1636	LogRel(("VGDrvCommonCreateUserSession: no memory!\n"));
1637	return VERR_NO_MEMORY;
1638	}
1639
1640	pSession->Process = RTProcSelf();
1641	pSession->R0Process = RTR0ProcHandleSelf();
1642	pSession->pDevExt = pDevExt;
1643	pSession->fRequestor = fRequestor;
1644	pSession->fUserSession = RT_BOOL(fRequestor & VMMDEV_REQUESTOR_USER_DEVICE);
1645	RTSpinlockAcquire(pDevExt->SessionSpinlock);
1646	RTListAppend(&pDevExt->SessionList, &pSession->ListNode);
1647	pDevExt->cSessions++;
1648	RTSpinlockRelease(pDevExt->SessionSpinlock);
1649
1650	*ppSession = pSession;
1651	LogFlow(("VGDrvCommonCreateUserSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
1652	pSession, pSession->Process, (int)pSession->Process, (uintptr_t)pSession->R0Process)); /** @todo %RTr0proc */
1653	return VINF_SUCCESS;
1654	}
1655
1656
1657	/**
1658	* Creates a VBoxGuest kernel session.
1659	*
1660	* The native code calls this when a ring-0 client connects to the device.
1661	* Use VGDrvCommonCreateUserSession when a ring-3 client opens the device.
1662	*
1663	* @returns VBox status code.
1664	* @param pDevExt The device extension.
1665	* @param ppSession Where to store the session on success.
1666	*/
1667	int VGDrvCommonCreateKernelSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION *ppSession)
1668	{
1669	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)RTMemAllocZ(sizeof(*pSession));
1670	if (RT_UNLIKELY(!pSession))
1671	{
1672	LogRel(("VGDrvCommonCreateKernelSession: no memory!\n"));
1673	return VERR_NO_MEMORY;
1674	}
1675
1676	pSession->Process = NIL_RTPROCESS;
1677	pSession->R0Process = NIL_RTR0PROCESS;
1678	pSession->pDevExt = pDevExt;
1679	pSession->fRequestor = VMMDEV_REQUESTOR_KERNEL \| VMMDEV_REQUESTOR_USR_DRV_OTHER
1680	\| VMMDEV_REQUESTOR_CON_DONT_KNOW \| VMMDEV_REQUESTOR_TRUST_NOT_GIVEN;
1681	RTSpinlockAcquire(pDevExt->SessionSpinlock);
1682	RTListAppend(&pDevExt->SessionList, &pSession->ListNode);
1683	pDevExt->cSessions++;
1684	RTSpinlockRelease(pDevExt->SessionSpinlock);
1685
1686	*ppSession = pSession;
1687	LogFlow(("VGDrvCommonCreateKernelSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
1688	pSession, pSession->Process, (int)pSession->Process, (uintptr_t)pSession->R0Process)); /** @todo %RTr0proc */
1689	return VINF_SUCCESS;
1690	}
1691
1692
1693	/**
1694	* Closes a VBoxGuest session.
1695	*
1696	* @param pDevExt The device extension.
1697	* @param pSession The session to close (and free).
1698	*/
1699	void VGDrvCommonCloseSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
1700	{
1701	#ifdef VBOX_WITH_HGCM
1702	unsigned i;
1703	#endif
1704	LogFlow(("VGDrvCommonCloseSession: pSession=%p proc=%RTproc (%d) r0proc=%p\n",
1705	pSession, pSession->Process, (int)pSession->Process, (uintptr_t)pSession->R0Process)); /** @todo %RTr0proc */
1706
1707	RTSpinlockAcquire(pDevExt->SessionSpinlock);
1708	RTListNodeRemove(&pSession->ListNode);
1709	pDevExt->cSessions--;
1710	RTSpinlockRelease(pDevExt->SessionSpinlock);
1711	vgdrvAcquireSessionCapabilities(pDevExt, pSession, 0, UINT32_MAX, VBGL_IOC_AGC_FLAGS_DEFAULT, true /fSessionTermination/);
1712	vgdrvSetSessionCapabilities(pDevExt, pSession, 0 /fOrMask/, UINT32_MAX /fNotMask/,
1713	NULL /pfSessionCaps/, NULL /pfGlobalCaps/, true /fSessionTermination/);
1714	vgdrvSetSessionEventFilter(pDevExt, pSession, 0 /fOrMask/, UINT32_MAX /fNotMask/, true /fSessionTermination/);
1715	vgdrvSetSessionMouseStatus(pDevExt, pSession, 0 /fOrMask/, UINT32_MAX /fNotMask/, true /fSessionTermination/);
1716
1717	vgdrvIoCtl_CancelAllWaitEvents(pDevExt, pSession);
1718
1719	#ifdef VBOX_WITH_HGCM
1720	for (i = 0; i < RT_ELEMENTS(pSession->aHGCMClientIds); i++)
1721	if (pSession->aHGCMClientIds[i])
1722	{
1723	uint32_t idClient = pSession->aHGCMClientIds[i];
1724	pSession->aHGCMClientIds[i] = 0;
1725	Log(("VGDrvCommonCloseSession: disconnecting client id %#RX32\n", idClient));
1726	VbglR0HGCMInternalDisconnect(idClient, VMMDEV_REQUESTOR_KERNEL \| VMMDEV_REQUESTOR_USR_DRV,
1727	vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
1728	}
1729	#endif
1730
1731	pSession->pDevExt = NULL;
1732	pSession->Process = NIL_RTPROCESS;
1733	pSession->R0Process = NIL_RTR0PROCESS;
1734	vgdrvCloseMemBalloon(pDevExt, pSession);
1735	RTMemFree(pSession);
1736	}
1737
1738
1739	/**
1740	* Allocates a wait-for-event entry.
1741	*
1742	* @returns The wait-for-event entry.
1743	* @param pDevExt The device extension.
1744	* @param pSession The session that's allocating this. Can be NULL.
1745	*/
1746	static PVBOXGUESTWAIT vgdrvWaitAlloc(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
1747	{
1748	/*
1749	* Allocate it one way or the other.
1750	*/
1751	PVBOXGUESTWAIT pWait = RTListGetFirst(&pDevExt->FreeList, VBOXGUESTWAIT, ListNode);
1752	if (pWait)
1753	{
1754	RTSpinlockAcquire(pDevExt->EventSpinlock);
1755
1756	pWait = RTListGetFirst(&pDevExt->FreeList, VBOXGUESTWAIT, ListNode);
1757	if (pWait)
1758	RTListNodeRemove(&pWait->ListNode);
1759
1760	RTSpinlockRelease(pDevExt->EventSpinlock);
1761	}
1762	if (!pWait)
1763	{
1764	int rc;
1765
1766	pWait = (PVBOXGUESTWAIT)RTMemAlloc(sizeof(*pWait));
1767	if (!pWait)
1768	{
1769	LogRelMax(32, ("vgdrvWaitAlloc: out-of-memory!\n"));
1770	return NULL;
1771	}
1772
1773	rc = RTSemEventMultiCreate(&pWait->Event);
1774	if (RT_FAILURE(rc))
1775	{
1776	LogRelMax(32, ("vgdrvWaitAlloc: RTSemEventMultiCreate failed with rc=%Rrc!\n", rc));
1777	RTMemFree(pWait);
1778	return NULL;
1779	}
1780
1781	pWait->ListNode.pNext = NULL;
1782	pWait->ListNode.pPrev = NULL;
1783	}
1784
1785	/*
1786	* Zero members just as an precaution.
1787	*/
1788	pWait->fReqEvents = 0;
1789	pWait->fResEvents = 0;
1790	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
1791	pWait->fPendingWakeUp = false;
1792	pWait->fFreeMe = false;
1793	#endif
1794	pWait->pSession = pSession;
1795	#ifdef VBOX_WITH_HGCM
1796	pWait->pHGCMReq = NULL;
1797	#endif
1798	RTSemEventMultiReset(pWait->Event);
1799	return pWait;
1800	}
1801
1802
1803	/**
1804	* Frees the wait-for-event entry.
1805	*
1806	* The caller must own the wait spinlock !
1807	* The entry must be in a list!
1808	*
1809	* @param pDevExt The device extension.
1810	* @param pWait The wait-for-event entry to free.
1811	*/
1812	static void vgdrvWaitFreeLocked(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTWAIT pWait)
1813	{
1814	pWait->fReqEvents = 0;
1815	pWait->fResEvents = 0;
1816	#ifdef VBOX_WITH_HGCM
1817	pWait->pHGCMReq = NULL;
1818	#endif
1819	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
1820	Assert(!pWait->fFreeMe);
1821	if (pWait->fPendingWakeUp)
1822	pWait->fFreeMe = true;
1823	else
1824	#endif
1825	{
1826	RTListNodeRemove(&pWait->ListNode);
1827	RTListAppend(&pDevExt->FreeList, &pWait->ListNode);
1828	}
1829	}
1830
1831
1832	/**
1833	* Frees the wait-for-event entry.
1834	*
1835	* @param pDevExt The device extension.
1836	* @param pWait The wait-for-event entry to free.
1837	*/
1838	static void vgdrvWaitFreeUnlocked(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTWAIT pWait)
1839	{
1840	RTSpinlockAcquire(pDevExt->EventSpinlock);
1841	vgdrvWaitFreeLocked(pDevExt, pWait);
1842	RTSpinlockRelease(pDevExt->EventSpinlock);
1843	}
1844
1845
1846	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
1847	/**
1848	* Processes the wake-up list.
1849	*
1850	* All entries in the wake-up list gets signalled and moved to the woken-up
1851	* list.
1852	* At least on Windows this function can be invoked concurrently from
1853	* different VCPUs. So, be thread-safe.
1854	*
1855	* @param pDevExt The device extension.
1856	*/
1857	void VGDrvCommonWaitDoWakeUps(PVBOXGUESTDEVEXT pDevExt)
1858	{
1859	if (!RTListIsEmpty(&pDevExt->WakeUpList))
1860	{
1861	RTSpinlockAcquire(pDevExt->EventSpinlock);
1862	for (;;)
1863	{
1864	int rc;
1865	PVBOXGUESTWAIT pWait = RTListGetFirst(&pDevExt->WakeUpList, VBOXGUESTWAIT, ListNode);
1866	if (!pWait)
1867	break;
1868	/* Prevent other threads from accessing pWait when spinlock is released. */
1869	RTListNodeRemove(&pWait->ListNode);
1870
1871	pWait->fPendingWakeUp = true;
1872	RTSpinlockRelease(pDevExt->EventSpinlock);
1873
1874	rc = RTSemEventMultiSignal(pWait->Event);
1875	AssertRC(rc);
1876
1877	RTSpinlockAcquire(pDevExt->EventSpinlock);
1878	Assert(pWait->ListNode.pNext == NULL && pWait->ListNode.pPrev == NULL);
1879	RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
1880	pWait->fPendingWakeUp = false;
1881	if (RT_LIKELY(!pWait->fFreeMe))
1882	{ /* likely */ }
1883	else
1884	{
1885	pWait->fFreeMe = false;
1886	vgdrvWaitFreeLocked(pDevExt, pWait);
1887	}
1888	}
1889	RTSpinlockRelease(pDevExt->EventSpinlock);
1890	}
1891	}
1892	#endif /* VBOXGUEST_USE_DEFERRED_WAKE_UP */
1893
1894
1895	/**
1896	* Implements the fast (no input or output) type of IOCtls.
1897	*
1898	* This is currently just a placeholder stub inherited from the support driver code.
1899	*
1900	* @returns VBox status code.
1901	* @param iFunction The IOCtl function number.
1902	* @param pDevExt The device extension.
1903	* @param pSession The session.
1904	*/
1905	int VGDrvCommonIoCtlFast(uintptr_t iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
1906	{
1907	LogFlow(("VGDrvCommonIoCtlFast: iFunction=%#x pDevExt=%p pSession=%p\n", iFunction, pDevExt, pSession));
1908
1909	NOREF(iFunction);
1910	NOREF(pDevExt);
1911	NOREF(pSession);
1912	return VERR_NOT_SUPPORTED;
1913	}
1914
1915
1916	/**
1917	* Gets the driver I/O control interface version, maybe adjusting it for
1918	* backwards compatibility.
1919	*
1920	* The adjusting is currently not implemented as we only have one major I/O
1921	* control interface version out there to support. This is something we will
1922	* implement as needed.
1923	*
1924	* returns IPRT status code.
1925	* @param pDevExt The device extension.
1926	* @param pSession The session.
1927	* @param pReq The request info.
1928	*/
1929	static int vgdrvIoCtl_DriverVersionInfo(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCDRIVERVERSIONINFO pReq)
1930	{
1931	int rc;
1932	LogFlow(("VBGL_IOCTL_DRIVER_VERSION_INFO: uReqVersion=%#x uMinVersion=%#x uReserved1=%#x uReserved2=%#x\n",
1933	pReq->u.In.uReqVersion, pReq->u.In.uMinVersion, pReq->u.In.uReserved1, pReq->u.In.uReserved2));
1934	RT_NOREF2(pDevExt, pSession);
1935
1936	/*
1937	* Input validation.
1938	*/
1939	if ( pReq->u.In.uMinVersion <= pReq->u.In.uReqVersion
1940	&& RT_HI_U16(pReq->u.In.uMinVersion) == RT_HI_U16(pReq->u.In.uReqVersion))
1941	{
1942	/*
1943	* Match the version.
1944	* The current logic is very simple, match the major interface version.
1945	*/
1946	if ( pReq->u.In.uMinVersion <= VBGL_IOC_VERSION
1947	&& RT_HI_U16(pReq->u.In.uMinVersion) == RT_HI_U16(VBGL_IOC_VERSION))
1948	rc = VINF_SUCCESS;
1949	else
1950	{
1951	LogRel(("VBGL_IOCTL_DRIVER_VERSION_INFO: Version mismatch. Requested: %#x Min: %#x Current: %#x\n",
1952	pReq->u.In.uReqVersion, pReq->u.In.uMinVersion, VBGL_IOC_VERSION));
1953	rc = VERR_VERSION_MISMATCH;
1954	}
1955	}
1956	else
1957	{
1958	LogRel(("VBGL_IOCTL_DRIVER_VERSION_INFO: uMinVersion=%#x uMaxVersion=%#x doesn't match!\n",
1959	pReq->u.In.uMinVersion, pReq->u.In.uReqVersion));
1960	rc = VERR_INVALID_PARAMETER;
1961	}
1962
1963	pReq->u.Out.uSessionVersion = RT_SUCCESS(rc) ? VBGL_IOC_VERSION : UINT32_MAX;
1964	pReq->u.Out.uDriverVersion = VBGL_IOC_VERSION;
1965	pReq->u.Out.uDriverRevision = VBOX_SVN_REV;
1966	pReq->u.Out.uReserved1 = 0;
1967	pReq->u.Out.uReserved2 = 0;
1968	return rc;
1969	}
1970
1971
1972	/**
1973	* Similar to vgdrvIoCtl_DriverVersionInfo, except its for IDC.
1974	*
1975	* returns IPRT status code.
1976	* @param pDevExt The device extension.
1977	* @param pSession The session.
1978	* @param pReq The request info.
1979	*/
1980	static int vgdrvIoCtl_IdcConnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCIDCCONNECT pReq)
1981	{
1982	int rc;
1983	LogFlow(("VBGL_IOCTL_IDC_CONNECT: u32MagicCookie=%#x uReqVersion=%#x uMinVersion=%#x uReserved=%#x\n",
1984	pReq->u.In.u32MagicCookie, pReq->u.In.uReqVersion, pReq->u.In.uMinVersion, pReq->u.In.uReserved));
1985	Assert(pSession != NULL);
1986	RT_NOREF(pDevExt);
1987
1988	/*
1989	* Input validation.
1990	*/
1991	if (pReq->u.In.u32MagicCookie == VBGL_IOCTL_IDC_CONNECT_MAGIC_COOKIE)
1992	{
1993	if ( pReq->u.In.uMinVersion <= pReq->u.In.uReqVersion
1994	&& RT_HI_U16(pReq->u.In.uMinVersion) == RT_HI_U16(pReq->u.In.uReqVersion))
1995	{
1996	/*
1997	* Match the version.
1998	* The current logic is very simple, match the major interface version.
1999	*/
2000	if ( pReq->u.In.uMinVersion <= VBGL_IOC_VERSION
2001	&& RT_HI_U16(pReq->u.In.uMinVersion) == RT_HI_U16(VBGL_IOC_VERSION))
2002	{
2003	pReq->u.Out.pvSession = pSession;
2004	pReq->u.Out.uSessionVersion = VBGL_IOC_VERSION;
2005	pReq->u.Out.uDriverVersion = VBGL_IOC_VERSION;
2006	pReq->u.Out.uDriverRevision = VBOX_SVN_REV;
2007	pReq->u.Out.uReserved1 = 0;
2008	pReq->u.Out.pvReserved2 = NULL;
2009	return VINF_SUCCESS;
2010
2011	}
2012	LogRel(("VBGL_IOCTL_IDC_CONNECT: Version mismatch. Requested: %#x Min: %#x Current: %#x\n",
2013	pReq->u.In.uReqVersion, pReq->u.In.uMinVersion, VBGL_IOC_VERSION));
2014	rc = VERR_VERSION_MISMATCH;
2015	}
2016	else
2017	{
2018	LogRel(("VBGL_IOCTL_IDC_CONNECT: uMinVersion=%#x uMaxVersion=%#x doesn't match!\n",
2019	pReq->u.In.uMinVersion, pReq->u.In.uReqVersion));
2020	rc = VERR_INVALID_PARAMETER;
2021	}
2022
2023	pReq->u.Out.pvSession = NULL;
2024	pReq->u.Out.uSessionVersion = UINT32_MAX;
2025	pReq->u.Out.uDriverVersion = VBGL_IOC_VERSION;
2026	pReq->u.Out.uDriverRevision = VBOX_SVN_REV;
2027	pReq->u.Out.uReserved1 = 0;
2028	pReq->u.Out.pvReserved2 = NULL;
2029	}
2030	else
2031	{
2032	LogRel(("VBGL_IOCTL_IDC_CONNECT: u32MagicCookie=%#x expected %#x!\n",
2033	pReq->u.In.u32MagicCookie, VBGL_IOCTL_IDC_CONNECT_MAGIC_COOKIE));
2034	rc = VERR_INVALID_PARAMETER;
2035	}
2036	return rc;
2037	}
2038
2039
2040	/**
2041	* Counterpart to vgdrvIoCtl_IdcConnect, destroys the session.
2042	*
2043	* returns IPRT status code.
2044	* @param pDevExt The device extension.
2045	* @param pSession The session.
2046	* @param pReq The request info.
2047	*/
2048	static int vgdrvIoCtl_IdcDisconnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCIDCDISCONNECT pReq)
2049	{
2050	LogFlow(("VBGL_IOCTL_IDC_DISCONNECT: pvSession=%p vs pSession=%p\n", pReq->u.In.pvSession, pSession));
2051	RT_NOREF(pDevExt);
2052	Assert(pSession != NULL);
2053
2054	if (pReq->u.In.pvSession == pSession)
2055	{
2056	VGDrvCommonCloseSession(pDevExt, pSession);
2057	return VINF_SUCCESS;
2058	}
2059	LogRel(("VBGL_IOCTL_IDC_DISCONNECT: In.pvSession=%p is not equal to pSession=%p!\n", pReq->u.In.pvSession, pSession));
2060	return VERR_INVALID_PARAMETER;
2061	}
2062
2063
2064	/**
2065	* Return the VMM device I/O info.
2066	*
2067	* returns IPRT status code.
2068	* @param pDevExt The device extension.
2069	* @param pInfo The request info.
2070	* @note Ring-0 only, caller checked.
2071	*/
2072	static int vgdrvIoCtl_GetVMMDevIoInfo(PVBOXGUESTDEVEXT pDevExt, PVBGLIOCGETVMMDEVIOINFO pInfo)
2073	{
2074	LogFlow(("VBGL_IOCTL_GET_VMMDEV_IO_INFO\n"));
2075
2076	pInfo->u.Out.IoPort = pDevExt->IOPortBase;
2077	pInfo->u.Out.pvVmmDevMapping = pDevExt->pVMMDevMemory;
2078	pInfo->u.Out.auPadding[0] = 0;
2079	#if HC_ARCH_BITS != 32
2080	pInfo->u.Out.auPadding[1] = 0;
2081	pInfo->u.Out.auPadding[2] = 0;
2082	#endif
2083	return VINF_SUCCESS;
2084	}
2085
2086
2087	/**
2088	* Set the callback for the kernel mouse handler.
2089	*
2090	* returns IPRT status code.
2091	* @param pDevExt The device extension.
2092	* @param pNotify The new callback information.
2093	*/
2094	static int vgdrvIoCtl_SetMouseNotifyCallback(PVBOXGUESTDEVEXT pDevExt, PVBGLIOCSETMOUSENOTIFYCALLBACK pNotify)
2095	{
2096	LogFlow(("VBOXGUEST_IOCTL_SET_MOUSE_NOTIFY_CALLBACK: pfnNotify=%p pvUser=%p\n", pNotify->u.In.pfnNotify, pNotify->u.In.pvUser));
2097
2098	#ifdef VBOXGUEST_MOUSE_NOTIFY_CAN_PREEMPT
2099	VGDrvNativeSetMouseNotifyCallback(pDevExt, pNotify);
2100	#else
2101	RTSpinlockAcquire(pDevExt->EventSpinlock);
2102	pDevExt->pfnMouseNotifyCallback = pNotify->u.In.pfnNotify;
2103	pDevExt->pvMouseNotifyCallbackArg = pNotify->u.In.pvUser;
2104	RTSpinlockRelease(pDevExt->EventSpinlock);
2105	#endif
2106	return VINF_SUCCESS;
2107	}
2108
2109
2110	/**
2111	* Worker vgdrvIoCtl_WaitEvent.
2112	*
2113	* The caller enters the spinlock, we leave it.
2114	*
2115	* @returns VINF_SUCCESS if we've left the spinlock and can return immediately.
2116	*/
2117	DECLINLINE(int) vbdgCheckWaitEventCondition(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
2118	PVBGLIOCWAITFOREVENTS pInfo, int iEvent, const uint32_t fReqEvents)
2119	{
2120	uint32_t fMatches = pDevExt->f32PendingEvents & fReqEvents;
2121	if (fMatches & VBOXGUEST_ACQUIRE_STYLE_EVENTS)
2122	fMatches &= vgdrvGetAllowedEventMaskForSession(pDevExt, pSession);
2123	if (fMatches \|\| pSession->fPendingCancelWaitEvents)
2124	{
2125	ASMAtomicAndU32(&pDevExt->f32PendingEvents, ~fMatches);
2126	RTSpinlockRelease(pDevExt->EventSpinlock);
2127
2128	pInfo->u.Out.fEvents = fMatches;
2129	if (fReqEvents & ~((uint32_t)1 << iEvent))
2130	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns %#x\n", pInfo->u.Out.fEvents));
2131	else
2132	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns %#x/%d\n", pInfo->u.Out.fEvents, iEvent));
2133	pSession->fPendingCancelWaitEvents = false;
2134	return VINF_SUCCESS;
2135	}
2136
2137	RTSpinlockRelease(pDevExt->EventSpinlock);
2138	return VERR_TIMEOUT;
2139	}
2140
2141
2142	static int vgdrvIoCtl_WaitForEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
2143	PVBGLIOCWAITFOREVENTS pInfo, bool fInterruptible)
2144	{
2145	uint32_t const cMsTimeout = pInfo->u.In.cMsTimeOut;
2146	const uint32_t fReqEvents = pInfo->u.In.fEvents;
2147	uint32_t fResEvents;
2148	int iEvent;
2149	PVBOXGUESTWAIT pWait;
2150	int rc;
2151
2152	pInfo->u.Out.fEvents = 0; /* Note! This overwrites pInfo->u.In.* fields! */
2153
2154	/*
2155	* Copy and verify the input mask.
2156	*/
2157	iEvent = ASMBitFirstSetU32(fReqEvents) - 1;
2158	if (RT_UNLIKELY(iEvent < 0))
2159	{
2160	LogRel(("VBOXGUEST_IOCTL_WAITEVENT: Invalid input mask %#x!!\n", fReqEvents));
2161	return VERR_INVALID_PARAMETER;
2162	}
2163
2164	/*
2165	* Check the condition up front, before doing the wait-for-event allocations.
2166	*/
2167	RTSpinlockAcquire(pDevExt->EventSpinlock);
2168	rc = vbdgCheckWaitEventCondition(pDevExt, pSession, pInfo, iEvent, fReqEvents);
2169	if (rc == VINF_SUCCESS)
2170	return rc;
2171
2172	if (!cMsTimeout)
2173	{
2174	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns VERR_TIMEOUT\n"));
2175	return VERR_TIMEOUT;
2176	}
2177
2178	pWait = vgdrvWaitAlloc(pDevExt, pSession);
2179	if (!pWait)
2180	return VERR_NO_MEMORY;
2181	pWait->fReqEvents = fReqEvents;
2182
2183	/*
2184	* We've got the wait entry now, re-enter the spinlock and check for the condition.
2185	* If the wait condition is met, return.
2186	* Otherwise enter into the list and go to sleep waiting for the ISR to signal us.
2187	*/
2188	RTSpinlockAcquire(pDevExt->EventSpinlock);
2189	RTListAppend(&pDevExt->WaitList, &pWait->ListNode);
2190	rc = vbdgCheckWaitEventCondition(pDevExt, pSession, pInfo, iEvent, fReqEvents);
2191	if (rc == VINF_SUCCESS)
2192	{
2193	vgdrvWaitFreeUnlocked(pDevExt, pWait);
2194	return rc;
2195	}
2196
2197	if (fInterruptible)
2198	rc = RTSemEventMultiWaitNoResume(pWait->Event, cMsTimeout == UINT32_MAX ? RT_INDEFINITE_WAIT : cMsTimeout);
2199	else
2200	rc = RTSemEventMultiWait(pWait->Event, cMsTimeout == UINT32_MAX ? RT_INDEFINITE_WAIT : cMsTimeout);
2201
2202	/*
2203	* There is one special case here and that's when the semaphore is
2204	* destroyed upon device driver unload. This shouldn't happen of course,
2205	* but in case it does, just get out of here ASAP.
2206	*/
2207	if (rc == VERR_SEM_DESTROYED)
2208	return rc;
2209
2210	/*
2211	* Unlink the wait item and dispose of it.
2212	*/
2213	RTSpinlockAcquire(pDevExt->EventSpinlock);
2214	fResEvents = pWait->fResEvents;
2215	vgdrvWaitFreeLocked(pDevExt, pWait);
2216	RTSpinlockRelease(pDevExt->EventSpinlock);
2217
2218	/*
2219	* Now deal with the return code.
2220	*/
2221	if ( fResEvents
2222	&& fResEvents != UINT32_MAX)
2223	{
2224	pInfo->u.Out.fEvents = fResEvents;
2225	if (fReqEvents & ~((uint32_t)1 << iEvent))
2226	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns %#x\n", pInfo->u.Out.fEvents));
2227	else
2228	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns %#x/%d\n", pInfo->u.Out.fEvents, iEvent));
2229	rc = VINF_SUCCESS;
2230	}
2231	else if ( fResEvents == UINT32_MAX
2232	\|\| rc == VERR_INTERRUPTED)
2233	{
2234	rc = VERR_INTERRUPTED;
2235	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns VERR_INTERRUPTED\n"));
2236	}
2237	else if (rc == VERR_TIMEOUT)
2238	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns VERR_TIMEOUT (2)\n"));
2239	else
2240	{
2241	if (RT_SUCCESS(rc))
2242	{
2243	LogRelMax(32, ("VBOXGUEST_IOCTL_WAITEVENT: returns %Rrc but no events!\n", rc));
2244	rc = VERR_INTERNAL_ERROR;
2245	}
2246	LogFlow(("VBOXGUEST_IOCTL_WAITEVENT: returns %Rrc\n", rc));
2247	}
2248
2249	return rc;
2250	}
2251
2252
2253	/** @todo the semantics of this IoCtl have been tightened, so that no calls to
2254	* VBOXGUEST_IOCTL_WAITEVENT are allowed in a session after it has been
2255	* called. Change the code to make calls to VBOXGUEST_IOCTL_WAITEVENT made
2256	* after that to return VERR_INTERRUPTED or something appropriate. */
2257	static int vgdrvIoCtl_CancelAllWaitEvents(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
2258	{
2259	PVBOXGUESTWAIT pWait;
2260	PVBOXGUESTWAIT pSafe;
2261	int rc = 0;
2262	/* Was as least one WAITEVENT in process for this session? If not we
2263	* set a flag that the next call should be interrupted immediately. This
2264	* is needed so that a user thread can reliably interrupt another one in a
2265	* WAITEVENT loop. */
2266	bool fCancelledOne = false;
2267
2268	LogFlow(("VBOXGUEST_IOCTL_CANCEL_ALL_WAITEVENTS\n"));
2269
2270	/*
2271	* Walk the event list and wake up anyone with a matching session.
2272	*/
2273	RTSpinlockAcquire(pDevExt->EventSpinlock);
2274	RTListForEachSafe(&pDevExt->WaitList, pWait, pSafe, VBOXGUESTWAIT, ListNode)
2275	{
2276	if (pWait->pSession == pSession)
2277	{
2278	fCancelledOne = true;
2279	pWait->fResEvents = UINT32_MAX;
2280	RTListNodeRemove(&pWait->ListNode);
2281	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
2282	RTListAppend(&pDevExt->WakeUpList, &pWait->ListNode);
2283	#else
2284	rc \|= RTSemEventMultiSignal(pWait->Event);
2285	RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
2286	#endif
2287	}
2288	}
2289	if (!fCancelledOne)
2290	pSession->fPendingCancelWaitEvents = true;
2291	RTSpinlockRelease(pDevExt->EventSpinlock);
2292	Assert(rc == 0);
2293	NOREF(rc);
2294
2295	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
2296	VGDrvCommonWaitDoWakeUps(pDevExt);
2297	#endif
2298
2299	return VINF_SUCCESS;
2300	}
2301
2302
2303	/**
2304	* Checks if the VMM request is allowed in the context of the given session.
2305	*
2306	* @returns VINF_SUCCESS or VERR_PERMISSION_DENIED.
2307	* @param pDevExt The device extension.
2308	* @param pSession The calling session.
2309	* @param enmType The request type.
2310	* @param pReqHdr The request.
2311	*/
2312	static int vgdrvCheckIfVmmReqIsAllowed(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, VMMDevRequestType enmType,
2313	VMMDevRequestHeader const *pReqHdr)
2314	{
2315	/*
2316	* Categorize the request being made.
2317	*/
2318	/** @todo This need quite some more work! */
2319	enum
2320	{
2321	kLevel_Invalid, kLevel_NoOne, kLevel_OnlyVBoxGuest, kLevel_OnlyKernel, kLevel_TrustedUsers, kLevel_AllUsers
2322	} enmRequired;
2323	RT_NOREF1(pDevExt);
2324
2325	switch (enmType)
2326	{
2327	/*
2328	* Deny access to anything we don't know or provide specialized I/O controls for.
2329	*/
2330	#ifdef VBOX_WITH_HGCM
2331	case VMMDevReq_HGCMConnect:
2332	case VMMDevReq_HGCMDisconnect:
2333	# ifdef VBOX_WITH_64_BITS_GUESTS
2334	case VMMDevReq_HGCMCall64:
2335	# endif
2336	case VMMDevReq_HGCMCall32:
2337	case VMMDevReq_HGCMCancel:
2338	case VMMDevReq_HGCMCancel2:
2339	#endif /* VBOX_WITH_HGCM */
2340	case VMMDevReq_SetGuestCapabilities:
2341	default:
2342	enmRequired = kLevel_NoOne;
2343	break;
2344
2345	/*
2346	* There are a few things only this driver can do (and it doesn't use
2347	* the VMMRequst I/O control route anyway, but whatever).
2348	*/
2349	case VMMDevReq_ReportGuestInfo:
2350	case VMMDevReq_ReportGuestInfo2:
2351	case VMMDevReq_GetHypervisorInfo:
2352	case VMMDevReq_SetHypervisorInfo:
2353	case VMMDevReq_RegisterPatchMemory:
2354	case VMMDevReq_DeregisterPatchMemory:
2355	case VMMDevReq_GetMemBalloonChangeRequest:
2356	case VMMDevReq_ChangeMemBalloon:
2357	enmRequired = kLevel_OnlyVBoxGuest;
2358	break;
2359
2360	/*
2361	* Trusted users apps only.
2362	*/
2363	case VMMDevReq_QueryCredentials:
2364	case VMMDevReq_ReportCredentialsJudgement:
2365	case VMMDevReq_RegisterSharedModule:
2366	case VMMDevReq_UnregisterSharedModule:
2367	case VMMDevReq_WriteCoreDump:
2368	case VMMDevReq_GetCpuHotPlugRequest:
2369	case VMMDevReq_SetCpuHotPlugStatus:
2370	case VMMDevReq_CheckSharedModules:
2371	case VMMDevReq_GetPageSharingStatus:
2372	case VMMDevReq_DebugIsPageShared:
2373	case VMMDevReq_ReportGuestStats:
2374	case VMMDevReq_ReportGuestUserState:
2375	case VMMDevReq_GetStatisticsChangeRequest:
2376	enmRequired = kLevel_TrustedUsers;
2377	break;
2378
2379	/*
2380	* Anyone.
2381	*/
2382	case VMMDevReq_GetMouseStatus:
2383	case VMMDevReq_SetMouseStatus:
2384	case VMMDevReq_SetPointerShape:
2385	case VMMDevReq_GetHostVersion:
2386	case VMMDevReq_Idle:
2387	case VMMDevReq_GetHostTime:
2388	case VMMDevReq_SetPowerStatus:
2389	case VMMDevReq_AcknowledgeEvents:
2390	case VMMDevReq_CtlGuestFilterMask:
2391	case VMMDevReq_ReportGuestStatus:
2392	case VMMDevReq_GetDisplayChangeRequest:
2393	case VMMDevReq_VideoModeSupported:
2394	case VMMDevReq_GetHeightReduction:
2395	case VMMDevReq_GetDisplayChangeRequest2:
2396	case VMMDevReq_VideoModeSupported2:
2397	case VMMDevReq_VideoAccelEnable:
2398	case VMMDevReq_VideoAccelFlush:
2399	case VMMDevReq_VideoSetVisibleRegion:
2400	case VMMDevReq_VideoUpdateMonitorPositions:
2401	case VMMDevReq_GetDisplayChangeRequestEx:
2402	case VMMDevReq_GetDisplayChangeRequestMulti:
2403	case VMMDevReq_GetSeamlessChangeRequest:
2404	case VMMDevReq_GetVRDPChangeRequest:
2405	case VMMDevReq_LogString:
2406	case VMMDevReq_GetSessionId:
2407	enmRequired = kLevel_AllUsers;
2408	break;
2409
2410	/*
2411	* Depends on the request parameters...
2412	*/
2413	/** @todo this have to be changed into an I/O control and the facilities
2414	* tracked in the session so they can automatically be failed when the
2415	* session terminates without reporting the new status.
2416	*
2417	* The information presented by IGuest is not reliable without this! */
2418	case VMMDevReq_ReportGuestCapabilities:
2419	switch (((VMMDevReportGuestStatus const *)pReqHdr)->guestStatus.facility)
2420	{
2421	case VBoxGuestFacilityType_All:
2422	case VBoxGuestFacilityType_VBoxGuestDriver:
2423	enmRequired = kLevel_OnlyVBoxGuest;
2424	break;
2425	case VBoxGuestFacilityType_VBoxService:
2426	enmRequired = kLevel_TrustedUsers;
2427	break;
2428	case VBoxGuestFacilityType_VBoxTrayClient:
2429	case VBoxGuestFacilityType_Seamless:
2430	case VBoxGuestFacilityType_Graphics:
2431	default:
2432	enmRequired = kLevel_AllUsers;
2433	break;
2434	}
2435	break;
2436	}
2437
2438	/*
2439	* Check against the session.
2440	*/
2441	switch (enmRequired)
2442	{
2443	default:
2444	case kLevel_NoOne:
2445	break;
2446	case kLevel_OnlyVBoxGuest:
2447	case kLevel_OnlyKernel:
2448	if (pSession->R0Process == NIL_RTR0PROCESS)
2449	return VINF_SUCCESS;
2450	break;
2451	case kLevel_TrustedUsers:
2452	if (pSession->fUserSession)
2453	break;
2454	RT_FALL_THRU();
2455	case kLevel_AllUsers:
2456	return VINF_SUCCESS;
2457	}
2458
2459	return VERR_PERMISSION_DENIED;
2460	}
2461
2462	static int vgdrvIoCtl_VMMDevRequest(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
2463	VMMDevRequestHeader *pReqHdr, size_t cbData)
2464	{
2465	int rc;
2466	VMMDevRequestHeader *pReqCopy;
2467
2468	/*
2469	* Validate the header and request size.
2470	*/
2471	const VMMDevRequestType enmType = pReqHdr->requestType;
2472	const uint32_t cbReq = pReqHdr->size;
2473	const uint32_t cbMinSize = (uint32_t)vmmdevGetRequestSize(enmType);
2474
2475	LogFlow(("VBOXGUEST_IOCTL_VMMREQUEST: type %d\n", pReqHdr->requestType));
2476
2477	if (cbReq < cbMinSize)
2478	{
2479	LogRel(("VBOXGUEST_IOCTL_VMMREQUEST: invalid hdr size %#x, expected >= %#x; type=%#x!!\n",
2480	cbReq, cbMinSize, enmType));
2481	return VERR_INVALID_PARAMETER;
2482	}
2483	if (cbReq > cbData)
2484	{
2485	LogRel(("VBOXGUEST_IOCTL_VMMREQUEST: invalid size %#x, expected >= %#x (hdr); type=%#x!!\n",
2486	cbData, cbReq, enmType));
2487	return VERR_INVALID_PARAMETER;
2488	}
2489	rc = VbglGR0Verify(pReqHdr, cbData);
2490	if (RT_FAILURE(rc))
2491	{
2492	Log(("VBOXGUEST_IOCTL_VMMREQUEST: invalid header: size %#x, expected >= %#x (hdr); type=%#x; rc=%Rrc!!\n",
2493	cbData, cbReq, enmType, rc));
2494	return rc;
2495	}
2496
2497	rc = vgdrvCheckIfVmmReqIsAllowed(pDevExt, pSession, enmType, pReqHdr);
2498	if (RT_FAILURE(rc))
2499	{
2500	Log(("VBOXGUEST_IOCTL_VMMREQUEST: Operation not allowed! type=%#x rc=%Rrc\n", enmType, rc));
2501	return rc;
2502	}
2503
2504	/*
2505	* Make a copy of the request in the physical memory heap so
2506	* the VBoxGuestLibrary can more easily deal with the request.
2507	* (This is really a waste of time since the OS or the OS specific
2508	* code has already buffered or locked the input/output buffer, but
2509	* it does makes things a bit simpler wrt to phys address.)
2510	*/
2511	rc = VbglR0GRAlloc(&pReqCopy, cbReq, enmType);
2512	if (RT_FAILURE(rc))
2513	{
2514	Log(("VBOXGUEST_IOCTL_VMMREQUEST: failed to allocate %u (%#x) bytes to cache the request. rc=%Rrc!!\n",
2515	cbReq, cbReq, rc));
2516	return rc;
2517	}
2518	memcpy(pReqCopy, pReqHdr, cbReq);
2519	Assert(pReqCopy->reserved1 == cbReq);
2520	pReqCopy->reserved1 = 0; /* VGDrvCommonIoCtl or caller sets cbOut, so clear it. */
2521	pReqCopy->fRequestor = pSession->fRequestor;
2522
2523	if (enmType == VMMDevReq_GetMouseStatus) /* clear poll condition. */
2524	pSession->u32MousePosChangedSeq = ASMAtomicUoReadU32(&pDevExt->u32MousePosChangedSeq);
2525
2526	rc = VbglR0GRPerform(pReqCopy);
2527	if ( RT_SUCCESS(rc)
2528	&& RT_SUCCESS(pReqCopy->rc))
2529	{
2530	Assert(rc != VINF_HGCM_ASYNC_EXECUTE);
2531	Assert(pReqCopy->rc != VINF_HGCM_ASYNC_EXECUTE);
2532
2533	memcpy(pReqHdr, pReqCopy, cbReq);
2534	pReqHdr->reserved1 = cbReq; /* preserve cbOut */
2535	}
2536	else if (RT_FAILURE(rc))
2537	Log(("VBOXGUEST_IOCTL_VMMREQUEST: VbglR0GRPerform - rc=%Rrc!\n", rc));
2538	else
2539	{
2540	Log(("VBOXGUEST_IOCTL_VMMREQUEST: request execution failed; VMMDev rc=%Rrc!\n", pReqCopy->rc));
2541	rc = pReqCopy->rc;
2542	}
2543
2544	VbglR0GRFree(pReqCopy);
2545	return rc;
2546	}
2547
2548
2549	#ifdef VBOX_WITH_HGCM
2550
2551	AssertCompile(RT_INDEFINITE_WAIT == (uint32_t)RT_INDEFINITE_WAIT); /* assumed by code below */
2552
2553	/** Worker for vgdrvHgcmAsyncWaitCallback. /
2554	static int vgdrvHgcmAsyncWaitCallbackWorker(VMMDevHGCMRequestHeader volatile *pHdr, PVBOXGUESTDEVEXT pDevExt,
2555	bool fInterruptible, uint32_t cMillies)
2556	{
2557	int rc;
2558
2559	/*
2560	* Check to see if the condition was met by the time we got here.
2561	*
2562	* We create a simple poll loop here for dealing with out-of-memory
2563	* conditions since the caller isn't necessarily able to deal with
2564	* us returning too early.
2565	*/
2566	PVBOXGUESTWAIT pWait;
2567	for (;;)
2568	{
2569	RTSpinlockAcquire(pDevExt->EventSpinlock);
2570	if ((pHdr->fu32Flags & VBOX_HGCM_REQ_DONE) != 0)
2571	{
2572	RTSpinlockRelease(pDevExt->EventSpinlock);
2573	return VINF_SUCCESS;
2574	}
2575	RTSpinlockRelease(pDevExt->EventSpinlock);
2576
2577	pWait = vgdrvWaitAlloc(pDevExt, NULL);
2578	if (pWait)
2579	break;
2580	if (fInterruptible)
2581	return VERR_INTERRUPTED;
2582	RTThreadSleep(1);
2583	}
2584	pWait->fReqEvents = VMMDEV_EVENT_HGCM;
2585	pWait->pHGCMReq = pHdr;
2586
2587	/*
2588	* Re-enter the spinlock and re-check for the condition.
2589	* If the condition is met, return.
2590	* Otherwise link us into the HGCM wait list and go to sleep.
2591	*/
2592	RTSpinlockAcquire(pDevExt->EventSpinlock);
2593	RTListAppend(&pDevExt->HGCMWaitList, &pWait->ListNode);
2594	if ((pHdr->fu32Flags & VBOX_HGCM_REQ_DONE) != 0)
2595	{
2596	vgdrvWaitFreeLocked(pDevExt, pWait);
2597	RTSpinlockRelease(pDevExt->EventSpinlock);
2598	return VINF_SUCCESS;
2599	}
2600	RTSpinlockRelease(pDevExt->EventSpinlock);
2601
2602	if (fInterruptible)
2603	rc = RTSemEventMultiWaitNoResume(pWait->Event, cMillies);
2604	else
2605	rc = RTSemEventMultiWait(pWait->Event, cMillies);
2606	if (rc == VERR_SEM_DESTROYED)
2607	return rc;
2608
2609	/*
2610	* Unlink, free and return.
2611	*/
2612	if ( RT_FAILURE(rc)
2613	&& rc != VERR_TIMEOUT
2614	&& ( !fInterruptible
2615	\|\| rc != VERR_INTERRUPTED))
2616	LogRel(("vgdrvHgcmAsyncWaitCallback: wait failed! %Rrc\n", rc));
2617
2618	vgdrvWaitFreeUnlocked(pDevExt, pWait);
2619	return rc;
2620	}
2621
2622
2623	/**
2624	* This is a callback for dealing with async waits.
2625	*
2626	* It operates in a manner similar to vgdrvIoCtl_WaitEvent.
2627	*/
2628	static DECLCALLBACK(int) vgdrvHgcmAsyncWaitCallback(VMMDevHGCMRequestHeader pHdr, void pvUser, uint32_t u32User)
2629	{
2630	PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
2631	LogFlow(("vgdrvHgcmAsyncWaitCallback: requestType=%d\n", pHdr->header.requestType));
2632	return vgdrvHgcmAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt,
2633	false /* fInterruptible /, u32User / cMillies */);
2634	}
2635
2636
2637	/**
2638	* This is a callback for dealing with async waits with a timeout.
2639	*
2640	* It operates in a manner similar to vgdrvIoCtl_WaitEvent.
2641	*/
2642	static DECLCALLBACK(int) vgdrvHgcmAsyncWaitCallbackInterruptible(VMMDevHGCMRequestHeader pHdr, void pvUser, uint32_t u32User)
2643	{
2644	PVBOXGUESTDEVEXT pDevExt = (PVBOXGUESTDEVEXT)pvUser;
2645	LogFlow(("vgdrvHgcmAsyncWaitCallbackInterruptible: requestType=%d\n", pHdr->header.requestType));
2646	return vgdrvHgcmAsyncWaitCallbackWorker((VMMDevHGCMRequestHeader volatile *)pHdr, pDevExt,
2647	true /* fInterruptible /, u32User / cMillies */);
2648	}
2649
2650
2651	static int vgdrvIoCtl_HGCMConnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCHGCMCONNECT pInfo)
2652	{
2653	int rc;
2654	HGCMCLIENTID idClient = 0;
2655
2656	/*
2657	* The VbglHGCMConnect call will invoke the callback if the HGCM
2658	* call is performed in an ASYNC fashion. The function is not able
2659	* to deal with cancelled requests.
2660	*/
2661	Log(("VBOXGUEST_IOCTL_HGCM_CONNECT: %.128s\n",
2662	pInfo->u.In.Loc.type == VMMDevHGCMLoc_LocalHost \|\| pInfo->u.In.Loc.type == VMMDevHGCMLoc_LocalHost_Existing
2663	? pInfo->u.In.Loc.u.host.achName : "<not local host>"));
2664
2665	rc = VbglR0HGCMInternalConnect(&pInfo->u.In.Loc, pSession->fRequestor, &idClient,
2666	vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
2667	Log(("VBOXGUEST_IOCTL_HGCM_CONNECT: idClient=%RX32 (rc=%Rrc)\n", idClient, rc));
2668	if (RT_SUCCESS(rc))
2669	{
2670	/*
2671	* Append the client id to the client id table.
2672	* If the table has somehow become filled up, we'll disconnect the session.
2673	*/
2674	unsigned i;
2675	RTSpinlockAcquire(pDevExt->SessionSpinlock);
2676	for (i = 0; i < RT_ELEMENTS(pSession->aHGCMClientIds); i++)
2677	if (!pSession->aHGCMClientIds[i])
2678	{
2679	pSession->aHGCMClientIds[i] = idClient;
2680	break;
2681	}
2682	RTSpinlockRelease(pDevExt->SessionSpinlock);
2683	if (i >= RT_ELEMENTS(pSession->aHGCMClientIds))
2684	{
2685	LogRelMax(32, ("VBOXGUEST_IOCTL_HGCM_CONNECT: too many HGCMConnect calls for one session!\n"));
2686	VbglR0HGCMInternalDisconnect(idClient, pSession->fRequestor, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
2687
2688	pInfo->u.Out.idClient = 0;
2689	return VERR_TOO_MANY_OPEN_FILES;
2690	}
2691	}
2692	pInfo->u.Out.idClient = idClient;
2693	return rc;
2694	}
2695
2696
2697	static int vgdrvIoCtl_HGCMDisconnect(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCHGCMDISCONNECT pInfo)
2698	{
2699	/*
2700	* Validate the client id and invalidate its entry while we're in the call.
2701	*/
2702	int rc;
2703	const uint32_t idClient = pInfo->u.In.idClient;
2704	unsigned i;
2705	RTSpinlockAcquire(pDevExt->SessionSpinlock);
2706	for (i = 0; i < RT_ELEMENTS(pSession->aHGCMClientIds); i++)
2707	if (pSession->aHGCMClientIds[i] == idClient)
2708	{
2709	pSession->aHGCMClientIds[i] = UINT32_MAX;
2710	break;
2711	}
2712	RTSpinlockRelease(pDevExt->SessionSpinlock);
2713	if (i >= RT_ELEMENTS(pSession->aHGCMClientIds))
2714	{
2715	LogRelMax(32, ("VBOXGUEST_IOCTL_HGCM_DISCONNECT: idClient=%RX32\n", idClient));
2716	return VERR_INVALID_HANDLE;
2717	}
2718
2719	/*
2720	* The VbglHGCMConnect call will invoke the callback if the HGCM
2721	* call is performed in an ASYNC fashion. The function is not able
2722	* to deal with cancelled requests.
2723	*/
2724	Log(("VBOXGUEST_IOCTL_HGCM_DISCONNECT: idClient=%RX32\n", idClient));
2725	rc = VbglR0HGCMInternalDisconnect(idClient, pSession->fRequestor, vgdrvHgcmAsyncWaitCallback, pDevExt, RT_INDEFINITE_WAIT);
2726	LogFlow(("VBOXGUEST_IOCTL_HGCM_DISCONNECT: rc=%Rrc\n", rc));
2727
2728	/* Update the client id array according to the result. */
2729	RTSpinlockAcquire(pDevExt->SessionSpinlock);
2730	if (pSession->aHGCMClientIds[i] == UINT32_MAX)
2731	pSession->aHGCMClientIds[i] = RT_SUCCESS(rc) ? 0 : idClient;
2732	RTSpinlockRelease(pDevExt->SessionSpinlock);
2733
2734	return rc;
2735	}
2736
2737
2738	static int vgdrvIoCtl_HGCMCallInner(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCHGCMCALL pInfo,
2739	uint32_t cMillies, bool fInterruptible, bool f32bit, bool fUserData,
2740	size_t cbExtra, size_t cbData)
2741	{
2742	const uint32_t u32ClientId = pInfo->u32ClientID;
2743	uint32_t fFlags;
2744	size_t cbActual;
2745	unsigned i;
2746	int rc;
2747
2748	/*
2749	* Some more validations.
2750	*/
2751	if (RT_LIKELY(pInfo->cParms <= VMMDEV_MAX_HGCM_PARMS)) /* (Just make sure it doesn't overflow the next check.) */
2752	{ /* likely */}
2753	else
2754	{
2755	LogRel(("VBOXGUEST_IOCTL_HGCM_CALL: cParm=%RX32 is not sane\n", pInfo->cParms));
2756	return VERR_INVALID_PARAMETER;
2757	}
2758
2759	cbActual = cbExtra + sizeof(*pInfo);
2760	#ifdef RT_ARCH_AMD64
2761	if (f32bit)
2762	cbActual += pInfo->cParms * sizeof(HGCMFunctionParameter32);
2763	else
2764	#endif
2765	cbActual += pInfo->cParms * sizeof(HGCMFunctionParameter);
2766	if (RT_LIKELY(cbData >= cbActual))
2767	{ /* likely */}
2768	else
2769	{
2770	LogRel(("VBOXGUEST_IOCTL_HGCM_CALL: cbData=%#zx (%zu) required size is %#zx (%zu)\n",
2771	cbData, cbData, cbActual, cbActual));
2772	return VERR_INVALID_PARAMETER;
2773	}
2774	pInfo->Hdr.cbOut = (uint32_t)cbActual;
2775
2776	/*
2777	* Validate the client id.
2778	*/
2779	RTSpinlockAcquire(pDevExt->SessionSpinlock);
2780	for (i = 0; i < RT_ELEMENTS(pSession->aHGCMClientIds); i++)
2781	if (pSession->aHGCMClientIds[i] == u32ClientId)
2782	break;
2783	RTSpinlockRelease(pDevExt->SessionSpinlock);
2784	if (RT_LIKELY(i < RT_ELEMENTS(pSession->aHGCMClientIds)))
2785	{ /* likely */}
2786	else
2787	{
2788	LogRelMax(32, ("VBOXGUEST_IOCTL_HGCM_CALL: Invalid handle. u32Client=%RX32\n", u32ClientId));
2789	return VERR_INVALID_HANDLE;
2790	}
2791
2792	/*
2793	* The VbglHGCMCall call will invoke the callback if the HGCM
2794	* call is performed in an ASYNC fashion. This function can
2795	* deal with cancelled requests, so we let user more requests
2796	* be interruptible (should add a flag for this later I guess).
2797	*/
2798	LogFlow(("VBOXGUEST_IOCTL_HGCM_CALL: u32Client=%RX32\n", pInfo->u32ClientID));
2799	fFlags = !fUserData && pSession->R0Process == NIL_RTR0PROCESS ? VBGLR0_HGCMCALL_F_KERNEL : VBGLR0_HGCMCALL_F_USER;
2800	uint32_t cbInfo = (uint32_t)(cbData - cbExtra);
2801	#ifdef RT_ARCH_AMD64
2802	if (f32bit)
2803	{
2804	if (fInterruptible)
2805	rc = VbglR0HGCMInternalCall32(pInfo, cbInfo, fFlags, pSession->fRequestor,
2806	vgdrvHgcmAsyncWaitCallbackInterruptible, pDevExt, cMillies);
2807	else
2808	rc = VbglR0HGCMInternalCall32(pInfo, cbInfo, fFlags, pSession->fRequestor,
2809	vgdrvHgcmAsyncWaitCallback, pDevExt, cMillies);
2810	}
2811	else
2812	#endif
2813	{
2814	if (fInterruptible)
2815	rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, pSession->fRequestor,
2816	vgdrvHgcmAsyncWaitCallbackInterruptible, pDevExt, cMillies);
2817	else
2818	rc = VbglR0HGCMInternalCall(pInfo, cbInfo, fFlags, pSession->fRequestor,
2819	vgdrvHgcmAsyncWaitCallback, pDevExt, cMillies);
2820	}
2821	if (RT_SUCCESS(rc))
2822	{
2823	rc = pInfo->Hdr.rc;
2824	LogFlow(("VBOXGUEST_IOCTL_HGCM_CALL: result=%Rrc\n", rc));
2825	}
2826	else
2827	{
2828	if ( rc != VERR_INTERRUPTED
2829	&& rc != VERR_TIMEOUT)
2830	LogRelMax(32, ("VBOXGUEST_IOCTL_HGCM_CALL: %s Failed. rc=%Rrc (Hdr.rc=%Rrc).\n", f32bit ? "32" : "64", rc, pInfo->Hdr.rc));
2831	else
2832	Log(("VBOXGUEST_IOCTL_HGCM_CALL: %s Failed. rc=%Rrc (Hdr.rc=%Rrc).\n", f32bit ? "32" : "64", rc, pInfo->Hdr.rc));
2833	}
2834	return rc;
2835	}
2836
2837
2838	static int vgdrvIoCtl_HGCMCallWrapper(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCHGCMCALL pInfo,
2839	bool f32bit, bool fUserData, size_t cbData)
2840	{
2841	return vgdrvIoCtl_HGCMCallInner(pDevExt, pSession, pInfo, pInfo->cMsTimeout,
2842	pInfo->fInterruptible \|\| pSession->R0Process != NIL_RTR0PROCESS,
2843	f32bit, fUserData, 0 /cbExtra/, cbData);
2844	}
2845
2846
2847	/**
2848	* Handles a fast HGCM call from another driver.
2849	*
2850	* The driver has provided a fully assembled HGCM call request and all we need
2851	* to do is send it to the host and do the wait processing.
2852	*
2853	* @returns VBox status code of the request submission part.
2854	* @param pDevExt The device extension.
2855	* @param pCallReq The call request.
2856	*/
2857	static int vgdrvIoCtl_HGCMFastCall(PVBOXGUESTDEVEXT pDevExt, VBGLIOCIDCHGCMFASTCALL volatile *pCallReq)
2858	{
2859	VMMDevHGCMCall volatile pHgcmCall = (VMMDevHGCMCall volatile )(pCallReq + 1);
2860	int rc;
2861
2862	/*
2863	* Check out the physical address.
2864	*/
2865	Assert((pCallReq->GCPhysReq & PAGE_OFFSET_MASK) == ((uintptr_t)pHgcmCall & PAGE_OFFSET_MASK));
2866
2867	AssertReturn(!pCallReq->fInterruptible, VERR_NOT_IMPLEMENTED);
2868
2869	/*
2870	* Submit the request.
2871	*/
2872	Log(("vgdrvIoCtl_HGCMFastCall -> host\n"));
2873	ASMOutU32(pDevExt->IOPortBase + VMMDEV_PORT_OFF_REQUEST, (uint32_t)pCallReq->GCPhysReq);
2874
2875	/* Make the compiler aware that the host has changed memory. */
2876	ASMCompilerBarrier();
2877
2878	rc = pHgcmCall->header.header.rc;
2879	Log(("vgdrvIoCtl_HGCMFastCall -> %Rrc (header rc=%Rrc)\n", rc, pHgcmCall->header.result));
2880
2881	/*
2882	* The host is likely to engage in asynchronous execution of HGCM, unless it fails.
2883	*/
2884	if (rc == VINF_HGCM_ASYNC_EXECUTE)
2885	{
2886	rc = vgdrvHgcmAsyncWaitCallbackWorker(&pHgcmCall->header, pDevExt, false /* fInterruptible */, RT_INDEFINITE_WAIT);
2887	if (pHgcmCall->header.fu32Flags & VBOX_HGCM_REQ_DONE)
2888	{
2889	Assert(!(pHgcmCall->header.fu32Flags & VBOX_HGCM_REQ_CANCELLED));
2890	rc = VINF_SUCCESS;
2891	}
2892	else
2893	{
2894	/*
2895	* Timeout and interrupt scenarios are messy and requires
2896	* cancelation, so implement later.
2897	*/
2898	AssertReleaseMsgFailed(("rc=%Rrc\n", rc));
2899	}
2900	}
2901	else
2902	Assert((pHgcmCall->header.fu32Flags & VBOX_HGCM_REQ_DONE) \|\| RT_FAILURE_NP(rc));
2903
2904	Log(("vgdrvIoCtl_HGCMFastCall: rc=%Rrc result=%Rrc fu32Flags=%#x\n", rc, pHgcmCall->header.result, pHgcmCall->header.fu32Flags));
2905	return rc;
2906
2907	}
2908
2909	#endif /* VBOX_WITH_HGCM */
2910
2911	/**
2912	* Handle VBGL_IOCTL_CHECK_BALLOON from R3.
2913	*
2914	* Ask the host for the size of the balloon and try to set it accordingly. If
2915	* this approach fails because it's not supported, return with fHandleInR3 set
2916	* and let the user land supply memory we can lock via the other ioctl.
2917	*
2918	* @returns VBox status code.
2919	*
2920	* @param pDevExt The device extension.
2921	* @param pSession The session.
2922	* @param pInfo The output buffer.
2923	*/
2924	static int vgdrvIoCtl_CheckMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCCHECKBALLOON pInfo)
2925	{
2926	VMMDevGetMemBalloonChangeRequest *pReq;
2927	int rc;
2928
2929	LogFlow(("VBGL_IOCTL_CHECK_BALLOON:\n"));
2930	rc = RTSemFastMutexRequest(pDevExt->MemBalloon.hMtx);
2931	AssertRCReturn(rc, rc);
2932
2933	/*
2934	* The first user trying to query/change the balloon becomes the
2935	* owner and owns it until the session is closed (vgdrvCloseMemBalloon).
2936	*/
2937	if ( pDevExt->MemBalloon.pOwner != pSession
2938	&& pDevExt->MemBalloon.pOwner == NULL)
2939	pDevExt->MemBalloon.pOwner = pSession;
2940
2941	if (pDevExt->MemBalloon.pOwner == pSession)
2942	{
2943	/*
2944	* This is a response to that event. Setting this bit means that
2945	* we request the value from the host and change the guest memory
2946	* balloon according to this value.
2947	*/
2948	rc = VbglR0GRAlloc((VMMDevRequestHeader **)&pReq, sizeof(VMMDevGetMemBalloonChangeRequest), VMMDevReq_GetMemBalloonChangeRequest);
2949	if (RT_SUCCESS(rc))
2950	{
2951	pReq->header.fRequestor = pSession->fRequestor;
2952	pReq->eventAck = VMMDEV_EVENT_BALLOON_CHANGE_REQUEST;
2953	rc = VbglR0GRPerform(&pReq->header);
2954	if (RT_SUCCESS(rc))
2955	{
2956	Assert(pDevExt->MemBalloon.cMaxChunks == pReq->cPhysMemChunks \|\| pDevExt->MemBalloon.cMaxChunks == 0);
2957	pDevExt->MemBalloon.cMaxChunks = pReq->cPhysMemChunks;
2958
2959	pInfo->u.Out.cBalloonChunks = pReq->cBalloonChunks;
2960	pInfo->u.Out.fHandleInR3 = false;
2961	pInfo->u.Out.afPadding[0] = false;
2962	pInfo->u.Out.afPadding[1] = false;
2963	pInfo->u.Out.afPadding[2] = false;
2964
2965	rc = vgdrvSetBalloonSizeKernel(pDevExt, pReq->cBalloonChunks, &pInfo->u.Out.fHandleInR3);
2966	/* Ignore various out of memory failures. */
2967	if ( rc == VERR_NO_MEMORY
2968	\|\| rc == VERR_NO_PHYS_MEMORY
2969	\|\| rc == VERR_NO_CONT_MEMORY)
2970	rc = VINF_SUCCESS;
2971	}
2972	else
2973	LogRel(("VBGL_IOCTL_CHECK_BALLOON: VbglR0GRPerform failed. rc=%Rrc\n", rc));
2974	VbglR0GRFree(&pReq->header);
2975	}
2976	}
2977	else
2978	rc = VERR_PERMISSION_DENIED;
2979
2980	RTSemFastMutexRelease(pDevExt->MemBalloon.hMtx);
2981	LogFlow(("VBGL_IOCTL_CHECK_BALLOON returns %Rrc\n", rc));
2982	return rc;
2983	}
2984
2985
2986	/**
2987	* Handle a request for changing the memory balloon.
2988	*
2989	* @returns VBox status code.
2990	*
2991	* @param pDevExt The device extention.
2992	* @param pSession The session.
2993	* @param pInfo The change request structure (input).
2994	*/
2995	static int vgdrvIoCtl_ChangeMemoryBalloon(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCCHANGEBALLOON pInfo)
2996	{
2997	int rc;
2998	LogFlow(("VBGL_IOCTL_CHANGE_BALLOON: fInflate=%RTbool u64ChunkAddr=%p\n", pInfo->u.In.fInflate, pInfo->u.In.pvChunk));
2999	if ( pInfo->u.In.abPadding[0]
3000	\|\| pInfo->u.In.abPadding[1]
3001	\|\| pInfo->u.In.abPadding[2]
3002	\|\| pInfo->u.In.abPadding[3]
3003	\|\| pInfo->u.In.abPadding[4]
3004	\|\| pInfo->u.In.abPadding[5]
3005	\|\| pInfo->u.In.abPadding[6]
3006	#if ARCH_BITS == 32
3007	\|\| pInfo->u.In.abPadding[7]
3008	\|\| pInfo->u.In.abPadding[8]
3009	\|\| pInfo->u.In.abPadding[9]
3010	#endif
3011	)
3012	{
3013	Log(("VBGL_IOCTL_CHANGE_BALLOON: Padding isn't all zero: %.*Rhxs\n", sizeof(pInfo->u.In.abPadding), pInfo->u.In.abPadding));
3014	return VERR_INVALID_PARAMETER;
3015	}
3016
3017	rc = RTSemFastMutexRequest(pDevExt->MemBalloon.hMtx);
3018	AssertRCReturn(rc, rc);
3019
3020	if (!pDevExt->MemBalloon.fUseKernelAPI)
3021	{
3022	/*
3023	* The first user trying to query/change the balloon becomes the
3024	* owner and owns it until the session is closed (vgdrvCloseMemBalloon).
3025	*/
3026	if ( pDevExt->MemBalloon.pOwner != pSession
3027	&& pDevExt->MemBalloon.pOwner == NULL)
3028	pDevExt->MemBalloon.pOwner = pSession;
3029
3030	if (pDevExt->MemBalloon.pOwner == pSession)
3031	rc = vgdrvSetBalloonSizeFromUser(pDevExt, pSession, pInfo->u.In.pvChunk, pInfo->u.In.fInflate != false);
3032	else
3033	rc = VERR_PERMISSION_DENIED;
3034	}
3035	else
3036	rc = VERR_PERMISSION_DENIED;
3037
3038	RTSemFastMutexRelease(pDevExt->MemBalloon.hMtx);
3039	return rc;
3040	}
3041
3042
3043	/**
3044	* Handle a request for writing a core dump of the guest on the host.
3045	*
3046	* @returns VBox status code.
3047	*
3048	* @param pDevExt The device extension.
3049	* @param pSession The session.
3050	* @param pInfo The output buffer.
3051	*/
3052	static int vgdrvIoCtl_WriteCoreDump(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCWRITECOREDUMP pInfo)
3053	{
3054	VMMDevReqWriteCoreDump *pReq = NULL;
3055	int rc;
3056	LogFlow(("VBOXGUEST_IOCTL_WRITE_CORE_DUMP\n"));
3057	RT_NOREF1(pDevExt);
3058
3059	rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_WriteCoreDump);
3060	if (RT_SUCCESS(rc))
3061	{
3062	pReq->header.fRequestor = pSession->fRequestor;
3063	pReq->fFlags = pInfo->u.In.fFlags;
3064	rc = VbglR0GRPerform(&pReq->header);
3065	if (RT_FAILURE(rc))
3066	Log(("VBOXGUEST_IOCTL_WRITE_CORE_DUMP: VbglR0GRPerform failed, rc=%Rrc!\n", rc));
3067
3068	VbglR0GRFree(&pReq->header);
3069	}
3070	else
3071	Log(("VBOXGUEST_IOCTL_WRITE_CORE_DUMP: failed to allocate %u (%#x) bytes to cache the request. rc=%Rrc!!\n",
3072	sizeof(pReq), sizeof(pReq), rc));
3073	return rc;
3074	}
3075
3076
3077	/**
3078	* Guest backdoor logging.
3079	*
3080	* @returns VBox status code.
3081	*
3082	* @param pDevExt The device extension.
3083	* @param pch The log message (need not be NULL terminated).
3084	* @param cbData Size of the buffer.
3085	* @param fUserSession Copy of VBOXGUESTSESSION::fUserSession for the
3086	* call. True normal user, false root user.
3087	*/
3088	static int vgdrvIoCtl_Log(PVBOXGUESTDEVEXT pDevExt, const char *pch, size_t cbData, bool fUserSession)
3089	{
3090	if (pDevExt->fLoggingEnabled)
3091	RTLogBackdoorPrintf("%.*s", cbData, pch);
3092	else if (!fUserSession)
3093	LogRel(("%.*s", cbData, pch));
3094	else
3095	Log(("%.*s", cbData, pch));
3096	return VINF_SUCCESS;
3097	}
3098
3099
3100	/** @name Guest Capabilities, Mouse Status and Event Filter
3101	* @{
3102	*/
3103
3104	/**
3105	* Clears a bit usage tracker (init time).
3106	*
3107	* @param pTracker The tracker to clear.
3108	*/
3109	static void vgdrvBitUsageTrackerClear(PVBOXGUESTBITUSAGETRACER pTracker)
3110	{
3111	uint32_t iBit;
3112	AssertCompile(sizeof(pTracker->acPerBitUsage) == 32 * sizeof(uint32_t));
3113
3114	for (iBit = 0; iBit < 32; iBit++)
3115	pTracker->acPerBitUsage[iBit] = 0;
3116	pTracker->fMask = 0;
3117	}
3118
3119
3120	#ifdef VBOX_STRICT
3121	/**
3122	* Checks that pTracker->fMask is correct and that the usage values are within
3123	* the valid range.
3124	*
3125	* @param pTracker The tracker.
3126	* @param cMax Max valid usage value.
3127	* @param pszWhat Identifies the tracker in assertions.
3128	*/
3129	static void vgdrvBitUsageTrackerCheckMask(PCVBOXGUESTBITUSAGETRACER pTracker, uint32_t cMax, const char *pszWhat)
3130	{
3131	uint32_t fMask = 0;
3132	uint32_t iBit;
3133	AssertCompile(sizeof(pTracker->acPerBitUsage) == 32 * sizeof(uint32_t));
3134
3135	for (iBit = 0; iBit < 32; iBit++)
3136	if (pTracker->acPerBitUsage[iBit])
3137	{
3138	fMask \|= RT_BIT_32(iBit);
3139	AssertMsg(pTracker->acPerBitUsage[iBit] <= cMax,
3140	("%s: acPerBitUsage[%u]=%#x cMax=%#x\n", pszWhat, iBit, pTracker->acPerBitUsage[iBit], cMax));
3141	}
3142
3143	AssertMsg(fMask == pTracker->fMask, ("%s: %#x vs %#x\n", pszWhat, fMask, pTracker->fMask));
3144	}
3145	#endif
3146
3147
3148	/**
3149	* Applies a change to the bit usage tracker.
3150	*
3151	*
3152	* @returns true if the mask changed, false if not.
3153	* @param pTracker The bit usage tracker.
3154	* @param fChanged The bits to change.
3155	* @param fPrevious The previous value of the bits.
3156	* @param cMax The max valid usage value for assertions.
3157	* @param pszWhat Identifies the tracker in assertions.
3158	*/
3159	static bool vgdrvBitUsageTrackerChange(PVBOXGUESTBITUSAGETRACER pTracker, uint32_t fChanged, uint32_t fPrevious,
3160	uint32_t cMax, const char *pszWhat)
3161	{
3162	bool fGlobalChange = false;
3163	AssertCompile(sizeof(pTracker->acPerBitUsage) == 32 * sizeof(uint32_t));
3164
3165	while (fChanged)
3166	{
3167	uint32_t const iBit = ASMBitFirstSetU32(fChanged) - 1;
3168	uint32_t const fBitMask = RT_BIT_32(iBit);
3169	Assert(iBit < 32); Assert(fBitMask & fChanged);
3170
3171	if (fBitMask & fPrevious)
3172	{
3173	pTracker->acPerBitUsage[iBit] -= 1;
3174	AssertMsg(pTracker->acPerBitUsage[iBit] <= cMax,
3175	("%s: acPerBitUsage[%u]=%#x cMax=%#x\n", pszWhat, iBit, pTracker->acPerBitUsage[iBit], cMax));
3176	if (pTracker->acPerBitUsage[iBit] == 0)
3177	{
3178	fGlobalChange = true;
3179	pTracker->fMask &= ~fBitMask;
3180	}
3181	}
3182	else
3183	{
3184	pTracker->acPerBitUsage[iBit] += 1;
3185	AssertMsg(pTracker->acPerBitUsage[iBit] > 0 && pTracker->acPerBitUsage[iBit] <= cMax,
3186	("pTracker->acPerBitUsage[%u]=%#x cMax=%#x\n", pszWhat, iBit, pTracker->acPerBitUsage[iBit], cMax));
3187	if (pTracker->acPerBitUsage[iBit] == 1)
3188	{
3189	fGlobalChange = true;
3190	pTracker->fMask \|= fBitMask;
3191	}
3192	}
3193
3194	fChanged &= ~fBitMask;
3195	}
3196
3197	#ifdef VBOX_STRICT
3198	vgdrvBitUsageTrackerCheckMask(pTracker, cMax, pszWhat);
3199	#endif
3200	NOREF(pszWhat); NOREF(cMax);
3201	return fGlobalChange;
3202	}
3203
3204
3205	/**
3206	* Init and termination worker for resetting the (host) event filter on the host
3207	*
3208	* @returns VBox status code.
3209	* @param pDevExt The device extension.
3210	* @param fFixedEvents Fixed events (init time).
3211	*/
3212	static int vgdrvResetEventFilterOnHost(PVBOXGUESTDEVEXT pDevExt, uint32_t fFixedEvents)
3213	{
3214	VMMDevCtlGuestFilterMask *pReq;
3215	int rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_CtlGuestFilterMask);
3216	if (RT_SUCCESS(rc))
3217	{
3218	pReq->u32NotMask = UINT32_MAX & ~fFixedEvents;
3219	pReq->u32OrMask = fFixedEvents;
3220	rc = VbglR0GRPerform(&pReq->header);
3221	if (RT_FAILURE(rc))
3222	LogRelFunc(("failed with rc=%Rrc\n", rc));
3223	VbglR0GRFree(&pReq->header);
3224	}
3225	RT_NOREF1(pDevExt);
3226	return rc;
3227	}
3228
3229
3230	/**
3231	* Changes the event filter mask for the given session.
3232	*
3233	* This is called in response to VBGL_IOCTL_CHANGE_FILTER_MASK as well as to do
3234	* session cleanup.
3235	*
3236	* @returns VBox status code.
3237	* @param pDevExt The device extension.
3238	* @param pSession The session.
3239	* @param fOrMask The events to add.
3240	* @param fNotMask The events to remove.
3241	* @param fSessionTermination Set if we're called by the session cleanup code.
3242	* This tweaks the error handling so we perform
3243	* proper session cleanup even if the host
3244	* misbehaves.
3245	*
3246	* @remarks Takes the session spinlock.
3247	*/
3248	static int vgdrvSetSessionEventFilter(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
3249	uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
3250	{
3251	VMMDevCtlGuestFilterMask *pReq;
3252	uint32_t fChanged;
3253	uint32_t fPrevious;
3254	int rc;
3255
3256	/*
3257	* Preallocate a request buffer so we can do all in one go without leaving the spinlock.
3258	*/
3259	rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_CtlGuestFilterMask);
3260	if (RT_SUCCESS(rc))
3261	{ /* nothing */ }
3262	else if (!fSessionTermination)
3263	{
3264	LogRel(("vgdrvSetSessionFilterMask: VbglR0GRAlloc failure: %Rrc\n", rc));
3265	return rc;
3266	}
3267	else
3268	pReq = NULL; /* Ignore failure, we must do session cleanup. */
3269
3270
3271	RTSpinlockAcquire(pDevExt->SessionSpinlock);
3272
3273	/*
3274	* Apply the changes to the session mask.
3275	*/
3276	fPrevious = pSession->fEventFilter;
3277	pSession->fEventFilter \|= fOrMask;
3278	pSession->fEventFilter &= ~fNotMask;
3279
3280	/*
3281	* If anything actually changed, update the global usage counters.
3282	*/
3283	fChanged = fPrevious ^ pSession->fEventFilter;
3284	LogFlow(("vgdrvSetSessionEventFilter: Session->fEventFilter: %#x -> %#x (changed %#x)\n",
3285	fPrevious, pSession->fEventFilter, fChanged));
3286	if (fChanged)
3287	{
3288	bool fGlobalChange = vgdrvBitUsageTrackerChange(&pDevExt->EventFilterTracker, fChanged, fPrevious,
3289	pDevExt->cSessions, "EventFilterTracker");
3290
3291	/*
3292	* If there are global changes, update the event filter on the host.
3293	*/
3294	if (fGlobalChange \|\| pDevExt->fEventFilterHost == UINT32_MAX)
3295	{
3296	Assert(pReq \|\| fSessionTermination);
3297	if (pReq)
3298	{
3299	pReq->u32OrMask = pDevExt->fFixedEvents \| pDevExt->EventFilterTracker.fMask;
3300	if (pReq->u32OrMask == pDevExt->fEventFilterHost)
3301	rc = VINF_SUCCESS;
3302	else
3303	{
3304	pDevExt->fEventFilterHost = pReq->u32OrMask;
3305	pReq->u32NotMask = ~pReq->u32OrMask;
3306	rc = VbglR0GRPerform(&pReq->header);
3307	if (RT_FAILURE(rc))
3308	{
3309	/*
3310	* Failed, roll back (unless it's session termination time).
3311	*/
3312	pDevExt->fEventFilterHost = UINT32_MAX;
3313	if (!fSessionTermination)
3314	{
3315	vgdrvBitUsageTrackerChange(&pDevExt->EventFilterTracker, fChanged, pSession->fEventFilter,
3316	pDevExt->cSessions, "EventFilterTracker");
3317	pSession->fEventFilter = fPrevious;
3318	}
3319	}
3320	}
3321	}
3322	else
3323	rc = VINF_SUCCESS;
3324	}
3325	}
3326
3327	RTSpinlockRelease(pDevExt->SessionSpinlock);
3328	if (pReq)
3329	VbglR0GRFree(&pReq->header);
3330	return rc;
3331	}
3332
3333
3334	/**
3335	* Handle VBGL_IOCTL_CHANGE_FILTER_MASK.
3336	*
3337	* @returns VBox status code.
3338	*
3339	* @param pDevExt The device extension.
3340	* @param pSession The session.
3341	* @param pInfo The request.
3342	*/
3343	static int vgdrvIoCtl_ChangeFilterMask(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCCHANGEFILTERMASK pInfo)
3344	{
3345	LogFlow(("VBGL_IOCTL_CHANGE_FILTER_MASK: or=%#x not=%#x\n", pInfo->u.In.fOrMask, pInfo->u.In.fNotMask));
3346
3347	if ((pInfo->u.In.fOrMask \| pInfo->u.In.fNotMask) & ~VMMDEV_EVENT_VALID_EVENT_MASK)
3348	{
3349	Log(("VBGL_IOCTL_CHANGE_FILTER_MASK: or=%#x not=%#x: Invalid masks!\n", pInfo->u.In.fOrMask, pInfo->u.In.fNotMask));
3350	return VERR_INVALID_PARAMETER;
3351	}
3352
3353	return vgdrvSetSessionEventFilter(pDevExt, pSession, pInfo->u.In.fOrMask, pInfo->u.In.fNotMask, false /fSessionTermination/);
3354	}
3355
3356
3357	/**
3358	* Init and termination worker for set mouse feature status to zero on the host.
3359	*
3360	* @returns VBox status code.
3361	* @param pDevExt The device extension.
3362	*/
3363	static int vgdrvResetMouseStatusOnHost(PVBOXGUESTDEVEXT pDevExt)
3364	{
3365	VMMDevReqMouseStatus *pReq;
3366	int rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_SetMouseStatus);
3367	if (RT_SUCCESS(rc))
3368	{
3369	pReq->mouseFeatures = 0;
3370	pReq->pointerXPos = 0;
3371	pReq->pointerYPos = 0;
3372	rc = VbglR0GRPerform(&pReq->header);
3373	if (RT_FAILURE(rc))
3374	LogRelFunc(("failed with rc=%Rrc\n", rc));
3375	VbglR0GRFree(&pReq->header);
3376	}
3377	RT_NOREF1(pDevExt);
3378	return rc;
3379	}
3380
3381
3382	/**
3383	* Changes the mouse status mask for the given session.
3384	*
3385	* This is called in response to VBOXGUEST_IOCTL_SET_MOUSE_STATUS as well as to
3386	* do session cleanup.
3387	*
3388	* @returns VBox status code.
3389	* @param pDevExt The device extension.
3390	* @param pSession The session.
3391	* @param fOrMask The status flags to add.
3392	* @param fNotMask The status flags to remove.
3393	* @param fSessionTermination Set if we're called by the session cleanup code.
3394	* This tweaks the error handling so we perform
3395	* proper session cleanup even if the host
3396	* misbehaves.
3397	*
3398	* @remarks Takes the session spinlock.
3399	*/
3400	static int vgdrvSetSessionMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
3401	uint32_t fOrMask, uint32_t fNotMask, bool fSessionTermination)
3402	{
3403	VMMDevReqMouseStatus *pReq;
3404	uint32_t fChanged;
3405	uint32_t fPrevious;
3406	int rc;
3407
3408	/*
3409	* Preallocate a request buffer so we can do all in one go without leaving the spinlock.
3410	*/
3411	rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_SetMouseStatus);
3412	if (RT_SUCCESS(rc))
3413	{
3414	if (!fSessionTermination)
3415	pReq->header.fRequestor = pSession->fRequestor;
3416	}
3417	else if (!fSessionTermination)
3418	{
3419	LogRel(("vgdrvSetSessionMouseStatus: VbglR0GRAlloc failure: %Rrc\n", rc));
3420	return rc;
3421	}
3422	else
3423	pReq = NULL; /* Ignore failure, we must do session cleanup. */
3424
3425
3426	RTSpinlockAcquire(pDevExt->SessionSpinlock);
3427
3428	/*
3429	* Apply the changes to the session mask.
3430	*/
3431	fPrevious = pSession->fMouseStatus;
3432	pSession->fMouseStatus \|= fOrMask;
3433	pSession->fMouseStatus &= ~fNotMask;
3434
3435	/*
3436	* If anything actually changed, update the global usage counters.
3437	*/
3438	fChanged = fPrevious ^ pSession->fMouseStatus;
3439	if (fChanged)
3440	{
3441	bool fGlobalChange = vgdrvBitUsageTrackerChange(&pDevExt->MouseStatusTracker, fChanged, fPrevious,
3442	pDevExt->cSessions, "MouseStatusTracker");
3443
3444	/*
3445	* If there are global changes, update the event filter on the host.
3446	*/
3447	if (fGlobalChange \|\| pDevExt->fMouseStatusHost == UINT32_MAX)
3448	{
3449	Assert(pReq \|\| fSessionTermination);
3450	if (pReq)
3451	{
3452	pReq->mouseFeatures = pDevExt->MouseStatusTracker.fMask;
3453	if (pReq->mouseFeatures == pDevExt->fMouseStatusHost)
3454	rc = VINF_SUCCESS;
3455	else
3456	{
3457	pDevExt->fMouseStatusHost = pReq->mouseFeatures;
3458	pReq->pointerXPos = 0;
3459	pReq->pointerYPos = 0;
3460	rc = VbglR0GRPerform(&pReq->header);
3461	if (RT_FAILURE(rc))
3462	{
3463	/*
3464	* Failed, roll back (unless it's session termination time).
3465	*/
3466	pDevExt->fMouseStatusHost = UINT32_MAX;
3467	if (!fSessionTermination)
3468	{
3469	vgdrvBitUsageTrackerChange(&pDevExt->MouseStatusTracker, fChanged, pSession->fMouseStatus,
3470	pDevExt->cSessions, "MouseStatusTracker");
3471	pSession->fMouseStatus = fPrevious;
3472	}
3473	}
3474	}
3475	}
3476	else
3477	rc = VINF_SUCCESS;
3478	}
3479	}
3480
3481	RTSpinlockRelease(pDevExt->SessionSpinlock);
3482	if (pReq)
3483	VbglR0GRFree(&pReq->header);
3484	return rc;
3485	}
3486
3487
3488	/**
3489	* Sets the mouse status features for this session and updates them globally.
3490	*
3491	* @returns VBox status code.
3492	*
3493	* @param pDevExt The device extention.
3494	* @param pSession The session.
3495	* @param fFeatures New bitmap of enabled features.
3496	*/
3497	static int vgdrvIoCtl_SetMouseStatus(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, uint32_t fFeatures)
3498	{
3499	LogFlow(("VBGL_IOCTL_SET_MOUSE_STATUS: features=%#x\n", fFeatures));
3500
3501	if (fFeatures & ~VMMDEV_MOUSE_GUEST_MASK)
3502	return VERR_INVALID_PARAMETER;
3503
3504	return vgdrvSetSessionMouseStatus(pDevExt, pSession, fFeatures, ~fFeatures, false /fSessionTermination/);
3505	}
3506
3507
3508	/**
3509	* Return the mask of VMM device events that this session is allowed to see (wrt
3510	* to "acquire" mode guest capabilities).
3511	*
3512	* The events associated with guest capabilities in "acquire" mode will be
3513	* restricted to sessions which has acquired the respective capabilities.
3514	* If someone else tries to wait for acquired events, they won't be woken up
3515	* when the event becomes pending. Should some other thread in the session
3516	* acquire the capability while the corresponding event is pending, the waiting
3517	* thread will woken up.
3518	*
3519	* @returns Mask of events valid for the given session.
3520	* @param pDevExt The device extension.
3521	* @param pSession The session.
3522	*
3523	* @remarks Needs only be called when dispatching events in the
3524	* VBOXGUEST_ACQUIRE_STYLE_EVENTS mask.
3525	*/
3526	static uint32_t vgdrvGetAllowedEventMaskForSession(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession)
3527	{
3528	uint32_t fAcquireModeGuestCaps;
3529	uint32_t fAcquiredGuestCaps;
3530	uint32_t fAllowedEvents;
3531
3532	/*
3533	* Note! Reads pSession->fAcquiredGuestCaps and pDevExt->fAcquireModeGuestCaps
3534	* WITHOUT holding VBOXGUESTDEVEXT::SessionSpinlock.
3535	*/
3536	fAcquireModeGuestCaps = ASMAtomicUoReadU32(&pDevExt->fAcquireModeGuestCaps);
3537	if (fAcquireModeGuestCaps == 0)
3538	return VMMDEV_EVENT_VALID_EVENT_MASK;
3539	fAcquiredGuestCaps = ASMAtomicUoReadU32(&pSession->fAcquiredGuestCaps);
3540
3541	/*
3542	* Calculate which events to allow according to the cap config and caps
3543	* acquired by the session.
3544	*/
3545	fAllowedEvents = VMMDEV_EVENT_VALID_EVENT_MASK;
3546	if ( !(fAcquiredGuestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS)
3547	&& (fAcquireModeGuestCaps & VMMDEV_GUEST_SUPPORTS_GRAPHICS))
3548	fAllowedEvents &= ~VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
3549
3550	if ( !(fAcquiredGuestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS)
3551	&& (fAcquireModeGuestCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS))
3552	fAllowedEvents &= ~VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
3553
3554	return fAllowedEvents;
3555	}
3556
3557
3558	/**
3559	* Init and termination worker for set guest capabilities to zero on the host.
3560	*
3561	* @returns VBox status code.
3562	* @param pDevExt The device extension.
3563	*/
3564	static int vgdrvResetCapabilitiesOnHost(PVBOXGUESTDEVEXT pDevExt)
3565	{
3566	VMMDevReqGuestCapabilities2 *pReq;
3567	int rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_SetGuestCapabilities);
3568	if (RT_SUCCESS(rc))
3569	{
3570	pReq->u32NotMask = UINT32_MAX;
3571	pReq->u32OrMask = 0;
3572	rc = VbglR0GRPerform(&pReq->header);
3573
3574	if (RT_FAILURE(rc))
3575	LogRelFunc(("failed with rc=%Rrc\n", rc));
3576	VbglR0GRFree(&pReq->header);
3577	}
3578	RT_NOREF1(pDevExt);
3579	return rc;
3580	}
3581
3582
3583	/**
3584	* Sets the guest capabilities to the host while holding the lock.
3585	*
3586	* This will ASSUME that we're the ones in charge of the mask, so
3587	* we'll simply clear all bits we don't set.
3588	*
3589	* @returns VBox status code.
3590	* @param pDevExt The device extension.
3591	* @param pReq The request.
3592	*/
3593	static int vgdrvUpdateCapabilitiesOnHostWithReqAndLock(PVBOXGUESTDEVEXT pDevExt, VMMDevReqGuestCapabilities2 *pReq)
3594	{
3595	int rc;
3596
3597	pReq->u32OrMask = pDevExt->fAcquiredGuestCaps \| pDevExt->SetGuestCapsTracker.fMask;
3598	if (pReq->u32OrMask == pDevExt->fGuestCapsHost)
3599	rc = VINF_SUCCESS;
3600	else
3601	{
3602	pDevExt->fGuestCapsHost = pReq->u32OrMask;
3603	pReq->u32NotMask = ~pReq->u32OrMask;
3604	rc = VbglR0GRPerform(&pReq->header);
3605	if (RT_FAILURE(rc))
3606	pDevExt->fGuestCapsHost = UINT32_MAX;
3607	}
3608
3609	return rc;
3610	}
3611
3612
3613	/**
3614	* Switch a set of capabilities into "acquire" mode and (maybe) acquire them for
3615	* the given session.
3616	*
3617	* This is called in response to VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE as well as
3618	* to do session cleanup.
3619	*
3620	* @returns VBox status code.
3621	* @param pDevExt The device extension.
3622	* @param pSession The session.
3623	* @param fOrMask The capabilities to add .
3624	* @param fNotMask The capabilities to remove. Ignored in
3625	* VBOXGUESTCAPSACQUIRE_FLAGS_CONFIG_ACQUIRE_MODE.
3626	* @param fFlags Confusing operation modifier.
3627	* VBOXGUESTCAPSACQUIRE_FLAGS_NONE means to both
3628	* configure and acquire/release the capabilities.
3629	* VBOXGUESTCAPSACQUIRE_FLAGS_CONFIG_ACQUIRE_MODE
3630	* means only configure capabilities in the
3631	* @a fOrMask capabilities for "acquire" mode.
3632	* @param fSessionTermination Set if we're called by the session cleanup code.
3633	* This tweaks the error handling so we perform
3634	* proper session cleanup even if the host
3635	* misbehaves.
3636	*
3637	* @remarks Takes both the session and event spinlocks.
3638	*/
3639	static int vgdrvAcquireSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
3640	uint32_t fOrMask, uint32_t fNotMask, uint32_t fFlags,
3641	bool fSessionTermination)
3642	{
3643	uint32_t fCurrentOwnedCaps;
3644	uint32_t fSessionRemovedCaps;
3645	uint32_t fSessionAddedCaps;
3646	uint32_t fOtherConflictingCaps;
3647	VMMDevReqGuestCapabilities2 *pReq = NULL;
3648	int rc;
3649
3650
3651	/*
3652	* Validate and adjust input.
3653	*/
3654	if (fOrMask & ~( VMMDEV_GUEST_SUPPORTS_SEAMLESS
3655	\| VMMDEV_GUEST_SUPPORTS_GUEST_HOST_WINDOW_MAPPING
3656	\| VMMDEV_GUEST_SUPPORTS_GRAPHICS ) )
3657	{
3658	LogRel(("vgdrvAcquireSessionCapabilities: invalid fOrMask=%#x (pSession=%p fNotMask=%#x fFlags=%#x)\n",
3659	fOrMask, pSession, fNotMask, fFlags));
3660	return VERR_INVALID_PARAMETER;
3661	}
3662
3663	if ((fFlags & ~VBGL_IOC_AGC_FLAGS_VALID_MASK) != 0)
3664	{
3665	LogRel(("vgdrvAcquireSessionCapabilities: invalid fFlags=%#x (pSession=%p fOrMask=%#x fNotMask=%#x)\n",
3666	fFlags, pSession, fOrMask, fNotMask));
3667	return VERR_INVALID_PARAMETER;
3668	}
3669	Assert(!fOrMask \|\| !fSessionTermination);
3670
3671	/* The fNotMask no need to have all values valid, invalid ones will simply be ignored. */
3672	fNotMask &= ~fOrMask;
3673
3674	/*
3675	* Preallocate a update request if we're about to do more than just configure
3676	* the capability mode.
3677	*/
3678	if (!(fFlags & VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE))
3679	{
3680	rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_SetGuestCapabilities);
3681	if (RT_SUCCESS(rc))
3682	{
3683	if (!fSessionTermination)
3684	pReq->header.fRequestor = pSession->fRequestor;
3685	}
3686	else if (!fSessionTermination)
3687	{
3688	LogRel(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x fFlags=%#x: VbglR0GRAlloc failure: %Rrc\n",
3689	pSession, fOrMask, fNotMask, fFlags, rc));
3690	return rc;
3691	}
3692	else
3693	pReq = NULL; /* Ignore failure, we must do session cleanup. */
3694	}
3695
3696	/*
3697	* Try switch the capabilities in the OR mask into "acquire" mode.
3698	*
3699	* Note! We currently ignore anyone which may already have "set" the capabilities
3700	* in fOrMask. Perhaps not the best way to handle it, but it's simple...
3701	*/
3702	RTSpinlockAcquire(pDevExt->EventSpinlock);
3703
3704	if (!(pDevExt->fSetModeGuestCaps & fOrMask))
3705	pDevExt->fAcquireModeGuestCaps \|= fOrMask;
3706	else
3707	{
3708	RTSpinlockRelease(pDevExt->EventSpinlock);
3709
3710	if (pReq)
3711	VbglR0GRFree(&pReq->header);
3712	AssertMsgFailed(("Trying to change caps mode: %#x\n", fOrMask));
3713	LogRel(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x fFlags=%#x: calling caps acquire for set caps\n",
3714	pSession, fOrMask, fNotMask, fFlags));
3715	return VERR_INVALID_STATE;
3716	}
3717
3718	/*
3719	* If we only wanted to switch the capabilities into "acquire" mode, we're done now.
3720	*/
3721	if (fFlags & VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE)
3722	{
3723	RTSpinlockRelease(pDevExt->EventSpinlock);
3724
3725	Assert(!pReq);
3726	Log(("vgdrvAcquireSessionCapabilities: pSession=%p fOrMask=%#x fNotMask=%#x fFlags=%#x: configured acquire caps: 0x%x\n",
3727	pSession, fOrMask, fNotMask, fFlags));
3728	return VINF_SUCCESS;
3729	}
3730	Assert(pReq \|\| fSessionTermination);
3731
3732	/*
3733	* Caller wants to acquire/release the capabilities too.
3734	*
3735	* Note! The mode change of the capabilities above won't be reverted on
3736	* failure, this is intentional.
3737	*/
3738	fCurrentOwnedCaps = pSession->fAcquiredGuestCaps;
3739	fSessionRemovedCaps = fCurrentOwnedCaps & fNotMask;
3740	fSessionAddedCaps = fOrMask & ~fCurrentOwnedCaps;
3741	fOtherConflictingCaps = pDevExt->fAcquiredGuestCaps & ~fCurrentOwnedCaps;
3742	fOtherConflictingCaps &= fSessionAddedCaps;
3743
3744	if (!fOtherConflictingCaps)
3745	{
3746	if (fSessionAddedCaps)
3747	{
3748	pSession->fAcquiredGuestCaps \|= fSessionAddedCaps;
3749	pDevExt->fAcquiredGuestCaps \|= fSessionAddedCaps;
3750	}
3751
3752	if (fSessionRemovedCaps)
3753	{
3754	pSession->fAcquiredGuestCaps &= ~fSessionRemovedCaps;
3755	pDevExt->fAcquiredGuestCaps &= ~fSessionRemovedCaps;
3756	}
3757
3758	/*
3759	* If something changes (which is very likely), tell the host.
3760	*/
3761	if (fSessionAddedCaps \|\| fSessionRemovedCaps \|\| pDevExt->fGuestCapsHost == UINT32_MAX)
3762	{
3763	Assert(pReq \|\| fSessionTermination);
3764	if (pReq)
3765	{
3766	rc = vgdrvUpdateCapabilitiesOnHostWithReqAndLock(pDevExt, pReq);
3767	if (RT_FAILURE(rc) && !fSessionTermination)
3768	{
3769	/* Failed, roll back. */
3770	if (fSessionAddedCaps)
3771	{
3772	pSession->fAcquiredGuestCaps &= ~fSessionAddedCaps;
3773	pDevExt->fAcquiredGuestCaps &= ~fSessionAddedCaps;
3774	}
3775	if (fSessionRemovedCaps)
3776	{
3777	pSession->fAcquiredGuestCaps \|= fSessionRemovedCaps;
3778	pDevExt->fAcquiredGuestCaps \|= fSessionRemovedCaps;
3779	}
3780
3781	RTSpinlockRelease(pDevExt->EventSpinlock);
3782	LogRel(("vgdrvAcquireSessionCapabilities: vgdrvUpdateCapabilitiesOnHostWithReqAndLock failed: rc=%Rrc\n", rc));
3783	VbglR0GRFree(&pReq->header);
3784	return rc;
3785	}
3786	}
3787	}
3788	}
3789	else
3790	{
3791	RTSpinlockRelease(pDevExt->EventSpinlock);
3792
3793	Log(("vgdrvAcquireSessionCapabilities: Caps %#x were busy\n", fOtherConflictingCaps));
3794	VbglR0GRFree(&pReq->header);
3795	return VERR_RESOURCE_BUSY;
3796	}
3797
3798	RTSpinlockRelease(pDevExt->EventSpinlock);
3799	if (pReq)
3800	VbglR0GRFree(&pReq->header);
3801
3802	/*
3803	* If we added a capability, check if that means some other thread in our
3804	* session should be unblocked because there are events pending.
3805	*
3806	* HACK ALERT! When the seamless support capability is added we generate a
3807	* seamless change event so that the ring-3 client can sync with
3808	* the seamless state. Although this introduces a spurious
3809	* wakeups of the ring-3 client, it solves the problem of client
3810	* state inconsistency in multiuser environment (on Windows).
3811	*/
3812	if (fSessionAddedCaps)
3813	{
3814	uint32_t fGenFakeEvents = 0;
3815	if (fSessionAddedCaps & VMMDEV_GUEST_SUPPORTS_SEAMLESS)
3816	fGenFakeEvents \|= VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
3817
3818	RTSpinlockAcquire(pDevExt->EventSpinlock);
3819	if (fGenFakeEvents \|\| pDevExt->f32PendingEvents)
3820	vgdrvDispatchEventsLocked(pDevExt, fGenFakeEvents);
3821	RTSpinlockRelease(pDevExt->EventSpinlock);
3822
3823	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
3824	VGDrvCommonWaitDoWakeUps(pDevExt);
3825	#endif
3826	}
3827
3828	return VINF_SUCCESS;
3829	}
3830
3831
3832	/**
3833	* Handle VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES.
3834	*
3835	* @returns VBox status code.
3836	*
3837	* @param pDevExt The device extension.
3838	* @param pSession The session.
3839	* @param pAcquire The request.
3840	*/
3841	static int vgdrvIoCtl_GuestCapsAcquire(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCACQUIREGUESTCAPS pAcquire)
3842	{
3843	int rc;
3844	LogFlow(("VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES: or=%#x not=%#x flags=%#x\n",
3845	pAcquire->u.In.fOrMask, pAcquire->u.In.fNotMask, pAcquire->u.In.fFlags));
3846
3847	rc = vgdrvAcquireSessionCapabilities(pDevExt, pSession, pAcquire->u.In.fOrMask, pAcquire->u.In.fNotMask,
3848	pAcquire->u.In.fFlags, false /fSessionTermination/);
3849	if (RT_FAILURE(rc))
3850	LogRel(("VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES failed rc=%Rrc\n", rc));
3851	return rc;
3852	}
3853
3854
3855	/**
3856	* Sets the guest capabilities for a session.
3857	*
3858	* @returns VBox status code.
3859	* @param pDevExt The device extension.
3860	* @param pSession The session.
3861	* @param fOrMask The capabilities to add.
3862	* @param fNotMask The capabilities to remove.
3863	* @param pfSessionCaps Where to return the guest capabilities reported
3864	* for this session. Optional.
3865	* @param pfGlobalCaps Where to return the guest capabilities reported
3866	* for all the sessions. Optional.
3867	*
3868	* @param fSessionTermination Set if we're called by the session cleanup code.
3869	* This tweaks the error handling so we perform
3870	* proper session cleanup even if the host
3871	* misbehaves.
3872	*
3873	* @remarks Takes the session spinlock.
3874	*/
3875	static int vgdrvSetSessionCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession,
3876	uint32_t fOrMask, uint32_t fNotMask, uint32_t pfSessionCaps, uint32_t pfGlobalCaps,
3877	bool fSessionTermination)
3878	{
3879	/*
3880	* Preallocate a request buffer so we can do all in one go without leaving the spinlock.
3881	*/
3882	VMMDevReqGuestCapabilities2 *pReq;
3883	int rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReq, sizeof(pReq), VMMDevReq_SetGuestCapabilities);
3884	if (RT_SUCCESS(rc))
3885	{
3886	if (!fSessionTermination)
3887	pReq->header.fRequestor = pSession->fRequestor;
3888	}
3889	else if (!fSessionTermination)
3890	{
3891	if (pfSessionCaps)
3892	*pfSessionCaps = UINT32_MAX;
3893	if (pfGlobalCaps)
3894	*pfGlobalCaps = UINT32_MAX;
3895	LogRel(("vgdrvSetSessionCapabilities: VbglR0GRAlloc failure: %Rrc\n", rc));
3896	return rc;
3897	}
3898	else
3899	pReq = NULL; /* Ignore failure, we must do session cleanup. */
3900
3901
3902	RTSpinlockAcquire(pDevExt->SessionSpinlock);
3903
3904	#ifndef VBOXGUEST_DISREGARD_ACQUIRE_MODE_GUEST_CAPS
3905	/*
3906	* Capabilities in "acquire" mode cannot be set via this API.
3907	* (Acquire mode is only used on windows at the time of writing.)
3908	*/
3909	if (!(fOrMask & pDevExt->fAcquireModeGuestCaps))
3910	#endif
3911	{
3912	/*
3913	* Apply the changes to the session mask.
3914	*/
3915	uint32_t fChanged;
3916	uint32_t fPrevious = pSession->fCapabilities;
3917	pSession->fCapabilities \|= fOrMask;
3918	pSession->fCapabilities &= ~fNotMask;
3919
3920	/*
3921	* If anything actually changed, update the global usage counters.
3922	*/
3923	fChanged = fPrevious ^ pSession->fCapabilities;
3924	if (fChanged)
3925	{
3926	bool fGlobalChange = vgdrvBitUsageTrackerChange(&pDevExt->SetGuestCapsTracker, fChanged, fPrevious,
3927	pDevExt->cSessions, "SetGuestCapsTracker");
3928
3929	/*
3930	* If there are global changes, update the capabilities on the host.
3931	*/
3932	if (fGlobalChange \|\| pDevExt->fGuestCapsHost == UINT32_MAX)
3933	{
3934	Assert(pReq \|\| fSessionTermination);
3935	if (pReq)
3936	{
3937	rc = vgdrvUpdateCapabilitiesOnHostWithReqAndLock(pDevExt, pReq);
3938
3939	/* On failure, roll back (unless it's session termination time). */
3940	if (RT_FAILURE(rc) && !fSessionTermination)
3941	{
3942	vgdrvBitUsageTrackerChange(&pDevExt->SetGuestCapsTracker, fChanged, pSession->fCapabilities,
3943	pDevExt->cSessions, "SetGuestCapsTracker");
3944	pSession->fCapabilities = fPrevious;
3945	}
3946	}
3947	}
3948	}
3949	}
3950	#ifndef VBOXGUEST_DISREGARD_ACQUIRE_MODE_GUEST_CAPS
3951	else
3952	rc = VERR_RESOURCE_BUSY;
3953	#endif
3954
3955	if (pfSessionCaps)
3956	*pfSessionCaps = pSession->fCapabilities;
3957	if (pfGlobalCaps)
3958	*pfGlobalCaps = pDevExt->fAcquiredGuestCaps \| pDevExt->SetGuestCapsTracker.fMask;
3959
3960	RTSpinlockRelease(pDevExt->SessionSpinlock);
3961	if (pReq)
3962	VbglR0GRFree(&pReq->header);
3963	return rc;
3964	}
3965
3966
3967	/**
3968	* Handle VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES.
3969	*
3970	* @returns VBox status code.
3971	*
3972	* @param pDevExt The device extension.
3973	* @param pSession The session.
3974	* @param pInfo The request.
3975	*/
3976	static int vgdrvIoCtl_SetCapabilities(PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLIOCSETGUESTCAPS pInfo)
3977	{
3978	int rc;
3979	LogFlow(("VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES: or=%#x not=%#x\n", pInfo->u.In.fOrMask, pInfo->u.In.fNotMask));
3980
3981	if (!((pInfo->u.In.fOrMask \| pInfo->u.In.fNotMask) & ~VMMDEV_GUEST_CAPABILITIES_MASK))
3982	rc = vgdrvSetSessionCapabilities(pDevExt, pSession, pInfo->u.In.fOrMask, pInfo->u.In.fNotMask,
3983	&pInfo->u.Out.fSessionCaps, &pInfo->u.Out.fGlobalCaps, false /fSessionTermination/);
3984	else
3985	rc = VERR_INVALID_PARAMETER;
3986
3987	return rc;
3988	}
3989
3990	/** @} */
3991
3992
3993	/**
3994	* Common IOCtl for user to kernel and kernel to kernel communication.
3995	*
3996	* This function only does the basic validation and then invokes
3997	* worker functions that takes care of each specific function.
3998	*
3999	* @returns VBox status code.
4000	*
4001	* @param iFunction The requested function.
4002	* @param pDevExt The device extension.
4003	* @param pSession The client session.
4004	* @param pReqHdr Pointer to the request. This always starts with
4005	* a request common header.
4006	* @param cbReq The max size of the request buffer.
4007	*/
4008	int VGDrvCommonIoCtl(uintptr_t iFunction, PVBOXGUESTDEVEXT pDevExt, PVBOXGUESTSESSION pSession, PVBGLREQHDR pReqHdr, size_t cbReq)
4009	{
4010	uintptr_t const iFunctionStripped = VBGL_IOCTL_CODE_STRIPPED(iFunction);
4011	int rc;
4012
4013	LogFlow(("VGDrvCommonIoCtl: iFunction=%#x pDevExt=%p pSession=%p pReqHdr=%p cbReq=%zu\n",
4014	iFunction, pDevExt, pSession, pReqHdr, cbReq));
4015
4016	/*
4017	* Define some helper macros to simplify validation.
4018	*/
4019	#define REQ_CHECK_SIZES_EX(Name, cbInExpect, cbOutExpect) \
4020	do { \
4021	if (RT_LIKELY( pReqHdr->cbIn == (cbInExpect) \
4022	&& ( pReqHdr->cbOut == (cbOutExpect) \
4023	\|\| ((cbInExpect) == (cbOutExpect) && pReqHdr->cbOut == 0) ) )) \
4024	{ /* likely */ } \
4025	else \
4026	{ \
4027	Log(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld. cbOut=%ld expected %ld.\n", \
4028	(long)pReqHdr->cbIn, (long)(cbInExpect), (long)pReqHdr->cbOut, (long)(cbOutExpect))); \
4029	return pReqHdr->rc = VERR_INVALID_PARAMETER; \
4030	} \
4031	} while (0)
4032
4033	#define REQ_CHECK_SIZES(Name) REQ_CHECK_SIZES_EX(Name, Name ## _SIZE_IN, Name ## _SIZE_OUT)
4034
4035	#define REQ_CHECK_SIZE_IN(Name, cbInExpect) \
4036	do { \
4037	if (RT_LIKELY(pReqHdr->cbIn == (cbInExpect))) \
4038	{ /* likely */ } \
4039	else \
4040	{ \
4041	Log(( #Name ": Invalid input/output sizes. cbIn=%ld expected %ld.\n", \
4042	(long)pReqHdr->cbIn, (long)(cbInExpect))); \
4043	return pReqHdr->rc = VERR_INVALID_PARAMETER; \
4044	} \
4045	} while (0)
4046
4047	#define REQ_CHECK_SIZE_OUT(Name, cbOutExpect) \
4048	do { \
4049	if (RT_LIKELY( pReqHdr->cbOut == (cbOutExpect) \
4050	\|\| (pReqHdr->cbOut == 0 && pReqHdr->cbIn == (cbOutExpect)))) \
4051	{ /* likely */ } \
4052	else \
4053	{ \
4054	Log(( #Name ": Invalid input/output sizes. cbOut=%ld (%ld) expected %ld.\n", \
4055	(long)pReqHdr->cbOut, (long)pReqHdr->cbIn, (long)(cbOutExpect))); \
4056	return pReqHdr->rc = VERR_INVALID_PARAMETER; \
4057	} \
4058	} while (0)
4059
4060	#define REQ_CHECK_EXPR(Name, expr) \
4061	do { \
4062	if (RT_LIKELY(!!(expr))) \
4063	{ /* likely */ } \
4064	else \
4065	{ \
4066	Log(( #Name ": %s\n", #expr)); \
4067	return pReqHdr->rc = VERR_INVALID_PARAMETER; \
4068	} \
4069	} while (0)
4070
4071	#define REQ_CHECK_EXPR_FMT(expr, fmt) \
4072	do { \
4073	if (RT_LIKELY(!!(expr))) \
4074	{ /* likely */ } \
4075	else \
4076	{ \
4077	Log( fmt ); \
4078	return pReqHdr->rc = VERR_INVALID_PARAMETER; \
4079	} \
4080	} while (0)
4081
4082	#define REQ_CHECK_RING0(mnemonic) \
4083	do { \
4084	if (pSession->R0Process != NIL_RTR0PROCESS) \
4085	{ \
4086	LogFunc((mnemonic ": Ring-0 only, caller is %RTproc/%p\n", \
4087	pSession->Process, (uintptr_t)pSession->R0Process)); \
4088	return pReqHdr->rc = VERR_PERMISSION_DENIED; \
4089	} \
4090	} while (0)
4091
4092
4093	/*
4094	* Validate the request.
4095	*/
4096	if (RT_LIKELY(cbReq >= sizeof(*pReqHdr)))
4097	{ /* likely */ }
4098	else
4099	{
4100	Log(("VGDrvCommonIoCtl: Bad ioctl request size; cbReq=%#lx\n", (long)cbReq));
4101	return VERR_INVALID_PARAMETER;
4102	}
4103
4104	if (pReqHdr->cbOut == 0)
4105	pReqHdr->cbOut = pReqHdr->cbIn;
4106
4107	if (RT_LIKELY( pReqHdr->uVersion == VBGLREQHDR_VERSION
4108	&& pReqHdr->cbIn >= sizeof(*pReqHdr)
4109	&& pReqHdr->cbIn <= cbReq
4110	&& pReqHdr->cbOut >= sizeof(*pReqHdr)
4111	&& pReqHdr->cbOut <= cbReq))
4112	{ /* likely */ }
4113	else
4114	{
4115	Log(("VGDrvCommonIoCtl: Bad ioctl request header; cbIn=%#lx cbOut=%#lx version=%#lx\n",
4116	(long)pReqHdr->cbIn, (long)pReqHdr->cbOut, (long)pReqHdr->uVersion));
4117	return VERR_INVALID_PARAMETER;
4118	}
4119
4120	if (RT_LIKELY(RT_VALID_PTR(pSession)))
4121	{ /* likely */ }
4122	else
4123	{
4124	Log(("VGDrvCommonIoCtl: Invalid pSession value %p (ioctl=%#x)\n", pSession, iFunction));
4125	return VERR_INVALID_PARAMETER;
4126	}
4127
4128
4129	/*
4130	* Deal with variably sized requests first.
4131	*/
4132	rc = VINF_SUCCESS;
4133	if ( iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_VMMDEV_REQUEST(0))
4134	\|\| iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_VMMDEV_REQUEST_BIG) )
4135	{
4136	REQ_CHECK_EXPR(VBGL_IOCTL_VMMDEV_REQUEST, pReqHdr->uType != VBGLREQHDR_TYPE_DEFAULT);
4137	REQ_CHECK_EXPR_FMT(pReqHdr->cbIn == pReqHdr->cbOut,
4138	("VBGL_IOCTL_VMMDEV_REQUEST: cbIn=%ld != cbOut=%ld\n", (long)pReqHdr->cbIn, (long)pReqHdr->cbOut));
4139	pReqHdr->rc = vgdrvIoCtl_VMMDevRequest(pDevExt, pSession, (VMMDevRequestHeader *)pReqHdr, cbReq);
4140	}
4141	else if (RT_LIKELY(pReqHdr->uType == VBGLREQHDR_TYPE_DEFAULT))
4142	{
4143	if (iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_LOG(0)))
4144	{
4145	REQ_CHECK_SIZE_OUT(VBGL_IOCTL_LOG, VBGL_IOCTL_LOG_SIZE_OUT);
4146	pReqHdr->rc = vgdrvIoCtl_Log(pDevExt, &((PVBGLIOCLOG)pReqHdr)->u.In.szMsg[0], pReqHdr->cbIn - sizeof(VBGLREQHDR),
4147	pSession->fUserSession);
4148	}
4149	#ifdef VBOX_WITH_HGCM
4150	else if (iFunction == VBGL_IOCTL_IDC_HGCM_FAST_CALL) /* (is variable size, but we don't bother encoding it) */
4151	{
4152	REQ_CHECK_RING0("VBGL_IOCTL_IDC_HGCM_FAST_CALL");
4153	REQ_CHECK_EXPR(VBGL_IOCTL_IDC_HGCM_FAST_CALL, cbReq >= sizeof(VBGLIOCIDCHGCMFASTCALL) + sizeof(VMMDevHGCMCall));
4154	pReqHdr->rc = vgdrvIoCtl_HGCMFastCall(pDevExt, (VBGLIOCIDCHGCMFASTCALL volatile *)pReqHdr);
4155	}
4156	else if ( iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL(0))
4157	# if ARCH_BITS == 64
4158	\|\| iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL_32(0))
4159	# endif
4160	)
4161	{
4162	REQ_CHECK_EXPR(VBGL_IOCTL_HGCM_CALL, pReqHdr->cbIn >= sizeof(VBGLIOCHGCMCALL));
4163	REQ_CHECK_EXPR(VBGL_IOCTL_HGCM_CALL, pReqHdr->cbIn == pReqHdr->cbOut);
4164	pReqHdr->rc = vgdrvIoCtl_HGCMCallWrapper(pDevExt, pSession, (PVBGLIOCHGCMCALL)pReqHdr,
4165	iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL_32(0)),
4166	false /fUserData/, cbReq);
4167	}
4168	else if (iFunctionStripped == VBGL_IOCTL_CODE_STRIPPED(VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA(0)))
4169	{
4170	REQ_CHECK_RING0("VBGL_IOCTL_HGCM_CALL_WITH_USER_DATA");
4171	REQ_CHECK_EXPR(VBGL_IOCTL_HGCM_CALL, pReqHdr->cbIn >= sizeof(VBGLIOCHGCMCALL));
4172	REQ_CHECK_EXPR(VBGL_IOCTL_HGCM_CALL, pReqHdr->cbIn == pReqHdr->cbOut);
4173	pReqHdr->rc = vgdrvIoCtl_HGCMCallWrapper(pDevExt, pSession, (PVBGLIOCHGCMCALL)pReqHdr,
4174	ARCH_BITS == 32, true /fUserData/, cbReq);
4175	}
4176	#endif /* VBOX_WITH_HGCM */
4177	else
4178	{
4179	switch (iFunction)
4180	{
4181	/*
4182	* Ring-0 only:
4183	*/
4184	case VBGL_IOCTL_IDC_CONNECT:
4185	REQ_CHECK_RING0("VBGL_IOCL_IDC_CONNECT");
4186	REQ_CHECK_SIZES(VBGL_IOCTL_IDC_CONNECT);
4187	pReqHdr->rc = vgdrvIoCtl_IdcConnect(pDevExt, pSession, (PVBGLIOCIDCCONNECT)pReqHdr);
4188	break;
4189
4190	case VBGL_IOCTL_IDC_DISCONNECT:
4191	REQ_CHECK_RING0("VBGL_IOCTL_IDC_DISCONNECT");
4192	REQ_CHECK_SIZES(VBGL_IOCTL_IDC_DISCONNECT);
4193	pReqHdr->rc = vgdrvIoCtl_IdcDisconnect(pDevExt, pSession, (PVBGLIOCIDCDISCONNECT)pReqHdr);
4194	break;
4195
4196	case VBGL_IOCTL_GET_VMMDEV_IO_INFO:
4197	REQ_CHECK_RING0("GET_VMMDEV_IO_INFO");
4198	REQ_CHECK_SIZES(VBGL_IOCTL_GET_VMMDEV_IO_INFO);
4199	pReqHdr->rc = vgdrvIoCtl_GetVMMDevIoInfo(pDevExt, (PVBGLIOCGETVMMDEVIOINFO)pReqHdr);
4200	break;
4201
4202	case VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK:
4203	REQ_CHECK_RING0("SET_MOUSE_NOTIFY_CALLBACK");
4204	REQ_CHECK_SIZES(VBGL_IOCTL_SET_MOUSE_NOTIFY_CALLBACK);
4205	pReqHdr->rc = vgdrvIoCtl_SetMouseNotifyCallback(pDevExt, (PVBGLIOCSETMOUSENOTIFYCALLBACK)pReqHdr);
4206	break;
4207
4208	/*
4209	* Ring-3 only:
4210	*/
4211	case VBGL_IOCTL_DRIVER_VERSION_INFO:
4212	REQ_CHECK_SIZES(VBGL_IOCTL_DRIVER_VERSION_INFO);
4213	pReqHdr->rc = vgdrvIoCtl_DriverVersionInfo(pDevExt, pSession, (PVBGLIOCDRIVERVERSIONINFO)pReqHdr);
4214	break;
4215
4216	/*
4217	* Both ring-3 and ring-0:
4218	*/
4219	case VBGL_IOCTL_WAIT_FOR_EVENTS:
4220	REQ_CHECK_SIZES(VBGL_IOCTL_WAIT_FOR_EVENTS);
4221	pReqHdr->rc = vgdrvIoCtl_WaitForEvents(pDevExt, pSession, (VBGLIOCWAITFOREVENTS *)pReqHdr,
4222	pSession->R0Process != NIL_RTR0PROCESS);
4223	break;
4224
4225	case VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS:
4226	REQ_CHECK_SIZES(VBGL_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS);
4227	pReqHdr->rc = vgdrvIoCtl_CancelAllWaitEvents(pDevExt, pSession);
4228	break;
4229
4230	case VBGL_IOCTL_CHANGE_FILTER_MASK:
4231	REQ_CHECK_SIZES(VBGL_IOCTL_CHANGE_FILTER_MASK);
4232	pReqHdr->rc = vgdrvIoCtl_ChangeFilterMask(pDevExt, pSession, (PVBGLIOCCHANGEFILTERMASK)pReqHdr);
4233	break;
4234
4235	#ifdef VBOX_WITH_HGCM
4236	case VBGL_IOCTL_HGCM_CONNECT:
4237	REQ_CHECK_SIZES(VBGL_IOCTL_HGCM_CONNECT);
4238	pReqHdr->rc = vgdrvIoCtl_HGCMConnect(pDevExt, pSession, (PVBGLIOCHGCMCONNECT)pReqHdr);
4239	break;
4240
4241	case VBGL_IOCTL_HGCM_DISCONNECT:
4242	REQ_CHECK_SIZES(VBGL_IOCTL_HGCM_DISCONNECT);
4243	pReqHdr->rc = vgdrvIoCtl_HGCMDisconnect(pDevExt, pSession, (PVBGLIOCHGCMDISCONNECT)pReqHdr);
4244	break;
4245	#endif
4246
4247	case VBGL_IOCTL_CHECK_BALLOON:
4248	REQ_CHECK_SIZES(VBGL_IOCTL_CHECK_BALLOON);
4249	pReqHdr->rc = vgdrvIoCtl_CheckMemoryBalloon(pDevExt, pSession, (PVBGLIOCCHECKBALLOON)pReqHdr);
4250	break;
4251
4252	case VBGL_IOCTL_CHANGE_BALLOON:
4253	REQ_CHECK_SIZES(VBGL_IOCTL_CHANGE_BALLOON);
4254	pReqHdr->rc = vgdrvIoCtl_ChangeMemoryBalloon(pDevExt, pSession, (PVBGLIOCCHANGEBALLOON)pReqHdr);
4255	break;
4256
4257	case VBGL_IOCTL_WRITE_CORE_DUMP:
4258	REQ_CHECK_SIZES(VBGL_IOCTL_WRITE_CORE_DUMP);
4259	pReqHdr->rc = vgdrvIoCtl_WriteCoreDump(pDevExt, pSession, (PVBGLIOCWRITECOREDUMP)pReqHdr);
4260	break;
4261
4262	case VBGL_IOCTL_SET_MOUSE_STATUS:
4263	REQ_CHECK_SIZES(VBGL_IOCTL_SET_MOUSE_STATUS);
4264	pReqHdr->rc = vgdrvIoCtl_SetMouseStatus(pDevExt, pSession, ((PVBGLIOCSETMOUSESTATUS)pReqHdr)->u.In.fStatus);
4265	break;
4266
4267	case VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES:
4268	REQ_CHECK_SIZES(VBGL_IOCTL_ACQUIRE_GUEST_CAPABILITIES);
4269	pReqHdr->rc = vgdrvIoCtl_GuestCapsAcquire(pDevExt, pSession, (PVBGLIOCACQUIREGUESTCAPS)pReqHdr);
4270	break;
4271
4272	case VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES:
4273	REQ_CHECK_SIZES(VBGL_IOCTL_CHANGE_GUEST_CAPABILITIES);
4274	pReqHdr->rc = vgdrvIoCtl_SetCapabilities(pDevExt, pSession, (PVBGLIOCSETGUESTCAPS)pReqHdr);
4275	break;
4276
4277	#ifdef VBOX_WITH_DPC_LATENCY_CHECKER
4278	case VBGL_IOCTL_DPC_LATENCY_CHECKER:
4279	REQ_CHECK_SIZES(VBGL_IOCTL_DPC_LATENCY_CHECKER);
4280	pReqHdr->rc = VGDrvNtIOCtl_DpcLatencyChecker();
4281	break;
4282	#endif
4283
4284	default:
4285	{
4286	LogRel(("VGDrvCommonIoCtl: Unknown request iFunction=%#x (stripped %#x) cbReq=%#x\n",
4287	iFunction, iFunctionStripped, cbReq));
4288	pReqHdr->rc = rc = VERR_NOT_SUPPORTED;
4289	break;
4290	}
4291	}
4292	}
4293	}
4294	else
4295	{
4296	Log(("VGDrvCommonIoCtl: uType=%#x, expected default (ioctl=%#x)\n", pReqHdr->uType, iFunction));
4297	return VERR_INVALID_PARAMETER;
4298	}
4299
4300	LogFlow(("VGDrvCommonIoCtl: returns %Rrc (req: rc=%Rrc cbOut=%#x)\n", rc, pReqHdr->rc, pReqHdr->cbOut));
4301	return rc;
4302	}
4303
4304
4305	/**
4306	* Used by VGDrvCommonISR as well as the acquire guest capability code.
4307	*
4308	* @returns VINF_SUCCESS on success. On failure, ORed together
4309	* RTSemEventMultiSignal errors (completes processing despite errors).
4310	* @param pDevExt The VBoxGuest device extension.
4311	* @param fEvents The events to dispatch.
4312	*/
4313	static int vgdrvDispatchEventsLocked(PVBOXGUESTDEVEXT pDevExt, uint32_t fEvents)
4314	{
4315	PVBOXGUESTWAIT pWait;
4316	PVBOXGUESTWAIT pSafe;
4317	int rc = VINF_SUCCESS;
4318
4319	fEvents \|= pDevExt->f32PendingEvents;
4320
4321	RTListForEachSafe(&pDevExt->WaitList, pWait, pSafe, VBOXGUESTWAIT, ListNode)
4322	{
4323	uint32_t fHandledEvents = pWait->fReqEvents & fEvents;
4324	if ( fHandledEvents != 0
4325	&& !pWait->fResEvents)
4326	{
4327	/* Does this one wait on any of the events we're dispatching? We do a quick
4328	check first, then deal with VBOXGUEST_ACQUIRE_STYLE_EVENTS as applicable. */
4329	if (fHandledEvents & VBOXGUEST_ACQUIRE_STYLE_EVENTS)
4330	fHandledEvents &= vgdrvGetAllowedEventMaskForSession(pDevExt, pWait->pSession);
4331	if (fHandledEvents)
4332	{
4333	pWait->fResEvents = pWait->fReqEvents & fEvents & fHandledEvents;
4334	fEvents &= ~pWait->fResEvents;
4335	RTListNodeRemove(&pWait->ListNode);
4336	#ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
4337	RTListAppend(&pDevExt->WakeUpList, &pWait->ListNode);
4338	#else
4339	RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
4340	rc \|= RTSemEventMultiSignal(pWait->Event);
4341	#endif
4342	if (!fEvents)
4343	break;
4344	}
4345	}
4346	}
4347
4348	ASMAtomicWriteU32(&pDevExt->f32PendingEvents, fEvents);
4349	return rc;
4350	}
4351
4352
4353	/**
4354	* Simply checks whether the IRQ is ours or not, does not do any interrupt
4355	* procesing.
4356	*
4357	* @returns true if it was our interrupt, false if it wasn't.
4358	* @param pDevExt The VBoxGuest device extension.
4359	*/
4360	bool VGDrvCommonIsOurIRQ(PVBOXGUESTDEVEXT pDevExt)
4361	{
4362	VMMDevMemory volatile *pVMMDevMemory;
4363	bool fOurIrq;
4364
4365	RTSpinlockAcquire(pDevExt->EventSpinlock);
4366	pVMMDevMemory = pDevExt->pVMMDevMemory;
4367	fOurIrq = pVMMDevMemory ? pVMMDevMemory->V.V1_04.fHaveEvents : false;
4368	RTSpinlockRelease(pDevExt->EventSpinlock);
4369
4370	return fOurIrq;
4371	}
4372
4373
4374	/**
4375	* Common interrupt service routine.
4376	*
4377	* This deals with events and with waking up thread waiting for those events.
4378	*
4379	* @returns true if it was our interrupt, false if it wasn't.
4380	* @param pDevExt The VBoxGuest device extension.
4381	*/
4382	bool VGDrvCommonISR(PVBOXGUESTDEVEXT pDevExt)
4383	{
4384	VMMDevEvents volatile *pReq;
4385	bool fMousePositionChanged = false;
4386	int rc = 0;
4387	VMMDevMemory volatile *pVMMDevMemory;
4388	bool fOurIrq;
4389
4390	/*
4391	* Make sure we've initialized the device extension.
4392	*/
4393	if (RT_LIKELY(pDevExt->fHostFeatures & VMMDEV_HVF_FAST_IRQ_ACK))
4394	pReq = NULL;
4395	else if (RT_LIKELY((pReq = pDevExt->pIrqAckEvents) != NULL))
4396	{ /* likely */ }
4397	else
4398	return false;
4399
4400	/*
4401	* Enter the spinlock and check if it's our IRQ or not.
4402	*/
4403	RTSpinlockAcquire(pDevExt->EventSpinlock);
4404	pVMMDevMemory = pDevExt->pVMMDevMemory;
4405	fOurIrq = pVMMDevMemory ? pVMMDevMemory->V.V1_04.fHaveEvents : false;
4406	if (fOurIrq)
4407	{
4408	/*
4409	* Acknowledge events.
4410	* We don't use VbglR0GRPerform here as it may take another spinlocks.
4411	*/
4412	uint32_t fEvents;
4413	if (!pReq)
4414	{
4415	fEvents = ASMInU32(pDevExt->IOPortBase + VMMDEV_PORT_OFF_REQUEST_FAST);
4416	ASMCompilerBarrier(); /* paranoia */
4417	rc = fEvents != UINT32_MAX ? VINF_SUCCESS : VERR_INTERNAL_ERROR;
4418	}
4419	else
4420	{
4421	pReq->header.rc = VERR_INTERNAL_ERROR;
4422	pReq->events = 0;
4423	ASMCompilerBarrier();
4424	ASMOutU32(pDevExt->IOPortBase + VMMDEV_PORT_OFF_REQUEST, (uint32_t)pDevExt->PhysIrqAckEvents);
4425	ASMCompilerBarrier(); /* paranoia */
4426	fEvents = pReq->events;
4427	rc = pReq->header.rc;
4428	}
4429	if (RT_SUCCESS(rc))
4430	{
4431	Log3(("VGDrvCommonISR: acknowledge events succeeded %#RX32\n", fEvents));
4432
4433	/*
4434	* VMMDEV_EVENT_MOUSE_POSITION_CHANGED can only be polled for.
4435	*/
4436	if (fEvents & VMMDEV_EVENT_MOUSE_POSITION_CHANGED)
4437	{
4438	fMousePositionChanged = true;
4439	fEvents &= ~VMMDEV_EVENT_MOUSE_POSITION_CHANGED;
4440	#if !defined(VBOXGUEST_MOUSE_NOTIFY_CAN_PREEMPT)
4441	if (pDevExt->pfnMouseNotifyCallback)
4442	pDevExt->pfnMouseNotifyCallback(pDevExt->pvMouseNotifyCallbackArg);
4443	#endif
4444	}
4445
4446	#ifdef VBOX_WITH_HGCM
4447	/*
4448	* The HGCM event/list is kind of different in that we evaluate all entries.
4449	*/
4450	if (fEvents & VMMDEV_EVENT_HGCM)
4451	{
4452	PVBOXGUESTWAIT pWait;
4453	PVBOXGUESTWAIT pSafe;
4454	RTListForEachSafe(&pDevExt->HGCMWaitList, pWait, pSafe, VBOXGUESTWAIT, ListNode)
4455	{
4456	if (pWait->pHGCMReq->fu32Flags & VBOX_HGCM_REQ_DONE)
4457	{
4458	pWait->fResEvents = VMMDEV_EVENT_HGCM;
4459	RTListNodeRemove(&pWait->ListNode);
4460	# ifdef VBOXGUEST_USE_DEFERRED_WAKE_UP
4461	RTListAppend(&pDevExt->WakeUpList, &pWait->ListNode);
4462	# else
4463	RTListAppend(&pDevExt->WokenUpList, &pWait->ListNode);
4464	rc \|= RTSemEventMultiSignal(pWait->Event);
4465	# endif
4466	}
4467	}
4468	fEvents &= ~VMMDEV_EVENT_HGCM;
4469	}
4470	#endif
4471
4472	/*
4473	* Normal FIFO waiter evaluation.
4474	*/
4475	rc \|= vgdrvDispatchEventsLocked(pDevExt, fEvents);
4476	}
4477	else /* something is serious wrong... */
4478	Log(("VGDrvCommonISR: acknowledge events failed rc=%Rrc (events=%#x)!!\n", rc, fEvents));
4479	}
4480	else
4481	Log3(("VGDrvCommonISR: not ours\n"));
4482
4483	RTSpinlockRelease(pDevExt->EventSpinlock);
4484
4485	/*
4486	* Execute the mouse notification callback here if it cannot be executed while
4487	* holding the interrupt safe spinlock, see @bugref{8639}.
4488	*/
4489	#if defined(VBOXGUEST_MOUSE_NOTIFY_CAN_PREEMPT) && !defined(RT_OS_WINDOWS) /* (Windows does this in the Dpc callback) */
4490	if ( fMousePositionChanged
4491	&& pDevExt->pfnMouseNotifyCallback)
4492	pDevExt->pfnMouseNotifyCallback(pDevExt->pvMouseNotifyCallbackArg);
4493	#endif
4494
4495	#if defined(VBOXGUEST_USE_DEFERRED_WAKE_UP) && !defined(RT_OS_WINDOWS)
4496	/*
4497	* Do wake-ups.
4498	* Note. On Windows this isn't possible at this IRQL, so a DPC will take
4499	* care of it. Same on darwin, doing it in the work loop callback.
4500	*/
4501	VGDrvCommonWaitDoWakeUps(pDevExt);
4502	#endif
4503
4504	/*
4505	* Work the poll and async notification queues on OSes that implements that.
4506	* (Do this outside the spinlock to prevent some recursive spinlocking.)
4507	*/
4508	if (fMousePositionChanged)
4509	{
4510	ASMAtomicIncU32(&pDevExt->u32MousePosChangedSeq);
4511	VGDrvNativeISRMousePollEvent(pDevExt);
4512	}
4513
4514	AssertMsg(rc == 0, ("rc=%#x (%d)\n", rc, rc));
4515	return fOurIrq;
4516	}

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

source: vbox/trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp@ 99120

Download in other formats: