SUPDrv-linux.c@ 57839

Last change on this file since 57839 was 57839, checked in by vboxsync, 9 years ago
HostDrivers/linux: don't check the error code of misc_deregister(), this doesn't work in Linux 4.3 and it's useless anyway
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.1 KB

Line
1	/* $Rev: 57839 $ */
2	/** @file
3	* VBoxDrv - The VirtualBox Support Driver - Linux specifics.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
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
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP LOG_GROUP_SUP_DRV
32	#include "../SUPDrvInternal.h"
33	#include "the-linux-kernel.h"
34	#include "version-generated.h"
35	#include "product-generated.h"
36
37	#include <iprt/assert.h>
38	#include <iprt/spinlock.h>
39	#include <iprt/semaphore.h>
40	#include <iprt/initterm.h>
41	#include <iprt/process.h>
42	#include <VBox/err.h>
43	#include <iprt/mem.h>
44	#include <VBox/log.h>
45	#include <iprt/mp.h>
46
47	/** @todo figure out the exact version number */
48	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 16)
49	# include <iprt/power.h>
50	# define VBOX_WITH_SUSPEND_NOTIFICATION
51	#endif
52
53	#include <linux/sched.h>
54	#ifdef CONFIG_DEVFS_FS
55	# include <linux/devfs_fs_kernel.h>
56	#endif
57	#ifdef CONFIG_VBOXDRV_AS_MISC
58	# include <linux/miscdevice.h>
59	#endif
60	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
61	# include <linux/platform_device.h>
62	#endif
63	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)) && defined(SUPDRV_WITH_MSR_PROBER)
64	# define SUPDRV_LINUX_HAS_SAFE_MSR_API
65	# include <asm/msr.h>
66	#endif
67	#include <iprt/asm-amd64-x86.h>
68
69
70	/*********************************************************************************************************************************
71	* Defined Constants And Macros *
72	*********************************************************************************************************************************/
73	/* check kernel version */
74	# ifndef SUPDRV_AGNOSTIC
75	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
76	# error Unsupported kernel version!
77	# endif
78	# endif
79
80	/* devfs defines */
81	#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
82	# ifdef VBOX_WITH_HARDENING
83	# define VBOX_DEV_FMASK (S_IWUSR \| S_IRUSR)
84	# else
85	# define VBOX_DEV_FMASK (S_IRUGO \| S_IWUGO)
86	# endif
87	#endif /* CONFIG_DEV_FS && !CONFIG_VBOXDEV_AS_MISC */
88
89	#ifdef CONFIG_X86_HIGH_ENTRY
90	# error "CONFIG_X86_HIGH_ENTRY is not supported by VBoxDrv at this time."
91	#endif
92
93	/* We cannot include x86.h, so we copy the defines we need here: */
94	#define X86_EFL_IF RT_BIT(9)
95	#define X86_EFL_AC RT_BIT(18)
96	#define X86_EFL_DF RT_BIT(10)
97	#define X86_EFL_IOPL (RT_BIT(12) \| RT_BIT(13))
98
99	/* To include the version number of VirtualBox into kernel backtraces: */
100	#define VBoxDrvLinuxVersion RT_CONCAT3(RT_CONCAT(VBOX_VERSION_MAJOR, _), \
101	RT_CONCAT(VBOX_VERSION_MINOR, _), \
102	VBOX_VERSION_BUILD)
103	#define VBoxDrvLinuxIOCtl RT_CONCAT(VBoxDrvLinuxIOCtl_,VBoxDrvLinuxVersion)
104
105
106
107	/*********************************************************************************************************************************
108	* Internal Functions *
109	*********************************************************************************************************************************/
110	static int VBoxDrvLinuxInit(void);
111	static void VBoxDrvLinuxUnload(void);
112	static int VBoxDrvLinuxCreateSys(struct inode pInode, struct file pFilp);
113	static int VBoxDrvLinuxCreateUsr(struct inode pInode, struct file pFilp);
114	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp);
115	#ifdef HAVE_UNLOCKED_IOCTL
116	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
117	#else
118	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg);
119	#endif
120	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PSUPDRVSESSION pSession);
121	static int VBoxDrvLinuxErr2LinuxErr(int);
122	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
123	static int VBoxDrvProbe(struct platform_device *pDev);
124	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
125	static int VBoxDrvSuspend(struct device *pDev);
126	static int VBoxDrvResume(struct device *pDev);
127	# else
128	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State);
129	static int VBoxDrvResume(struct platform_device *pDev);
130	# endif
131	static void VBoxDevRelease(struct device *pDev);
132	#endif
133
134
135	/*********************************************************************************************************************************
136	* Global Variables *
137	*********************************************************************************************************************************/
138	/**
139	* Device extention & session data association structure.
140	*/
141	static SUPDRVDEVEXT g_DevExt;
142
143	#ifndef CONFIG_VBOXDRV_AS_MISC
144	/** Module major number for vboxdrv. */
145	#define DEVICE_MAJOR_SYS 234
146	/** Saved major device number for vboxdrv. */
147	static int g_iModuleMajorSys;
148	/** Module major number for vboxdrvu. */
149	#define DEVICE_MAJOR_USR 235
150	/** Saved major device number for vboxdrvu. */
151	static int g_iModuleMajorUsr;
152	#endif /* !CONFIG_VBOXDRV_AS_MISC */
153
154	/** Module parameter.
155	* Not prefixed because the name is used by macros and the end of this file. */
156	static int force_async_tsc = 0;
157
158	/** The system device name. */
159	#define DEVICE_NAME_SYS "vboxdrv"
160	/** The user device name. */
161	#define DEVICE_NAME_USR "vboxdrvu"
162
163	#if (defined(RT_ARCH_AMD64) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)) \|\| defined(VBOX_WITH_TEXT_MODMEM_HACK)
164	/**
165	* Memory for the executable memory heap (in IPRT).
166	*/
167	# ifdef DEBUG
168	# define EXEC_MEMORY_SIZE 6291456 /* 6 MB */
169	# else
170	# define EXEC_MEMORY_SIZE 1572864 /* 1.5 MB */
171	# endif
172	extern uint8_t g_abExecMemory[EXEC_MEMORY_SIZE];
173	# ifndef VBOX_WITH_TEXT_MODMEM_HACK
174	__asm__(".section execmemory, \"awx\", @progbits\n\t"
175	".align 32\n\t"
176	".globl g_abExecMemory\n"
177	"g_abExecMemory:\n\t"
178	".zero " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
179	".type g_abExecMemory, @object\n\t"
180	".size g_abExecMemory, " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
181	".text\n\t");
182	# else
183	__asm__(".text\n\t"
184	".align 4096\n\t"
185	".globl g_abExecMemory\n"
186	"g_abExecMemory:\n\t"
187	".zero " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
188	".type g_abExecMemory, @object\n\t"
189	".size g_abExecMemory, " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
190	".text\n\t");
191	# endif
192	#endif
193
194	/** The file_operations structure. */
195	static struct file_operations gFileOpsVBoxDrvSys =
196	{
197	owner: THIS_MODULE,
198	open: VBoxDrvLinuxCreateSys,
199	release: VBoxDrvLinuxClose,
200	#ifdef HAVE_UNLOCKED_IOCTL
201	unlocked_ioctl: VBoxDrvLinuxIOCtl,
202	#else
203	ioctl: VBoxDrvLinuxIOCtl,
204	#endif
205	};
206
207	/** The file_operations structure. */
208	static struct file_operations gFileOpsVBoxDrvUsr =
209	{
210	owner: THIS_MODULE,
211	open: VBoxDrvLinuxCreateUsr,
212	release: VBoxDrvLinuxClose,
213	#ifdef HAVE_UNLOCKED_IOCTL
214	unlocked_ioctl: VBoxDrvLinuxIOCtl,
215	#else
216	ioctl: VBoxDrvLinuxIOCtl,
217	#endif
218	};
219
220	#ifdef CONFIG_VBOXDRV_AS_MISC
221	/** The miscdevice structure for vboxdrv. */
222	static struct miscdevice gMiscDeviceSys =
223	{
224	minor: MISC_DYNAMIC_MINOR,
225	name: DEVICE_NAME_SYS,
226	fops: &gFileOpsVBoxDrvSys,
227	# if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 17)
228	devfs_name: DEVICE_NAME_SYS,
229	# endif
230	};
231	/** The miscdevice structure for vboxdrvu. */
232	static struct miscdevice gMiscDeviceUsr =
233	{
234	minor: MISC_DYNAMIC_MINOR,
235	name: DEVICE_NAME_USR,
236	fops: &gFileOpsVBoxDrvUsr,
237	# if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 17)
238	devfs_name: DEVICE_NAME_USR,
239	# endif
240	};
241	#endif
242
243
244	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
245	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
246	static struct dev_pm_ops gPlatformPMOps =
247	{
248	.suspend = VBoxDrvSuspend, /* before entering deep sleep */
249	.resume = VBoxDrvResume, /* after wakeup from deep sleep */
250	.freeze = VBoxDrvSuspend, /* before creating hibernation image */
251	.restore = VBoxDrvResume, /* after waking up from hibernation */
252	};
253	# endif
254
255	static struct platform_driver gPlatformDriver =
256	{
257	.probe = VBoxDrvProbe,
258	# if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)
259	.suspend = VBoxDrvSuspend,
260	.resume = VBoxDrvResume,
261	# endif
262	/** @todo .shutdown? */
263	.driver =
264	{
265	.name = "vboxdrv",
266	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
267	.pm = &gPlatformPMOps,
268	# endif
269	}
270	};
271
272	static struct platform_device gPlatformDevice =
273	{
274	.name = "vboxdrv",
275	.dev =
276	{
277	.release = VBoxDevRelease
278	}
279	};
280	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
281
282
283	DECLINLINE(RTUID) vboxdrvLinuxUid(void)
284	{
285	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
286	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
287	return from_kuid(current_user_ns(), current->cred->uid);
288	# else
289	return current->cred->uid;
290	# endif
291	#else
292	return current->uid;
293	#endif
294	}
295
296	DECLINLINE(RTGID) vboxdrvLinuxGid(void)
297	{
298	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
299	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
300	return from_kgid(current_user_ns(), current->cred->gid);
301	# else
302	return current->cred->gid;
303	# endif
304	#else
305	return current->gid;
306	#endif
307	}
308
309	DECLINLINE(RTUID) vboxdrvLinuxEuid(void)
310	{
311	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
312	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)
313	return from_kuid(current_user_ns(), current->cred->euid);
314	# else
315	return current->cred->euid;
316	# endif
317	#else
318	return current->euid;
319	#endif
320	}
321
322	/**
323	* Initialize module.
324	*
325	* @returns appropriate status code.
326	*/
327	static int __init VBoxDrvLinuxInit(void)
328	{
329	int rc;
330
331	/*
332	* Check for synchronous/asynchronous TSC mode.
333	*/
334	printk(KERN_DEBUG "vboxdrv: Found %u processor cores\n", (unsigned)RTMpGetOnlineCount());
335	#ifdef CONFIG_VBOXDRV_AS_MISC
336	rc = misc_register(&gMiscDeviceSys);
337	if (rc)
338	{
339	printk(KERN_ERR "vboxdrv: Can't register system misc device! rc=%d\n", rc);
340	return rc;
341	}
342	rc = misc_register(&gMiscDeviceUsr);
343	if (rc)
344	{
345	printk(KERN_ERR "vboxdrv: Can't register user misc device! rc=%d\n", rc);
346	misc_deregister(&gMiscDeviceSys);
347	return rc;
348	}
349	#else /* !CONFIG_VBOXDRV_AS_MISC */
350	/*
351	* Register character devices and save the returned major numbers.
352	*/
353	/* /dev/vboxdrv */
354	g_iModuleMajorSys = DEVICE_MAJOR_SYS;
355	rc = register_chrdev((dev_t)g_iModuleMajorSys, DEVICE_NAME_SYS, &gFileOpsVBoxDrvSys);
356	if (rc < 0)
357	{
358	Log(("register_chrdev() failed with rc=%#x for vboxdrv!\n", rc));
359	return rc;
360	}
361	if (DEVICE_MAJOR_SYS != 0)
362	g_iModuleMajorSys = DEVICE_MAJOR_SYS;
363	else
364	g_iModuleMajorSys = rc;
365
366	/* /dev/vboxdrvu */
367	/** @todo Use a minor number of this bugger (not sure if this code is used
368	* though, so not bothering right now.) */
369	g_iModuleMajorUsr = DEVICE_MAJOR_USR;
370	rc = register_chrdev((dev_t)g_iModuleMajorUsr, DEVICE_NAME_USR, &gFileOpsVBoxDrvUsr);
371	if (rc < 0)
372	{
373	Log(("register_chrdev() failed with rc=%#x for vboxdrv!\n", rc));
374	return rc;
375	}
376	if (DEVICE_MAJOR_USR != 0)
377	g_iModuleMajorUsr = DEVICE_MAJOR_USR;
378	else
379	g_iModuleMajorUsr = rc;
380	rc = 0;
381
382	# ifdef CONFIG_DEVFS_FS
383	/*
384	* Register a device entry
385	*/
386	if ( devfs_mk_cdev(MKDEV(DEVICE_MAJOR_SYS, 0), S_IFCHR \| VBOX_DEV_FMASK, DEVICE_NAME_SYS) != 0
387	\|\| devfs_mk_cdev(MKDEV(DEVICE_MAJOR_USR, 0), S_IFCHR \| VBOX_DEV_FMASK, DEVICE_NAME_USR) != 0)
388	{
389	Log(("devfs_register failed!\n"));
390	rc = -EINVAL;
391	}
392	# endif
393	#endif /* !CONFIG_VBOXDRV_AS_MISC */
394	if (!rc)
395	{
396	/*
397	* Initialize the runtime.
398	* On AMD64 we'll have to donate the high rwx memory block to the exec allocator.
399	*/
400	rc = RTR0Init(0);
401	if (RT_SUCCESS(rc))
402	{
403	#if (defined(RT_ARCH_AMD64) && LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)) \|\| defined(VBOX_WITH_TEXT_MODMEM_HACK)
404	# ifdef VBOX_WITH_TEXT_MODMEM_HACK
405	set_memory_x(&g_abExecMemory[0], sizeof(g_abExecMemory) / PAGE_SIZE);
406	set_memory_rw(&g_abExecMemory[0], sizeof(g_abExecMemory) / PAGE_SIZE);
407	# endif
408	rc = RTR0MemExecDonate(&g_abExecMemory[0], sizeof(g_abExecMemory));
409	printk(KERN_DEBUG "VBoxDrv: dbg - g_abExecMemory=%p\n", (void *)&g_abExecMemory[0]);
410	#endif
411	Log(("VBoxDrv::ModuleInit\n"));
412
413	/*
414	* Initialize the device extension.
415	*/
416	if (RT_SUCCESS(rc))
417	rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
418	if (RT_SUCCESS(rc))
419	{
420	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
421	rc = platform_driver_register(&gPlatformDriver);
422	if (rc == 0)
423	{
424	rc = platform_device_register(&gPlatformDevice);
425	if (rc == 0)
426	#endif
427	{
428	printk(KERN_INFO "vboxdrv: TSC mode is %s, tentative frequency %llu Hz\n",
429	SUPGetGIPModeName(g_DevExt.pGip), g_DevExt.pGip->u64CpuHz);
430	LogFlow(("VBoxDrv::ModuleInit returning %#x\n", rc));
431	printk(KERN_DEBUG "vboxdrv: Successfully loaded version "
432	VBOX_VERSION_STRING " (interface " RT_XSTR(SUPDRV_IOC_VERSION) ")\n");
433	return rc;
434	}
435	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
436	else
437	platform_driver_unregister(&gPlatformDriver);
438	}
439	#endif
440	}
441
442	rc = -EINVAL;
443	RTR0TermForced();
444	}
445	else
446	rc = -EINVAL;
447
448	/*
449	* Failed, cleanup and return the error code.
450	*/
451	#if defined(CONFIG_DEVFS_FS) && !defined(CONFIG_VBOXDRV_AS_MISC)
452	devfs_remove(DEVICE_NAME_SYS);
453	devfs_remove(DEVICE_NAME_USR);
454	#endif
455	}
456	#ifdef CONFIG_VBOXDRV_AS_MISC
457	misc_deregister(&gMiscDeviceSys);
458	misc_deregister(&gMiscDeviceUsr);
459	Log(("VBoxDrv::ModuleInit returning %#x (minor:%d & %d)\n", rc, gMiscDeviceSys.minor, gMiscDeviceUsr.minor));
460	#else
461	unregister_chrdev(g_iModuleMajorUsr, DEVICE_NAME_USR);
462	unregister_chrdev(g_iModuleMajorSys, DEVICE_NAME_SYS);
463	Log(("VBoxDrv::ModuleInit returning %#x (major:%d & %d)\n", rc, g_iModuleMajorSys, g_iModuleMajorUsr));
464	#endif
465	return rc;
466	}
467
468
469	/**
470	* Unload the module.
471	*/
472	static void __exit VBoxDrvLinuxUnload(void)
473	{
474	int rc;
475	Log(("VBoxDrvLinuxUnload\n"));
476	NOREF(rc);
477
478	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
479	platform_device_unregister(&gPlatformDevice);
480	platform_driver_unregister(&gPlatformDriver);
481	#endif
482
483	/*
484	* I Don't think it's possible to unload a driver which processes have
485	* opened, at least we'll blindly assume that here.
486	*/
487	#ifdef CONFIG_VBOXDRV_AS_MISC
488	misc_deregister(&gMiscDeviceUsr);
489	misc_deregister(&gMiscDeviceSys);
490	#else /* !CONFIG_VBOXDRV_AS_MISC */
491	# ifdef CONFIG_DEVFS_FS
492	/*
493	* Unregister a device entry
494	*/
495	devfs_remove(DEVICE_NAME_USR);
496	devfs_remove(DEVICE_NAME_SYS);
497	# endif /* devfs */
498	unregister_chrdev(g_iModuleMajorUsr, DEVICE_NAME_USR);
499	unregister_chrdev(g_iModuleMajorSys, DEVICE_NAME_SYS);
500	#endif /* !CONFIG_VBOXDRV_AS_MISC */
501
502	/*
503	* Destroy GIP, delete the device extension and terminate IPRT.
504	*/
505	supdrvDeleteDevExt(&g_DevExt);
506	RTR0TermForced();
507	}
508
509
510	/**
511	* Common open code.
512	*
513	* @param pInode Pointer to inode info structure.
514	* @param pFilp Associated file pointer.
515	* @param fUnrestricted Indicates which device node which was opened.
516	*/
517	static int vboxdrvLinuxCreateCommon(struct inode pInode, struct file pFilp, bool fUnrestricted)
518	{
519	int rc;
520	PSUPDRVSESSION pSession;
521	Log(("VBoxDrvLinuxCreate: pFilp=%p pid=%d/%d %s\n", pFilp, RTProcSelf(), current->pid, current->comm));
522
523	#ifdef VBOX_WITH_HARDENING
524	/*
525	* Only root is allowed to access the unrestricted device, enforce it!
526	*/
527	if ( fUnrestricted
528	&& vboxdrvLinuxEuid() != 0 /* root */ )
529	{
530	Log(("VBoxDrvLinuxCreate: euid=%d, expected 0 (root)\n", vboxdrvLinuxEuid()));
531	return -EPERM;
532	}
533	#endif /* VBOX_WITH_HARDENING */
534
535	/*
536	* Call common code for the rest.
537	*/
538	rc = supdrvCreateSession(&g_DevExt, true /* fUser */, fUnrestricted, &pSession);
539	if (!rc)
540	{
541	pSession->Uid = vboxdrvLinuxUid();
542	pSession->Gid = vboxdrvLinuxGid();
543	}
544
545	pFilp->private_data = pSession;
546
547	Log(("VBoxDrvLinuxCreate: g_DevExt=%p pSession=%p rc=%d/%d (pid=%d/%d %s)\n",
548	&g_DevExt, pSession, rc, VBoxDrvLinuxErr2LinuxErr(rc),
549	RTProcSelf(), current->pid, current->comm));
550	return VBoxDrvLinuxErr2LinuxErr(rc);
551	}
552
553
554	/** /dev/vboxdrv. */
555	static int VBoxDrvLinuxCreateSys(struct inode pInode, struct file pFilp)
556	{
557	return vboxdrvLinuxCreateCommon(pInode, pFilp, true);
558	}
559
560
561	/** /dev/vboxdrvu. */
562	static int VBoxDrvLinuxCreateUsr(struct inode pInode, struct file pFilp)
563	{
564	return vboxdrvLinuxCreateCommon(pInode, pFilp, false);
565	}
566
567
568	/**
569	* Close device.
570	*
571	* @param pInode Pointer to inode info structure.
572	* @param pFilp Associated file pointer.
573	*/
574	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp)
575	{
576	Log(("VBoxDrvLinuxClose: pFilp=%p pSession=%p pid=%d/%d %s\n",
577	pFilp, pFilp->private_data, RTProcSelf(), current->pid, current->comm));
578	supdrvSessionRelease((PSUPDRVSESSION)pFilp->private_data);
579	pFilp->private_data = NULL;
580	return 0;
581	}
582
583
584	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
585	/**
586	* Dummy device release function. We have to provide this function,
587	* otherwise the kernel will complain.
588	*
589	* @param pDev Pointer to the platform device.
590	*/
591	static void VBoxDevRelease(struct device *pDev)
592	{
593	}
594
595	/**
596	* Dummy probe function.
597	*
598	* @param pDev Pointer to the platform device.
599	*/
600	static int VBoxDrvProbe(struct platform_device *pDev)
601	{
602	return 0;
603	}
604
605	/**
606	* Suspend callback.
607	* @param pDev Pointer to the platform device.
608	* @param State message type, see Documentation/power/devices.txt.
609	*/
610	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
611	static int VBoxDrvSuspend(struct device *pDev)
612	# else
613	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State)
614	# endif
615	{
616	RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
617	return 0;
618	}
619
620	/**
621	* Resume callback.
622	*
623	* @param pDev Pointer to the platform device.
624	*/
625	# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
626	static int VBoxDrvResume(struct device *pDev)
627	# else
628	static int VBoxDrvResume(struct platform_device *pDev)
629	# endif
630	{
631	RTPowerSignalEvent(RTPOWEREVENT_RESUME);
632	return 0;
633	}
634	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
635
636
637	/**
638	* Device I/O Control entry point.
639	*
640	* @param pFilp Associated file pointer.
641	* @param uCmd The function specified to ioctl().
642	* @param ulArg The argument specified to ioctl().
643	*/
644	#ifdef HAVE_UNLOCKED_IOCTL
645	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
646	#else
647	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg)
648	#endif
649	{
650	PSUPDRVSESSION pSession = (PSUPDRVSESSION)pFilp->private_data;
651	int rc;
652	#if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
653	RTCCUINTREG fSavedEfl;
654
655	/*
656	* Refuse all I/O control calls if we've ever detected EFLAGS.AC being cleared.
657	*
658	* This isn't a problem, as there is absolutely nothing in the kernel context that
659	* depend on user context triggering cleanups. That would be pretty wild, right?
660	*/
661	if (RT_UNLIKELY(g_DevExt.cBadContextCalls > 0))
662	{
663	SUPR0Printf("VBoxDrvLinuxIOCtl: EFLAGS.AC=0 detected %u times, refusing all I/O controls!\n", g_DevExt.cBadContextCalls);
664	return ESPIPE;
665	}
666
667	fSavedEfl = ASMAddFlags(X86_EFL_AC);
668	# else
669	stac();
670	# endif
671
672	/*
673	* Deal with the two high-speed IOCtl that takes it's arguments from
674	* the session and iCmd, and only returns a VBox status code.
675	*/
676	#ifdef HAVE_UNLOCKED_IOCTL
677	if (RT_LIKELY( ( uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
678	\|\| uCmd == SUP_IOCTL_FAST_DO_HM_RUN
679	\|\| uCmd == SUP_IOCTL_FAST_DO_NOP)
680	&& pSession->fUnrestricted == true))
681	rc = supdrvIOCtlFast(uCmd, ulArg, &g_DevExt, pSession);
682	else
683	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
684	#else /* !HAVE_UNLOCKED_IOCTL */
685	unlock_kernel();
686	if (RT_LIKELY( ( uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
687	\|\| uCmd == SUP_IOCTL_FAST_DO_HM_RUN
688	\|\| uCmd == SUP_IOCTL_FAST_DO_NOP)
689	&& pSession->fUnrestricted == true))
690	rc = supdrvIOCtlFast(uCmd, ulArg, &g_DevExt, pSession);
691	else
692	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
693	lock_kernel();
694	#endif /* !HAVE_UNLOCKED_IOCTL */
695
696	#if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
697	/*
698	* Before we restore AC and the rest of EFLAGS, check if the IOCtl handler code
699	* accidentially modified it or some other important flag.
700	*/
701	if (RT_UNLIKELY( (ASMGetFlags() & (X86_EFL_AC \| X86_EFL_IF \| X86_EFL_DF \| X86_EFL_IOPL))
702	!= ((fSavedEfl & (X86_EFL_AC \| X86_EFL_IF \| X86_EFL_DF \| X86_EFL_IOPL)) \| X86_EFL_AC) ))
703	{
704	char szTmp[48];
705	RTStrPrintf(szTmp, sizeof(szTmp), "uCmd=%#x: %#x->%#x!", _IOC_NR(uCmd), (uint32_t)fSavedEfl, (uint32_t)ASMGetFlags());
706	supdrvBadContext(&g_DevExt, "SUPDrv-linux.c", __LINE__, szTmp);
707	}
708	ASMSetFlags(fSavedEfl);
709	#else
710	clac();
711	#endif
712	return rc;
713	}
714
715
716	/**
717	* Device I/O Control entry point.
718	*
719	* @param pFilp Associated file pointer.
720	* @param uCmd The function specified to ioctl().
721	* @param ulArg The argument specified to ioctl().
722	* @param pSession The session instance.
723	*/
724	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PSUPDRVSESSION pSession)
725	{
726	int rc;
727	SUPREQHDR Hdr;
728	PSUPREQHDR pHdr;
729	uint32_t cbBuf;
730
731	Log6(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
732
733	/*
734	* Read the header.
735	*/
736	if (RT_FAILURE(RTR0MemUserCopyFrom(&Hdr, ulArg, sizeof(Hdr))))
737	{
738	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx,) failed; uCmd=%#x\n", ulArg, uCmd));
739	return -EFAULT;
740	}
741	if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
742	{
743	Log(("VBoxDrvLinuxIOCtl: bad header magic %#x; uCmd=%#x\n", Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, uCmd));
744	return -EINVAL;
745	}
746
747	/*
748	* Buffer the request.
749	*/
750	cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
751	if (RT_UNLIKELY(cbBuf > _1M*16))
752	{
753	Log(("VBoxDrvLinuxIOCtl: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
754	return -E2BIG;
755	}
756	if (RT_UNLIKELY(_IOC_SIZE(uCmd) ? cbBuf != _IOC_SIZE(uCmd) : Hdr.cbIn < sizeof(Hdr)))
757	{
758	Log(("VBoxDrvLinuxIOCtl: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
759	return -EINVAL;
760	}
761	pHdr = RTMemAlloc(cbBuf);
762	if (RT_UNLIKELY(!pHdr))
763	{
764	OSDBGPRINT(("VBoxDrvLinuxIOCtl: failed to allocate buffer of %d bytes for uCmd=%#x\n", cbBuf, uCmd));
765	return -ENOMEM;
766	}
767	if (RT_FAILURE(RTR0MemUserCopyFrom(pHdr, ulArg, Hdr.cbIn)))
768	{
769	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx, %#x) failed; uCmd=%#x\n", ulArg, Hdr.cbIn, uCmd));
770	RTMemFree(pHdr);
771	return -EFAULT;
772	}
773	if (Hdr.cbIn < cbBuf)
774	RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbBuf - Hdr.cbIn);
775
776	/*
777	* Process the IOCtl.
778	*/
779	rc = supdrvIOCtl(uCmd, &g_DevExt, pSession, pHdr, cbBuf);
780
781	/*
782	* Copy ioctl data and output buffer back to user space.
783	*/
784	if (RT_LIKELY(!rc))
785	{
786	uint32_t cbOut = pHdr->cbOut;
787	if (RT_UNLIKELY(cbOut > cbBuf))
788	{
789	OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n", cbOut, cbBuf, uCmd));
790	cbOut = cbBuf;
791	}
792	if (RT_FAILURE(RTR0MemUserCopyTo(ulArg, pHdr, cbOut)))
793	{
794	/* this is really bad! */
795	OSDBGPRINT(("VBoxDrvLinuxIOCtl: copy_to_user(%#lx,,%#x); uCmd=%#x!\n", ulArg, cbOut, uCmd));
796	rc = -EFAULT;
797	}
798	}
799	else
800	{
801	Log(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
802	rc = -EINVAL;
803	}
804	RTMemFree(pHdr);
805
806	Log6(("VBoxDrvLinuxIOCtl: returns %d (pid=%d/%d)\n", rc, RTProcSelf(), current->pid));
807	return rc;
808	}
809
810
811	/**
812	* The SUPDRV IDC entry point.
813	*
814	* @returns VBox status code, see supdrvIDC.
815	* @param iReq The request code.
816	* @param pReq The request.
817	*/
818	int VBOXCALL SUPDrvLinuxIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
819	{
820	PSUPDRVSESSION pSession;
821
822	/*
823	* Some quick validations.
824	*/
825	if (RT_UNLIKELY(!VALID_PTR(pReq)))
826	return VERR_INVALID_POINTER;
827
828	pSession = pReq->pSession;
829	if (pSession)
830	{
831	if (RT_UNLIKELY(!VALID_PTR(pSession)))
832	return VERR_INVALID_PARAMETER;
833	if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
834	return VERR_INVALID_PARAMETER;
835	}
836	else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
837	return VERR_INVALID_PARAMETER;
838
839	/*
840	* Do the job.
841	*/
842	return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
843	}
844
845	EXPORT_SYMBOL(SUPDrvLinuxIDC);
846
847
848	RTCCUINTREG VBOXCALL supdrvOSChangeCR4(RTCCUINTREG fOrMask, RTCCUINTREG fAndMask)
849	{
850	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 20, 0)
851	RTCCUINTREG uOld = this_cpu_read(cpu_tlbstate.cr4);
852	RTCCUINTREG uNew = (uOld & fAndMask) \| fOrMask;
853	if (uNew != uOld)
854	{
855	this_cpu_write(cpu_tlbstate.cr4, uNew);
856	__write_cr4(uNew);
857	}
858	#else
859	RTCCUINTREG uOld = ASMGetCR4();
860	RTCCUINTREG uNew = (uOld & fAndMask) \| fOrMask;
861	if (uNew != uOld)
862	ASMSetCR4(uNew);
863	#endif
864	return uOld;
865	}
866
867
868	void VBOXCALL supdrvOSCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
869	{
870	NOREF(pDevExt);
871	NOREF(pSession);
872	}
873
874
875	void VBOXCALL supdrvOSSessionHashTabInserted(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
876	{
877	NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
878	}
879
880
881	void VBOXCALL supdrvOSSessionHashTabRemoved(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
882	{
883	NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
884	}
885
886
887	/**
888	* Initializes any OS specific object creator fields.
889	*/
890	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
891	{
892	NOREF(pObj);
893	NOREF(pSession);
894	}
895
896
897	/**
898	* Checks if the session can access the object.
899	*
900	* @returns true if a decision has been made.
901	* @returns false if the default access policy should be applied.
902	*
903	* @param pObj The object in question.
904	* @param pSession The session wanting to access the object.
905	* @param pszObjName The object name, can be NULL.
906	* @param prc Where to store the result when returning true.
907	*/
908	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
909	{
910	NOREF(pObj);
911	NOREF(pSession);
912	NOREF(pszObjName);
913	NOREF(prc);
914	return false;
915	}
916
917
918	bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
919	{
920	return force_async_tsc != 0;
921	}
922
923
924	bool VBOXCALL supdrvOSAreCpusOfflinedOnSuspend(void)
925	{
926	return true;
927	}
928
929
930	bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
931	{
932	return false;
933	}
934
935
936	int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
937	{
938	NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
939	return VERR_NOT_SUPPORTED;
940	}
941
942
943	void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
944	{
945	NOREF(pDevExt); NOREF(pImage);
946	}
947
948
949	int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void pv, const uint8_t pbImageBits)
950	{
951	NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
952	return VERR_NOT_SUPPORTED;
953	}
954
955
956	int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
957	{
958	NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits); NOREF(pReq);
959	return VERR_NOT_SUPPORTED;
960	}
961
962
963	void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
964	{
965	NOREF(pDevExt); NOREF(pImage);
966	}
967
968
969	#ifdef SUPDRV_WITH_MSR_PROBER
970
971	int VBOXCALL supdrvOSMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue)
972	{
973	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
974	uint32_t u32Low, u32High;
975	int rc;
976
977	IPRT_LINUX_SAVE_EFL_AC();
978	if (idCpu == NIL_RTCPUID)
979	rc = rdmsr_safe(uMsr, &u32Low, &u32High);
980	else if (RTMpIsCpuOnline(idCpu))
981	rc = rdmsr_safe_on_cpu(idCpu, uMsr, &u32Low, &u32High);
982	else
983	return VERR_CPU_OFFLINE;
984	IPRT_LINUX_RESTORE_EFL_AC();
985	if (rc == 0)
986	{
987	*puValue = RT_MAKE_U64(u32Low, u32High);
988	return VINF_SUCCESS;
989	}
990	return VERR_ACCESS_DENIED;
991	# else
992	return VERR_NOT_SUPPORTED;
993	# endif
994	}
995
996
997	int VBOXCALL supdrvOSMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue)
998	{
999	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1000	int rc;
1001
1002	IPRT_LINUX_SAVE_EFL_AC();
1003	if (idCpu == NIL_RTCPUID)
1004	rc = wrmsr_safe(uMsr, RT_LODWORD(uValue), RT_HIDWORD(uValue));
1005	else if (RTMpIsCpuOnline(idCpu))
1006	rc = wrmsr_safe_on_cpu(idCpu, uMsr, RT_LODWORD(uValue), RT_HIDWORD(uValue));
1007	else
1008	return VERR_CPU_OFFLINE;
1009	IPRT_LINUX_RESTORE_EFL_AC();
1010
1011	if (rc == 0)
1012	return VINF_SUCCESS;
1013	return VERR_ACCESS_DENIED;
1014	# else
1015	return VERR_NOT_SUPPORTED;
1016	# endif
1017	}
1018
1019	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1020	/**
1021	* Worker for supdrvOSMsrProberModify.
1022	*/
1023	static DECLCALLBACK(void) supdrvLnxMsrProberModifyOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1024	{
1025	PSUPMSRPROBER pReq = (PSUPMSRPROBER)pvUser1;
1026	register uint32_t uMsr = pReq->u.In.uMsr;
1027	bool const fFaster = pReq->u.In.enmOp == SUPMSRPROBEROP_MODIFY_FASTER;
1028	uint64_t uBefore;
1029	uint64_t uWritten;
1030	uint64_t uAfter;
1031	int rcBefore, rcWrite, rcAfter, rcRestore;
1032	RTCCUINTREG fOldFlags;
1033
1034	/* Initialize result variables. */
1035	uBefore = uWritten = uAfter = 0;
1036	rcWrite = rcAfter = rcRestore = -EIO;
1037
1038	/*
1039	* Do the job.
1040	*/
1041	fOldFlags = ASMIntDisableFlags();
1042	ASMCompilerBarrier(); /* paranoia */
1043	if (!fFaster)
1044	ASMWriteBackAndInvalidateCaches();
1045
1046	rcBefore = rdmsrl_safe(uMsr, &uBefore);
1047	if (rcBefore >= 0)
1048	{
1049	register uint64_t uRestore = uBefore;
1050	uWritten = uRestore;
1051	uWritten &= pReq->u.In.uArgs.Modify.fAndMask;
1052	uWritten \|= pReq->u.In.uArgs.Modify.fOrMask;
1053
1054	rcWrite = wrmsr_safe(uMsr, RT_LODWORD(uWritten), RT_HIDWORD(uWritten));
1055	rcAfter = rdmsrl_safe(uMsr, &uAfter);
1056	rcRestore = wrmsr_safe(uMsr, RT_LODWORD(uRestore), RT_HIDWORD(uRestore));
1057
1058	if (!fFaster)
1059	{
1060	ASMWriteBackAndInvalidateCaches();
1061	ASMReloadCR3();
1062	ASMNopPause();
1063	}
1064	}
1065
1066	ASMCompilerBarrier(); /* paranoia */
1067	ASMSetFlags(fOldFlags);
1068
1069	/*
1070	* Write out the results.
1071	*/
1072	pReq->u.Out.uResults.Modify.uBefore = uBefore;
1073	pReq->u.Out.uResults.Modify.uWritten = uWritten;
1074	pReq->u.Out.uResults.Modify.uAfter = uAfter;
1075	pReq->u.Out.uResults.Modify.fBeforeGp = rcBefore != 0;
1076	pReq->u.Out.uResults.Modify.fModifyGp = rcWrite != 0;
1077	pReq->u.Out.uResults.Modify.fAfterGp = rcAfter != 0;
1078	pReq->u.Out.uResults.Modify.fRestoreGp = rcRestore != 0;
1079	RT_ZERO(pReq->u.Out.uResults.Modify.afReserved);
1080	}
1081	# endif
1082
1083
1084	int VBOXCALL supdrvOSMsrProberModify(RTCPUID idCpu, PSUPMSRPROBER pReq)
1085	{
1086	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1087	if (idCpu == NIL_RTCPUID)
1088	{
1089	supdrvLnxMsrProberModifyOnCpu(idCpu, pReq, NULL);
1090	return VINF_SUCCESS;
1091	}
1092	return RTMpOnSpecific(idCpu, supdrvLnxMsrProberModifyOnCpu, pReq, NULL);
1093	# else
1094	return VERR_NOT_SUPPORTED;
1095	# endif
1096	}
1097
1098	#endif /* SUPDRV_WITH_MSR_PROBER */
1099
1100
1101	/**
1102	* Converts a supdrv error code to an linux error code.
1103	*
1104	* @returns corresponding linux error code.
1105	* @param rc IPRT status code.
1106	*/
1107	static int VBoxDrvLinuxErr2LinuxErr(int rc)
1108	{
1109	switch (rc)
1110	{
1111	case VINF_SUCCESS: return 0;
1112	case VERR_GENERAL_FAILURE: return -EACCES;
1113	case VERR_INVALID_PARAMETER: return -EINVAL;
1114	case VERR_INVALID_MAGIC: return -EILSEQ;
1115	case VERR_INVALID_HANDLE: return -ENXIO;
1116	case VERR_INVALID_POINTER: return -EFAULT;
1117	case VERR_LOCK_FAILED: return -ENOLCK;
1118	case VERR_ALREADY_LOADED: return -EEXIST;
1119	case VERR_PERMISSION_DENIED: return -EPERM;
1120	case VERR_VERSION_MISMATCH: return -ENOSYS;
1121	case VERR_IDT_FAILED: return -1000;
1122	}
1123
1124	return -EPERM;
1125	}
1126
1127
1128	RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
1129	{
1130	va_list va;
1131	char szMsg[512];
1132	IPRT_LINUX_SAVE_EFL_AC();
1133
1134	va_start(va, pszFormat);
1135	RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
1136	va_end(va);
1137	szMsg[sizeof(szMsg) - 1] = '\0';
1138
1139	printk("%s", szMsg);
1140
1141	IPRT_LINUX_RESTORE_EFL_AC();
1142	return 0;
1143	}
1144
1145
1146	SUPR0DECL(uint32_t) SUPR0GetKernelFeatures(void)
1147	{
1148	uint32_t fFlags = 0;
1149	#ifdef CONFIG_PAX_KERNEXEC
1150	fFlags \|= SUPKERNELFEATURES_GDT_READ_ONLY;
1151	#endif
1152	#if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
1153	fFlags \|= SUPKERNELFEATURES_SMAP;
1154	#elif defined(CONFIG_X86_SMAP)
1155	if (ASMGetCR4() & X86_CR4_SMAP)
1156	fFlags \|= SUPKERNELFEATURES_SMAP;
1157	#endif
1158	return fFlags;
1159	}
1160
1161
1162	module_init(VBoxDrvLinuxInit);
1163	module_exit(VBoxDrvLinuxUnload);
1164
1165	MODULE_AUTHOR(VBOX_VENDOR);
1166	MODULE_DESCRIPTION(VBOX_PRODUCT " Support Driver");
1167	MODULE_LICENSE("GPL");
1168	#ifdef MODULE_VERSION
1169	MODULE_VERSION(VBOX_VERSION_STRING " (" RT_XSTR(SUPDRV_IOC_VERSION) ")");
1170	#endif
1171
1172	module_param(force_async_tsc, int, 0444);
1173	MODULE_PARM_DESC(force_async_tsc, "force the asynchronous TSC mode");
1174

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

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

Download in other formats: