SUPDrv-darwin.cpp@ 51116

Last change on this file since 51116 was 51100, checked in by vboxsync, 11 years ago
SUPDrv-darwin.cpp: Fixed buggy g_apSessionHashTab search in VBoxDrvDarwinIOCtl that could lead to spurious EINVAL/VERR_INVALID_PARAMETER errors and worse.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 48.8 KB

Line
1	/* $Id: SUPDrv-darwin.cpp 51100 2014-04-17 17:50:33Z vboxsync $ */
2	/** @file
3	* VirtualBox Support Driver - Darwin Specific Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2014 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	* Header Files *
29	*******************************************************************************/
30	#define LOG_GROUP LOG_GROUP_SUP_DRV
31	/*
32	* Deal with conflicts first.
33	* PVM - BSD mess, that FreeBSD has correct a long time ago.
34	* iprt/types.h before sys/param.h - prevents UINT32_C and friends.
35	*/
36	#include <iprt/types.h>
37	#include <sys/param.h>
38	#undef PVM
39
40	#include <IOKit/IOLib.h> /* Assert as function */
41
42	#include "../SUPDrvInternal.h"
43	#include <VBox/version.h>
44	#include <iprt/asm.h>
45	#include <iprt/asm-amd64-x86.h>
46	#include <iprt/initterm.h>
47	#include <iprt/assert.h>
48	#include <iprt/spinlock.h>
49	#include <iprt/semaphore.h>
50	#include <iprt/process.h>
51	#include <iprt/alloc.h>
52	#include <iprt/power.h>
53	#include <iprt/dbg.h>
54	#include <VBox/err.h>
55	#include <VBox/log.h>
56
57	#include <mach/kmod.h>
58	#include <miscfs/devfs/devfs.h>
59	#include <sys/conf.h>
60	#include <sys/errno.h>
61	#include <sys/ioccom.h>
62	#include <sys/malloc.h>
63	#include <sys/proc.h>
64	#include <sys/kauth.h>
65	#include <IOKit/IOService.h>
66	#include <IOKit/IOUserClient.h>
67	#include <IOKit/pwr_mgt/RootDomain.h>
68	#include <IOKit/IODeviceTreeSupport.h>
69	#include <IOKit/usb/IOUSBHIDDriver.h>
70	#include <IOKit/bluetooth/IOBluetoothHIDDriver.h>
71	#include <IOKit/bluetooth/IOBluetoothHIDDriverTypes.h>
72
73	#ifdef VBOX_WITH_HOST_VMX
74	# include <libkern/version.h>
75	RT_C_DECLS_BEGIN
76	# include <i386/vmx.h>
77	RT_C_DECLS_END
78	#endif
79
80
81	/*******************************************************************************
82	* Defined Constants And Macros *
83	*******************************************************************************/
84
85	/** The system device node name. */
86	#define DEVICE_NAME_SYS "vboxdrv"
87	/** The user device node name. */
88	#define DEVICE_NAME_USR "vboxdrvu"
89
90
91
92	/*******************************************************************************
93	* Internal Functions *
94	*******************************************************************************/
95	RT_C_DECLS_BEGIN
96	static kern_return_t VBoxDrvDarwinStart(struct kmod_info pKModInfo, void pvData);
97	static kern_return_t VBoxDrvDarwinStop(struct kmod_info pKModInfo, void pvData);
98
99	static int VBoxDrvDarwinOpen(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess);
100	static int VBoxDrvDarwinClose(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess);
101	static int VBoxDrvDarwinIOCtl(dev_t Dev, u_long iCmd, caddr_t pData, int fFlags, struct proc *pProcess);
102	static int VBoxDrvDarwinIOCtlSlow(PSUPDRVSESSION pSession, u_long iCmd, caddr_t pData, struct proc *pProcess);
103
104	static int VBoxDrvDarwinErr2DarwinErr(int rc);
105
106	static IOReturn VBoxDrvDarwinSleepHandler(void pvTarget, void pvRefCon, UInt32 uMessageType, IOService pProvider, void pvMessageArgument, vm_size_t argSize);
107	RT_C_DECLS_END
108
109	static void vboxdrvDarwinResolveSymbols(void);
110
111
112	/*******************************************************************************
113	* Structures and Typedefs *
114	*******************************************************************************/
115	/**
116	* The service class.
117	* This is just a formality really.
118	*/
119	class org_virtualbox_SupDrv : public IOService
120	{
121	OSDeclareDefaultStructors(org_virtualbox_SupDrv);
122
123	public:
124	virtual bool init(OSDictionary *pDictionary = 0);
125	virtual void free(void);
126	virtual bool start(IOService *pProvider);
127	virtual void stop(IOService *pProvider);
128	virtual IOService probe(IOService pProvider, SInt32 *pi32Score);
129	virtual bool terminate(IOOptionBits fOptions);
130	};
131
132	OSDefineMetaClassAndStructors(org_virtualbox_SupDrv, IOService);
133
134
135	/**
136	* An attempt at getting that clientDied() notification.
137	* I don't think it'll work as I cannot figure out where/what creates the correct
138	* port right.
139	*/
140	class org_virtualbox_SupDrvClient : public IOUserClient
141	{
142	OSDeclareDefaultStructors(org_virtualbox_SupDrvClient);
143
144	private:
145	PSUPDRVSESSION m_pSession; /*< The session. /
146	task_t m_Task; /*< The client task. /
147	org_virtualbox_SupDrv m_pProvider; /< The service provider. /
148
149	public:
150	virtual bool initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type);
151	virtual bool start(IOService *pProvider);
152	static void sessionClose(RTPROCESS Process);
153	virtual IOReturn clientClose(void);
154	virtual IOReturn clientDied(void);
155	virtual bool terminate(IOOptionBits fOptions = 0);
156	virtual bool finalize(IOOptionBits fOptions);
157	virtual void stop(IOService *pProvider);
158	};
159
160	OSDefineMetaClassAndStructors(org_virtualbox_SupDrvClient, IOUserClient);
161
162
163
164	/*******************************************************************************
165	* Global Variables *
166	*******************************************************************************/
167	/**
168	* Declare the module stuff.
169	*/
170	RT_C_DECLS_BEGIN
171	extern kern_return_t _start(struct kmod_info pKModInfo, void pvData);
172	extern kern_return_t _stop(struct kmod_info pKModInfo, void pvData);
173
174	KMOD_EXPLICIT_DECL(VBoxDrv, VBOX_VERSION_STRING, _start, _stop)
175	DECLHIDDEN(kmod_start_func_t *) _realmain = VBoxDrvDarwinStart;
176	DECLHIDDEN(kmod_stop_func_t *) _antimain = VBoxDrvDarwinStop;
177	DECLHIDDEN(int) _kext_apple_cc = __APPLE_CC__;
178	RT_C_DECLS_END
179
180
181	/**
182	* Device extention & session data association structure.
183	*/
184	static SUPDRVDEVEXT g_DevExt;
185
186	/**
187	* The character device switch table for the driver.
188	*/
189	static struct cdevsw g_DevCW =
190	{
191	/** @todo g++ doesn't like this syntax - it worked with gcc before renaming to .cpp. */
192	/.d_open = /VBoxDrvDarwinOpen,
193	/.d_close = /VBoxDrvDarwinClose,
194	/.d_read = /eno_rdwrt,
195	/.d_write = /eno_rdwrt,
196	/.d_ioctl = /VBoxDrvDarwinIOCtl,
197	/.d_stop = /eno_stop,
198	/.d_reset = /eno_reset,
199	/.d_ttys = /NULL,
200	/.d_select= /eno_select,
201	/.d_mmap = /eno_mmap,
202	/.d_strategy = /eno_strat,
203	/.d_getc = /eno_getc,
204	/.d_putc = /eno_putc,
205	/.d_type = /0
206	};
207
208	/** Major device number. */
209	static int g_iMajorDeviceNo = -1;
210	/** Registered devfs device handle for the system device. */
211	static void *g_hDevFsDeviceSys = NULL;
212	/** Registered devfs device handle for the user device. */
213	static void *g_hDevFsDeviceUsr = NULL;
214
215	/** Spinlock protecting g_apSessionHashTab. */
216	static RTSPINLOCK g_Spinlock = NIL_RTSPINLOCK;
217	/** Hash table */
218	static PSUPDRVSESSION g_apSessionHashTab[19];
219	/** Calculates the index into g_apSessionHashTab.*/
220	#define SESSION_HASH(pid) ((pid) % RT_ELEMENTS(g_apSessionHashTab))
221	/** The number of open sessions. */
222	static int32_t volatile g_cSessions = 0;
223	/** The notifier handle for the sleep callback handler. */
224	static IONotifier *g_pSleepNotifier = NULL;
225
226	/** Pointer to vmx_suspend(). */
227	static PFNRT g_pfnVmxSuspend = NULL;
228	/** Pointer to vmx_resume(). */
229	static PFNRT g_pfnVmxResume = NULL;
230	/** Pointer to vmx_use_count. */
231	static int volatile *g_pVmxUseCount = NULL;
232
233	#ifdef SUPDRV_WITH_MSR_PROBER
234	/** Pointer to rdmsr_carefully if found. Returns 0 on success. */
235	static int (g_pfnRdMsrCarefully)(uint32_t uMsr, uint32_t puLow, uint32_t *puHigh) = NULL;
236	/** Pointer to rdmsr64_carefully if found. Returns 0 on success. */
237	static int (g_pfnRdMsr64Carefully)(uint32_t uMsr, uint64_t uValue) = NULL;
238	/** Pointer to wrmsr[64]_carefully if found. Returns 0 on success. */
239	static int (*g_pfnWrMsr64Carefully)(uint32_t uMsr, uint64_t uValue) = NULL;
240	#endif
241
242
243	/**
244	* Start the kernel module.
245	*/
246	static kern_return_t VBoxDrvDarwinStart(struct kmod_info pKModInfo, void pvData)
247	{
248	int rc;
249	#ifdef DEBUG
250	printf("VBoxDrvDarwinStart\n");
251	#endif
252
253	/*
254	* Initialize IPRT.
255	*/
256	rc = RTR0Init(0);
257	if (RT_SUCCESS(rc))
258	{
259	/*
260	* Initialize the device extension.
261	*/
262	rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
263	if (RT_SUCCESS(rc))
264	{
265	/*
266	* Initialize the session hash table.
267	*/
268	memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab)); /* paranoia */
269	rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvDarwin");
270	if (RT_SUCCESS(rc))
271	{
272	/*
273	* Registering ourselves as a character device.
274	*/
275	g_iMajorDeviceNo = cdevsw_add(-1, &g_DevCW);
276	if (g_iMajorDeviceNo >= 0)
277	{
278	#ifdef VBOX_WITH_HARDENING
279	g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR,
280	UID_ROOT, GID_WHEEL, 0600, DEVICE_NAME_SYS);
281	#else
282	g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR,
283	UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_SYS);
284	#endif
285	if (g_hDevFsDeviceSys)
286	{
287	g_hDevFsDeviceUsr = devfs_make_node(makedev(g_iMajorDeviceNo, 1), DEVFS_CHAR,
288	UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_USR);
289	if (g_hDevFsDeviceUsr)
290	{
291	LogRel(("VBoxDrv: version " VBOX_VERSION_STRING " r%d; IOCtl version %#x; IDC version %#x; dev major=%d\n",
292	VBOX_SVN_REV, SUPDRV_IOC_VERSION, SUPDRV_IDC_VERSION, g_iMajorDeviceNo));
293
294	/* Register a sleep/wakeup notification callback */
295	g_pSleepNotifier = registerPrioritySleepWakeInterest(&VBoxDrvDarwinSleepHandler, &g_DevExt, NULL);
296	if (g_pSleepNotifier == NULL)
297	LogRel(("VBoxDrv: register for sleep/wakeup events failed\n"));
298
299	/* Find kernel symbols that are kind of optional. */
300	vboxdrvDarwinResolveSymbols();
301	return KMOD_RETURN_SUCCESS;
302	}
303
304	LogRel(("VBoxDrv: devfs_make_node(makedev(%d,1),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_USR));
305	devfs_remove(g_hDevFsDeviceSys);
306	g_hDevFsDeviceSys = NULL;
307	}
308	else
309	LogRel(("VBoxDrv: devfs_make_node(makedev(%d,0),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_SYS));
310
311	cdevsw_remove(g_iMajorDeviceNo, &g_DevCW);
312	g_iMajorDeviceNo = -1;
313	}
314	else
315	LogRel(("VBoxDrv: cdevsw_add failed (%d)\n", g_iMajorDeviceNo));
316	RTSpinlockDestroy(g_Spinlock);
317	g_Spinlock = NIL_RTSPINLOCK;
318	}
319	else
320	LogRel(("VBoxDrv: RTSpinlockCreate failed (rc=%d)\n", rc));
321	supdrvDeleteDevExt(&g_DevExt);
322	}
323	else
324	printf("VBoxDrv: failed to initialize device extension (rc=%d)\n", rc);
325	RTR0TermForced();
326	}
327	else
328	printf("VBoxDrv: failed to initialize IPRT (rc=%d)\n", rc);
329
330	memset(&g_DevExt, 0, sizeof(g_DevExt));
331	return KMOD_RETURN_FAILURE;
332	}
333
334
335	/**
336	* Resolves kernel symbols we want (but may do without).
337	*/
338	static void vboxdrvDarwinResolveSymbols(void)
339	{
340	RTDBGKRNLINFO hKrnlInfo;
341	int rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0);
342	if (RT_SUCCESS(rc))
343	{
344	/* The VMX stuff. */
345	int rc1 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_resume", (void **)&g_pfnVmxResume);
346	int rc2 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_suspend", (void **)&g_pfnVmxSuspend);
347	int rc3 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_use_count", (void **)&g_pVmxUseCount);
348	if (RT_SUCCESS(rc1) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
349	{
350	LogRel(("VBoxDrv: vmx_resume=%p vmx_suspend=%p vmx_use_count=%p (%d) cr4=%#x\n",
351	g_pfnVmxResume, g_pfnVmxSuspend, g_pVmxUseCount, *g_pVmxUseCount, ASMGetCR4() ));
352	}
353	else
354	{
355	LogRel(("VBoxDrv: failed to resolve vmx stuff: vmx_resume=%Rrc vmx_suspend=%Rrc vmx_use_count=%Rrc", rc1, rc2, rc3));
356	g_pfnVmxResume = NULL;
357	g_pfnVmxSuspend = NULL;
358	g_pVmxUseCount = NULL;
359	}
360
361	#ifdef SUPDRV_WITH_MSR_PROBER
362	/* MSR prober stuff. */
363	int rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "rdmsr_carefully", (void **)&g_pfnRdMsrCarefully);
364	if (RT_FAILURE(rc))
365	g_pfnRdMsrCarefully = NULL;
366	rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "rdmsr64_carefully", (void **)&g_pfnRdMsr64Carefully);
367	if (RT_FAILURE(rc))
368	g_pfnRdMsr64Carefully = NULL;
369	# ifdef RT_ARCH_AMD64 /* Missing 64 in name, so if implemented on 32-bit it could have different signature. */
370	rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "wrmsr_carefully", (void **)&g_pfnWrMsr64Carefully);
371	if (RT_FAILURE(rc))
372	# endif
373	g_pfnWrMsr64Carefully = NULL;
374
375	LogRel(("VBoxDrv: g_pfnRdMsrCarefully=%p g_pfnRdMsr64Carefully=%p g_pfnWrMsr64Carefully=%p\n",
376	g_pfnRdMsrCarefully, g_pfnRdMsr64Carefully, g_pfnWrMsr64Carefully));
377
378	#endif /* SUPDRV_WITH_MSR_PROBER */
379
380	RTR0DbgKrnlInfoRelease(hKrnlInfo);
381	}
382	else
383	LogRel(("VBoxDrv: Failed to open kernel symbols, rc=%Rrc\n", rc));
384	}
385
386
387	/**
388	* Stop the kernel module.
389	*/
390	static kern_return_t VBoxDrvDarwinStop(struct kmod_info pKModInfo, void pvData)
391	{
392	int rc;
393	LogFlow(("VBoxDrvDarwinStop\n"));
394
395	/** @todo I've got a nagging feeling that we'll have to keep track of users and refuse
396	* unloading if we're busy. Investigate and implement this! */
397
398	/*
399	* Undo the work done during start (in reverse order).
400	*/
401	if (g_pSleepNotifier)
402	{
403	g_pSleepNotifier->remove();
404	g_pSleepNotifier = NULL;
405	}
406
407	devfs_remove(g_hDevFsDeviceUsr);
408	g_hDevFsDeviceUsr = NULL;
409
410	devfs_remove(g_hDevFsDeviceSys);
411	g_hDevFsDeviceSys = NULL;
412
413	rc = cdevsw_remove(g_iMajorDeviceNo, &g_DevCW);
414	Assert(rc == g_iMajorDeviceNo);
415	g_iMajorDeviceNo = -1;
416
417	supdrvDeleteDevExt(&g_DevExt);
418
419	rc = RTSpinlockDestroy(g_Spinlock);
420	AssertRC(rc);
421	g_Spinlock = NIL_RTSPINLOCK;
422
423	RTR0TermForced();
424
425	memset(&g_DevExt, 0, sizeof(g_DevExt));
426	#ifdef DEBUG
427	printf("VBoxDrvDarwinStop - done\n");
428	#endif
429	return KMOD_RETURN_SUCCESS;
430	}
431
432
433	/**
434	* Device open. Called on open /dev/vboxdrv
435	*
436	* @param Dev The device number.
437	* @param fFlags ???.
438	* @param fDevType ???.
439	* @param pProcess The process issuing this request.
440	*/
441	static int VBoxDrvDarwinOpen(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess)
442	{
443	#ifdef DEBUG_DARWIN_GIP
444	char szName[128];
445	szName[0] = '\0';
446	proc_name(proc_pid(pProcess), szName, sizeof(szName));
447	Log(("VBoxDrvDarwinOpen: pid=%d '%s'\n", proc_pid(pProcess), szName));
448	#endif
449
450	/*
451	* Only two minor devices numbers are allowed.
452	*/
453	if (minor(Dev) != 0 && minor(Dev) != 1)
454	return EACCES;
455
456	/*
457	* The process issuing the request must be the current process.
458	*/
459	RTPROCESS Process = RTProcSelf();
460	if (Process != proc_pid(pProcess))
461	return EIO;
462
463	/*
464	* Find the session created by org_virtualbox_SupDrvClient, fail
465	* if no such session, and mark it as opened. We set the uid & gid
466	* here too, since that is more straight forward at this point.
467	*/
468	const bool fUnrestricted = minor(Dev) == 0;
469	int rc = VINF_SUCCESS;
470	PSUPDRVSESSION pSession = NULL;
471	kauth_cred_t pCred = kauth_cred_proc_ref(pProcess);
472	if (pCred)
473	{
474	#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
475	RTUID Uid = kauth_cred_getruid(pCred);
476	RTGID Gid = kauth_cred_getrgid(pCred);
477	#else
478	RTUID Uid = pCred->cr_ruid;
479	RTGID Gid = pCred->cr_rgid;
480	#endif
481	unsigned iHash = SESSION_HASH(Process);
482	RTSpinlockAcquire(g_Spinlock);
483
484	pSession = g_apSessionHashTab[iHash];
485	while (pSession && pSession->Process != Process)
486	pSession = pSession->pNextHash;
487	if (pSession)
488	{
489	if (!pSession->fOpened)
490	{
491	pSession->fOpened = true;
492	pSession->fUnrestricted = fUnrestricted;
493	pSession->Uid = Uid;
494	pSession->Gid = Gid;
495	}
496	else
497	rc = VERR_ALREADY_LOADED;
498	}
499	else
500	rc = VERR_GENERAL_FAILURE;
501
502	RTSpinlockReleaseNoInts(g_Spinlock);
503	#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
504	kauth_cred_unref(&pCred);
505	#else /* 10.4 */
506	/* The 10.4u SDK headers and 10.4.11 kernel source have inconsistent definitions
507	of kauth_cred_unref(), so use the other (now deprecated) API for releasing it. */
508	kauth_cred_rele(pCred);
509	#endif /* 10.4 */
510	}
511	else
512	rc = VERR_INVALID_PARAMETER;
513
514	#ifdef DEBUG_DARWIN_GIP
515	OSDBGPRINT(("VBoxDrvDarwinOpen: pid=%d '%s' pSession=%p rc=%d\n", proc_pid(pProcess), szName, pSession, rc));
516	#else
517	Log(("VBoxDrvDarwinOpen: g_DevExt=%p pSession=%p rc=%d pid=%d\n", &g_DevExt, pSession, rc, proc_pid(pProcess)));
518	#endif
519	return VBoxDrvDarwinErr2DarwinErr(rc);
520	}
521
522
523	/**
524	* Close device.
525	*/
526	static int VBoxDrvDarwinClose(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess)
527	{
528	Log(("VBoxDrvDarwinClose: pid=%d\n", (int)RTProcSelf()));
529	Assert(proc_pid(pProcess) == (int)RTProcSelf());
530
531	/*
532	* Hand the session closing to org_virtualbox_SupDrvClient.
533	*/
534	org_virtualbox_SupDrvClient::sessionClose(RTProcSelf());
535	return 0;
536	}
537
538
539	/**
540	* Device I/O Control entry point.
541	*
542	* @returns Darwin for slow IOCtls and VBox status code for the fast ones.
543	* @param Dev The device number (major+minor).
544	* @param iCmd The IOCtl command.
545	* @param pData Pointer to the data (if any it's a SUPDRVIOCTLDATA (kernel copy)).
546	* @param fFlags Flag saying we're a character device (like we didn't know already).
547	* @param pProcess The process issuing this request.
548	*/
549	static int VBoxDrvDarwinIOCtl(dev_t Dev, u_long iCmd, caddr_t pData, int fFlags, struct proc *pProcess)
550	{
551	const bool fUnrestricted = minor(Dev) == 0;
552	const RTPROCESS Process = proc_pid(pProcess);
553	const unsigned iHash = SESSION_HASH(Process);
554	PSUPDRVSESSION pSession;
555
556	/*
557	* Find the session.
558	*/
559	RTSpinlockAcquire(g_Spinlock);
560
561	pSession = g_apSessionHashTab[iHash];
562	while (pSession && (pSession->Process != Process \|\| pSession->fUnrestricted != fUnrestricted \|\| !pSession->fOpened))
563	pSession = pSession->pNextHash;
564
565	if (RT_LIKELY(pSession))
566	supdrvSessionRetain(pSession);
567
568	RTSpinlockReleaseNoInts(g_Spinlock);
569	if (RT_UNLIKELY(!pSession))
570	{
571	OSDBGPRINT(("VBoxDrvDarwinIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#lx\n",
572	(int)Process, iCmd));
573	return EINVAL;
574	}
575
576	/*
577	* Deal with the two high-speed IOCtl that takes it's arguments from
578	* the session and iCmd, and only returns a VBox status code.
579	*/
580	int rc;
581	if ( ( iCmd == SUP_IOCTL_FAST_DO_RAW_RUN
582	\|\| iCmd == SUP_IOCTL_FAST_DO_HM_RUN
583	\|\| iCmd == SUP_IOCTL_FAST_DO_NOP)
584	&& fUnrestricted)
585	rc = supdrvIOCtlFast(iCmd, (uint32_t )pData, &g_DevExt, pSession);
586	else
587	rc = VBoxDrvDarwinIOCtlSlow(pSession, iCmd, pData, pProcess);
588
589	supdrvSessionRelease(pSession);
590	return rc;
591	}
592
593
594	/**
595	* Worker for VBoxDrvDarwinIOCtl that takes the slow IOCtl functions.
596	*
597	* @returns Darwin errno.
598	*
599	* @param pSession The session.
600	* @param iCmd The IOCtl command.
601	* @param pData Pointer to the kernel copy of the SUPDRVIOCTLDATA buffer.
602	* @param pProcess The calling process.
603	*/
604	static int VBoxDrvDarwinIOCtlSlow(PSUPDRVSESSION pSession, u_long iCmd, caddr_t pData, struct proc *pProcess)
605	{
606	LogFlow(("VBoxDrvDarwinIOCtlSlow: pSession=%p iCmd=%p pData=%p pProcess=%p\n", pSession, iCmd, pData, pProcess));
607
608
609	/*
610	* Buffered or unbuffered?
611	*/
612	PSUPREQHDR pHdr;
613	user_addr_t pUser = 0;
614	void *pvPageBuf = NULL;
615	uint32_t cbReq = IOCPARM_LEN(iCmd);
616	if ((IOC_DIRMASK & iCmd) == IOC_INOUT)
617	{
618	pHdr = (PSUPREQHDR)pData;
619	if (RT_UNLIKELY(cbReq < sizeof(*pHdr)))
620	{
621	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: cbReq=%#x < %#x; iCmd=%#lx\n", cbReq, (int)sizeof(*pHdr), iCmd));
622	return EINVAL;
623	}
624	if (RT_UNLIKELY((pHdr->fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
625	{
626	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: bad magic fFlags=%#x; iCmd=%#lx\n", pHdr->fFlags, iCmd));
627	return EINVAL;
628	}
629	if (RT_UNLIKELY( RT_MAX(pHdr->cbIn, pHdr->cbOut) != cbReq
630	\|\| pHdr->cbIn < sizeof(*pHdr)
631	\|\| pHdr->cbOut < sizeof(*pHdr)))
632	{
633	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: max(%#x,%#x) != %#x; iCmd=%#lx\n", pHdr->cbIn, pHdr->cbOut, cbReq, iCmd));
634	return EINVAL;
635	}
636	}
637	else if ((IOC_DIRMASK & iCmd) == IOC_VOID && !cbReq)
638	{
639	/*
640	* Get the header and figure out how much we're gonna have to read.
641	*/
642	SUPREQHDR Hdr;
643	pUser = (user_addr_t)(void *)pData;
644	int rc = copyin(pUser, &Hdr, sizeof(Hdr));
645	if (RT_UNLIKELY(rc))
646	{
647	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: copyin(%llx,Hdr,) -> %#x; iCmd=%#lx\n", (unsigned long long)pUser, rc, iCmd));
648	return rc;
649	}
650	if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
651	{
652	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: bad magic fFlags=%#x; iCmd=%#lx\n", Hdr.fFlags, iCmd));
653	return EINVAL;
654	}
655	cbReq = RT_MAX(Hdr.cbIn, Hdr.cbOut);
656	if (RT_UNLIKELY( Hdr.cbIn < sizeof(Hdr)
657	\|\| Hdr.cbOut < sizeof(Hdr)
658	\|\| cbReq > _1M*16))
659	{
660	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: max(%#x,%#x); iCmd=%#lx\n", Hdr.cbIn, Hdr.cbOut, iCmd));
661	return EINVAL;
662	}
663
664	/*
665	* Allocate buffer and copy in the data.
666	*/
667	pHdr = (PSUPREQHDR)RTMemTmpAlloc(cbReq);
668	if (!pHdr)
669	pvPageBuf = pHdr = (PSUPREQHDR)IOMallocAligned(RT_ALIGN_Z(cbReq, PAGE_SIZE), 8);
670	if (RT_UNLIKELY(!pHdr))
671	{
672	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: failed to allocate buffer of %d bytes; iCmd=%#lx\n", cbReq, iCmd));
673	return ENOMEM;
674	}
675	rc = copyin(pUser, pHdr, Hdr.cbIn);
676	if (RT_UNLIKELY(rc))
677	{
678	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: copyin(%llx,%p,%#x) -> %#x; iCmd=%#lx\n",
679	(unsigned long long)pUser, pHdr, Hdr.cbIn, rc, iCmd));
680	if (pvPageBuf)
681	IOFreeAligned(pvPageBuf, RT_ALIGN_Z(cbReq, PAGE_SIZE));
682	else
683	RTMemTmpFree(pHdr);
684	return rc;
685	}
686	}
687	else
688	{
689	Log(("VBoxDrvDarwinIOCtlSlow: huh? cbReq=%#x iCmd=%#lx\n", cbReq, iCmd));
690	return EINVAL;
691	}
692
693	/*
694	* Process the IOCtl.
695	*/
696	int rc = supdrvIOCtl(iCmd, &g_DevExt, pSession, pHdr);
697	if (RT_LIKELY(!rc))
698	{
699	/*
700	* If not buffered, copy back the buffer before returning.
701	*/
702	if (pUser)
703	{
704	uint32_t cbOut = pHdr->cbOut;
705	if (cbOut > cbReq)
706	{
707	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: too much output! %#x > %#x; uCmd=%#lx!\n", cbOut, cbReq, iCmd));
708	cbOut = cbReq;
709	}
710	rc = copyout(pHdr, pUser, cbOut);
711	if (RT_UNLIKELY(rc))
712	OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: copyout(%p,%llx,%#x) -> %d; uCmd=%#lx!\n",
713	pHdr, (unsigned long long)pUser, cbOut, rc, iCmd));
714
715	/* cleanup */
716	if (pvPageBuf)
717	IOFreeAligned(pvPageBuf, RT_ALIGN_Z(cbReq, PAGE_SIZE));
718	else
719	RTMemTmpFree(pHdr);
720	}
721	}
722	else
723	{
724	/*
725	* The request failed, just clean up.
726	*/
727	if (pUser)
728	{
729	if (pvPageBuf)
730	IOFreeAligned(pvPageBuf, RT_ALIGN_Z(cbReq, PAGE_SIZE));
731	else
732	RTMemTmpFree(pHdr);
733	}
734
735	Log(("VBoxDrvDarwinIOCtlSlow: pid=%d iCmd=%lx pData=%p failed, rc=%d\n", proc_pid(pProcess), iCmd, (void *)pData, rc));
736	rc = EINVAL;
737	}
738
739	Log2(("VBoxDrvDarwinIOCtlSlow: returns %d\n", rc));
740	return rc;
741	}
742
743
744	/**
745	* The SUPDRV IDC entry point.
746	*
747	* @returns VBox status code, see supdrvIDC.
748	* @param iReq The request code.
749	* @param pReq The request.
750	*/
751	DECLEXPORT(int) VBOXCALL SUPDrvDarwinIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
752	{
753	PSUPDRVSESSION pSession;
754
755	/*
756	* Some quick validations.
757	*/
758	if (RT_UNLIKELY(!VALID_PTR(pReq)))
759	return VERR_INVALID_POINTER;
760
761	pSession = pReq->pSession;
762	if (pSession)
763	{
764	if (RT_UNLIKELY(!VALID_PTR(pSession)))
765	return VERR_INVALID_PARAMETER;
766	if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
767	return VERR_INVALID_PARAMETER;
768	}
769	else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
770	return VERR_INVALID_PARAMETER;
771
772	/*
773	* Do the job.
774	*/
775	return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
776	}
777
778
779	/**
780	* Initializes any OS specific object creator fields.
781	*/
782	void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
783	{
784	NOREF(pObj);
785	NOREF(pSession);
786	}
787
788
789	/**
790	* Checks if the session can access the object.
791	*
792	* @returns true if a decision has been made.
793	* @returns false if the default access policy should be applied.
794	*
795	* @param pObj The object in question.
796	* @param pSession The session wanting to access the object.
797	* @param pszObjName The object name, can be NULL.
798	* @param prc Where to store the result when returning true.
799	*/
800	bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char pszObjName, int prc)
801	{
802	NOREF(pObj);
803	NOREF(pSession);
804	NOREF(pszObjName);
805	NOREF(prc);
806	return false;
807	}
808
809	/**
810	* Callback for blah blah blah.
811	*/
812	IOReturn VBoxDrvDarwinSleepHandler(void * /* pvTarget /, void pvRefCon, UInt32 uMessageType, IOService * /* pProvider /, void /* pvMessageArgument /, vm_size_t / argSize */)
813	{
814	LogFlow(("VBoxDrv: Got sleep/wake notice. Message type was %X\n", (uint)uMessageType));
815
816	if (uMessageType == kIOMessageSystemWillSleep)
817	RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
818	else if (uMessageType == kIOMessageSystemHasPoweredOn)
819	RTPowerSignalEvent(RTPOWEREVENT_RESUME);
820
821	acknowledgeSleepWakeNotification(pvRefCon);
822
823	return 0;
824	}
825
826
827	/**
828	* @copydoc SUPR0EnableVTx
829	*/
830	int VBOXCALL supdrvOSEnableVTx(bool fEnable)
831	{
832	#ifdef VBOX_WITH_HOST_VMX
833	int rc;
834	if ( version_major >= 10 /* 10 = 10.6.x = Snow Leopard */
835	&& g_pfnVmxSuspend
836	&& g_pfnVmxResume
837	&& g_pVmxUseCount)
838	{
839	if (fEnable)
840	{
841	rc = host_vmxon(false /* exclusive */);
842	if (rc == VMX_OK)
843	rc = VINF_SUCCESS;
844	else if (rc == VMX_UNSUPPORTED)
845	rc = VERR_VMX_NO_VMX;
846	else if (rc == VMX_INUSE)
847	rc = VERR_VMX_IN_VMX_ROOT_MODE;
848	else /* shouldn't happen, but just in case. */
849	{
850	LogRel(("host_vmxon returned %d\n", rc));
851	rc = VERR_UNRESOLVED_ERROR;
852	}
853	LogRel(("VBoxDrv: host_vmxon -> vmx_use_count=%d rc=%Rrc\n", *g_pVmxUseCount, rc));
854	}
855	else
856	{
857	host_vmxoff();
858	rc = VINF_SUCCESS;
859	LogRel(("VBoxDrv: host_vmxoff -> vmx_use_count=%d\n", *g_pVmxUseCount));
860	}
861	}
862	else
863	{
864	/* In 10.5.x the host_vmxon is severely broken! Don't use it, it will
865	frequnetly panic the host. */
866	rc = VERR_NOT_SUPPORTED;
867	}
868	return rc;
869	#else
870	return VERR_NOT_SUPPORTED;
871	#endif
872	}
873
874
875	/**
876	* @copydoc SUPR0SuspendVTxOnCpu
877	*/
878	bool VBOXCALL supdrvOSSuspendVTxOnCpu(void)
879	{
880	#ifdef VBOX_WITH_HOST_VMX
881	/*
882	* Consult the VMX usage counter, don't try suspend if not enabled.
883	*
884	* Note! The host_vmxon/off code is still race prone since, but this is
885	* currently the best we can do without always enable VMX when
886	* loading the driver.
887	*/
888	if ( g_pVmxUseCount
889	&& *g_pVmxUseCount > 0)
890	{
891	g_pfnVmxSuspend();
892	return true;
893	}
894	return false;
895	#else
896	return false;
897	#endif
898	}
899
900
901	/**
902	* @copydoc SUPR0ResumeVTxOnCpu
903	*/
904	void VBOXCALL supdrvOSResumeVTxOnCpu(bool fSuspended)
905	{
906	#ifdef VBOX_WITH_HOST_VMX
907	/*
908	* Don't consult the counter here, the state knows better.
909	* We're executing with interrupts disabled and anyone racing us with
910	* disabling VT-x will be waiting in the rendezvous code.
911	*/
912	if ( fSuspended
913	&& g_pfnVmxResume)
914	g_pfnVmxResume();
915	else
916	Assert(!fSuspended);
917	#else
918	Assert(!fSuspended);
919	#endif
920	}
921
922
923	bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
924	{
925	NOREF(pDevExt);
926	return false;
927	}
928
929
930	void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
931	{
932	#if 1
933	NOREF(pDevExt); NOREF(pImage);
934	#else
935	/*
936	* Try store the image load address in NVRAM so we can retrived it on panic.
937	* Note! This only works if you're root! - Acutally, it doesn't work at all at the moment. FIXME!
938	*/
939	IORegistryEntry *pEntry = IORegistryEntry::fromPath("/options", gIODTPlane);
940	if (pEntry)
941	{
942	char szVar[80];
943	RTStrPrintf(szVar, sizeof(szVar), "vboximage"/-%s/, pImage->szName);
944	char szValue[48];
945	RTStrPrintf(szValue, sizeof(szValue), "%#llx,%#llx", (uint64_t)(uintptr_t)pImage->pvImage,
946	(uint64_t)(uintptr_t)pImage->pvImage + pImage->cbImageBits - 1);
947	bool fRc = pEntry->setProperty(szVar, szValue); NOREF(fRc);
948	pEntry->release();
949	SUPR0Printf("fRc=%d '%s'='%s'\n", fRc, szVar, szValue);
950	}
951	/*else
952	SUPR0Printf("failed to find /options in gIODTPlane\n");*/
953	#endif
954	}
955
956
957	int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
958	{
959	NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
960	return VERR_NOT_SUPPORTED;
961	}
962
963
964	int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void pv, const uint8_t pbImageBits)
965	{
966	NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
967	return VERR_NOT_SUPPORTED;
968	}
969
970
971	int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
972	{
973	NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits); NOREF(pReq);
974	return VERR_NOT_SUPPORTED;
975	}
976
977
978	void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
979	{
980	NOREF(pDevExt); NOREF(pImage);
981	}
982
983
984	#ifdef SUPDRV_WITH_MSR_PROBER
985
986	typedef struct SUPDRVDARWINMSRARGS
987	{
988	RTUINT64U uValue;
989	uint32_t uMsr;
990	int rc;
991	} SUPDRVDARWINMSRARGS, *PSUPDRVDARWINMSRARGS;
992
993	/**
994	* On CPU worker for supdrvOSMsrProberRead.
995	*
996	* @param idCpu Ignored.
997	* @param pvUser1 Pointer to a SUPDRVDARWINMSRARGS.
998	* @param pvUser2 Ignored.
999	*/
1000	static DECLCALLBACK(void) supdrvDarwinMsrProberReadOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1001	{
1002	PSUPDRVDARWINMSRARGS pArgs = (PSUPDRVDARWINMSRARGS)pvUser1;
1003	if (g_pfnRdMsr64Carefully)
1004	pArgs->rc = g_pfnRdMsr64Carefully(pArgs->uMsr, &pArgs->uValue.u);
1005	else if (g_pfnRdMsrCarefully)
1006	pArgs->rc = g_pfnRdMsrCarefully(pArgs->uMsr, &pArgs->uValue.s.Lo, &pArgs->uValue.s.Hi);
1007	else
1008	pArgs->rc = 2;
1009	NOREF(idCpu); NOREF(pvUser2);
1010	}
1011
1012
1013	int VBOXCALL supdrvOSMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue)
1014	{
1015	if (!g_pfnRdMsr64Carefully && !g_pfnRdMsrCarefully)
1016	return VERR_NOT_SUPPORTED;
1017
1018	SUPDRVDARWINMSRARGS Args;
1019	Args.uMsr = uMsr;
1020	Args.uValue.u = 0;
1021	Args.rc = -1;
1022
1023	if (idCpu == NIL_RTCPUID)
1024	supdrvDarwinMsrProberReadOnCpu(idCpu, &Args, NULL);
1025	else
1026	{
1027	int rc = RTMpOnSpecific(idCpu, supdrvDarwinMsrProberReadOnCpu, &Args, NULL);
1028	if (RT_FAILURE(rc))
1029	return rc;
1030	}
1031
1032	if (Args.rc)
1033	return VERR_ACCESS_DENIED;
1034	*puValue = Args.uValue.u;
1035	return VINF_SUCCESS;
1036	}
1037
1038
1039	/**
1040	* On CPU worker for supdrvOSMsrProberWrite.
1041	*
1042	* @param idCpu Ignored.
1043	* @param pvUser1 Pointer to a SUPDRVDARWINMSRARGS.
1044	* @param pvUser2 Ignored.
1045	*/
1046	static DECLCALLBACK(void) supdrvDarwinMsrProberWriteOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1047	{
1048	PSUPDRVDARWINMSRARGS pArgs = (PSUPDRVDARWINMSRARGS)pvUser1;
1049	if (g_pfnWrMsr64Carefully)
1050	pArgs->rc = g_pfnWrMsr64Carefully(pArgs->uMsr, pArgs->uValue.u);
1051	else
1052	pArgs->rc = 2;
1053	NOREF(idCpu); NOREF(pvUser2);
1054	}
1055
1056
1057	int VBOXCALL supdrvOSMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue)
1058	{
1059	if (!g_pfnWrMsr64Carefully)
1060	return VERR_NOT_SUPPORTED;
1061
1062	SUPDRVDARWINMSRARGS Args;
1063	Args.uMsr = uMsr;
1064	Args.uValue.u = uValue;
1065	Args.rc = -1;
1066
1067	if (idCpu == NIL_RTCPUID)
1068	supdrvDarwinMsrProberWriteOnCpu(idCpu, &Args, NULL);
1069	else
1070	{
1071	int rc = RTMpOnSpecific(idCpu, supdrvDarwinMsrProberWriteOnCpu, &Args, NULL);
1072	if (RT_FAILURE(rc))
1073	return rc;
1074	}
1075
1076	if (Args.rc)
1077	return VERR_ACCESS_DENIED;
1078	return VINF_SUCCESS;
1079	}
1080
1081
1082	/**
1083	* Worker for supdrvOSMsrProberModify.
1084	*/
1085	static DECLCALLBACK(void) supdrvDarwinMsrProberModifyOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1086	{
1087	PSUPMSRPROBER pReq = (PSUPMSRPROBER)pvUser1;
1088	register uint32_t uMsr = pReq->u.In.uMsr;
1089	bool const fFaster = pReq->u.In.enmOp == SUPMSRPROBEROP_MODIFY_FASTER;
1090	uint64_t uBefore;
1091	uint64_t uWritten;
1092	uint64_t uAfter;
1093	int rcBefore, rcWrite, rcAfter, rcRestore;
1094	RTCCUINTREG fOldFlags;
1095
1096	/* Initialize result variables. */
1097	uBefore = uWritten = uAfter = 0;
1098	rcWrite = rcAfter = rcRestore = -1;
1099
1100	/*
1101	* Do the job.
1102	*/
1103	fOldFlags = ASMIntDisableFlags();
1104	ASMCompilerBarrier(); /* paranoia */
1105	if (!fFaster)
1106	ASMWriteBackAndInvalidateCaches();
1107
1108	rcBefore = g_pfnRdMsr64Carefully(uMsr, &uBefore);
1109	if (rcBefore >= 0)
1110	{
1111	register uint64_t uRestore = uBefore;
1112	uWritten = uRestore;
1113	uWritten &= pReq->u.In.uArgs.Modify.fAndMask;
1114	uWritten \|= pReq->u.In.uArgs.Modify.fOrMask;
1115
1116	rcWrite = g_pfnWrMsr64Carefully(uMsr, uWritten);
1117	rcAfter = g_pfnRdMsr64Carefully(uMsr, &uAfter);
1118	rcRestore = g_pfnWrMsr64Carefully(uMsr, uRestore);
1119
1120	if (!fFaster)
1121	{
1122	ASMWriteBackAndInvalidateCaches();
1123	ASMReloadCR3();
1124	ASMNopPause();
1125	}
1126	}
1127
1128	ASMCompilerBarrier(); /* paranoia */
1129	ASMSetFlags(fOldFlags);
1130
1131	/*
1132	* Write out the results.
1133	*/
1134	pReq->u.Out.uResults.Modify.uBefore = uBefore;
1135	pReq->u.Out.uResults.Modify.uWritten = uWritten;
1136	pReq->u.Out.uResults.Modify.uAfter = uAfter;
1137	pReq->u.Out.uResults.Modify.fBeforeGp = rcBefore != 0;
1138	pReq->u.Out.uResults.Modify.fModifyGp = rcWrite != 0;
1139	pReq->u.Out.uResults.Modify.fAfterGp = rcAfter != 0;
1140	pReq->u.Out.uResults.Modify.fRestoreGp = rcRestore != 0;
1141	RT_ZERO(pReq->u.Out.uResults.Modify.afReserved);
1142	}
1143
1144
1145	int VBOXCALL supdrvOSMsrProberModify(RTCPUID idCpu, PSUPMSRPROBER pReq)
1146	{
1147	if (!g_pfnWrMsr64Carefully \|\| !g_pfnRdMsr64Carefully)
1148	return VERR_NOT_SUPPORTED;
1149	if (idCpu == NIL_RTCPUID)
1150	{
1151	supdrvDarwinMsrProberModifyOnCpu(idCpu, pReq, NULL);
1152	return VINF_SUCCESS;
1153	}
1154	return RTMpOnSpecific(idCpu, supdrvDarwinMsrProberModifyOnCpu, pReq, NULL);
1155	}
1156
1157	#endif /* SUPDRV_WITH_MSR_PROBER */
1158
1159	/**
1160	* Resume Bluetooth keyboard.
1161	* If there is no Bluetooth keyboard device connected to the system we just ignore this.
1162	*/
1163	static void supdrvDarwinResumeBluetoothKbd(void)
1164	{
1165	OSDictionary *pDictionary = IOService::serviceMatching("AppleBluetoothHIDKeyboard");
1166	if (pDictionary)
1167	{
1168	OSIterator *pIter;
1169	IOBluetoothHIDDriver *pDriver;
1170
1171	pIter = IOService::getMatchingServices(pDictionary);
1172	if (pIter)
1173	{
1174	while ((pDriver = (IOBluetoothHIDDriver *)pIter->getNextObject()))
1175	if (pDriver->isKeyboard())
1176	(void)pDriver->hidControl(IOBTHID_CONTROL_EXIT_SUSPEND);
1177
1178	pIter->release();
1179	}
1180	pDictionary->release();
1181	}
1182	}
1183
1184	/**
1185	* Resume built-in keyboard on MacBook Air and Pro hosts.
1186	* If there is no built-in keyboard device attached to the system we just ignore this.
1187	*/
1188	static void supdrvDarwinResumeBuiltinKbd(void)
1189	{
1190	/*
1191	* AppleUSBTCKeyboard KEXT is responsible for built-in keyboard management.
1192	* We resume keyboard by accessing to its IOService. */
1193	OSDictionary *pDictionary = IOService::serviceMatching("AppleUSBTCKeyboard");
1194	if (pDictionary)
1195	{
1196	OSIterator *pIter;
1197	IOUSBHIDDriver *pDriver;
1198
1199	pIter = IOService::getMatchingServices(pDictionary);
1200	if (pIter)
1201	{
1202	while ((pDriver = (IOUSBHIDDriver *)pIter->getNextObject()))
1203	if (pDriver->IsPortSuspended())
1204	pDriver->SuspendPort(false, 0);
1205
1206	pIter->release();
1207	}
1208	pDictionary->release();
1209	}
1210	}
1211
1212
1213	/**
1214	* Resume suspended keyboard devices (if any).
1215	*/
1216	int VBOXCALL supdrvDarwinResumeSuspendedKbds(void)
1217	{
1218	supdrvDarwinResumeBuiltinKbd();
1219	supdrvDarwinResumeBluetoothKbd();
1220
1221	return 0;
1222	}
1223
1224
1225	/**
1226	* Converts an IPRT error code to a darwin error code.
1227	*
1228	* @returns corresponding darwin error code.
1229	* @param rc IPRT status code.
1230	*/
1231	static int VBoxDrvDarwinErr2DarwinErr(int rc)
1232	{
1233	switch (rc)
1234	{
1235	case VINF_SUCCESS: return 0;
1236	case VERR_GENERAL_FAILURE: return EACCES;
1237	case VERR_INVALID_PARAMETER: return EINVAL;
1238	case VERR_INVALID_MAGIC: return EILSEQ;
1239	case VERR_INVALID_HANDLE: return ENXIO;
1240	case VERR_INVALID_POINTER: return EFAULT;
1241	case VERR_LOCK_FAILED: return ENOLCK;
1242	case VERR_ALREADY_LOADED: return EEXIST;
1243	case VERR_PERMISSION_DENIED: return EPERM;
1244	case VERR_VERSION_MISMATCH: return ENOSYS;
1245	}
1246
1247	return EPERM;
1248	}
1249
1250
1251	RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
1252	{
1253	va_list va;
1254	char szMsg[512];
1255
1256	va_start(va, pszFormat);
1257	RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
1258	va_end(va);
1259	szMsg[sizeof(szMsg) - 1] = '\0';
1260
1261	printf("%s", szMsg);
1262	return 0;
1263	}
1264
1265
1266	/*
1267	*
1268	* org_virtualbox_SupDrv
1269	*
1270	*/
1271
1272
1273	/**
1274	* Initialize the object.
1275	*/
1276	bool org_virtualbox_SupDrv::init(OSDictionary *pDictionary)
1277	{
1278	LogFlow(("org_virtualbox_SupDrv::init([%p], %p)\n", this, pDictionary));
1279	if (IOService::init(pDictionary))
1280	{
1281	/* init members. */
1282	return true;
1283	}
1284	return false;
1285	}
1286
1287
1288	/**
1289	* Free the object.
1290	*/
1291	void org_virtualbox_SupDrv::free(void)
1292	{
1293	LogFlow(("IOService::free([%p])\n", this));
1294	IOService::free();
1295	}
1296
1297
1298	/**
1299	* Check if it's ok to start this service.
1300	* It's always ok by us, so it's up to IOService to decide really.
1301	*/
1302	IOService org_virtualbox_SupDrv::probe(IOService pProvider, SInt32 *pi32Score)
1303	{
1304	LogFlow(("org_virtualbox_SupDrv::probe([%p])\n", this));
1305	return IOService::probe(pProvider, pi32Score);
1306	}
1307
1308
1309	/**
1310	* Start this service.
1311	*/
1312	bool org_virtualbox_SupDrv::start(IOService *pProvider)
1313	{
1314	LogFlow(("org_virtualbox_SupDrv::start([%p])\n", this));
1315
1316	if (IOService::start(pProvider))
1317	{
1318	/* register the service. */
1319	registerService();
1320	return true;
1321	}
1322	return false;
1323	}
1324
1325
1326	/**
1327	* Stop this service.
1328	*/
1329	void org_virtualbox_SupDrv::stop(IOService *pProvider)
1330	{
1331	LogFlow(("org_virtualbox_SupDrv::stop([%p], %p)\n", this, pProvider));
1332	IOService::stop(pProvider);
1333	}
1334
1335
1336	/**
1337	* Termination request.
1338	*
1339	* @return true if we're ok with shutting down now, false if we're not.
1340	* @param fOptions Flags.
1341	*/
1342	bool org_virtualbox_SupDrv::terminate(IOOptionBits fOptions)
1343	{
1344	bool fRc;
1345	LogFlow(("org_virtualbox_SupDrv::terminate: reference_count=%d g_cSessions=%d (fOptions=%#x)\n",
1346	KMOD_INFO_NAME.reference_count, ASMAtomicUoReadS32(&g_cSessions), fOptions));
1347	if ( KMOD_INFO_NAME.reference_count != 0
1348	\|\| ASMAtomicUoReadS32(&g_cSessions))
1349	fRc = false;
1350	else
1351	fRc = IOService::terminate(fOptions);
1352	LogFlow(("org_virtualbox_SupDrv::terminate: returns %d\n", fRc));
1353	return fRc;
1354	}
1355
1356
1357	/*
1358	*
1359	* org_virtualbox_SupDrvClient
1360	*
1361	*/
1362
1363
1364	/**
1365	* Initializer called when the client opens the service.
1366	*/
1367	bool org_virtualbox_SupDrvClient::initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type)
1368	{
1369	LogFlow(("org_virtualbox_SupDrvClient::initWithTask([%p], %#x, %p, %#x) (cur pid=%d proc=%p)\n",
1370	this, OwningTask, pvSecurityId, u32Type, RTProcSelf(), RTR0ProcHandleSelf()));
1371	AssertMsg((RTR0PROCESS)OwningTask == RTR0ProcHandleSelf(), ("%p %p\n", OwningTask, RTR0ProcHandleSelf()));
1372
1373	if (!OwningTask)
1374	return false;
1375	if (IOUserClient::initWithTask(OwningTask, pvSecurityId , u32Type))
1376	{
1377	m_Task = OwningTask;
1378	m_pSession = NULL;
1379	m_pProvider = NULL;
1380	return true;
1381	}
1382	return false;
1383	}
1384
1385
1386	/**
1387	* Start the client service.
1388	*/
1389	bool org_virtualbox_SupDrvClient::start(IOService *pProvider)
1390	{
1391	LogFlow(("org_virtualbox_SupDrvClient::start([%p], %p) (cur pid=%d proc=%p)\n",
1392	this, pProvider, RTProcSelf(), RTR0ProcHandleSelf() ));
1393	AssertMsgReturn((RTR0PROCESS)m_Task == RTR0ProcHandleSelf(),
1394	("%p %p\n", m_Task, RTR0ProcHandleSelf()),
1395	false);
1396
1397	if (IOUserClient::start(pProvider))
1398	{
1399	m_pProvider = OSDynamicCast(org_virtualbox_SupDrv, pProvider);
1400	if (m_pProvider)
1401	{
1402	Assert(!m_pSession);
1403
1404	/*
1405	* Create a new session.
1406	*/
1407	int rc = supdrvCreateSession(&g_DevExt, true /* fUser /, false /fUnrestricted*/, &m_pSession);
1408	if (RT_SUCCESS(rc))
1409	{
1410	m_pSession->fOpened = false;
1411	/* The Uid, Gid and fUnrestricted fields are set on open. */
1412
1413	/*
1414	* Insert it into the hash table, checking that there isn't
1415	* already one for this process first. (One session per proc!)
1416	*/
1417	unsigned iHash = SESSION_HASH(m_pSession->Process);
1418	RTSpinlockAcquire(g_Spinlock);
1419
1420	PSUPDRVSESSION pCur = g_apSessionHashTab[iHash];
1421	while (pCur && pCur->Process != m_pSession->Process)
1422	pCur = pCur->pNextHash;
1423	if (!pCur)
1424	{
1425	m_pSession->pNextHash = g_apSessionHashTab[iHash];
1426	g_apSessionHashTab[iHash] = m_pSession;
1427	m_pSession->pvSupDrvClient = this;
1428	ASMAtomicIncS32(&g_cSessions);
1429	rc = VINF_SUCCESS;
1430	}
1431	else
1432	rc = VERR_ALREADY_LOADED;
1433
1434	RTSpinlockReleaseNoInts(g_Spinlock);
1435	if (RT_SUCCESS(rc))
1436	{
1437	Log(("org_virtualbox_SupDrvClient::start: created session %p for pid %d\n", m_pSession, (int)RTProcSelf()));
1438	return true;
1439	}
1440
1441	LogFlow(("org_virtualbox_SupDrvClient::start: already got a session for this process (%p)\n", pCur));
1442	supdrvSessionRelease(m_pSession);
1443	}
1444
1445	m_pSession = NULL;
1446	LogFlow(("org_virtualbox_SupDrvClient::start: rc=%Rrc from supdrvCreateSession\n", rc));
1447	}
1448	else
1449	LogFlow(("org_virtualbox_SupDrvClient::start: %p isn't org_virtualbox_SupDrv\n", pProvider));
1450	}
1451	return false;
1452	}
1453
1454
1455	/**
1456	* Common worker for clientClose and VBoxDrvDarwinClose.
1457	*/
1458	/* static */ void org_virtualbox_SupDrvClient::sessionClose(RTPROCESS Process)
1459	{
1460	/*
1461	* Find the session and remove it from the hash table.
1462	*
1463	* Note! Only one session per process. (Both start() and
1464	* VBoxDrvDarwinOpen makes sure this is so.)
1465	*/
1466	const unsigned iHash = SESSION_HASH(Process);
1467	RTSpinlockAcquire(g_Spinlock);
1468	PSUPDRVSESSION pSession = g_apSessionHashTab[iHash];
1469	if (pSession)
1470	{
1471	if (pSession->Process == Process)
1472	{
1473	g_apSessionHashTab[iHash] = pSession->pNextHash;
1474	pSession->pNextHash = NULL;
1475	ASMAtomicDecS32(&g_cSessions);
1476	}
1477	else
1478	{
1479	PSUPDRVSESSION pPrev = pSession;
1480	pSession = pSession->pNextHash;
1481	while (pSession)
1482	{
1483	if (pSession->Process == Process)
1484	{
1485	pPrev->pNextHash = pSession->pNextHash;
1486	pSession->pNextHash = NULL;
1487	ASMAtomicDecS32(&g_cSessions);
1488	break;
1489	}
1490
1491	/* next */
1492	pPrev = pSession;
1493	pSession = pSession->pNextHash;
1494	}
1495	}
1496	}
1497	RTSpinlockReleaseNoInts(g_Spinlock);
1498	if (!pSession)
1499	{
1500	Log(("SupDrvClient::sessionClose: pSession == NULL, pid=%d; freed already?\n", (int)Process));
1501	return;
1502	}
1503
1504	/*
1505	* Remove it from the client object.
1506	*/
1507	org_virtualbox_SupDrvClient pThis = (org_virtualbox_SupDrvClient )pSession->pvSupDrvClient;
1508	pSession->pvSupDrvClient = NULL;
1509	if (pThis)
1510	{
1511	Assert(pThis->m_pSession == pSession);
1512	pThis->m_pSession = NULL;
1513	}
1514
1515	/*
1516	* Close the session.
1517	*/
1518	supdrvSessionRelease(pSession);
1519	}
1520
1521
1522	/**
1523	* Client exits normally.
1524	*/
1525	IOReturn org_virtualbox_SupDrvClient::clientClose(void)
1526	{
1527	LogFlow(("org_virtualbox_SupDrvClient::clientClose([%p]) (cur pid=%d proc=%p)\n", this, RTProcSelf(), RTR0ProcHandleSelf()));
1528	AssertMsg((RTR0PROCESS)m_Task == RTR0ProcHandleSelf(), ("%p %p\n", m_Task, RTR0ProcHandleSelf()));
1529
1530	/*
1531	* Clean up the session if it's still around.
1532	*
1533	* We cannot rely 100% on close, and in the case of a dead client
1534	* we'll end up hanging inside vm_map_remove() if we postpone it.
1535	*/
1536	if (m_pSession)
1537	{
1538	sessionClose(RTProcSelf());
1539	Assert(!m_pSession);
1540	}
1541
1542	m_pProvider = NULL;
1543	terminate();
1544
1545	return kIOReturnSuccess;
1546	}
1547
1548
1549	/**
1550	* The client exits abnormally / forgets to do cleanups. (logging)
1551	*/
1552	IOReturn org_virtualbox_SupDrvClient::clientDied(void)
1553	{
1554	LogFlow(("org_virtualbox_SupDrvClient::clientDied([%p]) m_Task=%p R0Process=%p Process=%d\n",
1555	this, m_Task, RTR0ProcHandleSelf(), RTProcSelf()));
1556
1557	/* IOUserClient::clientDied() calls clientClose, so we'll just do the work there. */
1558	return IOUserClient::clientDied();
1559	}
1560
1561
1562	/**
1563	* Terminate the service (initiate the destruction). (logging)
1564	*/
1565	bool org_virtualbox_SupDrvClient::terminate(IOOptionBits fOptions)
1566	{
1567	LogFlow(("org_virtualbox_SupDrvClient::terminate([%p], %#x)\n", this, fOptions));
1568	return IOUserClient::terminate(fOptions);
1569	}
1570
1571
1572	/**
1573	* The final stage of the client service destruction. (logging)
1574	*/
1575	bool org_virtualbox_SupDrvClient::finalize(IOOptionBits fOptions)
1576	{
1577	LogFlow(("org_virtualbox_SupDrvClient::finalize([%p], %#x)\n", this, fOptions));
1578	return IOUserClient::finalize(fOptions);
1579	}
1580
1581
1582	/**
1583	* Stop the client service. (logging)
1584	*/
1585	void org_virtualbox_SupDrvClient::stop(IOService *pProvider)
1586	{
1587	LogFlow(("org_virtualbox_SupDrvClient::stop([%p])\n", this));
1588	IOUserClient::stop(pProvider);
1589	}
1590

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

source: vbox/trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp@ 51116

Download in other formats: