SUPDrv-linux.c@ 85938

Last change on this file since 85938 was 85776, checked in by vboxsync, 4 years ago
SUPDrv/linux: Corrections to the 5.8 changes to supdrvOSChangeCR4. bugref:9801 ticketref:19644
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 45.7 KB

Line
1	/* $Id: SUPDrv-linux.c 85776 2020-08-14 20:05:40Z vboxsync $ */
2	/** @file
3	* VBoxDrv - The VirtualBox Support Driver - Linux specifics.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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	#include "revision-generated.h"
37
38	#include <iprt/assert.h>
39	#include <iprt/spinlock.h>
40	#include <iprt/semaphore.h>
41	#include <iprt/initterm.h>
42	#include <iprt/process.h>
43	#include <VBox/err.h>
44	#include <iprt/mem.h>
45	#include <VBox/log.h>
46	#include <iprt/mp.h>
47
48	/** @todo figure out the exact version number */
49	#if RTLNX_VER_MIN(2,6,16)
50	# include <iprt/power.h>
51	# define VBOX_WITH_SUSPEND_NOTIFICATION
52	#endif
53
54	#include <linux/sched.h>
55	#include <linux/miscdevice.h>
56	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
57	# include <linux/platform_device.h>
58	#endif
59	#if (RTLNX_VER_MIN(2,6,28)) && defined(SUPDRV_WITH_MSR_PROBER)
60	# define SUPDRV_LINUX_HAS_SAFE_MSR_API
61	# include <asm/msr.h>
62	#endif
63
64	#include <asm/desc.h>
65
66	#include <iprt/asm-amd64-x86.h>
67
68
69	/*********************************************************************************************************************************
70	* Defined Constants And Macros *
71	*********************************************************************************************************************************/
72	/* check kernel version */
73	# ifndef SUPDRV_AGNOSTIC
74	# if RTLNX_VER_MAX(2,6,0)
75	# error Unsupported kernel version!
76	# endif
77	# endif
78
79	#ifdef CONFIG_X86_HIGH_ENTRY
80	# error "CONFIG_X86_HIGH_ENTRY is not supported by VBoxDrv at this time."
81	#endif
82
83	/* We cannot include x86.h, so we copy the defines we need here: */
84	#define X86_EFL_IF RT_BIT(9)
85	#define X86_EFL_AC RT_BIT(18)
86	#define X86_EFL_DF RT_BIT(10)
87	#define X86_EFL_IOPL (RT_BIT(12) \| RT_BIT(13))
88
89	/* To include the version number of VirtualBox into kernel backtraces: */
90	#define VBoxDrvLinuxVersion RT_CONCAT3(RT_CONCAT(VBOX_VERSION_MAJOR, _), \
91	RT_CONCAT(VBOX_VERSION_MINOR, _), \
92	VBOX_VERSION_BUILD)
93	#define VBoxDrvLinuxIOCtl RT_CONCAT(VBoxDrvLinuxIOCtl_,VBoxDrvLinuxVersion)
94
95
96
97	/*********************************************************************************************************************************
98	* Internal Functions *
99	*********************************************************************************************************************************/
100	static int __init VBoxDrvLinuxInit(void);
101	static void __exit VBoxDrvLinuxUnload(void);
102	static int VBoxDrvLinuxCreateSys(struct inode pInode, struct file pFilp);
103	static int VBoxDrvLinuxCreateUsr(struct inode pInode, struct file pFilp);
104	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp);
105	#ifdef HAVE_UNLOCKED_IOCTL
106	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
107	#else
108	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg);
109	#endif
110	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PSUPDRVSESSION pSession);
111	static int VBoxDrvLinuxErr2LinuxErr(int);
112	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
113	static int VBoxDrvProbe(struct platform_device *pDev);
114	# if RTLNX_VER_MIN(2,6,30)
115	static int VBoxDrvSuspend(struct device *pDev);
116	static int VBoxDrvResume(struct device *pDev);
117	# else
118	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State);
119	static int VBoxDrvResume(struct platform_device *pDev);
120	# endif
121	static void VBoxDevRelease(struct device *pDev);
122	#endif
123
124
125	/*********************************************************************************************************************************
126	* Global Variables *
127	*********************************************************************************************************************************/
128	/**
129	* Device extention & session data association structure.
130	*/
131	static SUPDRVDEVEXT g_DevExt;
132
133	/** Module parameter.
134	* Not prefixed because the name is used by macros and the end of this file. */
135	static int force_async_tsc = 0;
136
137	/** The system device name. */
138	#define DEVICE_NAME_SYS "vboxdrv"
139	/** The user device name. */
140	#define DEVICE_NAME_USR "vboxdrvu"
141
142	#if (defined(RT_ARCH_AMD64) && RTLNX_VER_MAX(2,6,23)) \|\| defined(VBOX_WITH_TEXT_MODMEM_HACK)
143	/**
144	* Memory for the executable memory heap (in IPRT).
145	*/
146	# ifdef DEBUG
147	# define EXEC_MEMORY_SIZE 10485760 /* 10 MB */
148	# else
149	# define EXEC_MEMORY_SIZE 8388608 /* 8 MB */
150	# endif
151	extern uint8_t g_abExecMemory[EXEC_MEMORY_SIZE];
152	# ifndef VBOX_WITH_TEXT_MODMEM_HACK
153	__asm__(".section execmemory, \"awx\", @progbits\n\t"
154	".align 32\n\t"
155	".globl g_abExecMemory\n"
156	"g_abExecMemory:\n\t"
157	".zero " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
158	".type g_abExecMemory, @object\n\t"
159	".size g_abExecMemory, " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
160	".text\n\t");
161	# else
162	__asm__(".text\n\t"
163	".align 4096\n\t"
164	".globl g_abExecMemory\n"
165	"g_abExecMemory:\n\t"
166	".zero " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
167	".type g_abExecMemory, @object\n\t"
168	".size g_abExecMemory, " RT_XSTR(EXEC_MEMORY_SIZE) "\n\t"
169	".text\n\t");
170	# endif
171	#endif
172
173	/** The file_operations structure. */
174	static struct file_operations gFileOpsVBoxDrvSys =
175	{
176	owner: THIS_MODULE,
177	open: VBoxDrvLinuxCreateSys,
178	release: VBoxDrvLinuxClose,
179	#ifdef HAVE_UNLOCKED_IOCTL
180	unlocked_ioctl: VBoxDrvLinuxIOCtl,
181	#else
182	ioctl: VBoxDrvLinuxIOCtl,
183	#endif
184	};
185
186	/** The file_operations structure. */
187	static struct file_operations gFileOpsVBoxDrvUsr =
188	{
189	owner: THIS_MODULE,
190	open: VBoxDrvLinuxCreateUsr,
191	release: VBoxDrvLinuxClose,
192	#ifdef HAVE_UNLOCKED_IOCTL
193	unlocked_ioctl: VBoxDrvLinuxIOCtl,
194	#else
195	ioctl: VBoxDrvLinuxIOCtl,
196	#endif
197	};
198
199	/** The miscdevice structure for vboxdrv. */
200	static struct miscdevice gMiscDeviceSys =
201	{
202	minor: MISC_DYNAMIC_MINOR,
203	name: DEVICE_NAME_SYS,
204	fops: &gFileOpsVBoxDrvSys,
205	# if RTLNX_VER_MAX(2,6,18)
206	devfs_name: DEVICE_NAME_SYS,
207	# endif
208	};
209	/** The miscdevice structure for vboxdrvu. */
210	static struct miscdevice gMiscDeviceUsr =
211	{
212	minor: MISC_DYNAMIC_MINOR,
213	name: DEVICE_NAME_USR,
214	fops: &gFileOpsVBoxDrvUsr,
215	# if RTLNX_VER_MAX(2,6,18)
216	devfs_name: DEVICE_NAME_USR,
217	# endif
218	};
219
220
221	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
222	# if RTLNX_VER_MIN(2,6,30)
223	static struct dev_pm_ops gPlatformPMOps =
224	{
225	.suspend = VBoxDrvSuspend, /* before entering deep sleep */
226	.resume = VBoxDrvResume, /* after wakeup from deep sleep */
227	.freeze = VBoxDrvSuspend, /* before creating hibernation image */
228	.restore = VBoxDrvResume, /* after waking up from hibernation */
229	};
230	# endif
231
232	static struct platform_driver gPlatformDriver =
233	{
234	.probe = VBoxDrvProbe,
235	# if RTLNX_VER_MAX(2,6,30)
236	.suspend = VBoxDrvSuspend,
237	.resume = VBoxDrvResume,
238	# endif
239	/** @todo .shutdown? */
240	.driver =
241	{
242	.name = "vboxdrv",
243	# if RTLNX_VER_MIN(2,6,30)
244	.pm = &gPlatformPMOps,
245	# endif
246	}
247	};
248
249	static struct platform_device gPlatformDevice =
250	{
251	.name = "vboxdrv",
252	.dev =
253	{
254	.release = VBoxDevRelease
255	}
256	};
257	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
258
259
260	DECLINLINE(RTUID) vboxdrvLinuxUid(void)
261	{
262	#if RTLNX_VER_MIN(2,6,29)
263	# if RTLNX_VER_MIN(3,5,0)
264	return from_kuid(current_user_ns(), current->cred->uid);
265	# else
266	return current->cred->uid;
267	# endif
268	#else
269	return current->uid;
270	#endif
271	}
272
273	DECLINLINE(RTGID) vboxdrvLinuxGid(void)
274	{
275	#if RTLNX_VER_MIN(2,6,29)
276	# if RTLNX_VER_MIN(3,5,0)
277	return from_kgid(current_user_ns(), current->cred->gid);
278	# else
279	return current->cred->gid;
280	# endif
281	#else
282	return current->gid;
283	#endif
284	}
285
286	DECLINLINE(RTUID) vboxdrvLinuxEuid(void)
287	{
288	#if RTLNX_VER_MIN(2,6,29)
289	# if RTLNX_VER_MIN(3,5,0)
290	return from_kuid(current_user_ns(), current->cred->euid);
291	# else
292	return current->cred->euid;
293	# endif
294	#else
295	return current->euid;
296	#endif
297	}
298
299	/**
300	* Initialize module.
301	*
302	* @returns appropriate status code.
303	*/
304	static int __init VBoxDrvLinuxInit(void)
305	{
306	int rc;
307
308	/*
309	* Check for synchronous/asynchronous TSC mode.
310	*/
311	printk(KERN_DEBUG "vboxdrv: Found %u processor cores/threads\n", (unsigned)RTMpGetOnlineCount());
312	rc = misc_register(&gMiscDeviceSys);
313	if (rc)
314	{
315	printk(KERN_ERR "vboxdrv: Can't register system misc device! rc=%d\n", rc);
316	return rc;
317	}
318	rc = misc_register(&gMiscDeviceUsr);
319	if (rc)
320	{
321	printk(KERN_ERR "vboxdrv: Can't register user misc device! rc=%d\n", rc);
322	misc_deregister(&gMiscDeviceSys);
323	return rc;
324	}
325	if (!rc)
326	{
327	/*
328	* Initialize the runtime.
329	* On AMD64 we'll have to donate the high rwx memory block to the exec allocator.
330	*/
331	rc = RTR0Init(0);
332	if (RT_SUCCESS(rc))
333	{
334	#if (defined(RT_ARCH_AMD64) && RTLNX_VER_MAX(2,6,23)) \|\| defined(VBOX_WITH_TEXT_MODMEM_HACK)
335	# ifdef VBOX_WITH_TEXT_MODMEM_HACK
336	set_memory_x(&g_abExecMemory[0], sizeof(g_abExecMemory) / PAGE_SIZE);
337	set_memory_rw(&g_abExecMemory[0], sizeof(g_abExecMemory) / PAGE_SIZE);
338	# endif
339	rc = RTR0MemExecDonate(&g_abExecMemory[0], sizeof(g_abExecMemory));
340	printk(KERN_DEBUG "VBoxDrv: dbg - g_abExecMemory=%p\n", (void *)&g_abExecMemory[0]);
341	#endif
342	Log(("VBoxDrv::ModuleInit\n"));
343
344	/*
345	* Initialize the device extension.
346	*/
347	if (RT_SUCCESS(rc))
348	rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
349	if (RT_SUCCESS(rc))
350	{
351	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
352	rc = platform_driver_register(&gPlatformDriver);
353	if (rc == 0)
354	{
355	rc = platform_device_register(&gPlatformDevice);
356	if (rc == 0)
357	#endif
358	{
359	printk(KERN_INFO "vboxdrv: TSC mode is %s, tentative frequency %llu Hz\n",
360	SUPGetGIPModeName(g_DevExt.pGip), g_DevExt.pGip->u64CpuHz);
361	LogFlow(("VBoxDrv::ModuleInit returning %#x\n", rc));
362	printk(KERN_DEBUG "vboxdrv: Successfully loaded version "
363	VBOX_VERSION_STRING " (interface " RT_XSTR(SUPDRV_IOC_VERSION) ")\n");
364	return rc;
365	}
366	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
367	else
368	platform_driver_unregister(&gPlatformDriver);
369	}
370	#endif
371	}
372
373	rc = -EINVAL;
374	RTR0TermForced();
375	}
376	else
377	rc = -EINVAL;
378
379	/*
380	* Failed, cleanup and return the error code.
381	*/
382	}
383	misc_deregister(&gMiscDeviceSys);
384	misc_deregister(&gMiscDeviceUsr);
385	Log(("VBoxDrv::ModuleInit returning %#x (minor:%d & %d)\n", rc, gMiscDeviceSys.minor, gMiscDeviceUsr.minor));
386	return rc;
387	}
388
389
390	/**
391	* Unload the module.
392	*/
393	static void __exit VBoxDrvLinuxUnload(void)
394	{
395	Log(("VBoxDrvLinuxUnload\n"));
396
397	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
398	platform_device_unregister(&gPlatformDevice);
399	platform_driver_unregister(&gPlatformDriver);
400	#endif
401
402	/*
403	* I Don't think it's possible to unload a driver which processes have
404	* opened, at least we'll blindly assume that here.
405	*/
406	misc_deregister(&gMiscDeviceUsr);
407	misc_deregister(&gMiscDeviceSys);
408
409	/*
410	* Destroy GIP, delete the device extension and terminate IPRT.
411	*/
412	supdrvDeleteDevExt(&g_DevExt);
413	RTR0TermForced();
414	}
415
416
417	/**
418	* Common open code.
419	*
420	* @param pInode Pointer to inode info structure.
421	* @param pFilp Associated file pointer.
422	* @param fUnrestricted Indicates which device node which was opened.
423	*/
424	static int vboxdrvLinuxCreateCommon(struct inode pInode, struct file pFilp, bool fUnrestricted)
425	{
426	int rc;
427	PSUPDRVSESSION pSession;
428	Log(("VBoxDrvLinuxCreate: pFilp=%p pid=%d/%d %s\n", pFilp, RTProcSelf(), current->pid, current->comm));
429
430	#ifdef VBOX_WITH_HARDENING
431	/*
432	* Only root is allowed to access the unrestricted device, enforce it!
433	*/
434	if ( fUnrestricted
435	&& vboxdrvLinuxEuid() != 0 /* root */ )
436	{
437	Log(("VBoxDrvLinuxCreate: euid=%d, expected 0 (root)\n", vboxdrvLinuxEuid()));
438	return -EPERM;
439	}
440	#endif /* VBOX_WITH_HARDENING */
441
442	/*
443	* Call common code for the rest.
444	*/
445	rc = supdrvCreateSession(&g_DevExt, true /* fUser */, fUnrestricted, &pSession);
446	if (!rc)
447	{
448	pSession->Uid = vboxdrvLinuxUid();
449	pSession->Gid = vboxdrvLinuxGid();
450	}
451
452	pFilp->private_data = pSession;
453
454	Log(("VBoxDrvLinuxCreate: g_DevExt=%p pSession=%p rc=%d/%d (pid=%d/%d %s)\n",
455	&g_DevExt, pSession, rc, VBoxDrvLinuxErr2LinuxErr(rc),
456	RTProcSelf(), current->pid, current->comm));
457	return VBoxDrvLinuxErr2LinuxErr(rc);
458	}
459
460
461	/** /dev/vboxdrv. */
462	static int VBoxDrvLinuxCreateSys(struct inode pInode, struct file pFilp)
463	{
464	return vboxdrvLinuxCreateCommon(pInode, pFilp, true);
465	}
466
467
468	/** /dev/vboxdrvu. */
469	static int VBoxDrvLinuxCreateUsr(struct inode pInode, struct file pFilp)
470	{
471	return vboxdrvLinuxCreateCommon(pInode, pFilp, false);
472	}
473
474
475	/**
476	* Close device.
477	*
478	* @param pInode Pointer to inode info structure.
479	* @param pFilp Associated file pointer.
480	*/
481	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp)
482	{
483	Log(("VBoxDrvLinuxClose: pFilp=%p pSession=%p pid=%d/%d %s\n",
484	pFilp, pFilp->private_data, RTProcSelf(), current->pid, current->comm));
485	supdrvSessionRelease((PSUPDRVSESSION)pFilp->private_data);
486	pFilp->private_data = NULL;
487	return 0;
488	}
489
490
491	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
492	/**
493	* Dummy device release function. We have to provide this function,
494	* otherwise the kernel will complain.
495	*
496	* @param pDev Pointer to the platform device.
497	*/
498	static void VBoxDevRelease(struct device *pDev)
499	{
500	}
501
502	/**
503	* Dummy probe function.
504	*
505	* @param pDev Pointer to the platform device.
506	*/
507	static int VBoxDrvProbe(struct platform_device *pDev)
508	{
509	return 0;
510	}
511
512	/**
513	* Suspend callback.
514	* @param pDev Pointer to the platform device.
515	* @param State Message type, see Documentation/power/devices.txt.
516	* Ignored.
517	*/
518	# if RTLNX_VER_MIN(2,6,30) && !defined(DOXYGEN_RUNNING)
519	static int VBoxDrvSuspend(struct device *pDev)
520	# else
521	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State)
522	# endif
523	{
524	RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
525	return 0;
526	}
527
528	/**
529	* Resume callback.
530	*
531	* @param pDev Pointer to the platform device.
532	*/
533	# if RTLNX_VER_MIN(2,6,30)
534	static int VBoxDrvResume(struct device *pDev)
535	# else
536	static int VBoxDrvResume(struct platform_device *pDev)
537	# endif
538	{
539	RTPowerSignalEvent(RTPOWEREVENT_RESUME);
540	return 0;
541	}
542	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
543
544
545	/**
546	* Device I/O Control entry point.
547	*
548	* @param pFilp Associated file pointer.
549	* @param uCmd The function specified to ioctl().
550	* @param ulArg The argument specified to ioctl().
551	*/
552	#if defined(HAVE_UNLOCKED_IOCTL) \|\| defined(DOXYGEN_RUNNING)
553	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
554	#else
555	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg)
556	#endif
557	{
558	PSUPDRVSESSION pSession = (PSUPDRVSESSION)pFilp->private_data;
559	int rc;
560	#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
561	# if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
562	RTCCUINTREG fSavedEfl;
563
564	/*
565	* Refuse all I/O control calls if we've ever detected EFLAGS.AC being cleared.
566	*
567	* This isn't a problem, as there is absolutely nothing in the kernel context that
568	* depend on user context triggering cleanups. That would be pretty wild, right?
569	*/
570	if (RT_UNLIKELY(g_DevExt.cBadContextCalls > 0))
571	{
572	SUPR0Printf("VBoxDrvLinuxIOCtl: EFLAGS.AC=0 detected %u times, refusing all I/O controls!\n", g_DevExt.cBadContextCalls);
573	return ESPIPE;
574	}
575
576	fSavedEfl = ASMAddFlags(X86_EFL_AC);
577	# else
578	stac();
579	# endif
580	#endif
581
582	/*
583	* Deal with the two high-speed IOCtl that takes it's arguments from
584	* the session and iCmd, and only returns a VBox status code.
585	*/
586	AssertCompile(_IOC_NRSHIFT == 0 && _IOC_NRBITS == 8);
587	#ifdef HAVE_UNLOCKED_IOCTL
588	if (RT_LIKELY( (unsigned int)(uCmd - SUP_IOCTL_FAST_DO_FIRST) < (unsigned int)32
589	&& pSession->fUnrestricted))
590	rc = supdrvIOCtlFast(uCmd - SUP_IOCTL_FAST_DO_FIRST, ulArg, &g_DevExt, pSession);
591	else
592	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
593	#else /* !HAVE_UNLOCKED_IOCTL */
594	unlock_kernel();
595	if (RT_LIKELY( (unsigned int)(uCmd - SUP_IOCTL_FAST_DO_FIRST) < (unsigned int)32
596	&& pSession->fUnrestricted))
597	rc = supdrvIOCtlFast(uCmd - SUP_IOCTL_FAST_DO_FIRST, ulArg, &g_DevExt, pSession);
598	else
599	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
600	lock_kernel();
601	#endif /* !HAVE_UNLOCKED_IOCTL */
602
603	#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
604	# if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
605	/*
606	* Before we restore AC and the rest of EFLAGS, check if the IOCtl handler code
607	* accidentially modified it or some other important flag.
608	*/
609	if (RT_UNLIKELY( (ASMGetFlags() & (X86_EFL_AC \| X86_EFL_IF \| X86_EFL_DF))
610	!= ((fSavedEfl & (X86_EFL_AC \| X86_EFL_IF \| X86_EFL_DF)) \| X86_EFL_AC) ))
611	{
612	char szTmp[48];
613	RTStrPrintf(szTmp, sizeof(szTmp), "uCmd=%#x: %#x->%#x!", _IOC_NR(uCmd), (uint32_t)fSavedEfl, (uint32_t)ASMGetFlags());
614	supdrvBadContext(&g_DevExt, "SUPDrv-linux.c", __LINE__, szTmp);
615	}
616	ASMSetFlags(fSavedEfl);
617	# else
618	clac();
619	# endif
620	#endif
621	return rc;
622	}
623
624
625	/**
626	* Device I/O Control entry point.
627	*
628	* @param pFilp Associated file pointer.
629	* @param uCmd The function specified to ioctl().
630	* @param ulArg The argument specified to ioctl().
631	* @param pSession The session instance.
632	*/
633	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PSUPDRVSESSION pSession)
634	{
635	int rc;
636	SUPREQHDR Hdr;
637	PSUPREQHDR pHdr;
638	uint32_t cbBuf;
639
640	Log6(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
641
642	/*
643	* Read the header.
644	*/
645	if (RT_FAILURE(RTR0MemUserCopyFrom(&Hdr, ulArg, sizeof(Hdr))))
646	{
647	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx,) failed; uCmd=%#x\n", ulArg, uCmd));
648	return -EFAULT;
649	}
650	if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
651	{
652	Log(("VBoxDrvLinuxIOCtl: bad header magic %#x; uCmd=%#x\n", Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, uCmd));
653	return -EINVAL;
654	}
655
656	/*
657	* Buffer the request.
658	*/
659	cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
660	if (RT_UNLIKELY(cbBuf > _1M*16))
661	{
662	Log(("VBoxDrvLinuxIOCtl: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
663	return -E2BIG;
664	}
665	if (RT_UNLIKELY(_IOC_SIZE(uCmd) ? cbBuf != _IOC_SIZE(uCmd) : Hdr.cbIn < sizeof(Hdr)))
666	{
667	Log(("VBoxDrvLinuxIOCtl: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
668	return -EINVAL;
669	}
670	pHdr = RTMemAlloc(cbBuf);
671	if (RT_UNLIKELY(!pHdr))
672	{
673	OSDBGPRINT(("VBoxDrvLinuxIOCtl: failed to allocate buffer of %d bytes for uCmd=%#x\n", cbBuf, uCmd));
674	return -ENOMEM;
675	}
676	if (RT_FAILURE(RTR0MemUserCopyFrom(pHdr, ulArg, Hdr.cbIn)))
677	{
678	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx, %#x) failed; uCmd=%#x\n", ulArg, Hdr.cbIn, uCmd));
679	RTMemFree(pHdr);
680	return -EFAULT;
681	}
682	if (Hdr.cbIn < cbBuf)
683	RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbBuf - Hdr.cbIn);
684
685	/*
686	* Process the IOCtl.
687	*/
688	rc = supdrvIOCtl(uCmd, &g_DevExt, pSession, pHdr, cbBuf);
689
690	/*
691	* Copy ioctl data and output buffer back to user space.
692	*/
693	if (RT_LIKELY(!rc))
694	{
695	uint32_t cbOut = pHdr->cbOut;
696	if (RT_UNLIKELY(cbOut > cbBuf))
697	{
698	OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n", cbOut, cbBuf, uCmd));
699	cbOut = cbBuf;
700	}
701	if (RT_FAILURE(RTR0MemUserCopyTo(ulArg, pHdr, cbOut)))
702	{
703	/* this is really bad! */
704	OSDBGPRINT(("VBoxDrvLinuxIOCtl: copy_to_user(%#lx,,%#x); uCmd=%#x!\n", ulArg, cbOut, uCmd));
705	rc = -EFAULT;
706	}
707	}
708	else
709	{
710	Log(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
711	rc = -EINVAL;
712	}
713	RTMemFree(pHdr);
714
715	Log6(("VBoxDrvLinuxIOCtl: returns %d (pid=%d/%d)\n", rc, RTProcSelf(), current->pid));
716	return rc;
717	}
718
719
720	/**
721	* The SUPDRV IDC entry point.
722	*
723	* @returns VBox status code, see supdrvIDC.
724	* @param uReq The request code.
725	* @param pReq The request.
726	*/
727	int VBOXCALL SUPDrvLinuxIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
728	{
729	PSUPDRVSESSION pSession;
730
731	/*
732	* Some quick validations.
733	*/
734	if (RT_UNLIKELY(!VALID_PTR(pReq)))
735	return VERR_INVALID_POINTER;
736
737	pSession = pReq->pSession;
738	if (pSession)
739	{
740	if (RT_UNLIKELY(!VALID_PTR(pSession)))
741	return VERR_INVALID_PARAMETER;
742	if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
743	return VERR_INVALID_PARAMETER;
744	}
745	else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
746	return VERR_INVALID_PARAMETER;
747
748	/*
749	* Do the job.
750	*/
751	return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
752	}
753
754	EXPORT_SYMBOL(SUPDrvLinuxIDC);
755
756
757	RTCCUINTREG VBOXCALL supdrvOSChangeCR4(RTCCUINTREG fOrMask, RTCCUINTREG fAndMask)
758	{
759	#if RTLNX_VER_MIN(5,8,0)
760	unsigned long fSavedFlags;
761	local_irq_save(fSavedFlags);
762	RTCCUINTREG const uOld = cr4_read_shadow();
763	cr4_update_irqsoff(fOrMask, ~fAndMask); /* Same as this function, only it is not returning the old value. */
764	AssertMsg(cr4_read_shadow() == ((uOld & fAndMask) \| fOrMask),
765	("fOrMask=%#RTreg fAndMask=%#RTreg uOld=%#RTreg; new cr4=%#llx\n", fOrMask, fAndMask, uOld, cr4_read_shadow()));
766	local_irq_restore(fSavedFlags);
767	#else
768	# if RTLNX_VER_MIN(3,20,0)
769	RTCCUINTREG const uOld = this_cpu_read(cpu_tlbstate.cr4);
770	# else
771	RTCCUINTREG const uOld = ASMGetCR4();
772	# endif
773	RTCCUINTREG const uNew = (uOld & fAndMask) \| fOrMask;
774	if (uNew != uOld)
775	{
776	# if RTLNX_VER_MIN(3,20,0)
777	this_cpu_write(cpu_tlbstate.cr4, uNew);
778	__write_cr4(uNew);
779	# else
780	ASMSetCR4(uNew);
781	# endif
782	}
783	#endif
784	return uOld;
785	}
786
787
788	void VBOXCALL supdrvOSCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
789	{
790	NOREF(pDevExt);
791	NOREF(pSession);
792	}
793
794
795	void VBOXCALL supdrvOSSessionHashTabInserted(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
796	{
797	NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
798	}
799
800
801	void VBOXCALL supdrvOSSessionHashTabRemoved(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
802	{
803	NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
804	}
805
806
807	/**
808	* Initializes any OS specific object creator fields.
809	*/
810	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
811	{
812	NOREF(pObj);
813	NOREF(pSession);
814	}
815
816
817	/**
818	* Checks if the session can access the object.
819	*
820	* @returns true if a decision has been made.
821	* @returns false if the default access policy should be applied.
822	*
823	* @param pObj The object in question.
824	* @param pSession The session wanting to access the object.
825	* @param pszObjName The object name, can be NULL.
826	* @param prc Where to store the result when returning true.
827	*/
828	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
829	{
830	NOREF(pObj);
831	NOREF(pSession);
832	NOREF(pszObjName);
833	NOREF(prc);
834	return false;
835	}
836
837
838	bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
839	{
840	return force_async_tsc != 0;
841	}
842
843
844	bool VBOXCALL supdrvOSAreCpusOfflinedOnSuspend(void)
845	{
846	return true;
847	}
848
849
850	bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
851	{
852	return false;
853	}
854
855
856	int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
857	{
858	NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
859	return VERR_NOT_SUPPORTED;
860	}
861
862
863	int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv,
864	const uint8_t pbImageBits, const char pszSymbol)
865	{
866	NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits); NOREF(pszSymbol);
867	return VERR_NOT_SUPPORTED;
868	}
869
870
871	int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
872	{
873	NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits); NOREF(pReq);
874	return VERR_NOT_SUPPORTED;
875	}
876
877
878	void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
879	{
880	NOREF(pDevExt); NOREF(pImage);
881	}
882
883
884	/** @def VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS
885	* A very crude hack for debugging using perf and dtrace.
886	*
887	* DO ABSOLUTELY NOT ENABLE IN PRODUCTION BUILDS! DEVELOPMENT ONLY!!
888	* DO ABSOLUTELY NOT ENABLE IN PRODUCTION BUILDS! DEVELOPMENT ONLY!!
889	* DO ABSOLUTELY NOT ENABLE IN PRODUCTION BUILDS! DEVELOPMENT ONLY!!
890	*
891	*/
892	#if 0 \|\| defined(DOXYGEN_RUNNING)
893	# define VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS
894	#endif
895
896	#if defined(VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS) && defined(CONFIG_MODULES_TREE_LOOKUP)
897	/** Whether g_pfnModTreeInsert and g_pfnModTreeRemove have been initialized.
898	* @remarks can still be NULL after init. */
899	static volatile bool g_fLookedForModTreeFunctions = false;
900	static void (g_pfnModTreeInsert)(struct mod_tree_node ) = NULL; /*< __mod_tree_insert /
901	static void (g_pfnModTreeRemove)(struct mod_tree_node ) = NULL; /*< __mod_tree_remove /
902	#endif
903
904
905	void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
906	{
907	#ifdef VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS /* Not for production use!! Debugging only! */
908	/*
909	* This trick stops working with 4.2 when CONFIG_MODULES_TREE_LOOKUP is
910	* defined. The module lookups are done via a tree structure and we
911	* cannot get at the root of it. :-(
912	*/
913	# ifdef CONFIG_KALLSYMS
914	size_t const cchName = strlen(pImage->szName);
915	# endif
916	struct module pMyMod, pSelfMod, pTestMod, pTestModByName;
917	IPRT_LINUX_SAVE_EFL_AC();
918
919	pImage->pLnxModHack = NULL;
920
921	# ifdef CONFIG_MODULES_TREE_LOOKUP
922	/*
923	* This is pretty naive, but works for 4.2 on arch linux. I don't think we
924	* can count on finding __mod_tree_remove in all kernel builds as it's not
925	* marked noinline like __mod_tree_insert.
926	*/
927	if (!g_fLookedForModTreeFunctions)
928	{
929	unsigned long ulInsert = kallsyms_lookup_name("__mod_tree_insert");
930	unsigned long ulRemove = kallsyms_lookup_name("__mod_tree_remove");
931	if (!ulInsert \|\| !ulRemove)
932	{
933	g_fLookedForModTreeFunctions = true;
934	printk(KERN_ERR "vboxdrv: failed to locate __mod_tree_insert and __mod_tree_remove.\n");
935	IPRT_LINUX_RESTORE_EFL_AC();
936	return;
937	}
938	(unsigned long )&g_pfnModTreeInsert = ulInsert;
939	(unsigned long )&g_pfnModTreeRemove = ulRemove;
940	ASMCompilerBarrier();
941	g_fLookedForModTreeFunctions = true;
942	}
943	else if (!g_pfnModTreeInsert \|\| !g_pfnModTreeRemove)
944	return;
945	#endif
946
947	/*
948	* Make sure we've found our own module, otherwise we cannot access the linked list.
949	*/
950	mutex_lock(&module_mutex);
951	pSelfMod = find_module("vboxdrv");
952	mutex_unlock(&module_mutex);
953	if (!pSelfMod)
954	{
955	IPRT_LINUX_RESTORE_EFL_AC();
956	return;
957	}
958
959	/*
960	* Cook up a module structure for the image.
961	* We allocate symbol and string tables in the allocation and the module to keep things simple.
962	*/
963	# ifdef CONFIG_KALLSYMS
964	pMyMod = (struct module )RTMemAllocZ(sizeof(pMyMod)
965	+ sizeof(Elf_Sym) * 3
966	+ 1 + cchName * 2 + sizeof("_start") + sizeof("_end") + 4 );
967	# else
968	pMyMod = (struct module )RTMemAllocZ(sizeof(pMyMod));
969	# endif
970	if (pMyMod)
971	{
972	int rc = VINF_SUCCESS;
973	# ifdef CONFIG_KALLSYMS
974	Elf_Sym paSymbols = (Elf_Sym )(pMyMod + 1);
975	char pchStrTab = (char )(paSymbols + 3);
976	# endif
977
978	pMyMod->state = MODULE_STATE_LIVE;
979	INIT_LIST_HEAD(&pMyMod->list); /* just in case */
980
981	/* Perf only matches up files with a .ko extension (maybe .ko.gz),
982	so in order for this crap to work smoothly, we append .ko to the
983	module name and require the user to create symbolic links in
984	/lib/modules/`uname -r`:
985	for i in VMMR0.r0 VBoxDDR0.r0 VBoxDD2R0.r0; do
986	sudo ln -s /mnt/scratch/vbox/svn/trunk/out/linux.amd64/debug/bin/$i /lib/modules/`uname -r`/$i.ko;
987	done */
988	RTStrPrintf(pMyMod->name, sizeof(pMyMod->name), "%s", pImage->szName);
989
990	/* sysfs bits. */
991	INIT_LIST_HEAD(&pMyMod->mkobj.kobj.entry); /* rest of kobj is already zeroed, hopefully never accessed... */
992	pMyMod->mkobj.mod = pMyMod;
993	pMyMod->mkobj.drivers_dir = NULL;
994	pMyMod->mkobj.mp = NULL;
995	pMyMod->mkobj.kobj_completion = NULL;
996
997	pMyMod->modinfo_attrs = NULL; /* hopefully not accessed after setup. */
998	pMyMod->holders_dir = NULL; /* hopefully not accessed. */
999	pMyMod->version = "N/A";
1000	pMyMod->srcversion = "N/A";
1001
1002	/* We export no symbols. */
1003	pMyMod->num_syms = 0;
1004	pMyMod->syms = NULL;
1005	pMyMod->crcs = NULL;
1006
1007	pMyMod->num_gpl_syms = 0;
1008	pMyMod->gpl_syms = NULL;
1009	pMyMod->gpl_crcs = NULL;
1010
1011	pMyMod->num_gpl_future_syms = 0;
1012	pMyMod->gpl_future_syms = NULL;
1013	pMyMod->gpl_future_crcs = NULL;
1014
1015	# if CONFIG_UNUSED_SYMBOLS
1016	pMyMod->num_unused_syms = 0;
1017	pMyMod->unused_syms = NULL;
1018	pMyMod->unused_crcs = NULL;
1019
1020	pMyMod->num_unused_gpl_syms = 0;
1021	pMyMod->unused_gpl_syms = NULL;
1022	pMyMod->unused_gpl_crcs = NULL;
1023	# endif
1024	/* No kernel parameters either. */
1025	pMyMod->kp = NULL;
1026	pMyMod->num_kp = 0;
1027
1028	# ifdef CONFIG_MODULE_SIG
1029	/* Pretend ok signature. */
1030	pMyMod->sig_ok = true;
1031	# endif
1032	/* No exception table. */
1033	pMyMod->num_exentries = 0;
1034	pMyMod->extable = NULL;
1035
1036	/* No init function */
1037	pMyMod->init = NULL;
1038	pMyMod->module_init = NULL;
1039	pMyMod->init_size = 0;
1040	pMyMod->init_ro_size = 0;
1041	pMyMod->init_text_size = 0;
1042
1043	/* The module address and size. It's all text. */
1044	pMyMod->module_core = pImage->pvImage;
1045	pMyMod->core_size = pImage->cbImageBits;
1046	pMyMod->core_text_size = pImage->cbImageBits;
1047	pMyMod->core_ro_size = pImage->cbImageBits;
1048
1049	#ifdef CONFIG_MODULES_TREE_LOOKUP
1050	/* Fill in the self pointers for the tree nodes. */
1051	pMyMod->mtn_core.mod = pMyMod;
1052	pMyMod->mtn_init.mod = pMyMod;
1053	#endif
1054	/* They invented the tained bit for us, didn't they? */
1055	pMyMod->taints = 1;
1056
1057	# ifdef CONFIG_GENERIC_BUGS
1058	/* No BUGs in our modules. */
1059	pMyMod->num_bugs = 0;
1060	INIT_LIST_HEAD(&pMyMod->bug_list);
1061	pMyMod->bug_table = NULL;
1062	# endif
1063
1064	# ifdef CONFIG_KALLSYMS
1065	/* The core stuff is documented as only used when loading. So just zero them. */
1066	pMyMod->core_num_syms = 0;
1067	pMyMod->core_symtab = NULL;
1068	pMyMod->core_strtab = NULL;
1069
1070	/* Construct a symbol table with start and end symbols.
1071	Note! We don't have our own symbol table at this point, image bit
1072	are not uploaded yet! */
1073	pMyMod->num_symtab = 3;
1074	pMyMod->symtab = paSymbols;
1075	pMyMod->strtab = pchStrTab;
1076	RT_ZERO(paSymbols[0]);
1077	pchStrTab[0] = '\0';
1078	paSymbols[1].st_name = 1;
1079	paSymbols[2].st_name = 2 + RTStrPrintf(&pchStrTab[paSymbols[1].st_name], cchName + sizeof("_start"),
1080	"%s_start", pImage->szName);
1081	RTStrPrintf(&pchStrTab[paSymbols[2].st_name], cchName + sizeof("_end"), "%s_end", pImage->szName);
1082	paSymbols[1].st_info = 't';
1083	paSymbols[2].st_info = 'b';
1084	paSymbols[1].st_other = 0;
1085	paSymbols[2].st_other = 0;
1086	paSymbols[1].st_shndx = 0;
1087	paSymbols[2].st_shndx = 0;
1088	paSymbols[1].st_value = (uintptr_t)pImage->pvImage;
1089	paSymbols[2].st_value = (uintptr_t)pImage->pvImage + pImage->cbImageBits - 1;
1090	paSymbols[1].st_size = pImage->cbImageBits - 1;
1091	paSymbols[2].st_size = 1;
1092	# endif
1093	/* No arguments, but seems its always non-NULL so put empty string there. */
1094	pMyMod->args = "";
1095
1096	# ifdef CONFIG_SMP
1097	/* No per CPU data. */
1098	pMyMod->percpu = NULL;
1099	pMyMod->percpu_size = 0;
1100	# endif
1101	# ifdef CONFIG_TRACEPOINTS
1102	/* No tracepoints we like to share. */
1103	pMyMod->num_tracepoints = 0;
1104	pMyMod->tracepoints_ptrs = NULL;
1105	#endif
1106	# ifdef HAVE_JUMP_LABEL
1107	/* No jump lable stuff either. */
1108	pMyMod->jump_entries = NULL;
1109	pMyMod->num_jump_entries = 0;
1110	# endif
1111	# ifdef CONFIG_TRACING
1112	pMyMod->num_trace_bprintk_fmt = 0;
1113	pMyMod->trace_bprintk_fmt_start = NULL;
1114	# endif
1115	# ifdef CONFIG_EVENT_TRACING
1116	pMyMod->trace_events = NULL;
1117	pMyMod->num_trace_events = 0;
1118	# endif
1119	# ifdef CONFIG_FTRACE_MCOUNT_RECORD
1120	pMyMod->num_ftrace_callsites = 0;
1121	pMyMod->ftrace_callsites = NULL;
1122	# endif
1123	# ifdef CONFIG_MODULE_UNLOAD
1124	/* Dependency lists, not worth sharing */
1125	INIT_LIST_HEAD(&pMyMod->source_list);
1126	INIT_LIST_HEAD(&pMyMod->target_list);
1127
1128	/* Nobody waiting and no exit function. */
1129	# if RTLNX_VER_MAX(3,13,0)
1130	pMyMod->waiter = NULL;
1131	# endif
1132	pMyMod->exit = NULL;
1133
1134	/* References, very important as we must not allow the module
1135	to be unloaded using rmmod. */
1136	# if RTLNX_VER_MIN(3,19,0)
1137	atomic_set(&pMyMod->refcnt, 42);
1138	# else
1139	pMyMod->refptr = alloc_percpu(struct module_ref);
1140	if (pMyMod->refptr)
1141	{
1142	int iCpu;
1143	for_each_possible_cpu(iCpu)
1144	{
1145	per_cpu_ptr(pMyMod->refptr, iCpu)->decs = 0;
1146	per_cpu_ptr(pMyMod->refptr, iCpu)->incs = 1;
1147	}
1148	}
1149	else
1150	rc = VERR_NO_MEMORY;
1151	# endif
1152	# endif
1153	# ifdef CONFIG_CONSTRUCTORS
1154	/* No constructors. */
1155	pMyMod->ctors = NULL;
1156	pMyMod->num_ctors = 0;
1157	# endif
1158	if (RT_SUCCESS(rc))
1159	{
1160	bool fIsModText;
1161
1162	/*
1163	* Add the module to the list.
1164	*/
1165	mutex_lock(&module_mutex);
1166	list_add_rcu(&pMyMod->list, &pSelfMod->list);
1167	pImage->pLnxModHack = pMyMod;
1168	# ifdef CONFIG_MODULES_TREE_LOOKUP
1169	g_pfnModTreeInsert(&pMyMod->mtn_core); /* __mod_tree_insert */
1170	# endif
1171	mutex_unlock(&module_mutex);
1172
1173	/*
1174	* Test it.
1175	*/
1176	mutex_lock(&module_mutex);
1177	pTestModByName = find_module(pMyMod->name);
1178	pTestMod = __module_address((uintptr_t)pImage->pvImage + pImage->cbImageBits / 4);
1179	fIsModText = __module_text_address((uintptr_t)pImage->pvImage + pImage->cbImageBits / 2);
1180	mutex_unlock(&module_mutex);
1181	if ( pTestMod == pMyMod
1182	&& pTestModByName == pMyMod
1183	&& fIsModText)
1184	printk(KERN_ERR "vboxdrv: fake module works for '%s' (%#lx to %#lx)\n",
1185	pMyMod->name, (unsigned long)paSymbols[1].st_value, (unsigned long)paSymbols[2].st_value);
1186	else
1187	printk(KERN_ERR "vboxdrv: failed to find fake module (pTestMod=%p, pTestModByName=%p, pMyMod=%p, fIsModText=%d)\n",
1188	pTestMod, pTestModByName, pMyMod, fIsModText);
1189	}
1190	else
1191	RTMemFree(pMyMod);
1192	}
1193
1194	IPRT_LINUX_RESTORE_EFL_AC();
1195	#else
1196	pImage->pLnxModHack = NULL;
1197	#endif
1198	NOREF(pDevExt); NOREF(pImage);
1199	}
1200
1201
1202	void VBOXCALL supdrvOSLdrNotifyUnloaded(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1203	{
1204	#ifdef VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS /* Not for production use!! Debugging only! */
1205	struct module *pMyMod = pImage->pLnxModHack;
1206	pImage->pLnxModHack = NULL;
1207	if (pMyMod)
1208	{
1209	/*
1210	* Remove the fake module list entry and free it.
1211	*/
1212	IPRT_LINUX_SAVE_EFL_AC();
1213	mutex_lock(&module_mutex);
1214	list_del_rcu(&pMyMod->list);
1215	# ifdef CONFIG_MODULES_TREE_LOOKUP
1216	g_pfnModTreeRemove(&pMyMod->mtn_core);
1217	# endif
1218	synchronize_sched();
1219	mutex_unlock(&module_mutex);
1220
1221	# if RTLNX_VER_MAX(3,19,0)
1222	free_percpu(pMyMod->refptr);
1223	# endif
1224	RTMemFree(pMyMod);
1225	IPRT_LINUX_RESTORE_EFL_AC();
1226	}
1227
1228	#else
1229	Assert(pImage->pLnxModHack == NULL);
1230	#endif
1231	NOREF(pDevExt); NOREF(pImage);
1232	}
1233
1234
1235	int VBOXCALL supdrvOSLdrQuerySymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage,
1236	const char pszSymbol, size_t cchSymbol, void *ppvSymbol)
1237	{
1238	#ifdef VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS
1239	# error "implement me!"
1240	#endif
1241	RT_NOREF(pDevExt, pImage, pszSymbol, cchSymbol, ppvSymbol);
1242	return VERR_WRONG_ORDER;
1243	}
1244
1245
1246	#ifdef SUPDRV_WITH_MSR_PROBER
1247
1248	int VBOXCALL supdrvOSMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue)
1249	{
1250	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1251	uint32_t u32Low, u32High;
1252	int rc;
1253
1254	IPRT_LINUX_SAVE_EFL_AC();
1255	if (idCpu == NIL_RTCPUID)
1256	rc = rdmsr_safe(uMsr, &u32Low, &u32High);
1257	else if (RTMpIsCpuOnline(idCpu))
1258	rc = rdmsr_safe_on_cpu(idCpu, uMsr, &u32Low, &u32High);
1259	else
1260	return VERR_CPU_OFFLINE;
1261	IPRT_LINUX_RESTORE_EFL_AC();
1262	if (rc == 0)
1263	{
1264	*puValue = RT_MAKE_U64(u32Low, u32High);
1265	return VINF_SUCCESS;
1266	}
1267	return VERR_ACCESS_DENIED;
1268	# else
1269	return VERR_NOT_SUPPORTED;
1270	# endif
1271	}
1272
1273
1274	int VBOXCALL supdrvOSMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue)
1275	{
1276	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1277	int rc;
1278
1279	IPRT_LINUX_SAVE_EFL_AC();
1280	if (idCpu == NIL_RTCPUID)
1281	rc = wrmsr_safe(uMsr, RT_LODWORD(uValue), RT_HIDWORD(uValue));
1282	else if (RTMpIsCpuOnline(idCpu))
1283	rc = wrmsr_safe_on_cpu(idCpu, uMsr, RT_LODWORD(uValue), RT_HIDWORD(uValue));
1284	else
1285	return VERR_CPU_OFFLINE;
1286	IPRT_LINUX_RESTORE_EFL_AC();
1287
1288	if (rc == 0)
1289	return VINF_SUCCESS;
1290	return VERR_ACCESS_DENIED;
1291	# else
1292	return VERR_NOT_SUPPORTED;
1293	# endif
1294	}
1295
1296	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1297	/**
1298	* Worker for supdrvOSMsrProberModify.
1299	*/
1300	static DECLCALLBACK(void) supdrvLnxMsrProberModifyOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1301	{
1302	PSUPMSRPROBER pReq = (PSUPMSRPROBER)pvUser1;
1303	register uint32_t uMsr = pReq->u.In.uMsr;
1304	bool const fFaster = pReq->u.In.enmOp == SUPMSRPROBEROP_MODIFY_FASTER;
1305	uint64_t uBefore;
1306	uint64_t uWritten;
1307	uint64_t uAfter;
1308	int rcBefore, rcWrite, rcAfter, rcRestore;
1309	RTCCUINTREG fOldFlags;
1310
1311	/* Initialize result variables. */
1312	uBefore = uWritten = uAfter = 0;
1313	rcWrite = rcAfter = rcRestore = -EIO;
1314
1315	/*
1316	* Do the job.
1317	*/
1318	fOldFlags = ASMIntDisableFlags();
1319	ASMCompilerBarrier(); /* paranoia */
1320	if (!fFaster)
1321	ASMWriteBackAndInvalidateCaches();
1322
1323	rcBefore = rdmsrl_safe(uMsr, &uBefore);
1324	if (rcBefore >= 0)
1325	{
1326	register uint64_t uRestore = uBefore;
1327	uWritten = uRestore;
1328	uWritten &= pReq->u.In.uArgs.Modify.fAndMask;
1329	uWritten \|= pReq->u.In.uArgs.Modify.fOrMask;
1330
1331	rcWrite = wrmsr_safe(uMsr, RT_LODWORD(uWritten), RT_HIDWORD(uWritten));
1332	rcAfter = rdmsrl_safe(uMsr, &uAfter);
1333	rcRestore = wrmsr_safe(uMsr, RT_LODWORD(uRestore), RT_HIDWORD(uRestore));
1334
1335	if (!fFaster)
1336	{
1337	ASMWriteBackAndInvalidateCaches();
1338	ASMReloadCR3();
1339	ASMNopPause();
1340	}
1341	}
1342
1343	ASMCompilerBarrier(); /* paranoia */
1344	ASMSetFlags(fOldFlags);
1345
1346	/*
1347	* Write out the results.
1348	*/
1349	pReq->u.Out.uResults.Modify.uBefore = uBefore;
1350	pReq->u.Out.uResults.Modify.uWritten = uWritten;
1351	pReq->u.Out.uResults.Modify.uAfter = uAfter;
1352	pReq->u.Out.uResults.Modify.fBeforeGp = rcBefore != 0;
1353	pReq->u.Out.uResults.Modify.fModifyGp = rcWrite != 0;
1354	pReq->u.Out.uResults.Modify.fAfterGp = rcAfter != 0;
1355	pReq->u.Out.uResults.Modify.fRestoreGp = rcRestore != 0;
1356	RT_ZERO(pReq->u.Out.uResults.Modify.afReserved);
1357	}
1358	# endif
1359
1360
1361	int VBOXCALL supdrvOSMsrProberModify(RTCPUID idCpu, PSUPMSRPROBER pReq)
1362	{
1363	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1364	if (idCpu == NIL_RTCPUID)
1365	{
1366	supdrvLnxMsrProberModifyOnCpu(idCpu, pReq, NULL);
1367	return VINF_SUCCESS;
1368	}
1369	return RTMpOnSpecific(idCpu, supdrvLnxMsrProberModifyOnCpu, pReq, NULL);
1370	# else
1371	return VERR_NOT_SUPPORTED;
1372	# endif
1373	}
1374
1375	#endif /* SUPDRV_WITH_MSR_PROBER */
1376
1377
1378	/**
1379	* Converts a supdrv error code to an linux error code.
1380	*
1381	* @returns corresponding linux error code.
1382	* @param rc IPRT status code.
1383	*/
1384	static int VBoxDrvLinuxErr2LinuxErr(int rc)
1385	{
1386	switch (rc)
1387	{
1388	case VINF_SUCCESS: return 0;
1389	case VERR_GENERAL_FAILURE: return -EACCES;
1390	case VERR_INVALID_PARAMETER: return -EINVAL;
1391	case VERR_INVALID_MAGIC: return -EILSEQ;
1392	case VERR_INVALID_HANDLE: return -ENXIO;
1393	case VERR_INVALID_POINTER: return -EFAULT;
1394	case VERR_LOCK_FAILED: return -ENOLCK;
1395	case VERR_ALREADY_LOADED: return -EEXIST;
1396	case VERR_PERMISSION_DENIED: return -EPERM;
1397	case VERR_VERSION_MISMATCH: return -ENOSYS;
1398	case VERR_IDT_FAILED: return -1000;
1399	}
1400
1401	return -EPERM;
1402	}
1403
1404
1405	SUPR0DECL(int) SUPR0HCPhysToVirt(RTHCPHYS HCPhys, void **ppv)
1406	{
1407	AssertReturn(!(HCPhys & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1408	AssertReturn(HCPhys != NIL_RTHCPHYS, VERR_INVALID_POINTER);
1409	/* Would've like to use valid_phys_addr_range for this test, but it isn't exported. */
1410	AssertReturn((HCPhys \| PAGE_OFFSET_MASK) < __pa(high_memory), VERR_INVALID_POINTER);
1411	*ppv = phys_to_virt(HCPhys);
1412	return VINF_SUCCESS;
1413	}
1414
1415
1416	RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
1417	{
1418	va_list va;
1419	char szMsg[512];
1420	IPRT_LINUX_SAVE_EFL_AC();
1421
1422	va_start(va, pszFormat);
1423	RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
1424	va_end(va);
1425	szMsg[sizeof(szMsg) - 1] = '\0';
1426
1427	printk("%s", szMsg);
1428
1429	IPRT_LINUX_RESTORE_EFL_AC();
1430	return 0;
1431	}
1432
1433
1434	SUPR0DECL(uint32_t) SUPR0GetKernelFeatures(void)
1435	{
1436	uint32_t fFlags = 0;
1437	#ifdef CONFIG_PAX_KERNEXEC
1438	fFlags \|= SUPKERNELFEATURES_GDT_READ_ONLY;
1439	#endif
1440	#if RTLNX_VER_MIN(4,12,0)
1441	fFlags \|= SUPKERNELFEATURES_GDT_NEED_WRITABLE;
1442	#endif
1443	#if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
1444	fFlags \|= SUPKERNELFEATURES_SMAP;
1445	#elif defined(CONFIG_X86_SMAP)
1446	if (ASMGetCR4() & X86_CR4_SMAP)
1447	fFlags \|= SUPKERNELFEATURES_SMAP;
1448	#endif
1449	return fFlags;
1450	}
1451
1452
1453	int VBOXCALL supdrvOSGetCurrentGdtRw(RTHCUINTPTR *pGdtRw)
1454	{
1455	#if RTLNX_VER_MIN(4,12,0)
1456	*pGdtRw = (RTHCUINTPTR)get_current_gdt_rw();
1457	return VINF_SUCCESS;
1458	#else
1459	return VERR_NOT_IMPLEMENTED;
1460	#endif
1461	}
1462
1463
1464	module_init(VBoxDrvLinuxInit);
1465	module_exit(VBoxDrvLinuxUnload);
1466
1467	MODULE_AUTHOR(VBOX_VENDOR);
1468	MODULE_DESCRIPTION(VBOX_PRODUCT " Support Driver");
1469	MODULE_LICENSE("GPL");
1470	#ifdef MODULE_VERSION
1471	MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV) " (" RT_XSTR(SUPDRV_IOC_VERSION) ")");
1472	#endif
1473
1474	module_param(force_async_tsc, int, 0444);
1475	MODULE_PARM_DESC(force_async_tsc, "force the asynchronous TSC mode");
1476

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

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

Download in other formats: