VBoxGuest-linux.c@ 105641

Last change on this file since 105641 was 103788, checked in by vboxsync, 9 months ago

Linux Additions: Add possiblity to prevent kernel modules from loading in kernel command line, bugref:8409.

Add to kernel command line either vboxguest.disabled=1 and/or vboxsf.disabled=1
and/or vboxvideo.disabled=1 in order to prevent certain module or all of them
from loading during system boot.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 48.6 KB

Line
1	/* $Id: VBoxGuest-linux.c 103788 2024-03-11 17:50:25Z vboxsync $ */
2	/** @file
3	* VBoxGuest - Linux specifics.
4	*
5	* Note. Unfortunately, the difference between this and SUPDrv-linux.c is
6	* a little bit too big to be helpful.
7	*/
8
9	/*
10	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
11	*
12	* This file is part of VirtualBox base platform packages, as
13	* available from https://www.virtualbox.org.
14	*
15	* This program is free software; you can redistribute it and/or
16	* modify it under the terms of the GNU General Public License
17	* as published by the Free Software Foundation, in version 3 of the
18	* License.
19	*
20	* This program is distributed in the hope that it will be useful, but
21	* WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23	* General Public License for more details.
24	*
25	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, see <https://www.gnu.org/licenses>.
27	*
28	* The contents of this file may alternatively be used under the terms
29	* of the Common Development and Distribution License Version 1.0
30	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
31	* in the VirtualBox distribution, in which case the provisions of the
32	* CDDL are applicable instead of those of the GPL.
33	*
34	* You may elect to license modified versions of this file under the
35	* terms and conditions of either the GPL or the CDDL or both.
36	*
37	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
38	*/
39
40
41	/*********************************************************************************************************************************
42	* Header Files *
43	*********************************************************************************************************************************/
44	#define LOG_GROUP LOG_GROUP_SUP_DRV
45
46	#include "the-linux-kernel.h"
47
48	#if RTLNX_VER_MIN(2,6,15)
49	# define VBOXGUEST_WITH_INPUT_DRIVER
50	#endif
51
52	#if RTLNX_VER_MIN(4,15,0)
53	# define CONST_4_15 const
54	#else
55	# define CONST_4_15
56	#endif
57
58	#include "VBoxGuestInternal.h"
59	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
60	# include <linux/input.h>
61	#endif
62	#include <linux/miscdevice.h>
63	#include <linux/poll.h>
64	#if RTLNX_VER_MIN(2,6,28)
65	# include <linux/tty.h>
66	#endif
67	#include <VBox/version.h>
68	#include "revision-generated.h"
69
70	#include <iprt/assert.h>
71	#include <iprt/asm.h>
72	#include <iprt/ctype.h>
73	#include <iprt/initterm.h>
74	#include <iprt/mem.h>
75	#include <iprt/mp.h>
76	#include <iprt/process.h>
77	#include <iprt/spinlock.h>
78	#include <iprt/semaphore.h>
79	#include <iprt/string.h>
80	#include <VBox/err.h>
81	#include <VBox/log.h>
82	#include <VBox/VBoxLnxModInline.h>
83
84
85	/*********************************************************************************************************************************
86	* Defined Constants And Macros *
87	*********************************************************************************************************************************/
88	/** The device name. */
89	#define DEVICE_NAME "vboxguest"
90	/** The device name for the device node open to everyone. */
91	#define DEVICE_NAME_USER "vboxuser"
92	/** The name of the PCI driver */
93	#define DRIVER_NAME DEVICE_NAME
94
95
96	/* 2.4.x compatibility macros that may or may not be defined. */
97	#ifndef IRQ_RETVAL
98	# define irqreturn_t void
99	# define IRQ_RETVAL(n)
100	#endif
101
102	/* uidgid.h was introduced in 3.5.0. */
103	#if RTLNX_VER_MAX(3,5,0)
104	# define kgid_t gid_t
105	# define kuid_t uid_t
106	#endif
107
108	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
109	/** The name of input pointing device for mouse integration. */
110	# define VBOX_INPUT_DEVICE_NAME "VirtualBox mouse integration"
111	#endif
112
113
114	/*********************************************************************************************************************************
115	* Internal Functions *
116	*********************************************************************************************************************************/
117	static void vgdrvLinuxTermPci(struct pci_dev *pPciDev);
118	static int vgdrvLinuxProbePci(struct pci_dev pPciDev, const struct pci_device_id id);
119	static int __init vgdrvLinuxModInit(void);
120	static void __exit vgdrvLinuxModExit(void);
121	static int vgdrvLinuxOpen(struct inode pInode, struct file pFilp);
122	static int vgdrvLinuxRelease(struct inode pInode, struct file pFilp);
123	#ifdef HAVE_UNLOCKED_IOCTL
124	static long vgdrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
125	#else
126	static int vgdrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg);
127	#endif
128	static int vgdrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PVBOXGUESTSESSION pSession);
129	static int vgdrvLinuxFAsync(int fd, struct file *pFile, int fOn);
130	static unsigned int vgdrvLinuxPoll(struct file pFile, poll_table pPt);
131	static ssize_t vgdrvLinuxRead(struct file pFile, char pbBuf, size_t cbRead, loff_t *poff);
132
133
134	/*********************************************************************************************************************************
135	* Global Variables *
136	*********************************************************************************************************************************/
137	/**
138	* Device extention & session data association structure.
139	*/
140	static VBOXGUESTDEVEXT g_DevExt;
141	/** The PCI device. */
142	static struct pci_dev *g_pPciDev = NULL;
143	/** The base of the I/O port range. */
144	static RTIOPORT g_IOPortBase;
145	/** The base of the MMIO range. */
146	static RTHCPHYS g_MMIOPhysAddr = NIL_RTHCPHYS;
147	/** The size of the MMIO range as seen by PCI. */
148	static uint32_t g_cbMMIO;
149	/** The pointer to the mapping of the MMIO range. */
150	static void *g_pvMMIOBase;
151
152	static RTHCPHYS g_MmioReqPhysAddr = NIL_RTHCPHYS;
153	static uint32_t g_cbMmioReq;
154	static void *g_pvMmioReq = NULL;
155
156	/** Wait queue used by polling. */
157	static wait_queue_head_t g_PollEventQueue;
158	/** Asynchronous notification stuff. */
159	static struct fasync_struct *g_pFAsyncQueue;
160	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
161	/** Pre-allocated mouse status VMMDev requests for use in the IRQ handler. */
162	static VMMDevReqMouseStatusEx *g_pMouseStatusReqEx;
163	#endif
164	#if RTLNX_VER_MIN(2,6,0)
165	/** Whether we've create the logger or not. */
166	static volatile bool g_fLoggerCreated;
167	/** Release logger group settings. */
168	static char g_szLogGrp[128];
169	/** Release logger flags settings. */
170	static char g_szLogFlags[128];
171	/** Release logger destination settings. */
172	static char g_szLogDst[128];
173	# if 0
174	/** Debug logger group settings. */
175	static char g_szDbgLogGrp[128];
176	/** Debug logger flags settings. */
177	static char g_szDbgLogFlags[128];
178	/** Debug logger destination settings. */
179	static char g_szDbgLogDst[128];
180	# endif
181	#endif
182
183	/** The input device handle */
184	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
185	static struct input_dev *g_pInputDevice = NULL;
186	#endif
187
188	/** The file_operations structure. */
189	static struct file_operations g_FileOps =
190	{
191	owner: THIS_MODULE,
192	open: vgdrvLinuxOpen,
193	release: vgdrvLinuxRelease,
194	#ifdef HAVE_UNLOCKED_IOCTL
195	unlocked_ioctl: vgdrvLinuxIOCtl,
196	#else
197	ioctl: vgdrvLinuxIOCtl,
198	#endif
199	fasync: vgdrvLinuxFAsync,
200	read: vgdrvLinuxRead,
201	poll: vgdrvLinuxPoll,
202	llseek: no_llseek,
203	};
204
205	/** The miscdevice structure. */
206	static struct miscdevice g_MiscDevice =
207	{
208	minor: MISC_DYNAMIC_MINOR,
209	name: DEVICE_NAME,
210	fops: &g_FileOps,
211	};
212
213	/** The file_operations structure for the user device.
214	* @remarks For the time being we'll be using the same implementation as
215	* /dev/vboxguest here. */
216	static struct file_operations g_FileOpsUser =
217	{
218	owner: THIS_MODULE,
219	open: vgdrvLinuxOpen,
220	release: vgdrvLinuxRelease,
221	#ifdef HAVE_UNLOCKED_IOCTL
222	unlocked_ioctl: vgdrvLinuxIOCtl,
223	#else
224	ioctl: vgdrvLinuxIOCtl,
225	#endif
226	};
227
228	/** The miscdevice structure for the user device. */
229	static struct miscdevice g_MiscDeviceUser =
230	{
231	minor: MISC_DYNAMIC_MINOR,
232	name: DEVICE_NAME_USER,
233	fops: &g_FileOpsUser,
234	};
235
236
237	/** PCI hotplug structure. */
238	static const struct pci_device_id g_VBoxGuestPciId[] =
239	{
240	{
241	vendor: VMMDEV_VENDORID,
242	device: VMMDEV_DEVICEID
243	},
244	{
245	/* empty entry */
246	}
247	};
248
249	MODULE_DEVICE_TABLE(pci, g_VBoxGuestPciId);
250
251	/** Structure for registering the PCI driver. */
252	static struct pci_driver g_PciDriver =
253	{
254	name: DRIVER_NAME,
255	id_table: g_VBoxGuestPciId,
256	probe: vgdrvLinuxProbePci,
257	remove: vgdrvLinuxTermPci
258	};
259
260	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
261	/** Kernel IDC session to ourselves for use with the mouse events. */
262	static PVBOXGUESTSESSION g_pKernelSession = NULL;
263	#endif
264
265
266
267	/**
268	* Converts a VBox status code to a linux error code.
269	*
270	* @returns corresponding negative linux error code.
271	* @param rc supdrv error code (SUPDRV_ERR_* defines).
272	*/
273	static int vgdrvLinuxConvertToNegErrno(int rc)
274	{
275	if ( rc > -1000
276	&& rc < 1000)
277	return -RTErrConvertToErrno(rc);
278	switch (rc)
279	{
280	case VERR_HGCM_SERVICE_NOT_FOUND: return -ESRCH;
281	case VINF_HGCM_CLIENT_REJECTED: return 0;
282	case VERR_HGCM_INVALID_CMD_ADDRESS: return -EFAULT;
283	case VINF_HGCM_ASYNC_EXECUTE: return 0;
284	case VERR_HGCM_INTERNAL: return -EPROTO;
285	case VERR_HGCM_INVALID_CLIENT_ID: return -EINVAL;
286	case VINF_HGCM_SAVE_STATE: return 0;
287	/* No reason to return this to a guest */
288	// case VERR_HGCM_SERVICE_EXISTS: return -EEXIST;
289	default:
290	AssertMsgFailed(("Unhandled error code %Rrc\n", rc));
291	return -EPROTO;
292	}
293	}
294
295
296	#if defined(RT_ARCH_ARM64) \|\| defined(RT_ARCH_ARM32)
297	static int vgdrvLinuxMapMmio(struct pci_dev *pPciDev)
298	{
299	g_MmioReqPhysAddr = pci_resource_start(pPciDev, 3);
300	g_cbMmioReq = pci_resource_len(pPciDev, 3);
301	if (request_mem_region(g_MmioReqPhysAddr, g_cbMmioReq, DEVICE_NAME) != NULL)
302	{
303	g_pvMmioReq = ioremap(g_MmioReqPhysAddr, g_cbMmioReq);
304	if (g_pvMmioReq)
305	return 0;
306
307	/* failure cleanup path */
308	LogRel((DEVICE_NAME ": ioremap failed; MMIO Addr=%RHp cb=%#x\n", g_MmioReqPhysAddr, g_cbMmioReq));
309	release_mem_region(g_MmioReqPhysAddr, g_cbMmioReq);
310	return -ENOMEM;
311	}
312	else
313	LogRel((DEVICE_NAME ": failed to obtain adapter memory\n"));
314
315	return -EBUSY;
316	}
317	#endif
318
319
320	/**
321	* Does the PCI detection and init of the device.
322	*
323	* @returns 0 on success, negated errno on failure.
324	*/
325	static int vgdrvLinuxProbePci(struct pci_dev pPciDev, const struct pci_device_id id)
326	{
327	int rc;
328
329	NOREF(id);
330	AssertReturn(!g_pPciDev, -EINVAL);
331	rc = pci_enable_device(pPciDev);
332	if (rc >= 0)
333	{
334	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
335	/* I/O Ports are mandatory, the MMIO bit is not. */
336	g_IOPortBase = pci_resource_start(pPciDev, 0);
337	if (g_IOPortBase != 0)
338	#elif defined(RT_ARCH_ARM64) \|\| defined(RT_ARCH_ARM32)
339	rc = vgdrvLinuxMapMmio(pPciDev);
340	if (!rc)
341	#else
342	# error "I have no memory of this arechitecture"
343	#endif
344	{
345	/*
346	* Map the register address space.
347	*/
348	g_MMIOPhysAddr = pci_resource_start(pPciDev, 1);
349	g_cbMMIO = pci_resource_len(pPciDev, 1);
350	if (request_mem_region(g_MMIOPhysAddr, g_cbMMIO, DEVICE_NAME) != NULL)
351	{
352	g_pvMMIOBase = ioremap(g_MMIOPhysAddr, g_cbMMIO);
353	if (g_pvMMIOBase)
354	{
355	/** @todo why aren't we requesting ownership of the I/O ports as well? */
356	g_pPciDev = pPciDev;
357	return 0;
358	}
359
360	/* failure cleanup path */
361	LogRel((DEVICE_NAME ": ioremap failed; MMIO Addr=%RHp cb=%#x\n", g_MMIOPhysAddr, g_cbMMIO));
362	rc = -ENOMEM;
363	release_mem_region(g_MMIOPhysAddr, g_cbMMIO);
364	}
365	else
366	{
367	LogRel((DEVICE_NAME ": failed to obtain adapter memory\n"));
368	rc = -EBUSY;
369	}
370	g_MMIOPhysAddr = NIL_RTHCPHYS;
371	g_cbMMIO = 0;
372	g_IOPortBase = 0;
373	}
374	else
375	{
376	LogRel((DEVICE_NAME ": did not find expected hardware resources\n"));
377	rc = -ENXIO;
378	}
379	pci_disable_device(pPciDev);
380	}
381	else
382	LogRel((DEVICE_NAME ": could not enable device: %d\n", rc));
383	return rc;
384	}
385
386
387	/**
388	* Clean up the usage of the PCI device.
389	*/
390	static void vgdrvLinuxTermPci(struct pci_dev *pPciDev)
391	{
392	g_pPciDev = NULL;
393	if (pPciDev)
394	{
395	if (g_pvMmioReq)
396	{
397	iounmap(g_pvMmioReq);
398	g_pvMmioReq = NULL;
399
400	release_mem_region(g_MmioReqPhysAddr, g_cbMmioReq);
401	g_MmioReqPhysAddr = NIL_RTHCPHYS;
402	g_cbMmioReq = 0;
403	}
404
405	iounmap(g_pvMMIOBase);
406	g_pvMMIOBase = NULL;
407
408	release_mem_region(g_MMIOPhysAddr, g_cbMMIO);
409	g_MMIOPhysAddr = NIL_RTHCPHYS;
410	g_cbMMIO = 0;
411
412	pci_disable_device(pPciDev);
413	}
414	}
415
416
417	/**
418	* Interrupt service routine.
419	*
420	* @returns In 2.4 it returns void.
421	* In 2.6 we indicate whether we've handled the IRQ or not.
422	*
423	* @param iIrq The IRQ number.
424	* @param pvDevId The device ID, a pointer to g_DevExt.
425	* @param pRegs Register set. Removed in 2.6.19.
426	*/
427	#if RTLNX_VER_MIN(2,6,19) && !defined(DOXYGEN_RUNNING)
428	static irqreturn_t vgdrvLinuxISR(int iIrq, void *pvDevId)
429	#else
430	static irqreturn_t vgdrvLinuxISR(int iIrq, void pvDevId, struct pt_regs pRegs)
431	#endif
432	{
433	bool fTaken = VGDrvCommonISR(&g_DevExt);
434	return IRQ_RETVAL(fTaken);
435	}
436
437
438	/**
439	* Registers the ISR and initializes the poll wait queue.
440	*/
441	static int __init vgdrvLinuxInitISR(void)
442	{
443	int rc;
444
445	init_waitqueue_head(&g_PollEventQueue);
446	rc = request_irq(g_pPciDev->irq,
447	vgdrvLinuxISR,
448	#if RTLNX_VER_MIN(2,6,20)
449	IRQF_SHARED,
450	#else
451	SA_SHIRQ,
452	#endif
453	DEVICE_NAME,
454	&g_DevExt);
455	if (rc)
456	{
457	LogRel((DEVICE_NAME ": could not request IRQ %d: err=%d\n", g_pPciDev->irq, rc));
458	return rc;
459	}
460	return 0;
461	}
462
463
464	/**
465	* Deregisters the ISR.
466	*/
467	static void vgdrvLinuxTermISR(void)
468	{
469	free_irq(g_pPciDev->irq, &g_DevExt);
470	}
471
472	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
473
474	/**
475	* Check if extended mouse pointer state request protocol is currently used by driver.
476	*
477	* @returns True if extended protocol is used, False otherwise.
478	*/
479	static bool vgdrvLinuxUsesMouseStatusEx(void)
480	{
481	return g_pMouseStatusReqEx->Core.header.requestType == VMMDevReq_GetMouseStatusEx;
482	}
483
484	/**
485	* Reports the mouse integration status to the host.
486	*
487	* Calls the kernel IOCtl to report mouse status to the host on behalf of
488	* our kernel session.
489	*
490	* @param fStatus The mouse status to report.
491	*/
492	static int vgdrvLinuxSetMouseStatus(uint32_t fStatus)
493	{
494	int rc;
495	VBGLIOCSETMOUSESTATUS Req;
496	VBGLREQHDR_INIT(&Req.Hdr, SET_MOUSE_STATUS);
497	Req.u.In.fStatus = fStatus;
498	rc = VGDrvCommonIoCtl(VBGL_IOCTL_SET_MOUSE_STATUS, &g_DevExt, g_pKernelSession, &Req.Hdr, sizeof(Req));
499	if (RT_SUCCESS(rc))
500	rc = Req.Hdr.rc;
501	return rc;
502	}
503
504
505	/**
506	* Called when the input device is first opened.
507	*
508	* Sets up absolute mouse reporting.
509	*/
510	static int vboxguestOpenInputDevice(struct input_dev *pDev)
511	{
512	int rc = vgdrvLinuxSetMouseStatus( VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
513	\| VMMDEV_MOUSE_NEW_PROTOCOL
514	\| (vgdrvLinuxUsesMouseStatusEx() ? VMMDEV_MOUSE_GUEST_USES_FULL_STATE_PROTOCOL : 0));
515	if (RT_FAILURE(rc))
516	return ENODEV;
517	NOREF(pDev);
518	return 0;
519	}
520
521
522	/**
523	* Called if all open handles to the input device are closed.
524	*
525	* Disables absolute reporting.
526	*/
527	static void vboxguestCloseInputDevice(struct input_dev *pDev)
528	{
529	NOREF(pDev);
530	vgdrvLinuxSetMouseStatus(0);
531	}
532
533
534	/**
535	* Free corresponding mouse status request structure.
536	*/
537	static void vgdrvLinuxFreeMouseStatusReq(void)
538	{
539	VbglR0GRFree(&g_pMouseStatusReqEx->Core.header);
540	g_pMouseStatusReqEx = NULL;
541	}
542
543
544	/**
545	* Creates the kernel input device.
546	*/
547	static int __init vgdrvLinuxCreateInputDevice(void)
548	{
549	/* Try to allocate legacy request data first, and check if host supports extended protocol. */
550	int rc = VbglR0GRAlloc((VMMDevRequestHeader **)&g_pMouseStatusReqEx, sizeof(VMMDevReqMouseStatus), VMMDevReq_GetMouseStatus);
551	if (RT_SUCCESS(rc))
552	{
553	/* Check if host supports extended mouse state reporting. */
554	g_pMouseStatusReqEx->Core.mouseFeatures = 0;
555	rc = VbglR0GRPerform(&g_pMouseStatusReqEx->Core.header);
556	if (RT_SUCCESS(rc))
557	{
558	if (g_pMouseStatusReqEx->Core.mouseFeatures & VMMDEV_MOUSE_HOST_SUPPORTS_FULL_STATE_PROTOCOL)
559	{
560	VMMDevReqMouseStatusEx *pReqEx = NULL;
561	rc = VbglR0GRAlloc((VMMDevRequestHeader *)&pReqEx, sizeof(pReqEx), VMMDevReq_GetMouseStatusEx);
562	if (RT_SUCCESS(rc))
563	{
564	/* De-allocate legacy request data, */
565	VbglR0GRFree(&g_pMouseStatusReqEx->Core.header);
566	/* ..and switch to extended requests. */
567	g_pMouseStatusReqEx = pReqEx;
568	LogRel(("Host supports full mouse state reporting, switching to extended mouse integration protocol\n"));
569	}
570	else
571	LogRel(("Host supports full mouse state reporting, but feature cannot be initialized, switching to legacy mouse integration protocol\n"));
572	}
573	else
574	LogRel(("Host does not support full mouse state reporting, switching to legacy mouse integration protocol\n"));
575	}
576	else
577	LogRel(("Unable to get host mouse capabilities, switching to legacy mouse integration protocol\n"));
578	}
579	else
580	rc = -ENOMEM;
581
582	if (RT_SUCCESS(rc))
583	{
584	g_pInputDevice = input_allocate_device();
585	if (g_pInputDevice)
586	{
587	g_pInputDevice->name = VBOX_INPUT_DEVICE_NAME;
588	g_pInputDevice->id.bustype = BUS_PCI;
589	g_pInputDevice->id.vendor = VMMDEV_VENDORID;
590	g_pInputDevice->id.product = VMMDEV_DEVICEID;
591	g_pInputDevice->id.version = VBOX_SHORT_VERSION;
592	g_pInputDevice->open = vboxguestOpenInputDevice;
593	g_pInputDevice->close = vboxguestCloseInputDevice;
594	# if RTLNX_VER_MAX(2,6,22)
595	g_pInputDevice->cdev.dev = &g_pPciDev->dev;
596	# else
597	g_pInputDevice->dev.parent = &g_pPciDev->dev;
598	# endif
599	/* Set up input device capabilities. */
600	ASMBitSet(g_pInputDevice->evbit, EV_ABS);
601	ASMBitSet(g_pInputDevice->evbit, EV_KEY);
602	# ifdef EV_SYN
603	ASMBitSet(g_pInputDevice->evbit, EV_SYN);
604	# endif
605	ASMBitSet(g_pInputDevice->absbit, ABS_X);
606	ASMBitSet(g_pInputDevice->absbit, ABS_Y);
607
608	input_set_abs_params(g_pInputDevice, ABS_X, VMMDEV_MOUSE_RANGE_MIN, VMMDEV_MOUSE_RANGE_MAX, 0, 0);
609	input_set_abs_params(g_pInputDevice, ABS_Y, VMMDEV_MOUSE_RANGE_MIN, VMMDEV_MOUSE_RANGE_MAX, 0, 0);
610
611	ASMBitSet(g_pInputDevice->keybit, BTN_MOUSE);
612
613	/* Report extra capabilities to input layer if extended mouse state protocol
614	* will be used in communication with host. */
615	if (vgdrvLinuxUsesMouseStatusEx())
616	{
617	ASMBitSet(g_pInputDevice->evbit, EV_REL);
618	ASMBitSet(g_pInputDevice->evbit, EV_KEY);
619
620	ASMBitSet(g_pInputDevice->relbit, REL_WHEEL);
621	ASMBitSet(g_pInputDevice->relbit, REL_HWHEEL);
622
623	ASMBitSet(g_pInputDevice->keybit, BTN_LEFT);
624	ASMBitSet(g_pInputDevice->keybit, BTN_RIGHT);
625	ASMBitSet(g_pInputDevice->keybit, BTN_MIDDLE);
626	ASMBitSet(g_pInputDevice->keybit, BTN_SIDE);
627	ASMBitSet(g_pInputDevice->keybit, BTN_EXTRA);
628	}
629
630	rc = input_register_device(g_pInputDevice);
631	if (rc == 0)
632	return 0;
633
634	input_free_device(g_pInputDevice);
635	}
636	else
637	rc = -ENOMEM;
638
639	vgdrvLinuxFreeMouseStatusReq();
640	}
641
642	return rc;
643	}
644
645
646	/**
647	* Terminates the kernel input device.
648	*/
649	static void vgdrvLinuxTermInputDevice(void)
650	{
651	/* Notify host that mouse integration is no longer available. */
652	vgdrvLinuxSetMouseStatus(0);
653
654	vgdrvLinuxFreeMouseStatusReq();
655
656	/* See documentation of input_register_device(): input_free_device()
657	* should not be called after a device has been registered. */
658	input_unregister_device(g_pInputDevice);
659	}
660
661	#endif /* VBOXGUEST_WITH_INPUT_DRIVER */
662
663	/**
664	* Creates the device nodes.
665	*
666	* @returns 0 on success, negated errno on failure.
667	*/
668	static int __init vgdrvLinuxInitDeviceNodes(void)
669	{
670	/*
671	* The full feature device node.
672	*/
673	int rc = misc_register(&g_MiscDevice);
674	if (!rc)
675	{
676	/*
677	* The device node intended to be accessible by all users.
678	*/
679	rc = misc_register(&g_MiscDeviceUser);
680	if (!rc)
681	return 0;
682	LogRel((DEVICE_NAME ": misc_register failed for %s (rc=%d)\n", DEVICE_NAME_USER, rc));
683	misc_deregister(&g_MiscDevice);
684	}
685	else
686	LogRel((DEVICE_NAME ": misc_register failed for %s (rc=%d)\n", DEVICE_NAME, rc));
687	return rc;
688	}
689
690
691	/**
692	* Deregisters the device nodes.
693	*/
694	static void vgdrvLinuxTermDeviceNodes(void)
695	{
696	misc_deregister(&g_MiscDevice);
697	misc_deregister(&g_MiscDeviceUser);
698	}
699
700
701	/**
702	* Initialize module.
703	*
704	* @returns appropriate status code.
705	*/
706	static int __init vgdrvLinuxModInit(void)
707	{
708	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
709	PRTLOGGER pRelLogger;
710	int rc;
711
712	/* Check if modue loading was disabled. */
713	if (!vbox_mod_should_load())
714	return -EINVAL;
715
716	/*
717	* Initialize IPRT first.
718	*/
719	rc = RTR0Init(0);
720	if (RT_FAILURE(rc))
721	{
722	printk(KERN_ERR DEVICE_NAME ": RTR0Init failed, rc=%d.\n", rc);
723	return -EINVAL;
724	}
725
726	/*
727	* Create the release log.
728	* (We do that here instead of common code because we want to log
729	* early failures using the LogRel macro.)
730	*/
731	rc = RTLogCreate(&pRelLogger, 0 /* fFlags */, "all",
732	"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
733	RTLOGDEST_STDOUT \| RTLOGDEST_DEBUGGER \| RTLOGDEST_USER, NULL);
734	if (RT_SUCCESS(rc))
735	{
736	#if RTLNX_VER_MIN(2,6,0)
737	RTLogGroupSettings(pRelLogger, g_szLogGrp);
738	RTLogFlags(pRelLogger, g_szLogFlags);
739	RTLogDestinations(pRelLogger, g_szLogDst);
740	#endif
741	RTLogRelSetDefaultInstance(pRelLogger);
742	}
743	#if RTLNX_VER_MIN(2,6,0)
744	g_fLoggerCreated = true;
745	#endif
746
747	/*
748	* Locate and initialize the PCI device.
749	*/
750	rc = pci_register_driver(&g_PciDriver);
751	if (rc >= 0 && g_pPciDev)
752	{
753	/*
754	* Call the common device extension initializer.
755	*/
756	#if RTLNX_VER_MIN(2,6,0) && (defined(RT_ARCH_X86) \|\| defined(RT_ARCH_ARM32))
757	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux26;
758	#elif RTLNX_VER_MIN(2,6,0) && (defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_ARM64))
759	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux26_x64;
760	#elif RTLNX_VER_MIN(2,4,0) && defined(RT_ARCH_X86)
761	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux24;
762	#elif RTLNX_VER_MIN(2,4,0) && defined(RT_ARCH_AMD64)
763	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux24_x64;
764	#else
765	# warning "huh? which arch + version is this?"
766	VBOXOSTYPE enmOsType = VBOXOSTYPE_Linux;
767	#endif
768	rc = VGDrvCommonInitDevExt(&g_DevExt,
769	g_IOPortBase,
770	g_pvMmioReq,
771	g_pvMMIOBase,
772	g_cbMMIO,
773	enmOSType,
774	VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
775	if (RT_SUCCESS(rc))
776	{
777	/*
778	* Register the interrupt service routine for it now that g_DevExt can handle IRQs.
779	*/
780	rc = vgdrvLinuxInitISR();
781	if (rc >= 0) /** @todo r=bird: status check differs from that inside vgdrvLinuxInitISR. */
782	{
783	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
784	/*
785	* Create the kernel session for this driver.
786	*/
787	rc = VGDrvCommonCreateKernelSession(&g_DevExt, &g_pKernelSession);
788	if (RT_SUCCESS(rc))
789	{
790	/*
791	* Create the kernel input device.
792	*/
793	rc = vgdrvLinuxCreateInputDevice();
794	if (rc >= 0)
795	{
796	#endif
797	/*
798	* Read host configuration.
799	*/
800	VGDrvCommonProcessOptionsFromHost(&g_DevExt);
801
802	/*
803	* Finally, create the device nodes.
804	*/
805	rc = vgdrvLinuxInitDeviceNodes();
806	if (rc >= 0)
807	{
808	/* some useful information for the user but don't show this on the console */
809	LogRel((DEVICE_NAME ": Successfully loaded version " VBOX_VERSION_STRING " r" __stringify(VBOX_SVN_REV) "\n"));
810	LogRel((DEVICE_NAME ": misc device minor %d, IRQ %d, I/O port %RTiop, MMIO at %RHp (size 0x%x)\n",
811	g_MiscDevice.minor, g_pPciDev->irq, g_IOPortBase, g_MMIOPhysAddr, g_cbMMIO));
812	printk(KERN_DEBUG DEVICE_NAME ": Successfully loaded version "
813	VBOX_VERSION_STRING " r" __stringify(VBOX_SVN_REV) " (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
814	return rc;
815	}
816
817	/* bail out */
818	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
819	vgdrvLinuxTermInputDevice();
820	}
821	else
822	{
823	LogRel((DEVICE_NAME ": vboxguestCreateInputDevice failed with rc=%Rrc\n", rc));
824	rc = RTErrConvertFromErrno(rc);
825	}
826	VGDrvCommonCloseSession(&g_DevExt, g_pKernelSession);
827	}
828	#endif
829	vgdrvLinuxTermISR();
830	}
831	VGDrvCommonDeleteDevExt(&g_DevExt);
832	}
833	else
834	{
835	LogRel((DEVICE_NAME ": VGDrvCommonInitDevExt failed with rc=%Rrc\n", rc));
836	rc = RTErrConvertFromErrno(rc);
837	}
838	}
839	else
840	{
841	LogRel((DEVICE_NAME ": PCI device not found, probably running on physical hardware.\n"));
842	rc = -ENODEV;
843	}
844	pci_unregister_driver(&g_PciDriver);
845	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
846	RTLogDestroy(RTLogSetDefaultInstance(NULL));
847	RTR0Term();
848	return rc;
849	}
850
851
852	/**
853	* Unload the module.
854	*/
855	static void __exit vgdrvLinuxModExit(void)
856	{
857	/*
858	* Inverse order of init.
859	*/
860	vgdrvLinuxTermDeviceNodes();
861	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
862	vgdrvLinuxTermInputDevice();
863	VGDrvCommonCloseSession(&g_DevExt, g_pKernelSession);
864	#endif
865	vgdrvLinuxTermISR();
866	VGDrvCommonDeleteDevExt(&g_DevExt);
867	pci_unregister_driver(&g_PciDriver);
868	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
869	RTLogDestroy(RTLogSetDefaultInstance(NULL));
870	RTR0Term();
871	}
872
873
874	/**
875	* Get the process user ID.
876	*
877	* @returns UID.
878	*/
879	DECLINLINE(RTUID) vgdrvLinuxGetUid(void)
880	{
881	#if RTLNX_VER_MIN(2,6,29)
882	# if RTLNX_VER_MIN(3,5,0)
883	return from_kuid(current_user_ns(), current->cred->uid);
884	# else
885	return current->cred->uid;
886	# endif
887	#else
888	return current->uid;
889	#endif
890	}
891
892
893	/**
894	* Checks if the given group number is zero or not.
895	*
896	* @returns true / false.
897	* @param gid The group to check for.
898	*/
899	DECLINLINE(bool) vgdrvLinuxIsGroupZero(kgid_t gid)
900	{
901	#if RTLNX_VER_MIN(3,5,0)
902	return from_kgid(current_user_ns(), gid);
903	#else
904	return gid == 0;
905	#endif
906	}
907
908
909	/**
910	* Searches the effective group and supplementary groups for @a gid.
911	*
912	* @returns true if member, false if not.
913	* @param gid The group to check for.
914	*/
915	DECLINLINE(RTGID) vgdrvLinuxIsInGroupEff(kgid_t gid)
916	{
917	return in_egroup_p(gid) != 0;
918	}
919
920
921	/**
922	* Check if we can positively or negatively determine that the process is
923	* running under a login on the physical machine console.
924	*
925	* Havne't found a good way to figure this out for graphical sessions, so this
926	* is mostly pointless. But let us try do what we can do.
927	*
928	* @returns VMMDEV_REQUESTOR_CON_XXX.
929	*/
930	static uint32_t vgdrvLinuxRequestorOnConsole(void)
931	{
932	uint32_t fRet = VMMDEV_REQUESTOR_CON_DONT_KNOW;
933
934	#if RTLNX_VER_MIN(2,6,28) /* First with tty_kref_put(). */
935	/*
936	* Check for tty0..63, ASSUMING that these are only used for the physical console.
937	*/
938	struct tty_struct *pTty = get_current_tty();
939	if (pTty)
940	{
941	# if RTLNX_VER_MIN(4,2,0)
942	const char *pszName = tty_name(pTty);
943	# else
944	char szBuf[64];
945	const char *pszName = tty_name(pTty, szBuf);
946	# endif
947	if ( pszName
948	&& pszName[0] == 't'
949	&& pszName[1] == 't'
950	&& pszName[2] == 'y'
951	&& RT_C_IS_DIGIT(pszName[3])
952	&& ( pszName[4] == '\0'
953	\|\| ( RT_C_IS_DIGIT(pszName[4])
954	&& pszName[5] == '\0'
955	&& (pszName[3] - '0') * 10 + (pszName[4] - '0') <= 63)) )
956	fRet = VMMDEV_REQUESTOR_CON_YES;
957	tty_kref_put(pTty);
958	}
959	#endif
960
961	return fRet;
962	}
963
964
965	/**
966	* Device open. Called on open /dev/vboxdrv
967	*
968	* @param pInode Pointer to inode info structure.
969	* @param pFilp Associated file pointer.
970	*/
971	static int vgdrvLinuxOpen(struct inode pInode, struct file pFilp)
972	{
973	int rc;
974	PVBOXGUESTSESSION pSession;
975	uint32_t fRequestor;
976	Log((DEVICE_NAME ": pFilp=%p pid=%d/%d %s\n", pFilp, RTProcSelf(), current->pid, current->comm));
977
978	/*
979	* Figure out the requestor flags.
980	* ASSUMES that the gid of /dev/vboxuser is what we should consider the special vbox group.
981	*/
982	fRequestor = VMMDEV_REQUESTOR_USERMODE \| VMMDEV_REQUESTOR_TRUST_NOT_GIVEN;
983	if (vgdrvLinuxGetUid() == 0)
984	fRequestor \|= VMMDEV_REQUESTOR_USR_ROOT;
985	else
986	fRequestor \|= VMMDEV_REQUESTOR_USR_USER;
987	if (MINOR(pInode->i_rdev) == g_MiscDeviceUser.minor)
988	{
989	fRequestor \|= VMMDEV_REQUESTOR_USER_DEVICE;
990	if (!vgdrvLinuxIsGroupZero(pInode->i_gid) && vgdrvLinuxIsInGroupEff(pInode->i_gid))
991	fRequestor \|= VMMDEV_REQUESTOR_GRP_VBOX;
992	}
993	fRequestor \|= vgdrvLinuxRequestorOnConsole();
994
995	/*
996	* Call common code to create the user session. Associate it with
997	* the file so we can access it in the other methods.
998	*/
999	rc = VGDrvCommonCreateUserSession(&g_DevExt, fRequestor, &pSession);
1000	if (RT_SUCCESS(rc))
1001	pFilp->private_data = pSession;
1002
1003	Log(("vgdrvLinuxOpen: g_DevExt=%p pSession=%p rc=%d/%d (pid=%d/%d %s)\n",
1004	&g_DevExt, pSession, rc, vgdrvLinuxConvertToNegErrno(rc), RTProcSelf(), current->pid, current->comm));
1005	return vgdrvLinuxConvertToNegErrno(rc);
1006	}
1007
1008
1009	/**
1010	* Close device.
1011	*
1012	* @param pInode Pointer to inode info structure.
1013	* @param pFilp Associated file pointer.
1014	*/
1015	static int vgdrvLinuxRelease(struct inode pInode, struct file pFilp)
1016	{
1017	Log(("vgdrvLinuxRelease: pFilp=%p pSession=%p pid=%d/%d %s\n",
1018	pFilp, pFilp->private_data, RTProcSelf(), current->pid, current->comm));
1019
1020	#if RTLNX_VER_MAX(2,6,28)
1021	/* This housekeeping was needed in older kernel versions to ensure that
1022	* the file pointer didn't get left on the polling queue. */
1023	vgdrvLinuxFAsync(-1, pFilp, 0);
1024	#endif
1025	VGDrvCommonCloseSession(&g_DevExt, (PVBOXGUESTSESSION)pFilp->private_data);
1026	pFilp->private_data = NULL;
1027	return 0;
1028	}
1029
1030
1031	/**
1032	* Device I/O Control entry point.
1033	*
1034	* @param pFilp Associated file pointer.
1035	* @param uCmd The function specified to ioctl().
1036	* @param ulArg The argument specified to ioctl().
1037	*/
1038	#if defined(HAVE_UNLOCKED_IOCTL) \|\| defined(DOXYGEN_RUNNING)
1039	static long vgdrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
1040	#else
1041	static int vgdrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg)
1042	#endif
1043	{
1044	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFilp->private_data;
1045	int rc;
1046	#ifndef HAVE_UNLOCKED_IOCTL
1047	unlock_kernel();
1048	#endif
1049
1050	#if 0 /* no fast I/O controls defined atm. */
1051	if (RT_LIKELY( ( uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
1052	\|\| uCmd == SUP_IOCTL_FAST_DO_HM_RUN
1053	\|\| uCmd == SUP_IOCTL_FAST_DO_NOP)
1054	&& pSession->fUnrestricted == true))
1055	rc = VGDrvCommonIoCtlFast(uCmd, ulArg, &g_DevExt, pSession);
1056	else
1057	#endif
1058	rc = vgdrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
1059
1060	#ifndef HAVE_UNLOCKED_IOCTL
1061	lock_kernel();
1062	#endif
1063	return rc;
1064	}
1065
1066
1067	/**
1068	* Device I/O Control entry point, slow variant.
1069	*
1070	* @param pFilp Associated file pointer.
1071	* @param uCmd The function specified to ioctl().
1072	* @param ulArg The argument specified to ioctl().
1073	* @param pSession The session instance.
1074	*/
1075	static int vgdrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PVBOXGUESTSESSION pSession)
1076	{
1077	int rc;
1078	VBGLREQHDR Hdr;
1079	PVBGLREQHDR pHdr;
1080	uint32_t cbBuf;
1081
1082	Log6(("vgdrvLinuxIOCtlSlow: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
1083
1084	/*
1085	* Read the header.
1086	*/
1087	if (RT_FAILURE(RTR0MemUserCopyFrom(&Hdr, ulArg, sizeof(Hdr))))
1088	{
1089	Log(("vgdrvLinuxIOCtlSlow: copy_from_user(,%#lx,) failed; uCmd=%#x\n", ulArg, uCmd));
1090	return -EFAULT;
1091	}
1092	if (RT_UNLIKELY(Hdr.uVersion != VBGLREQHDR_VERSION))
1093	{
1094	Log(("vgdrvLinuxIOCtlSlow: bad header version %#x; uCmd=%#x\n", Hdr.uVersion, uCmd));
1095	return -EINVAL;
1096	}
1097
1098	/*
1099	* Buffer the request.
1100	* Note! The header is revalidated by the common code.
1101	*/
1102	cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
1103	if (RT_UNLIKELY(cbBuf > _1M*16))
1104	{
1105	Log(("vgdrvLinuxIOCtlSlow: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
1106	return -E2BIG;
1107	}
1108	if (RT_UNLIKELY( Hdr.cbIn < sizeof(Hdr)
1109	\|\| (cbBuf != _IOC_SIZE(uCmd) && _IOC_SIZE(uCmd) != 0)))
1110	{
1111	Log(("vgdrvLinuxIOCtlSlow: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
1112	return -EINVAL;
1113	}
1114	pHdr = RTMemAlloc(cbBuf);
1115	if (RT_UNLIKELY(!pHdr))
1116	{
1117	LogRel(("vgdrvLinuxIOCtlSlow: failed to allocate buffer of %d bytes for uCmd=%#x\n", cbBuf, uCmd));
1118	return -ENOMEM;
1119	}
1120	if (RT_FAILURE(RTR0MemUserCopyFrom(pHdr, ulArg, Hdr.cbIn)))
1121	{
1122	Log(("vgdrvLinuxIOCtlSlow: copy_from_user(,%#lx, %#x) failed; uCmd=%#x\n", ulArg, Hdr.cbIn, uCmd));
1123	RTMemFree(pHdr);
1124	return -EFAULT;
1125	}
1126	if (Hdr.cbIn < cbBuf)
1127	RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbBuf - Hdr.cbIn);
1128
1129	/*
1130	* Process the IOCtl.
1131	*/
1132	rc = VGDrvCommonIoCtl(uCmd, &g_DevExt, pSession, pHdr, cbBuf);
1133
1134	/*
1135	* Copy ioctl data and output buffer back to user space.
1136	*/
1137	if (RT_SUCCESS(rc))
1138	{
1139	uint32_t cbOut = pHdr->cbOut;
1140	if (RT_UNLIKELY(cbOut > cbBuf))
1141	{
1142	LogRel(("vgdrvLinuxIOCtlSlow: too much output! %#x > %#x; uCmd=%#x!\n", cbOut, cbBuf, uCmd));
1143	cbOut = cbBuf;
1144	}
1145	if (RT_FAILURE(RTR0MemUserCopyTo(ulArg, pHdr, cbOut)))
1146	{
1147	/* this is really bad! */
1148	LogRel(("vgdrvLinuxIOCtlSlow: copy_to_user(%#lx,,%#x); uCmd=%#x!\n", ulArg, cbOut, uCmd));
1149	rc = -EFAULT;
1150	}
1151	}
1152	else
1153	{
1154	Log(("vgdrvLinuxIOCtlSlow: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
1155	rc = -EINVAL;
1156	}
1157	RTMemFree(pHdr);
1158
1159	Log6(("vgdrvLinuxIOCtlSlow: returns %d (pid=%d/%d)\n", rc, RTProcSelf(), current->pid));
1160	return rc;
1161	}
1162
1163
1164	/**
1165	* @note This code is duplicated on other platforms with variations, so please
1166	* keep them all up to date when making changes!
1167	*/
1168	int VBOXCALL VBoxGuestIDC(void *pvSession, uintptr_t uReq, PVBGLREQHDR pReqHdr, size_t cbReq)
1169	{
1170	/*
1171	* Simple request validation (common code does the rest).
1172	*/
1173	int rc;
1174	if ( RT_VALID_PTR(pReqHdr)
1175	&& cbReq >= sizeof(*pReqHdr))
1176	{
1177	/*
1178	* All requests except the connect one requires a valid session.
1179	*/
1180	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pvSession;
1181	if (pSession)
1182	{
1183	if ( RT_VALID_PTR(pSession)
1184	&& pSession->pDevExt == &g_DevExt)
1185	rc = VGDrvCommonIoCtl(uReq, &g_DevExt, pSession, pReqHdr, cbReq);
1186	else
1187	rc = VERR_INVALID_HANDLE;
1188	}
1189	else if (uReq == VBGL_IOCTL_IDC_CONNECT)
1190	{
1191	rc = VGDrvCommonCreateKernelSession(&g_DevExt, &pSession);
1192	if (RT_SUCCESS(rc))
1193	{
1194	rc = VGDrvCommonIoCtl(uReq, &g_DevExt, pSession, pReqHdr, cbReq);
1195	if (RT_FAILURE(rc))
1196	VGDrvCommonCloseSession(&g_DevExt, pSession);
1197	}
1198	}
1199	else
1200	rc = VERR_INVALID_HANDLE;
1201	}
1202	else
1203	rc = VERR_INVALID_POINTER;
1204	return rc;
1205	}
1206	EXPORT_SYMBOL(VBoxGuestIDC);
1207
1208
1209	/**
1210	* Asynchronous notification activation method.
1211	*
1212	* @returns 0 on success, negative errno on failure.
1213	*
1214	* @param fd The file descriptor.
1215	* @param pFile The file structure.
1216	* @param fOn On/off indicator.
1217	*/
1218	static int vgdrvLinuxFAsync(int fd, struct file *pFile, int fOn)
1219	{
1220	return fasync_helper(fd, pFile, fOn, &g_pFAsyncQueue);
1221	}
1222
1223
1224	/**
1225	* Poll function.
1226	*
1227	* This returns ready to read if the mouse pointer mode or the pointer position
1228	* has changed since last call to read.
1229	*
1230	* @returns 0 if no changes, POLLIN \| POLLRDNORM if there are unseen changes.
1231	*
1232	* @param pFile The file structure.
1233	* @param pPt The poll table.
1234	*
1235	* @remarks This is probably not really used, X11 is said to use the fasync
1236	* interface instead.
1237	*/
1238	static unsigned int vgdrvLinuxPoll(struct file pFile, poll_table pPt)
1239	{
1240	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFile->private_data;
1241	uint32_t u32CurSeq = ASMAtomicUoReadU32(&g_DevExt.u32MousePosChangedSeq);
1242	unsigned int fMask = pSession->u32MousePosChangedSeq != u32CurSeq
1243	? POLLIN \| POLLRDNORM
1244	: 0;
1245	poll_wait(pFile, &g_PollEventQueue, pPt);
1246	return fMask;
1247	}
1248
1249
1250	/**
1251	* Read to go with our poll/fasync response.
1252	*
1253	* @returns 1 or -EINVAL.
1254	*
1255	* @param pFile The file structure.
1256	* @param pbBuf The buffer to read into.
1257	* @param cbRead The max number of bytes to read.
1258	* @param poff The current file position.
1259	*
1260	* @remarks This is probably not really used as X11 lets the driver do its own
1261	* event reading. The poll condition is therefore also cleared when we
1262	* see VMMDevReq_GetMouseStatus in vgdrvIoCtl_VMMRequest.
1263	*/
1264	static ssize_t vgdrvLinuxRead(struct file pFile, char pbBuf, size_t cbRead, loff_t *poff)
1265	{
1266	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFile->private_data;
1267	uint32_t u32CurSeq = ASMAtomicUoReadU32(&g_DevExt.u32MousePosChangedSeq);
1268
1269	if (*poff != 0)
1270	return -EINVAL;
1271
1272	/*
1273	* Fake a single byte read if we're not up to date with the current mouse position.
1274	*/
1275	if ( pSession->u32MousePosChangedSeq != u32CurSeq
1276	&& cbRead > 0)
1277	{
1278	pSession->u32MousePosChangedSeq = u32CurSeq;
1279	pbBuf[0] = 0;
1280	return 1;
1281	}
1282	return 0;
1283	}
1284
1285
1286	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
1287	/**
1288	* Get host mouse state.
1289	*
1290	* @returns IPRT status code.
1291	* @param pfMouseFeatures Where to store host mouse capabilities.
1292	* @param pX Where to store X axis coordinate.
1293	* @param pY Where to store Y axis coordinate.
1294	* @param pDz Where to store vertical wheel movement offset (only set if in case of VMMDevReq_GetMouseStatusEx request).
1295	* @param pDw Where to store horizontal wheel movement offset (only set if in case of VMMDevReq_GetMouseStatusEx request).
1296	* @param pfButtons Where to store mouse buttons state (only set if in case of VMMDevReq_GetMouseStatusEx request).
1297	*/
1298	static int vgdrvLinuxGetHostMouseState(uint32_t pfMouseFeatures, int32_t pX, int32_t pY, int32_t pDz, int32_t pDw, uint32_t pfButtons)
1299	{
1300	int rc = VERR_INVALID_PARAMETER;
1301
1302	Assert(pfMouseFeatures);
1303	Assert(pX);
1304	Assert(pY);
1305	Assert(pDz);
1306	Assert(pDw);
1307	Assert(pfButtons);
1308
1309	/* Initialize legacy request data. */
1310	g_pMouseStatusReqEx->Core.mouseFeatures = 0;
1311	g_pMouseStatusReqEx->Core.pointerXPos = 0;
1312	g_pMouseStatusReqEx->Core.pointerYPos = 0;
1313
1314	/* Initialize extended request data if VMMDevReq_GetMouseStatusEx is used. */
1315	if (vgdrvLinuxUsesMouseStatusEx())
1316	{
1317	g_pMouseStatusReqEx->dz = 0;
1318	g_pMouseStatusReqEx->dw = 0;
1319	g_pMouseStatusReqEx->fButtons = 0;
1320	}
1321
1322	/* Get host mouse state - either lagacy or extended version. */
1323	rc = VbglR0GRPerform(&g_pMouseStatusReqEx->Core.header);
1324	if (RT_SUCCESS(rc))
1325	{
1326	*pfMouseFeatures = g_pMouseStatusReqEx->Core.mouseFeatures;
1327	*pX = g_pMouseStatusReqEx->Core.pointerXPos;
1328	*pY = g_pMouseStatusReqEx->Core.pointerYPos;
1329
1330	/* Get extended mouse state data in case of VMMDevReq_GetMouseStatusEx. */
1331	if (vgdrvLinuxUsesMouseStatusEx())
1332	{
1333	*pDz = g_pMouseStatusReqEx->dz;
1334	*pDw = g_pMouseStatusReqEx->dw;
1335	*pfButtons = g_pMouseStatusReqEx->fButtons;
1336	}
1337	}
1338
1339	return rc;
1340	}
1341	#endif /* VBOXGUEST_WITH_INPUT_DRIVER */
1342
1343
1344	void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
1345	{
1346	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
1347	int rc;
1348	uint32_t fMouseFeatures = 0;
1349	int32_t x = 0;
1350	int32_t y = 0;
1351	int32_t dz = 0;
1352	int32_t dw = 0;
1353	uint32_t fButtons = 0;
1354	#endif
1355	NOREF(pDevExt);
1356
1357	/*
1358	* Wake up everyone that's in a poll() and post anyone that has
1359	* subscribed to async notifications.
1360	*/
1361	Log3(("VGDrvNativeISRMousePollEvent: wake_up_all\n"));
1362	wake_up_all(&g_PollEventQueue);
1363	Log3(("VGDrvNativeISRMousePollEvent: kill_fasync\n"));
1364	kill_fasync(&g_pFAsyncQueue, SIGIO, POLL_IN);
1365	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
1366	rc = vgdrvLinuxGetHostMouseState(&fMouseFeatures, &x, &y, &dz, &dw, &fButtons);
1367	if (RT_SUCCESS(rc))
1368	{
1369	input_report_abs(g_pInputDevice, ABS_X, x);
1370	input_report_abs(g_pInputDevice, ABS_Y, y);
1371
1372	if ( vgdrvLinuxUsesMouseStatusEx()
1373	&& ( fMouseFeatures
1374	& (VMMDEV_MOUSE_HOST_SUPPORTS_FULL_STATE_PROTOCOL \| VMMDEV_MOUSE_GUEST_USES_FULL_STATE_PROTOCOL))
1375	== ( VMMDEV_MOUSE_HOST_SUPPORTS_FULL_STATE_PROTOCOL \| VMMDEV_MOUSE_GUEST_USES_FULL_STATE_PROTOCOL ) )
1376	{
1377	/* Vertical and horizontal scroll values come as-is from GUI.
1378	* Invert values here as it is done in PS/2 mouse driver, so
1379	* scrolling direction will be exectly the same. */
1380	input_report_rel(g_pInputDevice, REL_WHEEL, -dz);
1381	input_report_rel(g_pInputDevice, REL_HWHEEL, -dw);
1382
1383	input_report_key(g_pInputDevice, BTN_LEFT, RT_BOOL(fButtons & VMMDEV_MOUSE_BUTTON_LEFT));
1384	input_report_key(g_pInputDevice, BTN_RIGHT, RT_BOOL(fButtons & VMMDEV_MOUSE_BUTTON_RIGHT));
1385	input_report_key(g_pInputDevice, BTN_MIDDLE, RT_BOOL(fButtons & VMMDEV_MOUSE_BUTTON_MIDDLE));
1386	input_report_key(g_pInputDevice, BTN_SIDE, RT_BOOL(fButtons & VMMDEV_MOUSE_BUTTON_X1));
1387	input_report_key(g_pInputDevice, BTN_EXTRA, RT_BOOL(fButtons & VMMDEV_MOUSE_BUTTON_X2));
1388	}
1389
1390	# ifdef EV_SYN
1391	input_sync(g_pInputDevice);
1392	# endif
1393	}
1394	#endif
1395	Log3(("VGDrvNativeISRMousePollEvent: done\n"));
1396	}
1397
1398
1399	bool VGDrvNativeProcessOption(PVBOXGUESTDEVEXT pDevExt, const char pszName, const char pszValue)
1400	{
1401	RT_NOREF(pDevExt); RT_NOREF(pszName); RT_NOREF(pszValue);
1402	return false;
1403	}
1404
1405
1406	#if RTLNX_VER_MIN(2,6,0)
1407
1408	/** log and dbg_log parameter setter. */
1409	static int vgdrvLinuxParamLogGrpSet(const char pszValue, CONST_4_15 struct kernel_param pParam)
1410	{
1411	if (g_fLoggerCreated)
1412	{
1413	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1414	if (pLogger)
1415	RTLogGroupSettings(pLogger, pszValue);
1416	}
1417	else if (pParam->name[0] != 'd')
1418	RTStrCopy(&g_szLogGrp[0], sizeof(g_szLogGrp), pszValue);
1419	return 0;
1420	}
1421
1422	/** log and dbg_log parameter getter. */
1423	static int vgdrvLinuxParamLogGrpGet(char pszBuf, CONST_4_15 struct kernel_param pParam)
1424	{
1425	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1426	*pszBuf = '\0';
1427	if (pLogger)
1428	RTLogQueryGroupSettings(pLogger, pszBuf, _4K);
1429	return strlen(pszBuf);
1430	}
1431
1432
1433	/** log and dbg_log_flags parameter setter. */
1434	static int vgdrvLinuxParamLogFlagsSet(const char pszValue, CONST_4_15 struct kernel_param pParam)
1435	{
1436	if (g_fLoggerCreated)
1437	{
1438	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1439	if (pLogger)
1440	RTLogFlags(pLogger, pszValue);
1441	}
1442	else if (pParam->name[0] != 'd')
1443	RTStrCopy(&g_szLogFlags[0], sizeof(g_szLogFlags), pszValue);
1444	return 0;
1445	}
1446
1447	/** log and dbg_log_flags parameter getter. */
1448	static int vgdrvLinuxParamLogFlagsGet(char pszBuf, CONST_4_15 struct kernel_param pParam)
1449	{
1450	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1451	*pszBuf = '\0';
1452	if (pLogger)
1453	RTLogQueryFlags(pLogger, pszBuf, _4K);
1454	return strlen(pszBuf);
1455	}
1456
1457
1458	/** log and dbg_log_dest parameter setter. */
1459	static int vgdrvLinuxParamLogDstSet(const char pszValue, CONST_4_15 struct kernel_param pParam)
1460	{
1461	if (g_fLoggerCreated)
1462	{
1463	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1464	if (pLogger)
1465	RTLogDestinations(pLogger, pszValue);
1466	}
1467	else if (pParam->name[0] != 'd')
1468	RTStrCopy(&g_szLogDst[0], sizeof(g_szLogDst), pszValue);
1469	return 0;
1470	}
1471
1472	/** log and dbg_log_dest parameter getter. */
1473	static int vgdrvLinuxParamLogDstGet(char pszBuf, CONST_4_15 struct kernel_param pParam)
1474	{
1475	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1476	*pszBuf = '\0';
1477	if (pLogger)
1478	RTLogQueryDestinations(pLogger, pszBuf, _4K);
1479	return strlen(pszBuf);
1480	}
1481
1482
1483	/** r3_log_to_host parameter setter. */
1484	static int vgdrvLinuxParamR3LogToHostSet(const char pszValue, CONST_4_15 struct kernel_param pParam)
1485	{
1486	g_DevExt.fLoggingEnabled = VBDrvCommonIsOptionValueTrue(pszValue);
1487	return 0;
1488	}
1489
1490	/** r3_log_to_host parameter getter. */
1491	static int vgdrvLinuxParamR3LogToHostGet(char pszBuf, CONST_4_15 struct kernel_param pParam)
1492	{
1493	strcpy(pszBuf, g_DevExt.fLoggingEnabled ? "enabled" : "disabled");
1494	return strlen(pszBuf);
1495	}
1496
1497
1498	/*
1499	* Define module parameters.
1500	*/
1501	module_param_call(log, vgdrvLinuxParamLogGrpSet, vgdrvLinuxParamLogGrpGet, NULL, 0664);
1502	module_param_call(log_flags, vgdrvLinuxParamLogFlagsSet, vgdrvLinuxParamLogFlagsGet, NULL, 0664);
1503	module_param_call(log_dest, vgdrvLinuxParamLogDstSet, vgdrvLinuxParamLogDstGet, NULL, 0664);
1504	# ifdef LOG_ENABLED
1505	module_param_call(dbg_log, vgdrvLinuxParamLogGrpSet, vgdrvLinuxParamLogGrpGet, NULL, 0664);
1506	module_param_call(dbg_log_flags, vgdrvLinuxParamLogFlagsSet, vgdrvLinuxParamLogFlagsGet, NULL, 0664);
1507	module_param_call(dbg_log_dest, vgdrvLinuxParamLogDstSet, vgdrvLinuxParamLogDstGet, NULL, 0664);
1508	# endif
1509	module_param_call(r3_log_to_host, vgdrvLinuxParamR3LogToHostSet, vgdrvLinuxParamR3LogToHostGet, NULL, 0664);
1510
1511	#endif /* 2.6.0 and later */
1512
1513
1514	module_init(vgdrvLinuxModInit);
1515	module_exit(vgdrvLinuxModExit);
1516
1517	MODULE_AUTHOR(VBOX_VENDOR);
1518	MODULE_DESCRIPTION(VBOX_PRODUCT " Guest Additions for Linux Module");
1519	MODULE_LICENSE("GPL");
1520	#ifdef MODULE_VERSION
1521	MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV));
1522	#endif
1523

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

source: vbox/trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest-linux.c@ 105641

Download in other formats: