SUPDrv-linux.c@ 106837

Last change on this file since 106837 was 106061, checked in by vboxsync, 5 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.1 KB

Line
1	/* $Id: SUPDrv-linux.c 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VBoxDrv - The VirtualBox Support Driver - Linux specifics.
4	*/
5
6	/*
7	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP LOG_GROUP_SUP_DRV
42	#include "../SUPDrvInternal.h"
43	#include "the-linux-kernel.h"
44	#include "version-generated.h"
45	#include "product-generated.h"
46	#include "revision-generated.h"
47
48	#include <iprt/assert.h>
49	#include <iprt/spinlock.h>
50	#include <iprt/semaphore.h>
51	#include <iprt/initterm.h>
52	#include <iprt/process.h>
53	#include <iprt/thread.h>
54	#include <VBox/err.h>
55	#include <iprt/mem.h>
56	#include <VBox/log.h>
57	#include <VBox/VBoxLnxModInline.h>
58	#include <iprt/mp.h>
59
60	/** @todo figure out the exact version number */
61	#if RTLNX_VER_MIN(2,6,16)
62	# include <iprt/power.h>
63	# define VBOX_WITH_SUSPEND_NOTIFICATION
64	#endif
65
66	#include <linux/sched.h>
67	#include <linux/miscdevice.h>
68	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
69	# include <linux/platform_device.h>
70	#endif
71	#if (RTLNX_VER_MIN(2,6,28)) && defined(SUPDRV_WITH_MSR_PROBER)
72	# define SUPDRV_LINUX_HAS_SAFE_MSR_API
73	# include <asm/msr.h>
74	#endif
75
76	#include <asm/desc.h>
77
78	#include <iprt/asm-amd64-x86.h>
79
80
81	/*********************************************************************************************************************************
82	* Defined Constants And Macros *
83	*********************************************************************************************************************************/
84	/* check kernel version */
85	# ifndef SUPDRV_AGNOSTIC
86	# if RTLNX_VER_MAX(2,6,0)
87	# error Unsupported kernel version!
88	# endif
89	# endif
90
91	#ifdef CONFIG_X86_HIGH_ENTRY
92	# error "CONFIG_X86_HIGH_ENTRY is not supported by VBoxDrv at this time."
93	#endif
94
95	/* We cannot include x86.h, so we copy the defines we need here: */
96	#define X86_EFL_IF RT_BIT(9)
97	#define X86_EFL_AC RT_BIT(18)
98	#define X86_EFL_DF RT_BIT(10)
99	#define X86_EFL_IOPL (RT_BIT(12) \| RT_BIT(13))
100
101	/* To include the version number of VirtualBox into kernel backtraces: */
102	#define VBoxDrvLinuxVersion RT_CONCAT3(RT_CONCAT(VBOX_VERSION_MAJOR, _), \
103	RT_CONCAT(VBOX_VERSION_MINOR, _), \
104	VBOX_VERSION_BUILD)
105	#define VBoxDrvLinuxIOCtl RT_CONCAT(VBoxDrvLinuxIOCtl_,VBoxDrvLinuxVersion)
106
107	/* Once externally provided, this string will be printed into kernel log on
108	* module start together with the rest of versioning information. */
109	#ifndef VBOX_EXTRA_VERSION_STRING
110	# define VBOX_EXTRA_VERSION_STRING ""
111	#endif
112
113
114	/*********************************************************************************************************************************
115	* Structures and Typedefs *
116	*********************************************************************************************************************************/
117	#if RTLNX_VER_MIN(5,0,0)
118	/** Wrapper module list entry. */
119	typedef struct SUPDRVLNXMODULE
120	{
121	RTLISTNODE ListEntry;
122	struct module *pModule;
123	} SUPDRVLNXMODULE;
124	/** Pointer to a wrapper module list entry. */
125	typedef SUPDRVLNXMODULE *PSUPDRVLNXMODULE;
126	#endif
127
128
129	/*********************************************************************************************************************************
130	* Internal Functions *
131	*********************************************************************************************************************************/
132	static int __init VBoxDrvLinuxInit(void);
133	static void __exit VBoxDrvLinuxUnload(void);
134	static int VBoxDrvLinuxCreateSys(struct inode pInode, struct file pFilp);
135	static int VBoxDrvLinuxCreateUsr(struct inode pInode, struct file pFilp);
136	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp);
137	#ifdef HAVE_UNLOCKED_IOCTL
138	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg);
139	#else
140	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg);
141	#endif
142	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PSUPDRVSESSION pSession);
143	static int VBoxDrvLinuxErr2LinuxErr(int);
144	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
145	static int VBoxDrvProbe(struct platform_device *pDev);
146	# if RTLNX_VER_MIN(2,6,30)
147	static int VBoxDrvSuspend(struct device *pDev);
148	static int VBoxDrvResume(struct device *pDev);
149	# else
150	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State);
151	static int VBoxDrvResume(struct platform_device *pDev);
152	# endif
153	static void VBoxDevRelease(struct device *pDev);
154	#endif
155	#if RTLNX_VER_MIN(5,0,0)
156	static int supdrvLinuxLdrModuleNotifyCallback(struct notifier_block *pBlock,
157	unsigned long uModuleState, void *pvModule);
158	#endif
159
160
161	/*********************************************************************************************************************************
162	* Global Variables *
163	*********************************************************************************************************************************/
164	/**
165	* Device extention & session data association structure.
166	*/
167	static SUPDRVDEVEXT g_DevExt;
168
169	/** Module parameter.
170	* Not prefixed because the name is used by macros and the end of this file. */
171	static int force_async_tsc = 0;
172
173	/** The system device name. */
174	#define DEVICE_NAME_SYS "vboxdrv"
175	/** The user device name. */
176	#define DEVICE_NAME_USR "vboxdrvu"
177
178	/** The file_operations structure. */
179	static struct file_operations gFileOpsVBoxDrvSys =
180	{
181	owner: THIS_MODULE,
182	open: VBoxDrvLinuxCreateSys,
183	release: VBoxDrvLinuxClose,
184	#ifdef HAVE_UNLOCKED_IOCTL
185	unlocked_ioctl: VBoxDrvLinuxIOCtl,
186	#else
187	ioctl: VBoxDrvLinuxIOCtl,
188	#endif
189	};
190
191	/** The file_operations structure. */
192	static struct file_operations gFileOpsVBoxDrvUsr =
193	{
194	owner: THIS_MODULE,
195	open: VBoxDrvLinuxCreateUsr,
196	release: VBoxDrvLinuxClose,
197	#ifdef HAVE_UNLOCKED_IOCTL
198	unlocked_ioctl: VBoxDrvLinuxIOCtl,
199	#else
200	ioctl: VBoxDrvLinuxIOCtl,
201	#endif
202	};
203
204	/** The miscdevice structure for vboxdrv. */
205	static struct miscdevice gMiscDeviceSys =
206	{
207	minor: MISC_DYNAMIC_MINOR,
208	name: DEVICE_NAME_SYS,
209	fops: &gFileOpsVBoxDrvSys,
210	# if RTLNX_VER_MAX(2,6,18)
211	devfs_name: DEVICE_NAME_SYS,
212	# endif
213	};
214	/** The miscdevice structure for vboxdrvu. */
215	static struct miscdevice gMiscDeviceUsr =
216	{
217	minor: MISC_DYNAMIC_MINOR,
218	name: DEVICE_NAME_USR,
219	fops: &gFileOpsVBoxDrvUsr,
220	# if RTLNX_VER_MAX(2,6,18)
221	devfs_name: DEVICE_NAME_USR,
222	# endif
223	};
224
225
226	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
227
228	# if RTLNX_VER_MIN(2,6,30)
229	static struct dev_pm_ops gPlatformPMOps =
230	{
231	.suspend = VBoxDrvSuspend, /* before entering deep sleep */
232	.resume = VBoxDrvResume, /* after wakeup from deep sleep */
233	.freeze = VBoxDrvSuspend, /* before creating hibernation image */
234	.restore = VBoxDrvResume, /* after waking up from hibernation */
235	};
236	# endif
237
238	static struct platform_driver gPlatformDriver =
239	{
240	.probe = VBoxDrvProbe,
241	# if RTLNX_VER_MAX(2,6,30)
242	.suspend = VBoxDrvSuspend,
243	.resume = VBoxDrvResume,
244	# endif
245	/** @todo .shutdown? */
246	.driver =
247	{
248	.name = "vboxdrv",
249	# if RTLNX_VER_MIN(2,6,30)
250	.pm = &gPlatformPMOps,
251	# endif
252	}
253	};
254
255	static struct platform_device gPlatformDevice =
256	{
257	.name = "vboxdrv",
258	.dev =
259	{
260	.release = VBoxDevRelease
261	}
262	};
263
264	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
265
266	#if RTLNX_VER_MIN(5,0,0)
267	/** Module load/unload notification registration record. */
268	static struct notifier_block g_supdrvLinuxModuleNotifierBlock =
269	{
270	.notifier_call = supdrvLinuxLdrModuleNotifyCallback,
271	.priority = 0
272	};
273	/** Spinlock protecting g_supdrvLinuxWrapperModuleList. */
274	static spinlock_t g_supdrvLinuxWrapperModuleSpinlock;
275	/** List of potential wrapper modules (PSUPDRVLNXMODULE). */
276	static RTLISTANCHOR g_supdrvLinuxWrapperModuleList;
277	#endif
278
279
280	/** Get the kernel UID for the current process. */
281	DECLINLINE(RTUID) vboxdrvLinuxKernUid(void)
282	{
283	#if RTLNX_VER_MIN(2,6,29)
284	# if RTLNX_VER_MIN(3,5,0)
285	return __kuid_val(current->cred->uid);
286	# else
287	return current->cred->uid;
288	# endif
289	#else
290	return current->uid;
291	#endif
292	}
293
294
295	/** Get the kernel GID for the current process. */
296	DECLINLINE(RTGID) vboxdrvLinuxKernGid(void)
297	{
298	#if RTLNX_VER_MIN(2,6,29)
299	# if RTLNX_VER_MIN(3,5,0)
300	return __kgid_val(current->cred->gid);
301	# else
302	return current->cred->gid;
303	# endif
304	#else
305	return current->gid;
306	#endif
307	}
308
309
310	#ifdef VBOX_WITH_HARDENING
311	/** Get the effective UID of the current process. */
312	DECLINLINE(RTUID) vboxdrvLinuxEuid(void)
313	{
314	# if RTLNX_VER_MIN(2,6,29)
315	# if RTLNX_VER_MIN(3,5,0)
316	return __kuid_val(current->cred->euid);
317	# else
318	return current->cred->euid;
319	# endif
320	# else
321	return current->euid;
322	# endif
323	}
324	#endif
325
326
327	/**
328	* Initialize module.
329	*
330	* @returns appropriate status code.
331	*/
332	static int __init VBoxDrvLinuxInit(void)
333	{
334	int rc;
335
336	/* Check if modue loading was disabled. */
337	if (!vbox_mod_should_load())
338	return -EINVAL;
339
340	#if RTLNX_VER_MIN(5,0,0)
341	spin_lock_init(&g_supdrvLinuxWrapperModuleSpinlock);
342	RTListInit(&g_supdrvLinuxWrapperModuleList);
343	#endif
344
345	/*
346	* Check for synchronous/asynchronous TSC mode.
347	*/
348	printk(KERN_DEBUG "vboxdrv: Found %u processor cores/threads\n", (unsigned)RTMpGetOnlineCount());
349	rc = misc_register(&gMiscDeviceSys);
350	if (rc)
351	{
352	printk(KERN_ERR "vboxdrv: Can't register system misc device! rc=%d\n", rc);
353	return rc;
354	}
355	rc = misc_register(&gMiscDeviceUsr);
356	if (rc)
357	{
358	printk(KERN_ERR "vboxdrv: Can't register user misc device! rc=%d\n", rc);
359	misc_deregister(&gMiscDeviceSys);
360	return rc;
361	}
362	if (!rc)
363	{
364	/*
365	* Initialize the runtime.
366	* On AMD64 we'll have to donate the high rwx memory block to the exec allocator.
367	*/
368	rc = RTR0Init(0);
369	if (RT_SUCCESS(rc))
370	{
371	Log(("VBoxDrv::ModuleInit\n"));
372
373	/*
374	* Initialize the device extension.
375	*/
376	rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
377	if (RT_SUCCESS(rc))
378	{
379	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
380	rc = platform_driver_register(&gPlatformDriver);
381	if (rc == 0)
382	{
383	rc = platform_device_register(&gPlatformDevice);
384	if (rc == 0)
385	#endif
386	{
387	#if RTLNX_VER_MIN(5,0,0)
388	/*
389	* Register the module notifier.
390	*/
391	int rc2 = register_module_notifier(&g_supdrvLinuxModuleNotifierBlock);
392	if (rc2)
393	printk(KERN_WARNING "vboxdrv: failed to register module notifier! rc2=%d\n", rc2);
394	#endif
395
396
397	printk(KERN_INFO "vboxdrv: TSC mode is %s, tentative frequency %llu Hz\n",
398	SUPGetGIPModeName(g_DevExt.pGip), g_DevExt.pGip->u64CpuHz);
399	LogFlow(("VBoxDrv::ModuleInit returning %#x\n", rc));
400	printk(KERN_DEBUG "vboxdrv: Successfully loaded version "
401	VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV)
402	VBOX_EXTRA_VERSION_STRING
403	" (interface " RT_XSTR(SUPDRV_IOC_VERSION) ")\n");
404	return rc;
405	}
406	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
407	else
408	platform_driver_unregister(&gPlatformDriver);
409	}
410	#endif
411	}
412
413	rc = -EINVAL;
414	RTR0TermForced();
415	}
416	else
417	rc = -EINVAL;
418
419	/*
420	* Failed, cleanup and return the error code.
421	*/
422	}
423	misc_deregister(&gMiscDeviceSys);
424	misc_deregister(&gMiscDeviceUsr);
425	Log(("VBoxDrv::ModuleInit returning %#x (minor:%d & %d)\n", rc, gMiscDeviceSys.minor, gMiscDeviceUsr.minor));
426	return rc;
427	}
428
429
430	/**
431	* Unload the module.
432	*/
433	static void __exit VBoxDrvLinuxUnload(void)
434	{
435	Log(("VBoxDrvLinuxUnload\n"));
436
437	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
438	platform_device_unregister(&gPlatformDevice);
439	platform_driver_unregister(&gPlatformDriver);
440	#endif
441
442	#if RTLNX_VER_MIN(5,0,0)
443	/*
444	* Kick the list of potential wrapper modules.
445	*/
446	unregister_module_notifier(&g_supdrvLinuxModuleNotifierBlock);
447
448	spin_lock(&g_supdrvLinuxWrapperModuleSpinlock);
449	while (!RTListIsEmpty(&g_supdrvLinuxWrapperModuleList))
450	{
451	PSUPDRVLNXMODULE pCur = RTListRemoveFirst(&g_supdrvLinuxWrapperModuleList, SUPDRVLNXMODULE, ListEntry);
452	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
453
454	pCur->pModule = NULL;
455	RTMemFree(pCur);
456
457	spin_lock(&g_supdrvLinuxWrapperModuleSpinlock);
458	}
459	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
460	#endif
461
462	/*
463	* I Don't think it's possible to unload a driver which processes have
464	* opened, at least we'll blindly assume that here.
465	*/
466	misc_deregister(&gMiscDeviceUsr);
467	misc_deregister(&gMiscDeviceSys);
468
469	/*
470	* Destroy GIP, delete the device extension and terminate IPRT.
471	*/
472	supdrvDeleteDevExt(&g_DevExt);
473	RTR0TermForced();
474	}
475
476
477	/**
478	* Common open code.
479	*
480	* @param pInode Pointer to inode info structure.
481	* @param pFilp Associated file pointer.
482	* @param fUnrestricted Indicates which device node which was opened.
483	*/
484	static int vboxdrvLinuxCreateCommon(struct inode pInode, struct file pFilp, bool fUnrestricted)
485	{
486	int rc;
487	PSUPDRVSESSION pSession;
488	Log(("VBoxDrvLinuxCreate: pFilp=%p pid=%d/%d %s\n", pFilp, RTProcSelf(), current->pid, current->comm));
489
490	#ifdef VBOX_WITH_HARDENING
491	/*
492	* Only root is allowed to access the unrestricted device, enforce it!
493	*/
494	if ( fUnrestricted
495	&& vboxdrvLinuxEuid() != 0 /* root */ )
496	{
497	Log(("VBoxDrvLinuxCreate: euid=%d, expected 0 (root)\n", vboxdrvLinuxEuid()));
498	return -EPERM;
499	}
500	#endif /* VBOX_WITH_HARDENING */
501
502	/*
503	* Call common code for the rest.
504	*/
505	rc = supdrvCreateSession(&g_DevExt, true /* fUser */, fUnrestricted, &pSession);
506	if (!rc)
507	{
508	pSession->Uid = vboxdrvLinuxKernUid();
509	pSession->Gid = vboxdrvLinuxKernGid();
510	}
511
512	pFilp->private_data = pSession;
513
514	Log(("VBoxDrvLinuxCreate: g_DevExt=%p pSession=%p rc=%d/%d (pid=%d/%d %s)\n",
515	&g_DevExt, pSession, rc, VBoxDrvLinuxErr2LinuxErr(rc),
516	RTProcSelf(), current->pid, current->comm));
517	return VBoxDrvLinuxErr2LinuxErr(rc);
518	}
519
520
521	/** /dev/vboxdrv. */
522	static int VBoxDrvLinuxCreateSys(struct inode pInode, struct file pFilp)
523	{
524	return vboxdrvLinuxCreateCommon(pInode, pFilp, true);
525	}
526
527
528	/** /dev/vboxdrvu. */
529	static int VBoxDrvLinuxCreateUsr(struct inode pInode, struct file pFilp)
530	{
531	return vboxdrvLinuxCreateCommon(pInode, pFilp, false);
532	}
533
534
535	/**
536	* Close device.
537	*
538	* @param pInode Pointer to inode info structure.
539	* @param pFilp Associated file pointer.
540	*/
541	static int VBoxDrvLinuxClose(struct inode pInode, struct file pFilp)
542	{
543	Log(("VBoxDrvLinuxClose: pFilp=%p pSession=%p pid=%d/%d %s\n",
544	pFilp, pFilp->private_data, RTProcSelf(), current->pid, current->comm));
545	supdrvSessionRelease((PSUPDRVSESSION)pFilp->private_data);
546	pFilp->private_data = NULL;
547	return 0;
548	}
549
550
551	#ifdef VBOX_WITH_SUSPEND_NOTIFICATION
552	/**
553	* Dummy device release function. We have to provide this function,
554	* otherwise the kernel will complain.
555	*
556	* @param pDev Pointer to the platform device.
557	*/
558	static void VBoxDevRelease(struct device *pDev)
559	{
560	}
561
562	/**
563	* Dummy probe function.
564	*
565	* @param pDev Pointer to the platform device.
566	*/
567	static int VBoxDrvProbe(struct platform_device *pDev)
568	{
569	return 0;
570	}
571
572	/**
573	* Suspend callback.
574	* @param pDev Pointer to the platform device.
575	* @param State Message type, see Documentation/power/devices.txt.
576	* Ignored.
577	*/
578	# if RTLNX_VER_MIN(2,6,30) && !defined(DOXYGEN_RUNNING)
579	static int VBoxDrvSuspend(struct device *pDev)
580	# else
581	static int VBoxDrvSuspend(struct platform_device *pDev, pm_message_t State)
582	# endif
583	{
584	RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
585	return 0;
586	}
587
588	/**
589	* Resume callback.
590	*
591	* @param pDev Pointer to the platform device.
592	*/
593	# if RTLNX_VER_MIN(2,6,30)
594	static int VBoxDrvResume(struct device *pDev)
595	# else
596	static int VBoxDrvResume(struct platform_device *pDev)
597	# endif
598	{
599	RTPowerSignalEvent(RTPOWEREVENT_RESUME);
600	return 0;
601	}
602	#endif /* VBOX_WITH_SUSPEND_NOTIFICATION */
603
604
605	/**
606	* Device I/O Control entry point.
607	*
608	* @param pFilp Associated file pointer.
609	* @param uCmd The function specified to ioctl().
610	* @param ulArg The argument specified to ioctl().
611	*/
612	#if defined(HAVE_UNLOCKED_IOCTL) \|\| defined(DOXYGEN_RUNNING)
613	static long VBoxDrvLinuxIOCtl(struct file *pFilp, unsigned int uCmd, unsigned long ulArg)
614	#else
615	static int VBoxDrvLinuxIOCtl(struct inode pInode, struct file pFilp, unsigned int uCmd, unsigned long ulArg)
616	#endif
617	{
618	PSUPDRVSESSION pSession = (PSUPDRVSESSION)pFilp->private_data;
619	int rc;
620	#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
621	# if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
622	RTCCUINTREG fSavedEfl;
623
624	/*
625	* Refuse all I/O control calls if we've ever detected EFLAGS.AC being cleared.
626	*
627	* This isn't a problem, as there is absolutely nothing in the kernel context that
628	* depend on user context triggering cleanups. That would be pretty wild, right?
629	*/
630	if (RT_UNLIKELY(g_DevExt.cBadContextCalls > 0))
631	{
632	SUPR0Printf("VBoxDrvLinuxIOCtl: EFLAGS.AC=0 detected %u times, refusing all I/O controls!\n", g_DevExt.cBadContextCalls);
633	return ESPIPE;
634	}
635
636	fSavedEfl = ASMAddFlags(X86_EFL_AC);
637	# else
638	stac();
639	# endif
640	#endif
641
642	/*
643	* Deal with the two high-speed IOCtl that takes it's arguments from
644	* the session and iCmd, and only returns a VBox status code.
645	*/
646	AssertCompile(_IOC_NRSHIFT == 0 && _IOC_NRBITS == 8);
647	#ifdef HAVE_UNLOCKED_IOCTL
648	if (RT_LIKELY( (unsigned int)(uCmd - SUP_IOCTL_FAST_DO_FIRST) < (unsigned int)32
649	&& pSession->fUnrestricted))
650	rc = supdrvIOCtlFast(uCmd - SUP_IOCTL_FAST_DO_FIRST, ulArg, &g_DevExt, pSession);
651	else
652	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
653	#else /* !HAVE_UNLOCKED_IOCTL */
654	unlock_kernel();
655	if (RT_LIKELY( (unsigned int)(uCmd - SUP_IOCTL_FAST_DO_FIRST) < (unsigned int)32
656	&& pSession->fUnrestricted))
657	rc = supdrvIOCtlFast(uCmd - SUP_IOCTL_FAST_DO_FIRST, ulArg, &g_DevExt, pSession);
658	else
659	rc = VBoxDrvLinuxIOCtlSlow(pFilp, uCmd, ulArg, pSession);
660	lock_kernel();
661	#endif /* !HAVE_UNLOCKED_IOCTL */
662
663	#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
664	# if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
665	/*
666	* Before we restore AC and the rest of EFLAGS, check if the IOCtl handler code
667	* accidentially modified it or some other important flag.
668	*/
669	if (RT_UNLIKELY( (ASMGetFlags() & (X86_EFL_AC \| X86_EFL_IF \| X86_EFL_DF))
670	!= ((fSavedEfl & (X86_EFL_AC \| X86_EFL_IF \| X86_EFL_DF)) \| X86_EFL_AC) ))
671	{
672	char szTmp[48];
673	RTStrPrintf(szTmp, sizeof(szTmp), "uCmd=%#x: %#x->%#x!", _IOC_NR(uCmd), (uint32_t)fSavedEfl, (uint32_t)ASMGetFlags());
674	supdrvBadContext(&g_DevExt, "SUPDrv-linux.c", __LINE__, szTmp);
675	}
676	ASMSetFlags(fSavedEfl);
677	# else
678	clac();
679	# endif
680	#endif
681	return rc;
682	}
683
684
685	/**
686	* Device I/O Control entry point.
687	*
688	* @param pFilp Associated file pointer.
689	* @param uCmd The function specified to ioctl().
690	* @param ulArg The argument specified to ioctl().
691	* @param pSession The session instance.
692	*/
693	static int VBoxDrvLinuxIOCtlSlow(struct file *pFilp, unsigned int uCmd, unsigned long ulArg, PSUPDRVSESSION pSession)
694	{
695	int rc;
696	SUPREQHDR Hdr;
697	PSUPREQHDR pHdr;
698	uint32_t cbBuf;
699
700	Log6(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p pid=%d/%d\n", pFilp, uCmd, (void *)ulArg, RTProcSelf(), current->pid));
701
702	/*
703	* Read the header.
704	*/
705	if (RT_FAILURE(RTR0MemUserCopyFrom(&Hdr, ulArg, sizeof(Hdr))))
706	{
707	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx,) failed; uCmd=%#x\n", ulArg, uCmd));
708	return -EFAULT;
709	}
710	if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
711	{
712	Log(("VBoxDrvLinuxIOCtl: bad header magic %#x; uCmd=%#x\n", Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK, uCmd));
713	return -EINVAL;
714	}
715
716	/*
717	* Buffer the request.
718	*/
719	cbBuf = RT_MAX(Hdr.cbIn, Hdr.cbOut);
720	if (RT_UNLIKELY(cbBuf > _1M*16))
721	{
722	Log(("VBoxDrvLinuxIOCtl: too big cbBuf=%#x; uCmd=%#x\n", cbBuf, uCmd));
723	return -E2BIG;
724	}
725	if (RT_UNLIKELY(_IOC_SIZE(uCmd) ? cbBuf != _IOC_SIZE(uCmd) : Hdr.cbIn < sizeof(Hdr)))
726	{
727	Log(("VBoxDrvLinuxIOCtl: bad ioctl cbBuf=%#x _IOC_SIZE=%#x; uCmd=%#x\n", cbBuf, _IOC_SIZE(uCmd), uCmd));
728	return -EINVAL;
729	}
730	pHdr = RTMemAlloc(cbBuf);
731	if (RT_UNLIKELY(!pHdr))
732	{
733	OSDBGPRINT(("VBoxDrvLinuxIOCtl: failed to allocate buffer of %d bytes for uCmd=%#x\n", cbBuf, uCmd));
734	return -ENOMEM;
735	}
736	if (RT_FAILURE(RTR0MemUserCopyFrom(pHdr, ulArg, Hdr.cbIn)))
737	{
738	Log(("VBoxDrvLinuxIOCtl: copy_from_user(,%#lx, %#x) failed; uCmd=%#x\n", ulArg, Hdr.cbIn, uCmd));
739	RTMemFree(pHdr);
740	return -EFAULT;
741	}
742	if (Hdr.cbIn < cbBuf)
743	RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbBuf - Hdr.cbIn);
744
745	/*
746	* Process the IOCtl.
747	*/
748	rc = supdrvIOCtl(uCmd, &g_DevExt, pSession, pHdr, cbBuf);
749
750	/*
751	* Copy ioctl data and output buffer back to user space.
752	*/
753	if (RT_LIKELY(!rc))
754	{
755	uint32_t cbOut = pHdr->cbOut;
756	if (RT_UNLIKELY(cbOut > cbBuf))
757	{
758	OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n", cbOut, cbBuf, uCmd));
759	cbOut = cbBuf;
760	}
761	if (RT_FAILURE(RTR0MemUserCopyTo(ulArg, pHdr, cbOut)))
762	{
763	/* this is really bad! */
764	OSDBGPRINT(("VBoxDrvLinuxIOCtl: copy_to_user(%#lx,,%#x); uCmd=%#x!\n", ulArg, cbOut, uCmd));
765	rc = -EFAULT;
766	}
767	}
768	else
769	{
770	Log(("VBoxDrvLinuxIOCtl: pFilp=%p uCmd=%#x ulArg=%p failed, rc=%d\n", pFilp, uCmd, (void *)ulArg, rc));
771	rc = -EINVAL;
772	}
773	RTMemFree(pHdr);
774
775	Log6(("VBoxDrvLinuxIOCtl: returns %d (pid=%d/%d)\n", rc, RTProcSelf(), current->pid));
776	return rc;
777	}
778
779
780	/**
781	* The SUPDRV IDC entry point.
782	*
783	* @returns VBox status code, see supdrvIDC.
784	* @param uReq The request code.
785	* @param pReq The request.
786	*/
787	int VBOXCALL SUPDrvLinuxIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
788	{
789	PSUPDRVSESSION pSession;
790
791	/*
792	* Some quick validations.
793	*/
794	if (RT_UNLIKELY(!RT_VALID_PTR(pReq)))
795	return VERR_INVALID_POINTER;
796
797	pSession = pReq->pSession;
798	if (pSession)
799	{
800	if (RT_UNLIKELY(!RT_VALID_PTR(pSession)))
801	return VERR_INVALID_PARAMETER;
802	if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
803	return VERR_INVALID_PARAMETER;
804	}
805	else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
806	return VERR_INVALID_PARAMETER;
807
808	/*
809	* Do the job.
810	*/
811	return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
812	}
813	EXPORT_SYMBOL(SUPDrvLinuxIDC);
814
815
816	#if RTLNX_VER_MIN(5,0,0)
817
818	/**
819	* Checks if the given module is one of our potential wrapper modules or not.
820	*/
821	static bool supdrvLinuxLdrIsPotentialWrapperModule(struct module const *pModule)
822	{
823	if ( pModule
824	&& strncmp(pModule->name, RT_STR_TUPLE("vbox_")) == 0)
825	return true;
826	return false;
827	}
828
829	/**
830	* Called when a kernel module changes state.
831	*
832	* We use this to listen for wrapper modules being loaded, since some evil
833	* bugger removed the find_module() export in 5.13.
834	*/
835	static int supdrvLinuxLdrModuleNotifyCallback(struct notifier_block pBlock, unsigned long uModuleState, void pvModule)
836	{
837	struct module pModule = (struct module )pvModule;
838	switch (uModuleState)
839	{
840	case MODULE_STATE_UNFORMED: /* Setting up the module... */
841	break;
842
843	/*
844	* The module is about to have its ctors & init functions called.
845	*
846	* Add anything that looks like a wrapper module to our tracker list.
847	*/
848	case MODULE_STATE_COMING:
849	if (supdrvLinuxLdrIsPotentialWrapperModule(pModule))
850	{
851	PSUPDRVLNXMODULE pTracker = (PSUPDRVLNXMODULE)RTMemAlloc(sizeof(*pTracker));
852	if (pTracker)
853	{
854	pTracker->pModule = pModule;
855	spin_lock(&g_supdrvLinuxWrapperModuleSpinlock);
856	RTListPrepend(&g_supdrvLinuxWrapperModuleList, &pTracker->ListEntry);
857	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
858	}
859	}
860	break;
861
862	case MODULE_STATE_LIVE:
863	break;
864
865	/*
866	* The module has been uninited and is going away.
867	*
868	* Remove the tracker entry for the module, if we have one.
869	*/
870	case MODULE_STATE_GOING:
871	{
872	PSUPDRVLNXMODULE pCur;
873	spin_lock(&g_supdrvLinuxWrapperModuleSpinlock);
874	RTListForEach(&g_supdrvLinuxWrapperModuleList, pCur, SUPDRVLNXMODULE, ListEntry)
875	{
876	if (pCur->pModule == pModule)
877	{
878	RTListNodeRemove(&pCur->ListEntry);
879	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
880
881	pCur->pModule = NULL;
882	RTMemFree(pCur);
883
884	spin_lock(&g_supdrvLinuxWrapperModuleSpinlock); /* silly */
885	break;
886	}
887	}
888	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
889	break;
890	}
891	}
892	RT_NOREF(pBlock);
893	return NOTIFY_OK;
894	}
895
896	/**
897	* Replacement for find_module() that's no longer exported with 5.13.
898	*/
899	static struct module supdrvLinuxLdrFindModule(const char pszLnxModName)
900	{
901	PSUPDRVLNXMODULE pCur;
902
903	spin_lock(&g_supdrvLinuxWrapperModuleSpinlock);
904	RTListForEach(&g_supdrvLinuxWrapperModuleList, pCur, SUPDRVLNXMODULE, ListEntry)
905	{
906	struct module * const pModule = pCur->pModule;
907	if ( pModule
908	&& strcmp(pszLnxModName, pModule->name) == 0)
909	{
910	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
911	return pModule;
912	}
913	}
914	spin_unlock(&g_supdrvLinuxWrapperModuleSpinlock);
915	return NULL;
916	}
917
918	#endif /* >= 5.0.0 */
919
920
921	/**
922	* Used by native wrapper modules, forwarding to supdrvLdrRegisterWrappedModule
923	* with device extension prepended to the argument list.
924	*/
925	SUPR0DECL(int) SUPDrvLinuxLdrRegisterWrappedModule(PCSUPLDRWRAPPEDMODULE pWrappedModInfo,
926	const char pszLnxModName, void *phMod)
927	{
928	AssertPtrReturn(pszLnxModName, VERR_INVALID_POINTER);
929	AssertReturn(*pszLnxModName, VERR_INVALID_NAME);
930
931	/* Locate the module structure for the caller so can later reference
932	and dereference it to prevent unloading while it is being used.
933
934	Before Linux v5.9 this could be done by address (__module_address()
935	or __module_text_address()), but someone (guess who) apparently on
936	a mission to make life miserable for out-of-tree modules or something,
937	decided it was only used by build-in code and unexported both of them.
938
939	I could find no init callouts getting a struct module pointer either,
940	nor any module name hint anywhere I could see. So, we're left with
941	hardcoding the module name via the compiler and pass it along to
942	SUPDrv so we can call find_module() here.
943
944	Sigh^2.
945
946	Update 5.13:
947	The find_module() and module_mutex symbols are no longer exported,
948	probably the doing of the same evil bugger mentioned above. So, we now
949	register a module notification callback and track the modules we're
950	interested in that way. */
951
952	#if RTLNX_VER_MIN(5,0,0)
953	struct module *pLnxModule = supdrvLinuxLdrFindModule(pszLnxModName);
954	if (pLnxModule)
955	return supdrvLdrRegisterWrappedModule(&g_DevExt, pWrappedModInfo, pLnxModule, phMod);
956	printk("vboxdrv: supdrvLinuxLdrFindModule(%s) failed in SUPDrvLinuxLdrRegisterWrappedModule!\n", pszLnxModName);
957	return VERR_MODULE_NOT_FOUND;
958
959	#elif RTLNX_VER_MIN(2,6,30)
960	if (mutex_lock_interruptible(&module_mutex) == 0)
961	{
962	struct module *pLnxModule = find_module(pszLnxModName);
963	mutex_unlock(&module_mutex);
964	if (pLnxModule)
965	return supdrvLdrRegisterWrappedModule(&g_DevExt, pWrappedModInfo, pLnxModule, phMod);
966	printk("vboxdrv: find_module(%s) failed in SUPDrvLinuxLdrRegisterWrappedModule!\n", pszLnxModName);
967	return VERR_MODULE_NOT_FOUND;
968	}
969	return VERR_INTERRUPTED;
970
971	#else
972	printk("vboxdrv: wrapper modules are not supported on 2.6.29 and earlier. sorry.\n");
973	return VERR_NOT_SUPPORTED;
974	#endif
975	}
976	EXPORT_SYMBOL(SUPDrvLinuxLdrRegisterWrappedModule);
977
978
979	/**
980	* Used by native wrapper modules, forwarding to supdrvLdrDeregisterWrappedModule
981	* with device extension prepended to the argument list.
982	*/
983	SUPR0DECL(int) SUPDrvLinuxLdrDeregisterWrappedModule(PCSUPLDRWRAPPEDMODULE pWrappedModInfo, void **phMod)
984	{
985	return supdrvLdrDeregisterWrappedModule(&g_DevExt, pWrappedModInfo, phMod);
986	}
987	EXPORT_SYMBOL(SUPDrvLinuxLdrDeregisterWrappedModule);
988
989
990	RTCCUINTREG VBOXCALL supdrvOSChangeCR4(RTCCUINTREG fOrMask, RTCCUINTREG fAndMask)
991	{
992	#if RTLNX_VER_MIN(5,8,0)
993	unsigned long fSavedFlags;
994	local_irq_save(fSavedFlags);
995	RTCCUINTREG const uOld = cr4_read_shadow();
996	cr4_update_irqsoff(fOrMask, ~fAndMask); /* Same as this function, only it is not returning the old value. */
997	AssertMsg(cr4_read_shadow() == ((uOld & fAndMask) \| fOrMask),
998	("fOrMask=%#RTreg fAndMask=%#RTreg uOld=%#RTreg; new cr4=%#llx\n", fOrMask, fAndMask, uOld, cr4_read_shadow()));
999	local_irq_restore(fSavedFlags);
1000	#else
1001	# if RTLNX_VER_MIN(3,20,0)
1002	RTCCUINTREG const uOld = this_cpu_read(cpu_tlbstate.cr4);
1003	# else
1004	RTCCUINTREG const uOld = ASMGetCR4();
1005	# endif
1006	RTCCUINTREG const uNew = (uOld & fAndMask) \| fOrMask;
1007	if (uNew != uOld)
1008	{
1009	# if RTLNX_VER_MIN(3,20,0)
1010	this_cpu_write(cpu_tlbstate.cr4, uNew);
1011	__write_cr4(uNew);
1012	# else
1013	ASMSetCR4(uNew);
1014	# endif
1015	}
1016	#endif
1017	return uOld;
1018	}
1019
1020
1021	void VBOXCALL supdrvOSCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
1022	{
1023	NOREF(pDevExt);
1024	NOREF(pSession);
1025	}
1026
1027
1028	void VBOXCALL supdrvOSSessionHashTabInserted(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
1029	{
1030	NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
1031	}
1032
1033
1034	void VBOXCALL supdrvOSSessionHashTabRemoved(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
1035	{
1036	NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
1037	}
1038
1039
1040	/**
1041	* Initializes any OS specific object creator fields.
1042	*/
1043	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
1044	{
1045	NOREF(pObj);
1046	NOREF(pSession);
1047	}
1048
1049
1050	/**
1051	* Checks if the session can access the object.
1052	*
1053	* @returns true if a decision has been made.
1054	* @returns false if the default access policy should be applied.
1055	*
1056	* @param pObj The object in question.
1057	* @param pSession The session wanting to access the object.
1058	* @param pszObjName The object name, can be NULL.
1059	* @param prc Where to store the result when returning true.
1060	*/
1061	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
1062	{
1063	NOREF(pObj);
1064	NOREF(pSession);
1065	NOREF(pszObjName);
1066	NOREF(prc);
1067	return false;
1068	}
1069
1070
1071	bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
1072	{
1073	return force_async_tsc != 0;
1074	}
1075
1076
1077	bool VBOXCALL supdrvOSAreCpusOfflinedOnSuspend(void)
1078	{
1079	return true;
1080	}
1081
1082
1083	bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
1084	{
1085	return false;
1086	}
1087
1088
1089	int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
1090	{
1091	NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
1092	return VERR_NOT_SUPPORTED;
1093	}
1094
1095
1096	int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv,
1097	const uint8_t pbImageBits, const char pszSymbol)
1098	{
1099	NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits); NOREF(pszSymbol);
1100	return VERR_NOT_SUPPORTED;
1101	}
1102
1103
1104	int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
1105	{
1106	NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits); NOREF(pReq);
1107	return VERR_NOT_SUPPORTED;
1108	}
1109
1110
1111	void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1112	{
1113	NOREF(pDevExt); NOREF(pImage);
1114	}
1115
1116
1117	/** @def VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS
1118	* A very crude hack for debugging using perf and dtrace.
1119	*
1120	* DO ABSOLUTELY NOT ENABLE IN PRODUCTION BUILDS! DEVELOPMENT ONLY!!
1121	* DO ABSOLUTELY NOT ENABLE IN PRODUCTION BUILDS! DEVELOPMENT ONLY!!
1122	* DO ABSOLUTELY NOT ENABLE IN PRODUCTION BUILDS! DEVELOPMENT ONLY!!
1123	*
1124	*/
1125	#if 0 \|\| defined(DOXYGEN_RUNNING)
1126	# define VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS
1127	#endif
1128
1129	#if defined(VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS) && defined(CONFIG_MODULES_TREE_LOOKUP)
1130	/** Whether g_pfnModTreeInsert and g_pfnModTreeRemove have been initialized.
1131	* @remarks can still be NULL after init. */
1132	static volatile bool g_fLookedForModTreeFunctions = false;
1133	static void (g_pfnModTreeInsert)(struct mod_tree_node ) = NULL; /*< __mod_tree_insert /
1134	static void (g_pfnModTreeRemove)(struct mod_tree_node ) = NULL; /*< __mod_tree_remove /
1135	#endif
1136
1137
1138	void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
1139	{
1140	#ifdef VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS /* Not for production use!! Debugging only! */
1141	/*
1142	* This trick stops working with 4.2 when CONFIG_MODULES_TREE_LOOKUP is
1143	* defined. The module lookups are done via a tree structure and we
1144	* cannot get at the root of it. :-(
1145	*/
1146	# ifdef CONFIG_KALLSYMS
1147	size_t const cchName = strlen(pImage->szName);
1148	# endif
1149	struct module pMyMod, pSelfMod, pTestMod, pTestModByName;
1150	IPRT_LINUX_SAVE_EFL_AC();
1151
1152	pImage->pLnxModHack = NULL;
1153
1154	# ifdef CONFIG_MODULES_TREE_LOOKUP
1155	/*
1156	* This is pretty naive, but works for 4.2 on arch linux. I don't think we
1157	* can count on finding __mod_tree_remove in all kernel builds as it's not
1158	* marked noinline like __mod_tree_insert.
1159	*/
1160	if (!g_fLookedForModTreeFunctions)
1161	{
1162	unsigned long ulInsert = kallsyms_lookup_name("__mod_tree_insert");
1163	unsigned long ulRemove = kallsyms_lookup_name("__mod_tree_remove");
1164	if (!ulInsert \|\| !ulRemove)
1165	{
1166	g_fLookedForModTreeFunctions = true;
1167	printk(KERN_ERR "vboxdrv: failed to locate __mod_tree_insert and __mod_tree_remove.\n");
1168	IPRT_LINUX_RESTORE_EFL_AC();
1169	return;
1170	}
1171	(unsigned long )&g_pfnModTreeInsert = ulInsert;
1172	(unsigned long )&g_pfnModTreeRemove = ulRemove;
1173	ASMCompilerBarrier();
1174	g_fLookedForModTreeFunctions = true;
1175	}
1176	else if (!g_pfnModTreeInsert \|\| !g_pfnModTreeRemove)
1177	return;
1178	#endif
1179
1180	/*
1181	* Make sure we've found our own module, otherwise we cannot access the linked list.
1182	*/
1183	mutex_lock(&module_mutex);
1184	pSelfMod = find_module("vboxdrv");
1185	mutex_unlock(&module_mutex);
1186	if (!pSelfMod)
1187	{
1188	IPRT_LINUX_RESTORE_EFL_AC();
1189	return;
1190	}
1191
1192	/*
1193	* Cook up a module structure for the image.
1194	* We allocate symbol and string tables in the allocation and the module to keep things simple.
1195	*/
1196	# ifdef CONFIG_KALLSYMS
1197	pMyMod = (struct module )RTMemAllocZ(sizeof(pMyMod)
1198	+ sizeof(Elf_Sym) * 3
1199	+ 1 + cchName * 2 + sizeof("_start") + sizeof("_end") + 4 );
1200	# else
1201	pMyMod = (struct module )RTMemAllocZ(sizeof(pMyMod));
1202	# endif
1203	if (pMyMod)
1204	{
1205	int rc = VINF_SUCCESS;
1206	# ifdef CONFIG_KALLSYMS
1207	Elf_Sym paSymbols = (Elf_Sym )(pMyMod + 1);
1208	char pchStrTab = (char )(paSymbols + 3);
1209	# endif
1210
1211	pMyMod->state = MODULE_STATE_LIVE;
1212	INIT_LIST_HEAD(&pMyMod->list); /* just in case */
1213
1214	/* Perf only matches up files with a .ko extension (maybe .ko.gz),
1215	so in order for this crap to work smoothly, we append .ko to the
1216	module name and require the user to create symbolic links in
1217	/lib/modules/`uname -r`:
1218	for i in VMMR0.r0 VBoxDDR0.r0 VBoxDD2R0.r0; do
1219	sudo ln -s /mnt/scratch/vbox/svn/trunk/out/linux.amd64/debug/bin/$i /lib/modules/`uname -r`/$i.ko;
1220	done */
1221	RTStrPrintf(pMyMod->name, sizeof(pMyMod->name), "%s", pImage->szName);
1222
1223	/* sysfs bits. */
1224	INIT_LIST_HEAD(&pMyMod->mkobj.kobj.entry); /* rest of kobj is already zeroed, hopefully never accessed... */
1225	pMyMod->mkobj.mod = pMyMod;
1226	pMyMod->mkobj.drivers_dir = NULL;
1227	pMyMod->mkobj.mp = NULL;
1228	pMyMod->mkobj.kobj_completion = NULL;
1229
1230	pMyMod->modinfo_attrs = NULL; /* hopefully not accessed after setup. */
1231	pMyMod->holders_dir = NULL; /* hopefully not accessed. */
1232	pMyMod->version = "N/A";
1233	pMyMod->srcversion = "N/A";
1234
1235	/* We export no symbols. */
1236	pMyMod->num_syms = 0;
1237	pMyMod->syms = NULL;
1238	pMyMod->crcs = NULL;
1239
1240	pMyMod->num_gpl_syms = 0;
1241	pMyMod->gpl_syms = NULL;
1242	pMyMod->gpl_crcs = NULL;
1243
1244	pMyMod->num_gpl_future_syms = 0;
1245	pMyMod->gpl_future_syms = NULL;
1246	pMyMod->gpl_future_crcs = NULL;
1247
1248	# if CONFIG_UNUSED_SYMBOLS
1249	pMyMod->num_unused_syms = 0;
1250	pMyMod->unused_syms = NULL;
1251	pMyMod->unused_crcs = NULL;
1252
1253	pMyMod->num_unused_gpl_syms = 0;
1254	pMyMod->unused_gpl_syms = NULL;
1255	pMyMod->unused_gpl_crcs = NULL;
1256	# endif
1257	/* No kernel parameters either. */
1258	pMyMod->kp = NULL;
1259	pMyMod->num_kp = 0;
1260
1261	# ifdef CONFIG_MODULE_SIG
1262	/* Pretend ok signature. */
1263	pMyMod->sig_ok = true;
1264	# endif
1265	/* No exception table. */
1266	pMyMod->num_exentries = 0;
1267	pMyMod->extable = NULL;
1268
1269	/* No init function */
1270	pMyMod->init = NULL;
1271	pMyMod->module_init = NULL;
1272	pMyMod->init_size = 0;
1273	pMyMod->init_ro_size = 0;
1274	pMyMod->init_text_size = 0;
1275
1276	/* The module address and size. It's all text. */
1277	pMyMod->module_core = pImage->pvImage;
1278	pMyMod->core_size = pImage->cbImageBits;
1279	pMyMod->core_text_size = pImage->cbImageBits;
1280	pMyMod->core_ro_size = pImage->cbImageBits;
1281
1282	#ifdef CONFIG_MODULES_TREE_LOOKUP
1283	/* Fill in the self pointers for the tree nodes. */
1284	pMyMod->mtn_core.mod = pMyMod;
1285	pMyMod->mtn_init.mod = pMyMod;
1286	#endif
1287	/* They invented the tained bit for us, didn't they? */
1288	pMyMod->taints = 1;
1289
1290	# ifdef CONFIG_GENERIC_BUGS
1291	/* No BUGs in our modules. */
1292	pMyMod->num_bugs = 0;
1293	INIT_LIST_HEAD(&pMyMod->bug_list);
1294	pMyMod->bug_table = NULL;
1295	# endif
1296
1297	# ifdef CONFIG_KALLSYMS
1298	/* The core stuff is documented as only used when loading. So just zero them. */
1299	pMyMod->core_num_syms = 0;
1300	pMyMod->core_symtab = NULL;
1301	pMyMod->core_strtab = NULL;
1302
1303	/* Construct a symbol table with start and end symbols.
1304	Note! We don't have our own symbol table at this point, image bit
1305	are not uploaded yet! */
1306	pMyMod->num_symtab = 3;
1307	pMyMod->symtab = paSymbols;
1308	pMyMod->strtab = pchStrTab;
1309	RT_ZERO(paSymbols[0]);
1310	pchStrTab[0] = '\0';
1311	paSymbols[1].st_name = 1;
1312	paSymbols[2].st_name = 2 + RTStrPrintf(&pchStrTab[paSymbols[1].st_name], cchName + sizeof("_start"),
1313	"%s_start", pImage->szName);
1314	RTStrPrintf(&pchStrTab[paSymbols[2].st_name], cchName + sizeof("_end"), "%s_end", pImage->szName);
1315	paSymbols[1].st_info = 't';
1316	paSymbols[2].st_info = 'b';
1317	paSymbols[1].st_other = 0;
1318	paSymbols[2].st_other = 0;
1319	paSymbols[1].st_shndx = 0;
1320	paSymbols[2].st_shndx = 0;
1321	paSymbols[1].st_value = (uintptr_t)pImage->pvImage;
1322	paSymbols[2].st_value = (uintptr_t)pImage->pvImage + pImage->cbImageBits - 1;
1323	paSymbols[1].st_size = pImage->cbImageBits - 1;
1324	paSymbols[2].st_size = 1;
1325	# endif
1326	/* No arguments, but seems its always non-NULL so put empty string there. */
1327	pMyMod->args = "";
1328
1329	# ifdef CONFIG_SMP
1330	/* No per CPU data. */
1331	pMyMod->percpu = NULL;
1332	pMyMod->percpu_size = 0;
1333	# endif
1334	# ifdef CONFIG_TRACEPOINTS
1335	/* No tracepoints we like to share. */
1336	pMyMod->num_tracepoints = 0;
1337	pMyMod->tracepoints_ptrs = NULL;
1338	#endif
1339	# ifdef HAVE_JUMP_LABEL
1340	/* No jump lable stuff either. */
1341	pMyMod->jump_entries = NULL;
1342	pMyMod->num_jump_entries = 0;
1343	# endif
1344	# ifdef CONFIG_TRACING
1345	pMyMod->num_trace_bprintk_fmt = 0;
1346	pMyMod->trace_bprintk_fmt_start = NULL;
1347	# endif
1348	# ifdef CONFIG_EVENT_TRACING
1349	pMyMod->trace_events = NULL;
1350	pMyMod->num_trace_events = 0;
1351	# endif
1352	# ifdef CONFIG_FTRACE_MCOUNT_RECORD
1353	pMyMod->num_ftrace_callsites = 0;
1354	pMyMod->ftrace_callsites = NULL;
1355	# endif
1356	# ifdef CONFIG_MODULE_UNLOAD
1357	/* Dependency lists, not worth sharing */
1358	INIT_LIST_HEAD(&pMyMod->source_list);
1359	INIT_LIST_HEAD(&pMyMod->target_list);
1360
1361	/* Nobody waiting and no exit function. */
1362	# if RTLNX_VER_MAX(3,13,0)
1363	pMyMod->waiter = NULL;
1364	# endif
1365	pMyMod->exit = NULL;
1366
1367	/* References, very important as we must not allow the module
1368	to be unloaded using rmmod. */
1369	# if RTLNX_VER_MIN(3,19,0)
1370	atomic_set(&pMyMod->refcnt, 42);
1371	# else
1372	pMyMod->refptr = alloc_percpu(struct module_ref);
1373	if (pMyMod->refptr)
1374	{
1375	int iCpu;
1376	for_each_possible_cpu(iCpu)
1377	{
1378	per_cpu_ptr(pMyMod->refptr, iCpu)->decs = 0;
1379	per_cpu_ptr(pMyMod->refptr, iCpu)->incs = 1;
1380	}
1381	}
1382	else
1383	rc = VERR_NO_MEMORY;
1384	# endif
1385	# endif
1386	# ifdef CONFIG_CONSTRUCTORS
1387	/* No constructors. */
1388	pMyMod->ctors = NULL;
1389	pMyMod->num_ctors = 0;
1390	# endif
1391	if (RT_SUCCESS(rc))
1392	{
1393	bool fIsModText;
1394
1395	/*
1396	* Add the module to the list.
1397	*/
1398	mutex_lock(&module_mutex);
1399	list_add_rcu(&pMyMod->list, &pSelfMod->list);
1400	pImage->pLnxModHack = pMyMod;
1401	# ifdef CONFIG_MODULES_TREE_LOOKUP
1402	g_pfnModTreeInsert(&pMyMod->mtn_core); /* __mod_tree_insert */
1403	# endif
1404	mutex_unlock(&module_mutex);
1405
1406	/*
1407	* Test it.
1408	*/
1409	mutex_lock(&module_mutex);
1410	pTestModByName = find_module(pMyMod->name);
1411	pTestMod = __module_address((uintptr_t)pImage->pvImage + pImage->cbImageBits / 4);
1412	fIsModText = __module_text_address((uintptr_t)pImage->pvImage + pImage->cbImageBits / 2);
1413	mutex_unlock(&module_mutex);
1414	if ( pTestMod == pMyMod
1415	&& pTestModByName == pMyMod
1416	&& fIsModText)
1417	printk(KERN_ERR "vboxdrv: fake module works for '%s' (%#lx to %#lx)\n",
1418	pMyMod->name, (unsigned long)paSymbols[1].st_value, (unsigned long)paSymbols[2].st_value);
1419	else
1420	printk(KERN_ERR "vboxdrv: failed to find fake module (pTestMod=%p, pTestModByName=%p, pMyMod=%p, fIsModText=%d)\n",
1421	pTestMod, pTestModByName, pMyMod, fIsModText);
1422	}
1423	else
1424	RTMemFree(pMyMod);
1425	}
1426
1427	IPRT_LINUX_RESTORE_EFL_AC();
1428	#else
1429	pImage->pLnxModHack = NULL;
1430	#endif
1431	NOREF(pDevExt); NOREF(pImage);
1432	}
1433
1434
1435	void VBOXCALL supdrvOSLdrNotifyUnloaded(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1436	{
1437	#ifdef VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS /* Not for production use!! Debugging only! */
1438	struct module *pMyMod = pImage->pLnxModHack;
1439	pImage->pLnxModHack = NULL;
1440	if (pMyMod)
1441	{
1442	/*
1443	* Remove the fake module list entry and free it.
1444	*/
1445	IPRT_LINUX_SAVE_EFL_AC();
1446	mutex_lock(&module_mutex);
1447	list_del_rcu(&pMyMod->list);
1448	# ifdef CONFIG_MODULES_TREE_LOOKUP
1449	g_pfnModTreeRemove(&pMyMod->mtn_core);
1450	# endif
1451	synchronize_sched();
1452	mutex_unlock(&module_mutex);
1453
1454	# if RTLNX_VER_MAX(3,19,0)
1455	free_percpu(pMyMod->refptr);
1456	# endif
1457	RTMemFree(pMyMod);
1458	IPRT_LINUX_RESTORE_EFL_AC();
1459	}
1460
1461	#else
1462	Assert(pImage->pLnxModHack == NULL);
1463	#endif
1464	NOREF(pDevExt); NOREF(pImage);
1465	}
1466
1467
1468	int VBOXCALL supdrvOSLdrQuerySymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage,
1469	const char pszSymbol, size_t cchSymbol, void *ppvSymbol)
1470	{
1471	#ifdef VBOX_WITH_NON_PROD_HACK_FOR_PERF_STACKS
1472	# error "implement me!"
1473	#endif
1474	RT_NOREF(pDevExt, pImage, pszSymbol, cchSymbol, ppvSymbol);
1475	return VERR_WRONG_ORDER;
1476	}
1477
1478
1479	void VBOXCALL supdrvOSLdrRetainWrapperModule(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1480	{
1481	struct module pLnxMod = (struct module )pImage->pvWrappedNative;
1482	Assert(!pImage->fLnxWrapperRef);
1483	AssertReturnVoid(pLnxMod);
1484	pImage->fLnxWrapperRef = try_module_get(pLnxMod);
1485	RT_NOREF(pDevExt);
1486	}
1487
1488
1489	void VBOXCALL supdrvOSLdrReleaseWrapperModule(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1490	{
1491	if (pImage->fLnxWrapperRef)
1492	{
1493	struct module pLnxMod = (struct module )pImage->pvWrappedNative;
1494	pImage->fLnxWrapperRef = false;
1495	module_put(pLnxMod);
1496	}
1497	RT_NOREF(pDevExt);
1498	}
1499
1500
1501	#ifdef SUPDRV_WITH_MSR_PROBER
1502
1503	int VBOXCALL supdrvOSMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue)
1504	{
1505	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1506	uint32_t u32Low, u32High;
1507	int rc;
1508
1509	IPRT_LINUX_SAVE_EFL_AC();
1510	if (idCpu == NIL_RTCPUID)
1511	rc = rdmsr_safe(uMsr, &u32Low, &u32High);
1512	else if (RTMpIsCpuOnline(idCpu))
1513	rc = rdmsr_safe_on_cpu(idCpu, uMsr, &u32Low, &u32High);
1514	else
1515	return VERR_CPU_OFFLINE;
1516	IPRT_LINUX_RESTORE_EFL_AC();
1517	if (rc == 0)
1518	{
1519	*puValue = RT_MAKE_U64(u32Low, u32High);
1520	return VINF_SUCCESS;
1521	}
1522	return VERR_ACCESS_DENIED;
1523	# else
1524	return VERR_NOT_SUPPORTED;
1525	# endif
1526	}
1527
1528
1529	int VBOXCALL supdrvOSMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue)
1530	{
1531	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1532	int rc;
1533
1534	IPRT_LINUX_SAVE_EFL_AC();
1535	if (idCpu == NIL_RTCPUID)
1536	rc = wrmsr_safe(uMsr, RT_LODWORD(uValue), RT_HIDWORD(uValue));
1537	else if (RTMpIsCpuOnline(idCpu))
1538	rc = wrmsr_safe_on_cpu(idCpu, uMsr, RT_LODWORD(uValue), RT_HIDWORD(uValue));
1539	else
1540	return VERR_CPU_OFFLINE;
1541	IPRT_LINUX_RESTORE_EFL_AC();
1542
1543	if (rc == 0)
1544	return VINF_SUCCESS;
1545	return VERR_ACCESS_DENIED;
1546	# else
1547	return VERR_NOT_SUPPORTED;
1548	# endif
1549	}
1550
1551	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1552	/**
1553	* Worker for supdrvOSMsrProberModify.
1554	*/
1555	static DECLCALLBACK(void) supdrvLnxMsrProberModifyOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1556	{
1557	PSUPMSRPROBER pReq = (PSUPMSRPROBER)pvUser1;
1558	register uint32_t uMsr = pReq->u.In.uMsr;
1559	bool const fFaster = pReq->u.In.enmOp == SUPMSRPROBEROP_MODIFY_FASTER;
1560	uint64_t uBefore;
1561	uint64_t uWritten;
1562	uint64_t uAfter;
1563	int rcBefore, rcWrite, rcAfter, rcRestore;
1564	RTCCUINTREG fOldFlags;
1565
1566	/* Initialize result variables. */
1567	uBefore = uWritten = uAfter = 0;
1568	rcWrite = rcAfter = rcRestore = -EIO;
1569
1570	/*
1571	* Do the job.
1572	*/
1573	fOldFlags = ASMIntDisableFlags();
1574	ASMCompilerBarrier(); /* paranoia */
1575	if (!fFaster)
1576	ASMWriteBackAndInvalidateCaches();
1577
1578	rcBefore = rdmsrl_safe(uMsr, &uBefore);
1579	if (rcBefore >= 0)
1580	{
1581	register uint64_t uRestore = uBefore;
1582	uWritten = uRestore;
1583	uWritten &= pReq->u.In.uArgs.Modify.fAndMask;
1584	uWritten \|= pReq->u.In.uArgs.Modify.fOrMask;
1585
1586	rcWrite = wrmsr_safe(uMsr, RT_LODWORD(uWritten), RT_HIDWORD(uWritten));
1587	rcAfter = rdmsrl_safe(uMsr, &uAfter);
1588	rcRestore = wrmsr_safe(uMsr, RT_LODWORD(uRestore), RT_HIDWORD(uRestore));
1589
1590	if (!fFaster)
1591	{
1592	ASMWriteBackAndInvalidateCaches();
1593	ASMReloadCR3();
1594	ASMNopPause();
1595	}
1596	}
1597
1598	ASMCompilerBarrier(); /* paranoia */
1599	ASMSetFlags(fOldFlags);
1600
1601	/*
1602	* Write out the results.
1603	*/
1604	pReq->u.Out.uResults.Modify.uBefore = uBefore;
1605	pReq->u.Out.uResults.Modify.uWritten = uWritten;
1606	pReq->u.Out.uResults.Modify.uAfter = uAfter;
1607	pReq->u.Out.uResults.Modify.fBeforeGp = rcBefore != 0;
1608	pReq->u.Out.uResults.Modify.fModifyGp = rcWrite != 0;
1609	pReq->u.Out.uResults.Modify.fAfterGp = rcAfter != 0;
1610	pReq->u.Out.uResults.Modify.fRestoreGp = rcRestore != 0;
1611	RT_ZERO(pReq->u.Out.uResults.Modify.afReserved);
1612	}
1613	# endif
1614
1615
1616	int VBOXCALL supdrvOSMsrProberModify(RTCPUID idCpu, PSUPMSRPROBER pReq)
1617	{
1618	# ifdef SUPDRV_LINUX_HAS_SAFE_MSR_API
1619	if (idCpu == NIL_RTCPUID)
1620	{
1621	supdrvLnxMsrProberModifyOnCpu(idCpu, pReq, NULL);
1622	return VINF_SUCCESS;
1623	}
1624	return RTMpOnSpecific(idCpu, supdrvLnxMsrProberModifyOnCpu, pReq, NULL);
1625	# else
1626	return VERR_NOT_SUPPORTED;
1627	# endif
1628	}
1629
1630	#endif /* SUPDRV_WITH_MSR_PROBER */
1631
1632
1633	/**
1634	* Converts a supdrv error code to an linux error code.
1635	*
1636	* @returns corresponding linux error code.
1637	* @param rc IPRT status code.
1638	*/
1639	static int VBoxDrvLinuxErr2LinuxErr(int rc)
1640	{
1641	switch (rc)
1642	{
1643	case VINF_SUCCESS: return 0;
1644	case VERR_GENERAL_FAILURE: return -EACCES;
1645	case VERR_INVALID_PARAMETER: return -EINVAL;
1646	case VERR_INVALID_MAGIC: return -EILSEQ;
1647	case VERR_INVALID_HANDLE: return -ENXIO;
1648	case VERR_INVALID_POINTER: return -EFAULT;
1649	case VERR_LOCK_FAILED: return -ENOLCK;
1650	case VERR_ALREADY_LOADED: return -EEXIST;
1651	case VERR_PERMISSION_DENIED: return -EPERM;
1652	case VERR_VERSION_MISMATCH: return -ENOSYS;
1653	case VERR_IDT_FAILED: return -1000;
1654	}
1655
1656	return -EPERM;
1657	}
1658
1659
1660	SUPR0DECL(int) SUPR0HCPhysToVirt(RTHCPHYS HCPhys, void **ppv)
1661	{
1662	AssertReturn(!(HCPhys & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
1663	AssertReturn(HCPhys != NIL_RTHCPHYS, VERR_INVALID_POINTER);
1664	/* Would've like to use valid_phys_addr_range for this test, but it isn't exported. */
1665	AssertReturn((HCPhys \| PAGE_OFFSET_MASK) < __pa(high_memory), VERR_INVALID_POINTER);
1666	*ppv = phys_to_virt(HCPhys);
1667	return VINF_SUCCESS;
1668	}
1669	SUPR0_EXPORT_SYMBOL(SUPR0HCPhysToVirt);
1670
1671
1672	RTDECL(int) SUPR0PrintfV(const char *pszFormat, va_list va)
1673	{
1674	char szMsg[512];
1675	IPRT_LINUX_SAVE_EFL_AC();
1676
1677	RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
1678	szMsg[sizeof(szMsg) - 1] = '\0';
1679
1680	printk("%s", szMsg);
1681
1682	IPRT_LINUX_RESTORE_EFL_AC();
1683	return 0;
1684	}
1685	SUPR0_EXPORT_SYMBOL(SUPR0PrintfV);
1686
1687
1688	SUPR0DECL(uint32_t) SUPR0GetKernelFeatures(void)
1689	{
1690	uint32_t fFlags = 0;
1691	/* Note! bird 2023-10-20: Apparently, with CONFIG_PAX_KERNEXEC these days,
1692	not only is the regular GDT read-only, but the one returned by
1693	get_current_gdt_rw() is also read-only despite the name.
1694
1695	We don't know exactly when this started, or if it was always like
1696	this, but getting hold of the relevant patches isn't all that
1697	straight forward any longer it seems (which is weird for linux
1698	patches), so, we've just enabled slow-mode for all PAX_KERNEXEC
1699	kernels regardless of kernel version.
1700
1701	Looking at grsecurity patch for 4.9.9, it looks like the writable
1702	GDT stuff never worked with PaX/grsec.
1703	*/
1704	#ifdef CONFIG_PAX_KERNEXEC
1705	fFlags \|= SUPKERNELFEATURES_GDT_READ_ONLY;
1706	#elif RTLNX_VER_MIN(4,12,0)
1707	fFlags \|= SUPKERNELFEATURES_GDT_NEED_WRITABLE;
1708	#endif
1709
1710	#if defined(VBOX_STRICT) \|\| defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
1711	fFlags \|= SUPKERNELFEATURES_SMAP;
1712	#elif defined(CONFIG_X86_SMAP)
1713	if (ASMGetCR4() & X86_CR4_SMAP)
1714	fFlags \|= SUPKERNELFEATURES_SMAP;
1715	#endif
1716	return fFlags;
1717	}
1718	SUPR0_EXPORT_SYMBOL(SUPR0GetKernelFeatures);
1719
1720
1721	SUPR0DECL(bool) SUPR0FpuBegin(bool fCtxHook)
1722	{
1723	RT_NOREF(fCtxHook);
1724	#if RTLNX_VER_MIN(4,19,0) /* Going back to 4.19.0 for better coverage, we
1725	probably only need 5.17.7+ in the end. */
1726	/*
1727	* HACK ALERT!
1728	*
1729	* We'd like to use the old __kernel_fpu_begin() API which was removed in
1730	* early 2019, because we typically run with preemption enabled and have an
1731	* preemption hook installed which will call kernel_fpu_end() in case we're
1732	* scheduled out after getting in here. The preemption hook is almost
1733	* useless if we run with preemption disabled.
1734	*
1735	* For the case where the kernel does not have preemption hooks, we get here
1736	* with preemption already disabled and one more count doesn't make any
1737	* difference.
1738	*
1739	* So, after the kernel_fpu_begin() call we undo the implicit preempt_disable()
1740	* call it does, so the preemption hook can do its work and the VBox user has
1741	* a more responsive system.
1742	*
1743	* See @bugref{10209#c12} and onwards for more details.
1744	*/
1745	Assert(fCtxHook \|\| !RTThreadPreemptIsEnabled(NIL_RTTHREAD));
1746	kernel_fpu_begin();
1747	# if 0 /* Always do it for now for better test coverage. */
1748	if (fCtxHook)
1749	# endif
1750	preempt_enable();
1751	return false; /** @todo Not sure if we have license to use any extended state, or
1752	* if we're limited to the SSE & x87 FPU. If it's the former,
1753	* we should return @a true and the caller can skip
1754	* saving+restoring the host state and save some time. */
1755	#else
1756	return false;
1757	#endif
1758	}
1759	SUPR0_EXPORT_SYMBOL(SUPR0FpuBegin);
1760
1761
1762	SUPR0DECL(void) SUPR0FpuEnd(bool fCtxHook)
1763	{
1764	RT_NOREF(fCtxHook);
1765	#if RTLNX_VER_MIN(4,19,0)
1766	/* HACK ALERT! See SUPR0FpuBegin for an explanation of this. */
1767	Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
1768	# if 0 /* Always do it for now for better test coverage. */
1769	if (fCtxHook)
1770	# endif
1771	preempt_disable();
1772	kernel_fpu_end();
1773	#endif
1774	}
1775	SUPR0_EXPORT_SYMBOL(SUPR0FpuEnd);
1776
1777
1778	int VBOXCALL supdrvOSGetCurrentGdtRw(RTHCUINTPTR *pGdtRw)
1779	{
1780	#if RTLNX_VER_MIN(4,12,0) && !defined(CONFIG_PAX_KERNEXEC)
1781	*pGdtRw = (RTHCUINTPTR)get_current_gdt_rw();
1782	return VINF_SUCCESS;
1783	#else
1784	return VERR_NOT_IMPLEMENTED;
1785	#endif
1786	}
1787
1788
1789	module_init(VBoxDrvLinuxInit);
1790	module_exit(VBoxDrvLinuxUnload);
1791
1792	MODULE_AUTHOR(VBOX_VENDOR);
1793	MODULE_DESCRIPTION(VBOX_PRODUCT " Support Driver");
1794	MODULE_LICENSE("GPL");
1795	#ifdef MODULE_VERSION
1796	MODULE_VERSION(VBOX_VERSION_STRING " r" RT_XSTR(VBOX_SVN_REV) " (" RT_XSTR(SUPDRV_IOC_VERSION) ")");
1797	#endif
1798
1799	module_param(force_async_tsc, int, 0444);
1800	MODULE_PARM_DESC(force_async_tsc, "force the asynchronous TSC mode");
1801

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

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

Download in other formats: