VBoxGuest-linux.c@ 62484

Last change on this file since 62484 was 60584, checked in by vboxsync, 8 years ago
Linux host/guest modules: include the revision into the Linux kernel modules (for modinfo MODULE.ko)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 34.1 KB

Line
1	/* $Rev: 60584 $ */
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-2015 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*/
20
21
22	/*********************************************************************************************************************************
23	* Header Files *
24	*********************************************************************************************************************************/
25	#define LOG_GROUP LOG_GROUP_SUP_DRV
26
27	#include "the-linux-kernel.h"
28
29	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 15)
30	# define VBOXGUEST_WITH_INPUT_DRIVER
31	#endif
32
33	#include "VBoxGuestInternal.h"
34	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
35	# include <linux/input.h>
36	#endif
37	#include <linux/miscdevice.h>
38	#include <linux/poll.h>
39	#include <VBox/version.h>
40	#include "revision-generated.h"
41
42	#include <iprt/assert.h>
43	#include <iprt/asm.h>
44	#include <iprt/err.h>
45	#include <iprt/initterm.h>
46	#include <iprt/mem.h>
47	#include <iprt/mp.h>
48	#include <iprt/process.h>
49	#include <iprt/spinlock.h>
50	#include <iprt/semaphore.h>
51	#include <VBox/log.h>
52
53
54	/*********************************************************************************************************************************
55	* Defined Constants And Macros *
56	*********************************************************************************************************************************/
57	/** The device name. */
58	#define DEVICE_NAME "vboxguest"
59	/** The device name for the device node open to everyone. */
60	#define DEVICE_NAME_USER "vboxuser"
61	/** The name of the PCI driver */
62	#define DRIVER_NAME DEVICE_NAME
63
64
65	/* 2.4.x compatibility macros that may or may not be defined. */
66	#ifndef IRQ_RETVAL
67	# define irqreturn_t void
68	# define IRQ_RETVAL(n)
69	#endif
70
71
72	/*********************************************************************************************************************************
73	* Internal Functions *
74	*********************************************************************************************************************************/
75	static void vgdrvLinuxTermPci(struct pci_dev *pPciDev);
76	static int vgdrvLinuxProbePci(struct pci_dev pPciDev, const struct pci_device_id id);
77	static int vgdrvLinuxModInit(void);
78	static void vgdrvLinuxModExit(void);
79	static int vgdrvLinuxOpen(struct inode pInode, struct file pFilp);
80	static int vgdrvLinuxRelease(struct inode pInode, struct file pFilp);
81	#ifdef HAVE_UNLOCKED_IOCTL
82	static long vgdrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
83	#else
84	static int vgdrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg);
85	#endif
86	static int vgdrvLinuxFAsync(int fd, struct file *pFile, int fOn);
87	static unsigned int vgdrvLinuxPoll(struct file pFile, poll_table pPt);
88	static ssize_t vgdrvLinuxRead(struct file pFile, char pbBuf, size_t cbRead, loff_t *poff);
89
90
91	/*********************************************************************************************************************************
92	* Global Variables *
93	*********************************************************************************************************************************/
94	/**
95	* Device extention & session data association structure.
96	*/
97	static VBOXGUESTDEVEXT g_DevExt;
98	/** The PCI device. */
99	static struct pci_dev *g_pPciDev = NULL;
100	/** The base of the I/O port range. */
101	static RTIOPORT g_IOPortBase;
102	/** The base of the MMIO range. */
103	static RTHCPHYS g_MMIOPhysAddr = NIL_RTHCPHYS;
104	/** The size of the MMIO range as seen by PCI. */
105	static uint32_t g_cbMMIO;
106	/** The pointer to the mapping of the MMIO range. */
107	static void *g_pvMMIOBase;
108	/** Wait queue used by polling. */
109	static wait_queue_head_t g_PollEventQueue;
110	/** Asynchronous notification stuff. */
111	static struct fasync_struct *g_pFAsyncQueue;
112	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
113	/** Pre-allocated mouse status VMMDev request for use in the IRQ
114	* handler. */
115	static VMMDevReqMouseStatus *g_pMouseStatusReq;
116	#endif
117	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
118	/** Whether we've create the logger or not. */
119	static volatile bool g_fLoggerCreated;
120	/** Release logger group settings. */
121	static char g_szLogGrp[128];
122	/** Release logger flags settings. */
123	static char g_szLogFlags[128];
124	/** Release logger destination settings. */
125	static char g_szLogDst[128];
126	# if 0
127	/** Debug logger group settings. */
128	static char g_szDbgLogGrp[128];
129	/** Debug logger flags settings. */
130	static char g_szDbgLogFlags[128];
131	/** Debug logger destination settings. */
132	static char g_szDbgLogDst[128];
133	# endif
134	#endif
135
136	/** The input device handle */
137	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
138	static struct input_dev *g_pInputDevice = NULL;
139	#endif
140
141	/** The file_operations structure. */
142	static struct file_operations g_FileOps =
143	{
144	owner: THIS_MODULE,
145	open: vgdrvLinuxOpen,
146	release: vgdrvLinuxRelease,
147	#ifdef HAVE_UNLOCKED_IOCTL
148	unlocked_ioctl: vgdrvLinuxIOCtl,
149	#else
150	ioctl: vgdrvLinuxIOCtl,
151	#endif
152	fasync: vgdrvLinuxFAsync,
153	read: vgdrvLinuxRead,
154	poll: vgdrvLinuxPoll,
155	llseek: no_llseek,
156	};
157
158	/** The miscdevice structure. */
159	static struct miscdevice g_MiscDevice =
160	{
161	minor: MISC_DYNAMIC_MINOR,
162	name: DEVICE_NAME,
163	fops: &g_FileOps,
164	};
165
166	/** The file_operations structure for the user device.
167	* @remarks For the time being we'll be using the same implementation as
168	* /dev/vboxguest here. */
169	static struct file_operations g_FileOpsUser =
170	{
171	owner: THIS_MODULE,
172	open: vgdrvLinuxOpen,
173	release: vgdrvLinuxRelease,
174	#ifdef HAVE_UNLOCKED_IOCTL
175	unlocked_ioctl: vgdrvLinuxIOCtl,
176	#else
177	ioctl: vgdrvLinuxIOCtl,
178	#endif
179	};
180
181	/** The miscdevice structure for the user device. */
182	static struct miscdevice g_MiscDeviceUser =
183	{
184	minor: MISC_DYNAMIC_MINOR,
185	name: DEVICE_NAME_USER,
186	fops: &g_FileOpsUser,
187	};
188
189
190	/** PCI hotplug structure. */
191	static const struct pci_device_id
192	#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 8, 0)
193	__devinitdata
194	#endif
195	g_VBoxGuestPciId[] =
196	{
197	{
198	vendor: VMMDEV_VENDORID,
199	device: VMMDEV_DEVICEID
200	},
201	{
202	/* empty entry */
203	}
204	};
205
206	MODULE_DEVICE_TABLE(pci, g_VBoxGuestPciId);
207
208	/** Structure for registering the PCI driver. */
209	static struct pci_driver g_PciDriver =
210	{
211	name: DRIVER_NAME,
212	id_table: g_VBoxGuestPciId,
213	probe: vgdrvLinuxProbePci,
214	remove: vgdrvLinuxTermPci
215	};
216
217	static PVBOXGUESTSESSION g_pKernelSession = NULL;
218
219
220
221	/**
222	* Converts a VBox status code to a linux error code.
223	*
224	* @returns corresponding negative linux error code.
225	* @param rc supdrv error code (SUPDRV_ERR_* defines).
226	*/
227	static int vgdrvLinuxConvertToNegErrno(int rc)
228	{
229	if ( rc > -1000
230	&& rc < 1000)
231	return -RTErrConvertToErrno(rc);
232	switch (rc)
233	{
234	case VERR_HGCM_SERVICE_NOT_FOUND: return -ESRCH;
235	case VINF_HGCM_CLIENT_REJECTED: return 0;
236	case VERR_HGCM_INVALID_CMD_ADDRESS: return -EFAULT;
237	case VINF_HGCM_ASYNC_EXECUTE: return 0;
238	case VERR_HGCM_INTERNAL: return -EPROTO;
239	case VERR_HGCM_INVALID_CLIENT_ID: return -EINVAL;
240	case VINF_HGCM_SAVE_STATE: return 0;
241	/* No reason to return this to a guest */
242	// case VERR_HGCM_SERVICE_EXISTS: return -EEXIST;
243	default:
244	AssertMsgFailed(("Unhandled error code %Rrc\n", rc));
245	return -EPROTO;
246	}
247	}
248
249
250	/**
251	* Does the PCI detection and init of the device.
252	*
253	* @returns 0 on success, negated errno on failure.
254	*/
255	static int vgdrvLinuxProbePci(struct pci_dev pPciDev, const struct pci_device_id id)
256	{
257	int rc;
258
259	NOREF(id);
260	AssertReturn(!g_pPciDev, -EINVAL);
261	rc = pci_enable_device(pPciDev);
262	if (rc >= 0)
263	{
264	/* I/O Ports are mandatory, the MMIO bit is not. */
265	g_IOPortBase = pci_resource_start(pPciDev, 0);
266	if (g_IOPortBase != 0)
267	{
268	/*
269	* Map the register address space.
270	*/
271	g_MMIOPhysAddr = pci_resource_start(pPciDev, 1);
272	g_cbMMIO = pci_resource_len(pPciDev, 1);
273	if (request_mem_region(g_MMIOPhysAddr, g_cbMMIO, DEVICE_NAME) != NULL)
274	{
275	g_pvMMIOBase = ioremap(g_MMIOPhysAddr, g_cbMMIO);
276	if (g_pvMMIOBase)
277	{
278	/** @todo why aren't we requesting ownership of the I/O ports as well? */
279	g_pPciDev = pPciDev;
280	return 0;
281	}
282
283	/* failure cleanup path */
284	LogRel((DEVICE_NAME ": ioremap failed; MMIO Addr=%RHp cb=%#x\n", g_MMIOPhysAddr, g_cbMMIO));
285	rc = -ENOMEM;
286	release_mem_region(g_MMIOPhysAddr, g_cbMMIO);
287	}
288	else
289	{
290	LogRel((DEVICE_NAME ": failed to obtain adapter memory\n"));
291	rc = -EBUSY;
292	}
293	g_MMIOPhysAddr = NIL_RTHCPHYS;
294	g_cbMMIO = 0;
295	g_IOPortBase = 0;
296	}
297	else
298	{
299	LogRel((DEVICE_NAME ": did not find expected hardware resources\n"));
300	rc = -ENXIO;
301	}
302	pci_disable_device(pPciDev);
303	}
304	else
305	LogRel((DEVICE_NAME ": could not enable device: %d\n", rc));
306	return rc;
307	}
308
309
310	/**
311	* Clean up the usage of the PCI device.
312	*/
313	static void vgdrvLinuxTermPci(struct pci_dev *pPciDev)
314	{
315	g_pPciDev = NULL;
316	if (pPciDev)
317	{
318	iounmap(g_pvMMIOBase);
319	g_pvMMIOBase = NULL;
320
321	release_mem_region(g_MMIOPhysAddr, g_cbMMIO);
322	g_MMIOPhysAddr = NIL_RTHCPHYS;
323	g_cbMMIO = 0;
324
325	pci_disable_device(pPciDev);
326	}
327	}
328
329
330	/**
331	* Interrupt service routine.
332	*
333	* @returns In 2.4 it returns void.
334	* In 2.6 we indicate whether we've handled the IRQ or not.
335	*
336	* @param iIrq The IRQ number.
337	* @param pvDevId The device ID, a pointer to g_DevExt.
338	* @param pRegs Register set. Removed in 2.6.19.
339	*/
340	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) && !defined(DOXYGEN_RUNNING)
341	static irqreturn_t vgdrvLinuxISR(int iIrq, void *pvDevId)
342	#else
343	static irqreturn_t vgdrvLinuxISR(int iIrq, void pvDevId, struct pt_regs pRegs)
344	#endif
345	{
346	bool fTaken = VGDrvCommonISR(&g_DevExt);
347	return IRQ_RETVAL(fTaken);
348	}
349
350
351	/**
352	* Registers the ISR and initializes the poll wait queue.
353	*/
354	static int __init vgdrvLinuxInitISR(void)
355	{
356	int rc;
357
358	init_waitqueue_head(&g_PollEventQueue);
359	rc = request_irq(g_pPciDev->irq,
360	vgdrvLinuxISR,
361	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
362	IRQF_SHARED,
363	#else
364	SA_SHIRQ,
365	#endif
366	DEVICE_NAME,
367	&g_DevExt);
368	if (rc)
369	{
370	LogRel((DEVICE_NAME ": could not request IRQ %d: err=%d\n", g_pPciDev->irq, rc));
371	return rc;
372	}
373	return 0;
374	}
375
376
377	/**
378	* Deregisters the ISR.
379	*/
380	static void vgdrvLinuxTermISR(void)
381	{
382	free_irq(g_pPciDev->irq, &g_DevExt);
383	}
384
385
386	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
387
388	/**
389	* Reports the mouse integration status to the host.
390	*
391	* Calls the kernel IOCtl to report mouse status to the host on behalf of
392	* our kernel session.
393	*
394	* @param fStatus The mouse status to report.
395	*/
396	static int vgdrvLinuxSetMouseStatus(uint32_t fStatus)
397	{
398	return VGDrvCommonIoCtl(VBOXGUEST_IOCTL_SET_MOUSE_STATUS, &g_DevExt, g_pKernelSession, &fStatus, sizeof(fStatus), NULL);
399	}
400
401
402	/**
403	* Called when the input device is first opened.
404	*
405	* Sets up absolute mouse reporting.
406	*/
407	static int vboxguestOpenInputDevice(struct input_dev *pDev)
408	{
409	int rc = vgdrvLinuxSetMouseStatus(VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE \| VMMDEV_MOUSE_NEW_PROTOCOL);
410	if (RT_FAILURE(rc))
411	return ENODEV;
412	NOREF(pDev);
413	return 0;
414	}
415
416
417	/**
418	* Called if all open handles to the input device are closed.
419	*
420	* Disables absolute reporting.
421	*/
422	static void vboxguestCloseInputDevice(struct input_dev *pDev)
423	{
424	NOREF(pDev);
425	vgdrvLinuxSetMouseStatus(0);
426	}
427
428
429	/**
430	* Creates the kernel input device.
431	*/
432	static int __init vgdrvLinuxCreateInputDevice(void)
433	{
434	int rc = VbglGRAlloc((VMMDevRequestHeader *)&g_pMouseStatusReq, sizeof(g_pMouseStatusReq), VMMDevReq_GetMouseStatus);
435	if (RT_SUCCESS(rc))
436	{
437	g_pInputDevice = input_allocate_device();
438	if (g_pInputDevice)
439	{
440	g_pInputDevice->id.bustype = BUS_PCI;
441	g_pInputDevice->id.vendor = VMMDEV_VENDORID;
442	g_pInputDevice->id.product = VMMDEV_DEVICEID;
443	g_pInputDevice->id.version = VBOX_SHORT_VERSION;
444	g_pInputDevice->open = vboxguestOpenInputDevice;
445	g_pInputDevice->close = vboxguestCloseInputDevice;
446	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
447	g_pInputDevice->cdev.dev = &g_pPciDev->dev;
448	# else
449	g_pInputDevice->dev.parent = &g_pPciDev->dev;
450	# endif
451	rc = input_register_device(g_pInputDevice);
452	if (rc == 0)
453	{
454	/* Do what one of our competitors apparently does as that works. */
455	ASMBitSet(g_pInputDevice->evbit, EV_ABS);
456	ASMBitSet(g_pInputDevice->evbit, EV_KEY);
457	# ifdef EV_SYN
458	ASMBitSet(g_pInputDevice->evbit, EV_SYN);
459	# endif
460	input_set_abs_params(g_pInputDevice, ABS_X, VMMDEV_MOUSE_RANGE_MIN, VMMDEV_MOUSE_RANGE_MAX, 0, 0);
461	input_set_abs_params(g_pInputDevice, ABS_Y, VMMDEV_MOUSE_RANGE_MIN, VMMDEV_MOUSE_RANGE_MAX, 0, 0);
462	ASMBitSet(g_pInputDevice->keybit, BTN_MOUSE);
463	/** @todo this string should be in a header file somewhere. */
464	g_pInputDevice->name = "VirtualBox mouse integration";
465	return 0;
466	}
467
468	input_free_device(g_pInputDevice);
469	}
470	else
471	rc = -ENOMEM;
472	VbglGRFree(&g_pMouseStatusReq->header);
473	g_pMouseStatusReq = NULL;
474	}
475	else
476	rc = -ENOMEM;
477	return rc;
478	}
479
480
481	/**
482	* Terminates the kernel input device.
483	*/
484	static void vgdrvLinuxTermInputDevice(void)
485	{
486	VbglGRFree(&g_pMouseStatusReq->header);
487	g_pMouseStatusReq = NULL;
488
489	/* See documentation of input_register_device(): input_free_device()
490	* should not be called after a device has been registered. */
491	input_unregister_device(g_pInputDevice);
492	}
493
494	#endif /* VBOXGUEST_WITH_INPUT_DRIVER */
495
496
497	/**
498	* Creates the device nodes.
499	*
500	* @returns 0 on success, negated errno on failure.
501	*/
502	static int __init vgdrvLinuxInitDeviceNodes(void)
503	{
504	/*
505	* The full feature device node.
506	*/
507	int rc = misc_register(&g_MiscDevice);
508	if (!rc)
509	{
510	/*
511	* The device node intended to be accessible by all users.
512	*/
513	rc = misc_register(&g_MiscDeviceUser);
514	if (!rc)
515	return 0;
516	LogRel((DEVICE_NAME ": misc_register failed for %s (rc=%d)\n", DEVICE_NAME_USER, rc));
517	misc_deregister(&g_MiscDevice);
518	}
519	else
520	LogRel((DEVICE_NAME ": misc_register failed for %s (rc=%d)\n", DEVICE_NAME, rc));
521	return rc;
522	}
523
524
525	/**
526	* Deregisters the device nodes.
527	*/
528	static void vgdrvLinuxTermDeviceNodes(void)
529	{
530	misc_deregister(&g_MiscDevice);
531	misc_deregister(&g_MiscDeviceUser);
532	}
533
534
535	/**
536	* Initialize module.
537	*
538	* @returns appropriate status code.
539	*/
540	static int __init vgdrvLinuxModInit(void)
541	{
542	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
543	PRTLOGGER pRelLogger;
544	int rc;
545
546	/*
547	* Initialize IPRT first.
548	*/
549	rc = RTR0Init(0);
550	if (RT_FAILURE(rc))
551	{
552	printk(KERN_ERR DEVICE_NAME ": RTR0Init failed, rc=%d.\n", rc);
553	return -EINVAL;
554	}
555
556	/*
557	* Create the release log.
558	* (We do that here instead of common code because we want to log
559	* early failures using the LogRel macro.)
560	*/
561	rc = RTLogCreate(&pRelLogger, 0 /* fFlags */, "all",
562	"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups,
563	RTLOGDEST_STDOUT \| RTLOGDEST_DEBUGGER \| RTLOGDEST_USER, NULL);
564	if (RT_SUCCESS(rc))
565	{
566	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
567	RTLogGroupSettings(pRelLogger, g_szLogGrp);
568	RTLogFlags(pRelLogger, g_szLogFlags);
569	RTLogDestinations(pRelLogger, g_szLogDst);
570	#endif
571	RTLogRelSetDefaultInstance(pRelLogger);
572	}
573	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
574	g_fLoggerCreated = true;
575	#endif
576
577	/*
578	* Locate and initialize the PCI device.
579	*/
580	rc = pci_register_driver(&g_PciDriver);
581	if (rc >= 0 && g_pPciDev)
582	{
583	/*
584	* Register the interrupt service routine for it.
585	*/
586	rc = vgdrvLinuxInitISR();
587	if (rc >= 0)
588	{
589	/*
590	* Call the common device extension initializer.
591	*/
592	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && defined(RT_ARCH_X86)
593	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux26;
594	#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && defined(RT_ARCH_AMD64)
595	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux26_x64;
596	#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0) && defined(RT_ARCH_X86)
597	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux24;
598	#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0) && defined(RT_ARCH_AMD64)
599	VBOXOSTYPE enmOSType = VBOXOSTYPE_Linux24_x64;
600	#else
601	# warning "huh? which arch + version is this?"
602	VBOXOSTYPE enmOsType = VBOXOSTYPE_Linux;
603	#endif
604	rc = VGDrvCommonInitDevExt(&g_DevExt,
605	g_IOPortBase,
606	g_pvMMIOBase,
607	g_cbMMIO,
608	enmOSType,
609	VMMDEV_EVENT_MOUSE_POSITION_CHANGED);
610	if (RT_SUCCESS(rc))
611	{
612	/*
613	* Create the kernel session for this driver.
614	*/
615	rc = VGDrvCommonCreateKernelSession(&g_DevExt, &g_pKernelSession);
616	if (RT_SUCCESS(rc))
617	{
618	/*
619	* Create the kernel input device.
620	*/
621	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
622	rc = vgdrvLinuxCreateInputDevice();
623	if (rc >= 0)
624	{
625	#endif
626	/*
627	* Finally, create the device nodes.
628	*/
629	rc = vgdrvLinuxInitDeviceNodes();
630	if (rc >= 0)
631	{
632	/* some useful information for the user but don't show this on the console */
633	LogRel((DEVICE_NAME ": misc device minor %d, IRQ %d, I/O port %RTiop, MMIO at %RHp (size 0x%x)\n",
634	g_MiscDevice.minor, g_pPciDev->irq, g_IOPortBase, g_MMIOPhysAddr, g_cbMMIO));
635	printk(KERN_DEBUG DEVICE_NAME ": Successfully loaded version "
636	VBOX_VERSION_STRING " (interface " RT_XSTR(VMMDEV_VERSION) ")\n");
637	return rc;
638	}
639
640	/* bail out */
641	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
642	vgdrvLinuxTermInputDevice();
643	}
644	else
645	{
646	LogRel((DEVICE_NAME ": vboxguestCreateInputDevice failed with rc=%Rrc\n", rc));
647	rc = RTErrConvertFromErrno(rc);
648	}
649	#endif
650	VGDrvCommonCloseSession(&g_DevExt, g_pKernelSession);
651	}
652	VGDrvCommonDeleteDevExt(&g_DevExt);
653	}
654	else
655	{
656	LogRel((DEVICE_NAME ": VGDrvCommonInitDevExt failed with rc=%Rrc\n", rc));
657	rc = RTErrConvertFromErrno(rc);
658	}
659	vgdrvLinuxTermISR();
660	}
661	}
662	else
663	{
664	LogRel((DEVICE_NAME ": PCI device not found, probably running on physical hardware.\n"));
665	rc = -ENODEV;
666	}
667	pci_unregister_driver(&g_PciDriver);
668	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
669	RTLogDestroy(RTLogSetDefaultInstance(NULL));
670	RTR0Term();
671	return rc;
672	}
673
674
675	/**
676	* Unload the module.
677	*/
678	static void __exit vgdrvLinuxModExit(void)
679	{
680	/*
681	* Inverse order of init.
682	*/
683	vgdrvLinuxTermDeviceNodes();
684	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
685	vgdrvLinuxTermInputDevice();
686	#endif
687	VGDrvCommonCloseSession(&g_DevExt, g_pKernelSession);
688	VGDrvCommonDeleteDevExt(&g_DevExt);
689	vgdrvLinuxTermISR();
690	pci_unregister_driver(&g_PciDriver);
691	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
692	RTLogDestroy(RTLogSetDefaultInstance(NULL));
693	RTR0Term();
694	}
695
696
697	/**
698	* Device open. Called on open /dev/vboxdrv
699	*
700	* @param pInode Pointer to inode info structure.
701	* @param pFilp Associated file pointer.
702	*/
703	static int vgdrvLinuxOpen(struct inode pInode, struct file pFilp)
704	{
705	int rc;
706	PVBOXGUESTSESSION pSession;
707	Log((DEVICE_NAME ": pFilp=%p pid=%d/%d %s\n", pFilp, RTProcSelf(), current->pid, current->comm));
708
709	/*
710	* Call common code to create the user session. Associate it with
711	* the file so we can access it in the other methods.
712	*/
713	rc = VGDrvCommonCreateUserSession(&g_DevExt, &pSession);
714	if (RT_SUCCESS(rc))
715	{
716	pFilp->private_data = pSession;
717	if (MINOR(pInode->i_rdev) == g_MiscDeviceUser.minor)
718	pSession->fUserSession = true;
719	}
720
721	Log(("vgdrvLinuxOpen: g_DevExt=%p pSession=%p rc=%d/%d (pid=%d/%d %s)\n",
722	&g_DevExt, pSession, rc, vgdrvLinuxConvertToNegErrno(rc), RTProcSelf(), current->pid, current->comm));
723	return vgdrvLinuxConvertToNegErrno(rc);
724	}
725
726
727	/**
728	* Close device.
729	*
730	* @param pInode Pointer to inode info structure.
731	* @param pFilp Associated file pointer.
732	*/
733	static int vgdrvLinuxRelease(struct inode pInode, struct file pFilp)
734	{
735	Log(("vgdrvLinuxRelease: pFilp=%p pSession=%p pid=%d/%d %s\n",
736	pFilp, pFilp->private_data, RTProcSelf(), current->pid, current->comm));
737
738	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 28)
739	/* This housekeeping was needed in older kernel versions to ensure that
740	* the file pointer didn't get left on the polling queue. */
741	vgdrvLinuxFAsync(-1, pFilp, 0);
742	#endif
743	VGDrvCommonCloseSession(&g_DevExt, (PVBOXGUESTSESSION)pFilp->private_data);
744	pFilp->private_data = NULL;
745	return 0;
746	}
747
748
749	/**
750	* Device I/O Control entry point.
751	*
752	* @param pInode Associated inode pointer.
753	* @param pFilp Associated file pointer.
754	* @param uCmd The function specified to ioctl().
755	* @param ulArg The argument specified to ioctl().
756	*/
757	#ifdef HAVE_UNLOCKED_IOCTL
758	static long vgdrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
759	#else
760	static int vgdrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg)
761	#endif
762	{
763	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFilp->private_data;
764	uint32_t cbData = _IOC_SIZE(uCmd);
765	void *pvBufFree;
766	void *pvBuf;
767	int rc;
768	uint64_t au64Buf[32/sizeof(uint64_t)];
769
770	Log6(("vgdrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
771
772	/*
773	* Buffer the request.
774	*/
775	if (cbData <= sizeof(au64Buf))
776	{
777	pvBufFree = NULL;
778	pvBuf = &au64Buf[0];
779	}
780	else
781	{
782	pvBufFree = pvBuf = RTMemTmpAlloc(cbData);
783	if (RT_UNLIKELY(!pvBuf))
784	{
785	LogRel((DEVICE_NAME "::IOCtl: RTMemTmpAlloc failed to alloc %u bytes.\n", cbData));
786	return -ENOMEM;
787	}
788	}
789	if (RT_LIKELY(copy_from_user(pvBuf, (void *)ulArg, cbData) == 0))
790	{
791	/*
792	* Process the IOCtl.
793	*/
794	size_t cbDataReturned;
795	rc = VGDrvCommonIoCtl(uCmd, &g_DevExt, pSession, pvBuf, cbData, &cbDataReturned);
796
797	/*
798	* Copy ioctl data and output buffer back to user space.
799	*/
800	if (RT_SUCCESS(rc))
801	{
802	rc = 0;
803	if (RT_UNLIKELY(cbDataReturned > cbData))
804	{
805	LogRel((DEVICE_NAME "::IOCtl: too much output data %u expected %u\n", cbDataReturned, cbData));
806	cbDataReturned = cbData;
807	}
808	if (cbDataReturned > 0)
809	{
810	if (RT_UNLIKELY(copy_to_user((void *)ulArg, pvBuf, cbDataReturned) != 0))
811	{
812	LogRel((DEVICE_NAME "::IOCtl: copy_to_user failed; pvBuf=%p ulArg=%p cbDataReturned=%u uCmd=%d\n",
813	pvBuf, (void *)ulArg, cbDataReturned, uCmd, rc));
814	rc = -EFAULT;
815	}
816	}
817	}
818	else
819	{
820	Log(("vgdrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
821	rc = -rc; Assert(rc > 0); /* Positive returns == negated VBox error status codes. */
822	}
823	}
824	else
825	{
826	Log((DEVICE_NAME "::IOCtl: copy_from_user(,%#lx, %#x) failed; uCmd=%#x.\n", ulArg, cbData, uCmd));
827	rc = -EFAULT;
828	}
829	if (pvBufFree)
830	RTMemFree(pvBufFree);
831
832	Log6(("vgdrvLinuxIOCtl: returns %d (pid=%d/%d)\n", rc, RTProcSelf(), current->pid));
833	return rc;
834	}
835
836
837	/**
838	* Asynchronous notification activation method.
839	*
840	* @returns 0 on success, negative errno on failure.
841	*
842	* @param fd The file descriptor.
843	* @param pFile The file structure.
844	* @param fOn On/off indicator.
845	*/
846	static int vgdrvLinuxFAsync(int fd, struct file *pFile, int fOn)
847	{
848	return fasync_helper(fd, pFile, fOn, &g_pFAsyncQueue);
849	}
850
851
852	/**
853	* Poll function.
854	*
855	* This returns ready to read if the mouse pointer mode or the pointer position
856	* has changed since last call to read.
857	*
858	* @returns 0 if no changes, POLLIN \| POLLRDNORM if there are unseen changes.
859	*
860	* @param pFile The file structure.
861	* @param pPt The poll table.
862	*
863	* @remarks This is probably not really used, X11 is said to use the fasync
864	* interface instead.
865	*/
866	static unsigned int vgdrvLinuxPoll(struct file pFile, poll_table pPt)
867	{
868	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFile->private_data;
869	uint32_t u32CurSeq = ASMAtomicUoReadU32(&g_DevExt.u32MousePosChangedSeq);
870	unsigned int fMask = pSession->u32MousePosChangedSeq != u32CurSeq
871	? POLLIN \| POLLRDNORM
872	: 0;
873	poll_wait(pFile, &g_PollEventQueue, pPt);
874	return fMask;
875	}
876
877
878	/**
879	* Read to go with our poll/fasync response.
880	*
881	* @returns 1 or -EINVAL.
882	*
883	* @param pFile The file structure.
884	* @param pbBuf The buffer to read into.
885	* @param cbRead The max number of bytes to read.
886	* @param poff The current file position.
887	*
888	* @remarks This is probably not really used as X11 lets the driver do its own
889	* event reading. The poll condition is therefore also cleared when we
890	* see VMMDevReq_GetMouseStatus in vgdrvIoCtl_VMMRequest.
891	*/
892	static ssize_t vgdrvLinuxRead(struct file pFile, char pbBuf, size_t cbRead, loff_t *poff)
893	{
894	PVBOXGUESTSESSION pSession = (PVBOXGUESTSESSION)pFile->private_data;
895	uint32_t u32CurSeq = ASMAtomicUoReadU32(&g_DevExt.u32MousePosChangedSeq);
896
897	if (*poff != 0)
898	return -EINVAL;
899
900	/*
901	* Fake a single byte read if we're not up to date with the current mouse position.
902	*/
903	if ( pSession->u32MousePosChangedSeq != u32CurSeq
904	&& cbRead > 0)
905	{
906	pSession->u32MousePosChangedSeq = u32CurSeq;
907	pbBuf[0] = 0;
908	return 1;
909	}
910	return 0;
911	}
912
913
914	void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
915	{
916	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
917	int rc;
918	#endif
919	NOREF(pDevExt);
920
921	/*
922	* Wake up everyone that's in a poll() and post anyone that has
923	* subscribed to async notifications.
924	*/
925	Log3(("VGDrvNativeISRMousePollEvent: wake_up_all\n"));
926	wake_up_all(&g_PollEventQueue);
927	Log3(("VGDrvNativeISRMousePollEvent: kill_fasync\n"));
928	kill_fasync(&g_pFAsyncQueue, SIGIO, POLL_IN);
929	#ifdef VBOXGUEST_WITH_INPUT_DRIVER
930	/* Report events to the kernel input device */
931	g_pMouseStatusReq->mouseFeatures = 0;
932	g_pMouseStatusReq->pointerXPos = 0;
933	g_pMouseStatusReq->pointerYPos = 0;
934	rc = VbglGRPerform(&g_pMouseStatusReq->header);
935	if (RT_SUCCESS(rc))
936	{
937	input_report_abs(g_pInputDevice, ABS_X,
938	g_pMouseStatusReq->pointerXPos);
939	input_report_abs(g_pInputDevice, ABS_Y,
940	g_pMouseStatusReq->pointerYPos);
941	# ifdef EV_SYN
942	input_sync(g_pInputDevice);
943	# endif
944	}
945	#endif
946	Log3(("VGDrvNativeISRMousePollEvent: done\n"));
947	}
948
949
950	/* Common code that depend on g_DevExt. */
951	#include "VBoxGuestIDC-unix.c.h"
952
953	EXPORT_SYMBOL(VBoxGuestIDCOpen);
954	EXPORT_SYMBOL(VBoxGuestIDCClose);
955	EXPORT_SYMBOL(VBoxGuestIDCCall);
956
957
958	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
959
960	/** log and dbg_log parameter setter. */
961	static int vgdrvLinuxParamLogGrpSet(const char pszValue, struct kernel_param pParam)
962	{
963	if (g_fLoggerCreated)
964	{
965	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
966	if (pLogger)
967	RTLogGroupSettings(pLogger, pszValue);
968	}
969	else if (pParam->name[0] != 'd')
970	strlcpy(&g_szLogGrp[0], pszValue, sizeof(g_szLogGrp));
971
972	return 0;
973	}
974
975	/** log and dbg_log parameter getter. */
976	static int vgdrvLinuxParamLogGrpGet(char pszBuf, struct kernel_param pParam)
977	{
978	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
979	*pszBuf = '\0';
980	if (pLogger)
981	RTLogGetGroupSettings(pLogger, pszBuf, _4K);
982	return strlen(pszBuf);
983	}
984
985
986	/** log and dbg_log_flags parameter setter. */
987	static int vgdrvLinuxParamLogFlagsSet(const char pszValue, struct kernel_param pParam)
988	{
989	if (g_fLoggerCreated)
990	{
991	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
992	if (pLogger)
993	RTLogFlags(pLogger, pszValue);
994	}
995	else if (pParam->name[0] != 'd')
996	strlcpy(&g_szLogFlags[0], pszValue, sizeof(g_szLogFlags));
997	return 0;
998	}
999
1000	/** log and dbg_log_flags parameter getter. */
1001	static int vgdrvLinuxParamLogFlagsGet(char pszBuf, struct kernel_param pParam)
1002	{
1003	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1004	*pszBuf = '\0';
1005	if (pLogger)
1006	RTLogGetFlags(pLogger, pszBuf, _4K);
1007	return strlen(pszBuf);
1008	}
1009
1010
1011	/** log and dbg_log_dest parameter setter. */
1012	static int vgdrvLinuxParamLogDstSet(const char pszValue, struct kernel_param pParam)
1013	{
1014	if (g_fLoggerCreated)
1015	{
1016	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1017	if (pLogger)
1018	RTLogDestinations(pLogger, pszValue);
1019	}
1020	else if (pParam->name[0] != 'd')
1021	strlcpy(&g_szLogDst[0], pszValue, sizeof(g_szLogDst));
1022	return 0;
1023	}
1024
1025	/** log and dbg_log_dest parameter getter. */
1026	static int vgdrvLinuxParamLogDstGet(char pszBuf, struct kernel_param pParam)
1027	{
1028	PRTLOGGER pLogger = pParam->name[0] == 'd' ? RTLogDefaultInstance() : RTLogRelGetDefaultInstance();
1029	*pszBuf = '\0';
1030	if (pLogger)
1031	RTLogGetDestinations(pLogger, pszBuf, _4K);
1032	return strlen(pszBuf);
1033	}
1034
1035
1036	/** r3_log_to_host parameter setter. */
1037	static int vgdrvLinuxParamR3LogToHostSet(const char pszValue, struct kernel_param pParam)
1038	{
1039	if ( pszValue == NULL
1040	\|\| *pszValue == '\0'
1041	\|\| *pszValue == 'n'
1042	\|\| *pszValue == 'N'
1043	\|\| *pszValue == 'd'
1044	\|\| *pszValue == 'D'
1045	\|\| ( (pszValue == 'o' \|\| pszValue == 'O')
1046	&& (pszValue == 'f' \|\| pszValue == 'F') )
1047	)
1048	g_DevExt.fLoggingEnabled = false;
1049	else
1050	g_DevExt.fLoggingEnabled = true;
1051	return 0;
1052	}
1053
1054	/** r3_log_to_host parameter getter. */
1055	static int vgdrvLinuxParamR3LogToHostGet(char pszBuf, struct kernel_param pParam)
1056	{
1057	strcpy(pszBuf, g_DevExt.fLoggingEnabled ? "enabled" : "disabled");
1058	return strlen(pszBuf);
1059	}
1060
1061
1062	/*
1063	* Define module parameters.
1064	*/
1065	module_param_call(log, vgdrvLinuxParamLogGrpSet, vgdrvLinuxParamLogGrpGet, NULL, 0664);
1066	module_param_call(log_flags, vgdrvLinuxParamLogFlagsSet, vgdrvLinuxParamLogFlagsGet, NULL, 0664);
1067	module_param_call(log_dest, vgdrvLinuxParamLogDstSet, vgdrvLinuxParamLogDstGet, NULL, 0664);
1068	# ifdef LOG_ENABLED
1069	module_param_call(dbg_log, vgdrvLinuxParamLogGrpSet, vgdrvLinuxParamLogGrpGet, NULL, 0664);
1070	module_param_call(dbg_log_flags, vgdrvLinuxParamLogFlagsSet, vgdrvLinuxParamLogFlagsGet, NULL, 0664);
1071	module_param_call(dbg_log_dest, vgdrvLinuxParamLogDstSet, vgdrvLinuxParamLogDstGet, NULL, 0664);
1072	# endif
1073	module_param_call(r3_log_to_host, vgdrvLinuxParamR3LogToHostSet, vgdrvLinuxParamR3LogToHostGet, NULL, 0664);
1074
1075	#endif /* 2.6.0 and later */
1076
1077
1078	module_init(vgdrvLinuxModInit);
1079	module_exit(vgdrvLinuxModExit);
1080
1081	MODULE_AUTHOR(VBOX_VENDOR);
1082	MODULE_DESCRIPTION(VBOX_PRODUCT " Guest Additions for Linux Module");
1083	MODULE_LICENSE("GPL");
1084	#ifdef MODULE_VERSION
1085	MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV));
1086	#endif
1087

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

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

Download in other formats: