SUPDrv-linux.c@ 14775

Last change on this file since 14775 was 13939, checked in by vboxsync, 16 years ago
siwtch to the older R0 notification mechanism
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 31.4 KB

Line
1	/* $Rev: 13939 $ */
2	/** @file
3	* VBoxDrv - The VirtualBox Support Driver - Linux specifics.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*
26	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	* Some lines of code to disable the local APIC on x86_64 machines taken
30	* from a Mandriva patch by Gwenole Beauchesne <[email protected]>.
31	*/
32
33	/*******************************************************************************
34	* Header Files *
35	*******************************************************************************/
36	#define LOG_GROUP LOG_GROUP_SUP_DRV
37	#include "../SUPDrvInternal.h"
38	#include "the-linux-kernel.h"
39	#include "version-generated.h"
40
41	#include <iprt/assert.h>
42	#include <iprt/spinlock.h>
43	#include <iprt/semaphore.h>
44	#include <iprt/initterm.h>
45	#include <iprt/process.h>
46	#include <iprt/err.h>
47	#include <iprt/mem.h>
48	#include <VBox/log.h>
49	#include <iprt/mp.h>
50
51	/** @todo figure out the exact version number */
52	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 16)
53	# include <iprt/power.h>
54	# define VBOX_WITH_SUSPEND_NOTIFICATION
55	#endif
56
57	#include <linux/sched.h>
58	#ifdef CONFIG_DEVFS_FS
59	# include <linux/devfs_fs_kernel.h>
60	#endif
61	#ifdef CONFIG_VBOXDRV_AS_MISC
62	# include <linux/miscdevice.h>
63	#endif
64	#ifdef CONFIG_X86_LOCAL_APIC
65	# include <asm/apic.h>
66	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
67	# include <asm/nmi.h>
68	# endif
69	#endif
70	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
71	# include <linux/platform_device.h>
72	#endif
73
74	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
75	# include <asm/pgtable.h>
76	# define global_flush_tlb __flush_tlb_global
77	#endif
78
79	#include <iprt/mem.h>
80
81
82	/* devfs defines */
83	#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
84	# ifdef VBOX_WITH_HARDENING
85	# define VBOX_DEV_FMASK (S_IWUSR \| S_IRUSR)
86	# else
87	# define VBOX_DEV_FMASK (S_IRUGO \| S_IWUGO)
88	# endif
89
90	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
91
92	# define VBOX_REGISTER_DEVFS() \
93	({ \
94	void *rc = NULL; \
95	if (devfs_mk_cdev(MKDEV(DEVICE_MAJOR, 0), \
96	S_IFCHR \| VBOX_DEV_FMASK, \
97	DEVICE_NAME) == 0) \
98	rc = (void )' '; / return not NULL */ \
99	rc; \
100	})
101
102	# define VBOX_UNREGISTER_DEVFS(handle) \
103	devfs_remove(DEVICE_NAME);
104
105	# else /* < 2.6.0 */
106
107	# define VBOX_REGISTER_DEVFS() \
108	devfs_register(NULL, DEVICE_NAME, DEVFS_FL_DEFAULT, \
109	DEVICE_MAJOR, 0, \
110	S_IFCHR \| VBOX_DEV_FMASK, \
111	&gFileOpsVBoxDrv, NULL)
112
113	# define VBOX_UNREGISTER_DEVFS(handle) \
114	if (handle != NULL) \
115	devfs_unregister(handle)
116
117	# endif /* < 2.6.0 */
118	#endif /* CONFIG_DEV_FS && !CONFIG_VBOXDEV_AS_MISC */
119
120	#ifndef CONFIG_VBOXDRV_AS_MISC
121	# if defined(CONFIG_DEVFS_FS) && LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 0)
122	# define VBOX_REGISTER_DEVICE(a,b,c) devfs_register_chrdev(a,b,c)
123	# define VBOX_UNREGISTER_DEVICE(a,b) devfs_unregister_chrdev(a,b)
124	# else
125	# define VBOX_REGISTER_DEVICE(a,b,c) register_chrdev(a,b,c)
126	# define VBOX_UNREGISTER_DEVICE(a,b) unregister_chrdev(a,b)
127	# endif
128	#endif /* !CONFIG_VBOXDRV_AS_MISC */
129
130
131	#ifdef CONFIG_X86_HIGH_ENTRY
132	# error "CONFIG_X86_HIGH_ENTRY is not supported by VBoxDrv at this time."
133	#endif
134
135	#ifdef CONFIG_X86_LOCAL_APIC
136
137	/* If an NMI occurs while we are inside the world switcher the machine will
138	* crash. The Linux NMI watchdog generates periodic NMIs increasing a counter
139	* which is compared with another counter increased in the timer interrupt
140	* handler. We disable the NMI watchdog.
141	*
142	* - Linux >= 2.6.21: The watchdog is disabled by default on i386 and x86_64.
143	* - Linux < 2.6.21: The watchdog is normally enabled by default on x86_64
144	* and disabled on i386.
145	*/
146	# if defined(RT_ARCH_AMD64)
147	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 21) && !defined(VBOX_REDHAT_KABI)
148	# define DO_DISABLE_NMI 1
149	# endif
150	# endif
151
152	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
153	extern int nmi_active;
154	# define nmi_atomic_read(P) *(P)
155	# define nmi_atomic_set(P, V) *(P) = (V)
156	# define nmi_atomic_dec(P) nmi_atomic_set(P, 0)
157	# else
158	# define nmi_atomic_read(P) atomic_read(P)
159	# define nmi_atomic_set(P, V) atomic_set(P, V)
160	# define nmi_atomic_dec(P) atomic_dec(P)
161	# endif
162
163	# ifndef X86_FEATURE_ARCH_PERFMON
164	# define X86_FEATURE_ARCH_PERFMON (332+9) / Intel Architectural PerfMon */
165	# endif
166	# ifndef MSR_ARCH_PERFMON_EVENTSEL0
167	# define MSR_ARCH_PERFMON_EVENTSEL0 0x186
168	# endif
169	# ifndef ARCH_PERFMON_UNHALTED_CORE_CYCLES_PRESENT
170	# define ARCH_PERFMON_UNHALTED_CORE_CYCLES_PRESENT (1 << 0)
171	# endif
172
173	#endif /* CONFIG_X86_LOCAL_APIC */
174
175	#define xstr(s) str(s)
176	#define str(s) #s
177
178
179	/*******************************************************************************
180	* Global Variables *
181	*******************************************************************************/
182	/**
183	* Device extention & session data association structure.
184	*/
185	static SUPDRVDEVEXT g_DevExt;
186
187	/** Registered devfs device handle. */
188	#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
189	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
190	static void *g_hDevFsVBoxDrv = NULL;
191	# else
192	static devfs_handle_t g_hDevFsVBoxDrv = NULL;
193	# endif
194	#endif
195
196	#ifndef CONFIG_VBOXDRV_AS_MISC
197	/** Module major number */
198	#define DEVICE_MAJOR 234
199	/** Saved major device number */
200	static int g_iModuleMajor;
201	#endif /* !CONFIG_VBOXDRV_AS_MISC */
202
203	/** Module parameter.
204	* Not prefixed because the name is used by macros and the end of this file. */
205	static int force_async_tsc = 0;
206
207	/** The module name. */
208	#define DEVICE_NAME "vboxdrv"
209
210	#ifdef RT_ARCH_AMD64
211	/**
212	* Memory for the executable memory heap (in IPRT).
213	*/
214	extern uint8_t g_abExecMemory[1572864]; /* 1.5 MB */
215	__asm__(".section execmemory, \"awx\", @progbits\n\t"
216	".align 32\n\t"
217	".globl g_abExecMemory\n"
218	"g_abExecMemory:\n\t"
219	".zero 1572864\n\t"
220	".type g_abExecMemory, @object\n\t"
221	".size g_abExecMemory, 1572864\n\t"
222	".text\n\t");
223	#endif
224
225
226	/*******************************************************************************
227	* Internal Functions *
228	*******************************************************************************/
229	static int VBoxDrvLinuxInit(void);
230	static void VBoxDrvLinuxUnload(void);
231	static int VBoxDrvLinuxCreate(struct inode pInode, struct file pFilp);
232	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp);
233	#ifdef HAVE_UNLOCKED_IOCTL
234	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
235	#else
236	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg);
237	#endif
238	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
239	static int VBoxDrvLinuxErr2LinuxErr(int);
240	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
241	static int VBoxDrvProbe(struct platform_device *pDev);
242	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State);
243	static int VBoxDrvResume(struct platform_device *pDev);
244	static void VBoxDevRelease(struct device *pDev);
245	#endif
246
247	/** The file_operations structure. */
248	static struct file_operations gFileOpsVBoxDrv =
249	{
250	owner: THIS_MODULE,
251	open: VBoxDrvLinuxCreate,
252	release: VBoxDrvLinuxClose,
253	#ifdef HAVE_UNLOCKED_IOCTL
254	unlocked_ioctl: VBoxDrvLinuxIOCtl,
255	#else
256	ioctl: VBoxDrvLinuxIOCtl,
257	#endif
258	};
259
260	#ifdef CONFIG_VBOXDRV_AS_MISC
261	/** The miscdevice structure. */
262	static struct miscdevice gMiscDevice =
263	{
264	minor: MISC_DYNAMIC_MINOR,
265	name: DEVICE_NAME,
266	fops: &gFileOpsVBoxDrv,
267	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && \
268	LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 17)
269	devfs_name: DEVICE_NAME,
270	# endif
271	};
272	#endif
273
274
275	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
276	static struct platform_driver gPlatformDriver =
277	{
278	.probe = VBoxDrvProbe,
279	.suspend = VBoxDrvSuspend,
280	.resume = VBoxDrvResume,
281	/** @todo .shutdown? */
282	.driver =
283	{
284	.name = "vboxdrv"
285	}
286	};
287
288	static struct platform_device gPlatformDevice =
289	{
290	.name = "vboxdrv",
291	.dev =
292	{
293	.release = VBoxDevRelease
294	}
295	};
296	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
297
298
299	#ifdef CONFIG_X86_LOCAL_APIC
300	# ifdef DO_DISABLE_NMI
301
302	/** Stop AMD NMI watchdog (x86_64 only). */
303	static int stop_k7_watchdog(void)
304	{
305	wrmsr(MSR_K7_EVNTSEL0, 0, 0);
306	return 1;
307	}
308
309	/** Stop Intel P4 NMI watchdog (x86_64 only). */
310	static int stop_p4_watchdog(void)
311	{
312	wrmsr(MSR_P4_IQ_CCCR0, 0, 0);
313	wrmsr(MSR_P4_IQ_CCCR1, 0, 0);
314	wrmsr(MSR_P4_CRU_ESCR0, 0, 0);
315	return 1;
316	}
317
318	/** The new method of detecting the event counter */
319	static int stop_intel_arch_watchdog(void)
320	{
321	unsigned ebx;
322
323	ebx = cpuid_ebx(10);
324	if (!(ebx & ARCH_PERFMON_UNHALTED_CORE_CYCLES_PRESENT))
325	wrmsr(MSR_ARCH_PERFMON_EVENTSEL0, 0, 0);
326	return 1;
327	}
328
329	/** Stop NMI watchdog. */
330	static void vbox_stop_apic_nmi_watchdog(void *unused)
331	{
332	int stopped = 0;
333
334	/* only support LOCAL and IO APICs for now */
335	if ((nmi_watchdog != NMI_LOCAL_APIC) &&
336	(nmi_watchdog != NMI_IO_APIC))
337	return;
338
339	if (nmi_watchdog == NMI_LOCAL_APIC)
340	{
341	switch (boot_cpu_data.x86_vendor)
342	{
343	case X86_VENDOR_AMD:
344	if (strstr(boot_cpu_data.x86_model_id, "Screwdriver"))
345	return;
346	stopped = stop_k7_watchdog();
347	break;
348	case X86_VENDOR_INTEL:
349	if (cpu_has(&boot_cpu_data, X86_FEATURE_ARCH_PERFMON))
350	{
351	stopped = stop_intel_arch_watchdog();
352	break;
353	}
354	stopped = stop_p4_watchdog();
355	break;
356	default:
357	return;
358	}
359	}
360
361	if (stopped)
362	nmi_atomic_dec(&nmi_active);
363	}
364
365	/** Disable LAPIC NMI watchdog. */
366	static void disable_lapic_nmi_watchdog(void)
367	{
368	BUG_ON(nmi_watchdog != NMI_LOCAL_APIC);
369
370	if (nmi_atomic_read(&nmi_active) <= 0)
371	return;
372
373	on_each_cpu(vbox_stop_apic_nmi_watchdog, NULL, 1, 1);
374
375	BUG_ON(nmi_atomic_read(&nmi_active) != 0);
376
377	/* tell do_nmi() and others that we're not active any more */
378	nmi_watchdog = NMI_NONE;
379	}
380
381	/** Shutdown NMI. */
382	static void nmi_cpu_shutdown(void * dummy)
383	{
384	unsigned int vERR, vPC;
385
386	vPC = apic_read(APIC_LVTPC);
387
388	if ((GET_APIC_DELIVERY_MODE(vPC) == APIC_MODE_NMI) && !(vPC & APIC_LVT_MASKED))
389	{
390	vERR = apic_read(APIC_LVTERR);
391	apic_write(APIC_LVTERR, vERR \| APIC_LVT_MASKED);
392	apic_write(APIC_LVTPC, vPC \| APIC_LVT_MASKED);
393	apic_write(APIC_LVTERR, vERR);
394	}
395	}
396
397	static void nmi_shutdown(void)
398	{
399	on_each_cpu(nmi_cpu_shutdown, NULL, 0, 1);
400	}
401	# endif /* DO_DISABLE_NMI */
402	#endif /* CONFIG_X86_LOCAL_APIC */
403
404
405	/**
406	* Initialize module.
407	*
408	* @returns appropriate status code.
409	*/
410	static int __init VBoxDrvLinuxInit(void)
411	{
412	int rc;
413
414	dprintf(("VBoxDrv::ModuleInit\n"));
415
416	#ifdef CONFIG_X86_LOCAL_APIC
417	/*
418	* If an NMI occurs while we are inside the world switcher the macine will crash.
419	* The Linux NMI watchdog generates periodic NMIs increasing a counter which is
420	* compared with another counter increased in the timer interrupt handler. Therefore
421	* we don't allow to setup an NMI watchdog.
422	*/
423	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && !defined(VBOX_REDHAT_KABI)
424	/*
425	* First test: NMI actiated? Works only works with Linux 2.6 -- 2.4 does not export
426	* the nmi_watchdog variable.
427	*/
428	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) \|\| \
429	(defined CONFIG_X86_64 && LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
430	# ifdef DO_DISABLE_NMI
431	if (nmi_atomic_read(&nmi_active) > 0)
432	{
433	printk(KERN_DEBUG DEVICE_NAME ": Trying to deactivate the NMI watchdog...\n");
434
435	switch (nmi_watchdog)
436	{
437	case NMI_LOCAL_APIC:
438	disable_lapic_nmi_watchdog();
439	break;
440	case NMI_NONE:
441	nmi_atomic_dec(&nmi_active);
442	break;
443	}
444
445	if (nmi_atomic_read(&nmi_active) == 0)
446	{
447	nmi_shutdown();
448	printk(KERN_DEBUG DEVICE_NAME ": Successfully done.\n");
449	}
450	else
451	printk(KERN_DEBUG DEVICE_NAME ": Failed!\n");
452	}
453	# endif /* DO_DISABLE_NMI */
454
455	/*
456	* Permanent IO_APIC mode active? No way to handle this!
457	*/
458	if (nmi_watchdog == NMI_IO_APIC)
459	{
460	printk(KERN_ERR DEVICE_NAME
461	": NMI watchdog in IO_APIC mode active -- refused to load the kernel module!\n"
462	DEVICE_NAME
463	": Please disable the NMI watchdog by specifying 'nmi_watchdog=0' at kernel\n"
464	DEVICE_NAME
465	": command line.\n");
466	return -EINVAL;
467	}
468
469	/*
470	* See arch/i386/kernel/nmi.c on >= 2.6.19: -1 means it can never enabled again
471	*/
472	nmi_atomic_set(&nmi_active, -1);
473	printk(KERN_DEBUG DEVICE_NAME ": Trying to deactivate the NMI watchdog permanently...\n");
474
475	/*
476	* Now fall through and see if it actually was enabled before. If so, fail
477	* as we cannot deactivate it cleanly from here.
478	*/
479	# else /* < 2.6.19 */
480	/*
481	* Older 2.6 kernels: nmi_watchdog is not initalized by default
482	*/
483	if (nmi_watchdog != NMI_NONE)
484	goto nmi_activated;
485	# endif
486	# endif /* >= 2.6.0 && !defined(VBOX_REDHAT_KABI) */
487
488	/*
489	* Second test: Interrupt generated by performance counter not masked and can
490	* generate an NMI. Works also with Linux 2.4.
491	*/
492	{
493	unsigned int v, ver, maxlvt;
494
495	v = apic_read(APIC_LVR);
496	ver = GET_APIC_VERSION(v);
497	/* 82489DXs do not report # of LVT entries. */
498	maxlvt = APIC_INTEGRATED(ver) ? GET_APIC_MAXLVT(v) : 2;
499	if (maxlvt >= 4)
500	{
501	/* Read status of performance counter IRQ vector */
502	v = apic_read(APIC_LVTPC);
503
504	/* performance counter generates NMI and is not masked? */
505	if ((GET_APIC_DELIVERY_MODE(v) == APIC_MODE_NMI) && !(v & APIC_LVT_MASKED))
506	{
507	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19) \|\| \
508	(defined CONFIG_X86_64 && LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
509	printk(KERN_ERR DEVICE_NAME
510	": NMI watchdog either active or at least initialized. Please disable the NMI\n"
511	DEVICE_NAME
512	": watchdog by specifying 'nmi_watchdog=0' at kernel command line.\n");
513	return -EINVAL;
514	# else /* < 2.6.19 */
515	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) && !defined(VBOX_REDHAT_KABI)
516	nmi_activated:
517	# endif
518	printk(KERN_ERR DEVICE_NAME
519	": NMI watchdog active -- refused to load the kernel module! Please disable\n"
520	DEVICE_NAME
521	": the NMI watchdog by specifying 'nmi_watchdog=0' at kernel command line.\n");
522	return -EINVAL;
523	# endif /* >= 2.6.19 */
524	}
525	}
526	}
527	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
528	printk(KERN_DEBUG DEVICE_NAME ": Successfully done.\n");
529	# endif /* >= 2.6.19 */
530	#endif /* CONFIG_X86_LOCAL_APIC */
531
532	/*
533	* Check for synchronous/asynchronous TSC mode.
534	*/
535	printk(KERN_DEBUG DEVICE_NAME ": Found %u processor cores.\n", (unsigned)RTMpGetOnlineCount());
536	#ifdef CONFIG_VBOXDRV_AS_MISC
537	rc = misc_register(&gMiscDevice);
538	if (rc)
539	{
540	printk(KERN_ERR DEVICE_NAME ": Can't register misc device! rc=%d\n", rc);
541	return rc;
542	}
543	#else /* !CONFIG_VBOXDRV_AS_MISC */
544	/*
545	* Register character device.
546	*/
547	g_iModuleMajor = DEVICE_MAJOR;
548	rc = VBOX_REGISTER_DEVICE((dev_t)g_iModuleMajor, DEVICE_NAME, &gFileOpsVBoxDrv);
549	if (rc < 0)
550	{
551	dprintf(("VBOX_REGISTER_DEVICE failed with rc=%#x!\n", rc));
552	return rc;
553	}
554
555	/*
556	* Save returned module major number
557	*/
558	if (DEVICE_MAJOR != 0)
559	g_iModuleMajor = DEVICE_MAJOR;
560	else
561	g_iModuleMajor = rc;
562	rc = 0;
563
564	#ifdef CONFIG_DEVFS_FS
565	/*
566	* Register a device entry
567	*/
568	g_hDevFsVBoxDrv = VBOX_REGISTER_DEVFS();
569	if (g_hDevFsVBoxDrv == NULL)
570	{
571	dprintf(("devfs_register failed!\n"));
572	rc = -EINVAL;
573	}
574	#endif
575	#endif /* !CONFIG_VBOXDRV_AS_MISC */
576	if (!rc)
577	{
578	/*
579	* Initialize the runtime.
580	* On AMD64 we'll have to donate the high rwx memory block to the exec allocator.
581	*/
582	rc = RTR0Init(0);
583	if (RT_SUCCESS(rc))
584	{
585	#ifdef RT_ARCH_AMD64
586	rc = RTR0MemExecDonate(&g_abExecMemory[0], sizeof(g_abExecMemory));
587	printk("VBoxDrv: dbg - g_abExecMemory=%p\n", (void *)&g_abExecMemory[0]);
588	#endif
589	/*
590	* Initialize the device extension.
591	*/
592	if (RT_SUCCESS(rc))
593	rc = supdrvInitDevExt(&g_DevExt);
594	if (RT_SUCCESS(rc))
595	{
596	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
597	rc = platform_driver_register(&gPlatformDriver);
598	if (rc == 0)
599	{
600	rc = platform_device_register(&gPlatformDevice);
601	if (rc == 0)
602	#endif
603	{
604	printk(KERN_INFO DEVICE_NAME ": TSC mode is %s, kernel timer mode is "
605	#ifdef VBOX_HRTIMER
606	"'high-res'"
607	#else
608	"'normal'"
609	#endif
610	".\n",
611	g_DevExt.pGip->u32Mode == SUPGIPMODE_SYNC_TSC ? "'synchronous'" : "'asynchronous'");
612	LogFlow(("VBoxDrv::ModuleInit returning %#x\n", rc));
613	printk(KERN_DEBUG DEVICE_NAME ": Successfully loaded version "
614	VBOX_VERSION_STRING " (interface " xstr(SUPDRV_IOC_VERSION) ").\n");
615	return rc;
616	}
617	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
618	else
619	platform_driver_unregister(&gPlatformDriver);
620	}
621	#endif
622	}
623
624	rc = -EINVAL;
625	RTR0Term();
626	}
627	else
628	rc = -EINVAL;
629
630	/*
631	* Failed, cleanup and return the error code.
632	*/
633	#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
634	VBOX_UNREGISTER_DEVFS(g_hDevFsVBoxDrv);
635	#endif
636	}
637	#ifdef CONFIG_VBOXDRV_AS_MISC
638	misc_deregister(&gMiscDevice);
639	dprintf(("VBoxDrv::ModuleInit returning %#x (minor:%d)\n", rc, gMiscDevice.minor));
640	#else
641	VBOX_UNREGISTER_DEVICE(g_iModuleMajor, DEVICE_NAME);
642	dprintf(("VBoxDrv::ModuleInit returning %#x (major:%d)\n", rc, g_iModuleMajor));
643	#endif
644	return rc;
645	}
646
647
648	/**
649	* Unload the module.
650	*/
651	static void __exit VBoxDrvLinuxUnload(void)
652	{
653	int rc;
654	dprintf(("VBoxDrvLinuxUnload\n"));
655	NOREF(rc);
656
657	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
658	platform_device_unregister(&gPlatformDevice);
659	platform_driver_unregister(&gPlatformDriver);
660	#endif
661
662	/*
663	* I Don't think it's possible to unload a driver which processes have
664	* opened, at least we'll blindly assume that here.
665	*/
666	#ifdef CONFIG_VBOXDRV_AS_MISC
667	rc = misc_deregister(&gMiscDevice);
668	if (rc < 0)
669	{
670	dprintf(("misc_deregister failed with rc=%#x\n", rc));
671	}
672	#else /* !CONFIG_VBOXDRV_AS_MISC */
673	# ifdef CONFIG_DEVFS_FS
674	/*
675	* Unregister a device entry
676	*/
677	VBOX_UNREGISTER_DEVFS(g_hDevFsVBoxDrv);
678	# endif /* devfs */
679	VBOX_UNREGISTER_DEVICE(g_iModuleMajor, DEVICE_NAME);
680	#endif /* !CONFIG_VBOXDRV_AS_MISC */
681
682	/*
683	* Destroy GIP, delete the device extension and terminate IPRT.
684	*/
685	supdrvDeleteDevExt(&g_DevExt);
686	RTR0Term();
687	}
688
689
690	/**
691	* Device open. Called on open /dev/vboxdrv
692	*
693	* @param pInode Pointer to inode info structure.
694	* @param pFilp Associated file pointer.
695	*/
696	static int VBoxDrvLinuxCreate(struct inode pInode, struct file pFilp)
697	{
698	int rc;
699	PSUPDRVSESSION pSession;
700	Log(("VBoxDrvLinuxCreate: pFilp=%p pid=%d/%d %s\n", pFilp, RTProcSelf(), current->pid, current->comm));
701
702	#ifdef VBOX_WITH_HARDENING
703	/*
704	* Only root is allowed to access the device, enforce it!
705	*/
706	if (current->euid != 0 /* root */ )
707	{
708	Log(("VBoxDrvLinuxCreate: euid=%d, expected 0 (root)\n", current->euid));
709	return -EPERM;
710	}
711	#endif /* VBOX_WITH_HARDENING */
712
713	/*
714	* Call common code for the rest.
715	*/
716	rc = supdrvCreateSession(&g_DevExt, true /* fUser /, (PSUPDRVSESSION )&pSession);
717	if (!rc)
718	{
719	pSession->Uid = current->uid;
720	pSession->Gid = current->gid;
721	}
722
723	pFilp->private_data = pSession;
724
725	Log(("VBoxDrvLinuxCreate: g_DevExt=%p pSession=%p rc=%d/%d (pid=%d/%d %s)\n",
726	&g_DevExt, pSession, rc, VBoxDrvLinuxErr2LinuxErr(rc),
727	RTProcSelf(), current->pid, current->comm));
728	return VBoxDrvLinuxErr2LinuxErr(rc);
729	}
730
731
732	/**
733	* Close device.
734	*
735	* @param pInode Pointer to inode info structure.
736	* @param pFilp Associated file pointer.
737	*/
738	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp)
739	{
740	Log(("VBoxDrvLinuxClose: pFilp=%p pSession=%p pid=%d/%d %s\n",
741	pFilp, pFilp->private_data, RTProcSelf(), current->pid, current->comm));
742	supdrvCloseSession(&g_DevExt, (PSUPDRVSESSION)pFilp->private_data);
743	pFilp->private_data = NULL;
744	return 0;
745	}
746
747
748	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
749	/**
750	* Dummy device release function. We have to provide this function,
751	* otherwise the kernel will complain.
752	*
753	* @param pDev Pointer to the platform device.
754	*/
755	static void VBoxDevRelease(struct device *pDev)
756	{
757	}
758
759	/**
760	* Dummy probe function.
761	*
762	* @param pDev Pointer to the platform device.
763	*/
764	static int VBoxDrvProbe(struct platform_device *pDev)
765	{
766	return 0;
767	}
768
769	/**
770	* Suspend callback.
771	* @param pDev Pointer to the platform device.
772	* @param State message type, see Documentation/power/devices.txt.
773	*/
774	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State)
775	{
776	RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
777	return 0;
778	}
779
780	/**
781	* Resume callback.
782	*
783	* @param pDev Pointer to the platform device.
784	*/
785	static int VBoxDrvResume(struct platform_device *pDev)
786	{
787	RTPowerSignalEvent(RTPOWEREVENT_RESUME);
788	return 0;
789	}
790	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
791
792
793	/**
794	* Device I/O Control entry point.
795	*
796	* @param pFilp Associated file pointer.
797	* @param uCmd The function specified to ioctl().
798	* @param ulArg The argument specified to ioctl().
799	*/
800	#ifdef HAVE_UNLOCKED_IOCTL
801	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
802	#else
803	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg)
804	#endif
805	{
806	/*
807	* Deal with the two high-speed IOCtl that takes it's arguments from
808	* the session and iCmd, and only returns a VBox status code.
809	*/
810	#ifdef HAVE_UNLOCKED_IOCTL
811	if (RT_LIKELY( uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
812	\|\| uCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
813	\|\| uCmd == SUP_IOCTL_FAST_DO_NOP))
814	return supdrvIOCtlFast(uCmd, ulArg, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data);
815	return VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg);
816
817	#else /* !HAVE_UNLOCKED_IOCTL */
818
819	int rc;
820	unlock_kernel();
821	if (RT_LIKELY( uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
822	\|\| uCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
823	\|\| uCmd == SUP_IOCTL_FAST_DO_NOP))
824	rc = supdrvIOCtlFast(uCmd, ulArg, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data);
825	else
826	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg);
827	lock_kernel();
828	return rc;
829	#endif /* !HAVE_UNLOCKED_IOCTL */
830	}
831
832
833	/**
834	* Device I/O Control entry point.
835	*
836	* @param pFilp Associated file pointer.
837	* @param uCmd The function specified to ioctl().
838	* @param ulArg The argument specified to ioctl().
839	*/
840	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
841	{
842	int rc;
843	SUPREQHDR Hdr;
844	PSUPREQHDR pHdr;
845	uint32_t cbBuf;
846
847	Log6(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
848
849	/*
850	* Read the header.
851	*/
852	if (RT_UNLIKELY(copy_from_user(&Hdr, (void *)ulArg, sizeof(Hdr))))
853	{
854	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx,) failed; uCmd=%#x.\n", ulArg, uCmd));
855	return -EFAULT;
856	}
857	if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
858	{
859	Log(("VBoxDrvLinuxIOCtl: bad header magic %#x; uCmd=%#x\n", Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, uCmd));
860	return -EINVAL;
861	}
862
863	/*
864	* Buffer the request.
865	*/
866	cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
867	if (RT_UNLIKELY(cbBuf > _1M*16))
868	{
869	Log(("VBoxDrvLinuxIOCtl: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
870	return -E2BIG;
871	}
872	if (RT_UNLIKELY(cbBuf != _IOC_SIZE(uCmd) && _IOC_SIZE(uCmd)))
873	{
874	Log(("VBoxDrvLinuxIOCtl: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x.\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
875	return -EINVAL;
876	}
877	pHdr = RTMemAlloc(cbBuf);
878	if (RT_UNLIKELY(!pHdr))
879	{
880	OSDBGPRINT(("VBoxDrvLinuxIOCtl: failed to allocate buffer of %d bytes for uCmd=%#x.\n", cbBuf, uCmd));
881	return -ENOMEM;
882	}
883	if (RT_UNLIKELY(copy_from_user(pHdr, (void *)ulArg, Hdr.cbIn)))
884	{
885	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx, %#x) failed; uCmd=%#x.\n", ulArg, Hdr.cbIn, uCmd));
886	RTMemFree(pHdr);
887	return -EFAULT;
888	}
889
890	/*
891	* Process the IOCtl.
892	*/
893	rc = supdrvIOCtl(uCmd, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data, pHdr);
894
895	/*
896	* Copy ioctl data and output buffer back to user space.
897	*/
898	if (RT_LIKELY(!rc))
899	{
900	uint32_t cbOut = pHdr->cbOut;
901	if (RT_UNLIKELY(cbOut > cbBuf))
902	{
903	OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n", cbOut, cbBuf, uCmd));
904	cbOut = cbBuf;
905	}
906	if (RT_UNLIKELY(copy_to_user((void *)ulArg, pHdr, cbOut)))
907	{
908	/* this is really bad! */
909	OSDBGPRINT(("VBoxDrvLinuxIOCtl: copy_to_user(%#lx,,%#x); uCmd=%#x!\n", ulArg, cbOut, uCmd));
910	rc = -EFAULT;
911	}
912	}
913	else
914	{
915	Log(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
916	rc = -EINVAL;
917	}
918	RTMemFree(pHdr);
919
920	Log6(("VBoxDrvLinuxIOCtl: returns %d (pid=%d/%d)\n", rc, RTProcSelf(), current->pid));
921	return rc;
922	}
923
924
925	/**
926	* The SUPDRV IDC entry point.
927	*
928	* @returns VBox status code, see supdrvIDC.
929	* @param iReq The request code.
930	* @param pReq The request.
931	*/
932	int VBOXCALL SUPDrvLinuxIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
933	{
934	PSUPDRVSESSION pSession;
935
936	/*
937	* Some quick validations.
938	*/
939	if (RT_UNLIKELY(!VALID_PTR(pReq)))
940	return VERR_INVALID_POINTER;
941
942	pSession = pReq->pSession;
943	if (pSession)
944	{
945	if (RT_UNLIKELY(!VALID_PTR(pSession)))
946	return VERR_INVALID_PARAMETER;
947	if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
948	return VERR_INVALID_PARAMETER;
949	}
950	else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
951	return VERR_INVALID_PARAMETER;
952
953	/*
954	* Do the job.
955	*/
956	return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
957	}
958
959	EXPORT_SYMBOL(SUPDrvLinuxIDC);
960
961
962	/**
963	* Initializes any OS specific object creator fields.
964	*/
965	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
966	{
967	NOREF(pObj);
968	NOREF(pSession);
969	}
970
971
972	/**
973	* Checks if the session can access the object.
974	*
975	* @returns true if a decision has been made.
976	* @returns false if the default access policy should be applied.
977	*
978	* @param pObj The object in question.
979	* @param pSession The session wanting to access the object.
980	* @param pszObjName The object name, can be NULL.
981	* @param prc Where to store the result when returning true.
982	*/
983	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
984	{
985	NOREF(pObj);
986	NOREF(pSession);
987	NOREF(pszObjName);
988	NOREF(prc);
989	return false;
990	}
991
992
993	bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
994	{
995	return force_async_tsc != 0;
996	}
997
998
999	/**
1000	* Converts a supdrv error code to an linux error code.
1001	*
1002	* @returns corresponding linux error code.
1003	* @param rc supdrv error code (SUPDRV_ERR_* defines).
1004	*/
1005	static int VBoxDrvLinuxErr2LinuxErr(int rc)
1006	{
1007	switch (rc)
1008	{
1009	case 0: return 0;
1010	case SUPDRV_ERR_GENERAL_FAILURE: return -EACCES;
1011	case SUPDRV_ERR_INVALID_PARAM: return -EINVAL;
1012	case SUPDRV_ERR_INVALID_MAGIC: return -EILSEQ;
1013	case SUPDRV_ERR_INVALID_HANDLE: return -ENXIO;
1014	case SUPDRV_ERR_INVALID_POINTER: return -EFAULT;
1015	case SUPDRV_ERR_LOCK_FAILED: return -ENOLCK;
1016	case SUPDRV_ERR_ALREADY_LOADED: return -EEXIST;
1017	case SUPDRV_ERR_PERMISSION_DENIED: return -EPERM;
1018	case SUPDRV_ERR_VERSION_MISMATCH: return -ENOSYS;
1019	case SUPDRV_ERR_IDT_FAILED: return -1000;
1020	}
1021
1022	return -EPERM;
1023	}
1024
1025
1026	RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
1027	{
1028	#if 1
1029	va_list args;
1030	char szMsg[512];
1031
1032	va_start(args, pszFormat);
1033	vsnprintf(szMsg, sizeof(szMsg) - 1, pszFormat, args);
1034	szMsg[sizeof(szMsg) - 1] = '\0';
1035	printk("%s", szMsg);
1036	va_end(args);
1037	#else
1038	/* forward to printf - needs some more GCC hacking to fix ebp... */
1039	__asm__ __volatile__ ("mov %0, %esp\n\t"
1040	"jmp %1\n\t",
1041	:: "r" ((uintptr_t)&pszFormat - 4),
1042	"m" (printk));
1043	#endif
1044	return 0;
1045	}
1046
1047	module_init(VBoxDrvLinuxInit);
1048	module_exit(VBoxDrvLinuxUnload);
1049
1050	MODULE_AUTHOR("Sun Microsystems, Inc.");
1051	MODULE_DESCRIPTION("VirtualBox Support Driver");
1052	MODULE_LICENSE("GPL");
1053	#ifdef MODULE_VERSION
1054	MODULE_VERSION(VBOX_VERSION_STRING " (" xstr(SUPDRV_IOC_VERSION) ")");
1055	#endif
1056
1057	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
1058	module_param(force_async_tsc, int, 0444);
1059	#else
1060	MODULE_PARM(force_async_tsc, "i");
1061	#endif
1062	MODULE_PARM_DESC(force_async_tsc, "force the asynchronous TSC mode");
1063

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

source: vbox/trunk/src/VBox/HostDrivers/Support/linux/SUPDrv-linux.c@ 14775

Download in other formats: