VirtualBox

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

Last change on this file was 98103, checked in by vboxsync, 15 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: 78.7 KB
Line 
1/* $Id: SUPDrv-darwin.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2/** @file
3 * VirtualBox Support Driver - Darwin Specific Code.
4 */
5
6/*
7 * Copyright (C) 2006-2023 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 "../../../Runtime/r0drv/darwin/the-darwin-kernel.h"
43
44#include "../SUPDrvInternal.h"
45#include <VBox/version.h>
46#include <iprt/assert.h>
47#include <iprt/asm.h>
48#include <iprt/asm-amd64-x86.h>
49#include <iprt/ctype.h>
50#include <iprt/dbg.h>
51#include <iprt/initterm.h>
52#include <iprt/file.h>
53#include <iprt/ldr.h>
54#include <iprt/mem.h>
55#include <iprt/power.h>
56#include <iprt/process.h>
57#include <iprt/spinlock.h>
58#include <iprt/semaphore.h>
59#include <iprt/x86.h>
60#include <iprt/crypto/applecodesign.h>
61#include <iprt/crypto/store.h>
62#include <iprt/crypto/pkcs7.h>
63#include <iprt/crypto/x509.h>
64#include <VBox/err.h>
65#include <VBox/log.h>
66
67#include <mach/kmod.h>
68#include <miscfs/devfs/devfs.h>
69#include <sys/conf.h>
70#include <sys/errno.h>
71#include <sys/ioccom.h>
72#include <sys/malloc.h>
73#include <sys/proc.h>
74#include <sys/kauth.h>
75#include <IOKit/IOService.h>
76#include <IOKit/IOUserClient.h>
77#include <IOKit/pwr_mgt/RootDomain.h>
78#include <IOKit/IODeviceTreeSupport.h>
79#if MAC_OS_X_VERSION_MIN_REQUIRED < 101100
80# include <IOKit/usb/IOUSBHIDDriver.h>
81#endif
82#include <IOKit/bluetooth/IOBluetoothHIDDriver.h>
83#include <IOKit/bluetooth/IOBluetoothHIDDriverTypes.h>
84
85#ifdef VBOX_WITH_HOST_VMX
86# include <libkern/version.h>
87RT_C_DECLS_BEGIN
88# include <i386/vmx.h>
89RT_C_DECLS_END
90#endif
91
92
93/*********************************************************************************************************************************
94* Defined Constants And Macros *
95*********************************************************************************************************************************/
96
97/** The system device node name. */
98#define DEVICE_NAME_SYS "vboxdrv"
99/** The user device node name. */
100#define DEVICE_NAME_USR "vboxdrvu"
101
102
103/** @name For debugging/whatever, now permanent.
104 * @{ */
105#define VBOX_PROC_SELFNAME_LEN 31
106#define VBOX_RETRIEVE_CUR_PROC_NAME(a_Name) char a_Name[VBOX_PROC_SELFNAME_LEN + 1]; \
107 proc_selfname(a_Name, VBOX_PROC_SELFNAME_LEN)
108/** @} */
109
110
111/*********************************************************************************************************************************
112* Internal Functions *
113*********************************************************************************************************************************/
114RT_C_DECLS_BEGIN
115static kern_return_t VBoxDrvDarwinStart(struct kmod_info *pKModInfo, void *pvData);
116static kern_return_t VBoxDrvDarwinStop(struct kmod_info *pKModInfo, void *pvData);
117#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
118static int supdrvDarwinInitCertStores(PSUPDRVDEVEXT pDevExt);
119static void supdrvDarwinDestroyCertStores(PSUPDRVDEVEXT pDevExt);
120#endif
121
122static int VBoxDrvDarwinOpen(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess);
123static int VBoxDrvDarwinClose(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess);
124static int VBoxDrvDarwinIOCtl(dev_t Dev, u_long iCmd, caddr_t pData, int fFlags, struct proc *pProcess);
125#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
126static int VBoxDrvDarwinIOCtlSMAP(dev_t Dev, u_long iCmd, caddr_t pData, int fFlags, struct proc *pProcess);
127#endif
128static int VBoxDrvDarwinIOCtlSlow(PSUPDRVSESSION pSession, u_long iCmd, caddr_t pData, struct proc *pProcess);
129
130static int VBoxDrvDarwinErr2DarwinErr(int rc);
131
132static IOReturn VBoxDrvDarwinSleepHandler(void *pvTarget, void *pvRefCon, UInt32 uMessageType, IOService *pProvider, void *pvMessageArgument, vm_size_t argSize);
133RT_C_DECLS_END
134
135static int vboxdrvDarwinResolveSymbols(void);
136static bool vboxdrvDarwinCpuHasSMAP(void);
137
138
139/*********************************************************************************************************************************
140* Structures and Typedefs *
141*********************************************************************************************************************************/
142/**
143 * The service class.
144 * This is just a formality really.
145 */
146class org_virtualbox_SupDrv : public IOService
147{
148 OSDeclareDefaultStructors(org_virtualbox_SupDrv);
149
150public:
151 virtual bool init(OSDictionary *pDictionary = 0);
152 virtual void free(void);
153 virtual bool start(IOService *pProvider);
154 virtual void stop(IOService *pProvider);
155 virtual IOService *probe(IOService *pProvider, SInt32 *pi32Score);
156 virtual bool terminate(IOOptionBits fOptions);
157
158 RTR0MEMEF_NEW_AND_DELETE_OPERATORS_IOKIT();
159
160private:
161 /** Guard against the parent class growing and us using outdated headers. */
162 uint8_t m_abSafetyPadding[256];
163};
164
165OSDefineMetaClassAndStructors(org_virtualbox_SupDrv, IOService);
166
167
168/**
169 * An attempt at getting that clientDied() notification.
170 * I don't think it'll work as I cannot figure out where/what creates the correct
171 * port right.
172 */
173class org_virtualbox_SupDrvClient : public IOUserClient
174{
175 OSDeclareDefaultStructors(org_virtualbox_SupDrvClient);
176
177private:
178 /** Guard against the parent class growing and us using outdated headers. */
179 uint8_t m_abSafetyPadding[256];
180
181 PSUPDRVSESSION m_pSession; /**< The session. */
182 task_t m_Task; /**< The client task. */
183 org_virtualbox_SupDrv *m_pProvider; /**< The service provider. */
184
185public:
186 virtual bool initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type);
187 virtual bool start(IOService *pProvider);
188 static void sessionClose(RTPROCESS Process);
189 virtual IOReturn clientClose(void);
190 virtual IOReturn clientDied(void);
191 virtual bool terminate(IOOptionBits fOptions = 0);
192 virtual bool finalize(IOOptionBits fOptions);
193 virtual void stop(IOService *pProvider);
194
195 RTR0MEMEF_NEW_AND_DELETE_OPERATORS_IOKIT();
196};
197
198OSDefineMetaClassAndStructors(org_virtualbox_SupDrvClient, IOUserClient);
199
200
201
202/*********************************************************************************************************************************
203* Global Variables *
204*********************************************************************************************************************************/
205/**
206 * Declare the module stuff.
207 */
208RT_C_DECLS_BEGIN
209extern kern_return_t _start(struct kmod_info *pKModInfo, void *pvData);
210extern kern_return_t _stop(struct kmod_info *pKModInfo, void *pvData);
211
212KMOD_EXPLICIT_DECL(VBoxDrv, VBOX_VERSION_STRING, _start, _stop)
213DECL_HIDDEN_DATA(kmod_start_func_t *) _realmain = VBoxDrvDarwinStart;
214DECL_HIDDEN_DATA(kmod_stop_func_t *) _antimain = VBoxDrvDarwinStop;
215DECL_HIDDEN_DATA(int) _kext_apple_cc = __APPLE_CC__;
216RT_C_DECLS_END
217
218
219/**
220 * Device extention & session data association structure.
221 */
222static SUPDRVDEVEXT g_DevExt;
223
224/**
225 * The character device switch table for the driver.
226 */
227static struct cdevsw g_DevCW =
228{
229 /** @todo g++ doesn't like this syntax - it worked with gcc before renaming to .cpp. */
230 /*.d_open = */VBoxDrvDarwinOpen,
231 /*.d_close = */VBoxDrvDarwinClose,
232 /*.d_read = */eno_rdwrt,
233 /*.d_write = */eno_rdwrt,
234 /*.d_ioctl = */VBoxDrvDarwinIOCtl,
235 /*.d_stop = */eno_stop,
236 /*.d_reset = */eno_reset,
237 /*.d_ttys = */NULL,
238 /*.d_select= */eno_select,
239 /*.d_mmap = */eno_mmap,
240 /*.d_strategy = */eno_strat,
241 /*.d_getc = */(void *)(uintptr_t)&enodev, //eno_getc,
242 /*.d_putc = */(void *)(uintptr_t)&enodev, //eno_putc,
243 /*.d_type = */0
244};
245
246/** Major device number. */
247static int g_iMajorDeviceNo = -1;
248/** Registered devfs device handle for the system device. */
249static void *g_hDevFsDeviceSys = NULL;
250/** Registered devfs device handle for the user device. */
251static void *g_hDevFsDeviceUsr = NULL;
252
253/** Spinlock protecting g_apSessionHashTab. */
254static RTSPINLOCK g_Spinlock = NIL_RTSPINLOCK;
255/** Hash table */
256static PSUPDRVSESSION g_apSessionHashTab[19];
257/** Calculates the index into g_apSessionHashTab.*/
258#define SESSION_HASH(pid) ((pid) % RT_ELEMENTS(g_apSessionHashTab))
259/** The number of open sessions. */
260static int32_t volatile g_cSessions = 0;
261/** The notifier handle for the sleep callback handler. */
262static IONotifier *g_pSleepNotifier = NULL;
263
264/** Pointer to vmx_suspend(). */
265static PFNRT g_pfnVmxSuspend = NULL;
266/** Pointer to vmx_resume(). */
267static PFNRT g_pfnVmxResume = NULL;
268/** Pointer to vmx_use_count. */
269static int volatile *g_pVmxUseCount = NULL;
270
271#ifdef SUPDRV_WITH_MSR_PROBER
272/** Pointer to rdmsr_carefully if found. Returns 0 on success. */
273static int (*g_pfnRdMsrCarefully)(uint32_t uMsr, uint32_t *puLow, uint32_t *puHigh) = NULL;
274/** Pointer to rdmsr64_carefully if found. Returns 0 on success. */
275static int (*g_pfnRdMsr64Carefully)(uint32_t uMsr, uint64_t *uValue) = NULL;
276/** Pointer to wrmsr[64]_carefully if found. Returns 0 on success. */
277static int (*g_pfnWrMsr64Carefully)(uint32_t uMsr, uint64_t uValue) = NULL;
278#endif
279
280/** SUPKERNELFEATURES_XXX */
281static uint32_t g_fKernelFeatures = 0;
282
283/**
284 * Start the kernel module.
285 */
286static kern_return_t VBoxDrvDarwinStart(struct kmod_info *pKModInfo, void *pvData)
287{
288 RT_NOREF(pKModInfo, pvData);
289#ifdef DEBUG
290 printf("VBoxDrvDarwinStart\n");
291#endif
292
293 /*
294 * Initialize IPRT.
295 */
296 int rc = RTR0Init(0);
297 if (RT_SUCCESS(rc))
298 {
299 /*
300 * Initialize the device extension.
301 */
302 rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION));
303 if (RT_SUCCESS(rc))
304 {
305#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
306 supdrvDarwinInitCertStores(&g_DevExt);
307#endif
308
309 /*
310 * Initialize the session hash table.
311 */
312 memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab)); /* paranoia */
313 rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvDarwin");
314 if (RT_SUCCESS(rc))
315 {
316 if (vboxdrvDarwinCpuHasSMAP())
317 {
318 g_fKernelFeatures |= SUPKERNELFEATURES_SMAP;
319#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
320 LogRel(("disabling SMAP for VBoxDrvDarwinIOCtl\n"));
321 g_DevCW.d_ioctl = VBoxDrvDarwinIOCtlSMAP;
322#endif
323 }
324
325 /*
326 * Resolve some extra kernel symbols.
327 */
328 rc = vboxdrvDarwinResolveSymbols();
329 if (RT_SUCCESS(rc))
330 {
331
332 /*
333 * Registering ourselves as a character device.
334 */
335 g_iMajorDeviceNo = cdevsw_add(-1, &g_DevCW);
336 if (g_iMajorDeviceNo >= 0)
337 {
338#ifdef VBOX_WITH_HARDENING
339 g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR,
340 UID_ROOT, GID_WHEEL, 0600, DEVICE_NAME_SYS);
341#else
342 g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR,
343 UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_SYS);
344#endif
345 if (g_hDevFsDeviceSys)
346 {
347 g_hDevFsDeviceUsr = devfs_make_node(makedev(g_iMajorDeviceNo, 1), DEVFS_CHAR,
348 UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_USR);
349 if (g_hDevFsDeviceUsr)
350 {
351 LogRel(("VBoxDrv: version " VBOX_VERSION_STRING " r%d; IOCtl version %#x; IDC version %#x; dev major=%d\n",
352 VBOX_SVN_REV, SUPDRV_IOC_VERSION, SUPDRV_IDC_VERSION, g_iMajorDeviceNo));
353
354 /* Register a sleep/wakeup notification callback */
355 g_pSleepNotifier = registerPrioritySleepWakeInterest(&VBoxDrvDarwinSleepHandler, &g_DevExt, NULL);
356 if (g_pSleepNotifier == NULL)
357 LogRel(("VBoxDrv: register for sleep/wakeup events failed\n"));
358
359 return KMOD_RETURN_SUCCESS;
360 }
361
362 LogRel(("VBoxDrv: devfs_make_node(makedev(%d,1),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_USR));
363 devfs_remove(g_hDevFsDeviceSys);
364 g_hDevFsDeviceSys = NULL;
365 }
366 else
367 LogRel(("VBoxDrv: devfs_make_node(makedev(%d,0),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_SYS));
368
369 cdevsw_remove(g_iMajorDeviceNo, &g_DevCW);
370 g_iMajorDeviceNo = -1;
371 }
372 else
373 LogRel(("VBoxDrv: cdevsw_add failed (%d)\n", g_iMajorDeviceNo));
374 }
375#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
376 supdrvDarwinDestroyCertStores(&g_DevExt);
377#endif
378 RTSpinlockDestroy(g_Spinlock);
379 g_Spinlock = NIL_RTSPINLOCK;
380 }
381 else
382 LogRel(("VBoxDrv: RTSpinlockCreate failed (rc=%d)\n", rc));
383 supdrvDeleteDevExt(&g_DevExt);
384 }
385 else
386 printf("VBoxDrv: failed to initialize device extension (rc=%d)\n", rc);
387 RTR0TermForced();
388 }
389 else
390 printf("VBoxDrv: failed to initialize IPRT (rc=%d)\n", rc);
391
392 memset(&g_DevExt, 0, sizeof(g_DevExt));
393 return KMOD_RETURN_FAILURE;
394}
395
396
397/**
398 * Resolves kernel symbols we need and some we just would like to have.
399 */
400static int vboxdrvDarwinResolveSymbols(void)
401{
402 RTDBGKRNLINFO hKrnlInfo;
403 int rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0);
404 if (RT_SUCCESS(rc))
405 {
406 /*
407 * The VMX stuff - required with raw-mode (in theory for 64-bit on
408 * 32-bit too, but we never did that on darwin).
409 */
410 int rc1 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_resume", (void **)&g_pfnVmxResume);
411 int rc2 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_suspend", (void **)&g_pfnVmxSuspend);
412 int rc3 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "vmx_use_count", (void **)&g_pVmxUseCount);
413 if (RT_SUCCESS(rc1) && RT_SUCCESS(rc2) && RT_SUCCESS(rc3))
414 {
415 LogRel(("VBoxDrv: vmx_resume=%p vmx_suspend=%p vmx_use_count=%p (%d) cr4=%#x\n",
416 g_pfnVmxResume, g_pfnVmxSuspend, g_pVmxUseCount, *g_pVmxUseCount, ASMGetCR4() ));
417 }
418 else
419 {
420 LogRel(("VBoxDrv: failed to resolve vmx stuff: vmx_resume=%Rrc vmx_suspend=%Rrc vmx_use_count=%Rrc", rc1, rc2, rc3));
421 g_pfnVmxResume = NULL;
422 g_pfnVmxSuspend = NULL;
423 g_pVmxUseCount = NULL;
424#ifdef VBOX_WITH_RAW_MODE
425 rc = VERR_SYMBOL_NOT_FOUND;
426#endif
427 }
428
429 if (RT_SUCCESS(rc))
430 {
431#ifdef SUPDRV_WITH_MSR_PROBER
432 /*
433 * MSR prober stuff - optional!
434 */
435 rc2 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "rdmsr_carefully", (void **)&g_pfnRdMsrCarefully);
436 if (RT_FAILURE(rc2))
437 g_pfnRdMsrCarefully = NULL;
438 rc2 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "rdmsr64_carefully", (void **)&g_pfnRdMsr64Carefully);
439 if (RT_FAILURE(rc2))
440 g_pfnRdMsr64Carefully = NULL;
441# ifdef RT_ARCH_AMD64 /* Missing 64 in name, so if implemented on 32-bit it could have different signature. */
442 rc2 = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, "wrmsr_carefully", (void **)&g_pfnWrMsr64Carefully);
443 if (RT_FAILURE(rc2))
444# endif
445 g_pfnWrMsr64Carefully = NULL;
446
447 LogRel(("VBoxDrv: g_pfnRdMsrCarefully=%p g_pfnRdMsr64Carefully=%p g_pfnWrMsr64Carefully=%p\n",
448 g_pfnRdMsrCarefully, g_pfnRdMsr64Carefully, g_pfnWrMsr64Carefully));
449
450#endif /* SUPDRV_WITH_MSR_PROBER */
451 }
452
453 RTR0DbgKrnlInfoRelease(hKrnlInfo);
454 }
455 else
456 LogRel(("VBoxDrv: Failed to open kernel symbols, rc=%Rrc\n", rc));
457 return rc;
458}
459
460
461#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
462
463/**
464 * Initalizes the certificate stores (code signing) in the device extension.
465 */
466static int supdrvDarwinInitCertStores(PSUPDRVDEVEXT pDevExt)
467{
468 pDevExt->hAdditionalStore = NIL_RTCRSTORE;
469
470 pDevExt->hRootStore = NIL_RTCRSTORE;
471 int rc = RTCrStoreCreateInMem(&pDevExt->hRootStore, g_cSUPTrustedTAs + 1);
472 if (RT_SUCCESS(rc))
473 {
474 for (uint32_t i = 0; i < g_cSUPTrustedTAs; i++)
475 {
476 int rc2 = RTCrStoreCertAddEncoded(pDevExt->hRootStore, RTCRCERTCTX_F_ENC_TAF_DER,
477 g_aSUPTrustedTAs[i].pch, g_aSUPTrustedTAs[i].cb, NULL);
478 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
479 {
480 printf("VBoxDrv: Error loading g_aSUPTrustedTAs[%u]: %d\n", i, rc);
481 rc = rc2;
482 }
483 }
484
485 /* We implicitly trust the build certificate. */
486 int rc2 = RTCrStoreCertAddEncoded(pDevExt->hRootStore, RTCRCERTCTX_F_ENC_X509_DER,
487 g_abSUPBuildCert, g_cbSUPBuildCert, NULL);
488 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
489 {
490 printf("VBoxDrv: Error loading g_cbSUPBuildCert: %d\n", rc);
491 rc = rc2;
492 }
493 }
494 return rc;
495}
496
497
498/**
499 * Releases the certificate stores in the device extension.
500 */
501static void supdrvDarwinDestroyCertStores(PSUPDRVDEVEXT pDevExt)
502{
503 if (pDevExt->hRootStore != NIL_RTCRSTORE)
504 {
505 uint32_t cRefs = RTCrStoreRelease(pDevExt->hRootStore);
506 Assert(cRefs == 0); RT_NOREF(cRefs);
507 pDevExt->hRootStore = NIL_RTCRSTORE;
508 }
509 if (pDevExt->hAdditionalStore != NIL_RTCRSTORE)
510 {
511 uint32_t cRefs = RTCrStoreRelease(pDevExt->hAdditionalStore);
512 Assert(cRefs == 0); RT_NOREF(cRefs);
513 pDevExt->hAdditionalStore = NIL_RTCRSTORE;
514 }
515}
516
517#endif /* VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION */
518
519/**
520 * Stop the kernel module.
521 */
522static kern_return_t VBoxDrvDarwinStop(struct kmod_info *pKModInfo, void *pvData)
523{
524 RT_NOREF(pKModInfo, pvData);
525 int rc;
526 LogFlow(("VBoxDrvDarwinStop\n"));
527
528 /** @todo I've got a nagging feeling that we'll have to keep track of users and refuse
529 * unloading if we're busy. Investigate and implement this! */
530
531 /*
532 * Undo the work done during start (in reverse order).
533 */
534 if (g_pSleepNotifier)
535 {
536 g_pSleepNotifier->remove();
537 g_pSleepNotifier = NULL;
538 }
539
540 devfs_remove(g_hDevFsDeviceUsr);
541 g_hDevFsDeviceUsr = NULL;
542
543 devfs_remove(g_hDevFsDeviceSys);
544 g_hDevFsDeviceSys = NULL;
545
546 rc = cdevsw_remove(g_iMajorDeviceNo, &g_DevCW);
547 Assert(rc == g_iMajorDeviceNo);
548 g_iMajorDeviceNo = -1;
549
550 supdrvDeleteDevExt(&g_DevExt);
551
552 rc = RTSpinlockDestroy(g_Spinlock);
553 AssertRC(rc);
554 g_Spinlock = NIL_RTSPINLOCK;
555
556#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
557 supdrvDarwinDestroyCertStores(&g_DevExt);
558#endif
559
560 RTR0TermForced();
561
562 memset(&g_DevExt, 0, sizeof(g_DevExt));
563#ifdef DEBUG
564 printf("VBoxDrvDarwinStop - done\n");
565#endif
566 return KMOD_RETURN_SUCCESS;
567}
568
569
570/**
571 * Device open. Called on open /dev/vboxdrv
572 *
573 * @param Dev The device number.
574 * @param fFlags ???.
575 * @param fDevType ???.
576 * @param pProcess The process issuing this request.
577 */
578static int VBoxDrvDarwinOpen(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess)
579{
580 RT_NOREF(fFlags, fDevType);
581#ifdef DEBUG_DARWIN_GIP
582 char szName[128];
583 szName[0] = '\0';
584 proc_name(proc_pid(pProcess), szName, sizeof(szName));
585 Log(("VBoxDrvDarwinOpen: pid=%d '%s'\n", proc_pid(pProcess), szName));
586#endif
587
588 /*
589 * Only two minor devices numbers are allowed.
590 */
591 if (minor(Dev) != 0 && minor(Dev) != 1)
592 return EACCES;
593
594 /*
595 * The process issuing the request must be the current process.
596 */
597 RTPROCESS Process = RTProcSelf();
598 if ((int)Process != proc_pid(pProcess))
599 return EIO;
600
601 /*
602 * Find the session created by org_virtualbox_SupDrvClient, fail
603 * if no such session, and mark it as opened. We set the uid & gid
604 * here too, since that is more straight forward at this point.
605 */
606 const bool fUnrestricted = minor(Dev) == 0;
607 int rc = VINF_SUCCESS;
608 PSUPDRVSESSION pSession = NULL;
609 kauth_cred_t pCred = kauth_cred_proc_ref(pProcess);
610 if (pCred)
611 {
612#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
613 RTUID Uid = kauth_cred_getruid(pCred);
614 RTGID Gid = kauth_cred_getrgid(pCred);
615#else
616 RTUID Uid = pCred->cr_ruid;
617 RTGID Gid = pCred->cr_rgid;
618#endif
619 unsigned iHash = SESSION_HASH(Process);
620 RTSpinlockAcquire(g_Spinlock);
621
622 pSession = g_apSessionHashTab[iHash];
623 while (pSession && pSession->Process != Process)
624 pSession = pSession->pNextHash;
625 if (pSession)
626 {
627 if (!pSession->fOpened)
628 {
629 pSession->fOpened = true;
630 pSession->fUnrestricted = fUnrestricted;
631 pSession->Uid = Uid;
632 pSession->Gid = Gid;
633 }
634 else
635 rc = VERR_ALREADY_LOADED;
636 }
637 else
638 rc = VERR_GENERAL_FAILURE;
639
640 RTSpinlockRelease(g_Spinlock);
641#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1050
642 kauth_cred_unref(&pCred);
643#else /* 10.4 */
644 /* The 10.4u SDK headers and 10.4.11 kernel source have inconsistent definitions
645 of kauth_cred_unref(), so use the other (now deprecated) API for releasing it. */
646 kauth_cred_rele(pCred);
647#endif /* 10.4 */
648 }
649 else
650 rc = VERR_INVALID_PARAMETER;
651
652#ifdef DEBUG_DARWIN_GIP
653 OSDBGPRINT(("VBoxDrvDarwinOpen: pid=%d '%s' pSession=%p rc=%d\n", proc_pid(pProcess), szName, pSession, rc));
654#else
655 Log(("VBoxDrvDarwinOpen: g_DevExt=%p pSession=%p rc=%d pid=%d\n", &g_DevExt, pSession, rc, proc_pid(pProcess)));
656#endif
657 return VBoxDrvDarwinErr2DarwinErr(rc);
658}
659
660
661/**
662 * Close device.
663 */
664static int VBoxDrvDarwinClose(dev_t Dev, int fFlags, int fDevType, struct proc *pProcess)
665{
666 RT_NOREF(Dev, fFlags, fDevType, pProcess);
667 Log(("VBoxDrvDarwinClose: pid=%d\n", (int)RTProcSelf()));
668 Assert(proc_pid(pProcess) == (int)RTProcSelf());
669
670 /*
671 * Hand the session closing to org_virtualbox_SupDrvClient.
672 */
673 org_virtualbox_SupDrvClient::sessionClose(RTProcSelf());
674 return 0;
675}
676
677
678/**
679 * Device I/O Control entry point.
680 *
681 * @returns Darwin for slow IOCtls and VBox status code for the fast ones.
682 * @param Dev The device number (major+minor).
683 * @param iCmd The IOCtl command.
684 * @param pData Pointer to the data (if any it's a SUPDRVIOCTLDATA (kernel copy)).
685 * @param fFlags Flag saying we're a character device (like we didn't know already).
686 * @param pProcess The process issuing this request.
687 */
688static int VBoxDrvDarwinIOCtl(dev_t Dev, u_long iCmd, caddr_t pData, int fFlags, struct proc *pProcess)
689{
690 RT_NOREF(fFlags);
691 const bool fUnrestricted = minor(Dev) == 0;
692 const RTPROCESS Process = proc_pid(pProcess);
693 const unsigned iHash = SESSION_HASH(Process);
694 PSUPDRVSESSION pSession;
695
696#ifdef VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV
697 /*
698 * Refuse all I/O control calls if we've ever detected EFLAGS.AC being cleared.
699 *
700 * This isn't a problem, as there is absolutely nothing in the kernel context that
701 * depend on user context triggering cleanups. That would be pretty wild, right?
702 */
703 if (RT_UNLIKELY(g_DevExt.cBadContextCalls > 0))
704 {
705 SUPR0Printf("VBoxDrvDarwinIOCtl: EFLAGS.AC=0 detected %u times, refusing all I/O controls!\n", g_DevExt.cBadContextCalls);
706 return EDEVERR;
707 }
708#endif
709
710 /*
711 * Find the session.
712 */
713 RTSpinlockAcquire(g_Spinlock);
714
715 pSession = g_apSessionHashTab[iHash];
716 while (pSession && (pSession->Process != Process || pSession->fUnrestricted != fUnrestricted || !pSession->fOpened))
717 pSession = pSession->pNextHash;
718
719 if (RT_LIKELY(pSession))
720 supdrvSessionRetain(pSession);
721
722 RTSpinlockRelease(g_Spinlock);
723 if (RT_UNLIKELY(!pSession))
724 {
725 OSDBGPRINT(("VBoxDrvDarwinIOCtl: WHAT?!? pSession == NULL! This must be a mistake... pid=%d iCmd=%#lx\n",
726 (int)Process, iCmd));
727 return EINVAL;
728 }
729
730 /*
731 * Deal with the two high-speed IOCtl that takes it's arguments from
732 * the session and iCmd, and only returns a VBox status code.
733 */
734 int rc;
735 AssertCompile((SUP_IOCTL_FAST_DO_FIRST & 0xff) == (SUP_IOCTL_FLAG | 64));
736 if ( (uintptr_t)(iCmd - SUP_IOCTL_FAST_DO_FIRST) < (uintptr_t)32
737 && fUnrestricted)
738 rc = supdrvIOCtlFast(iCmd - SUP_IOCTL_FAST_DO_FIRST, *(uint32_t *)pData, &g_DevExt, pSession);
739 else
740 rc = VBoxDrvDarwinIOCtlSlow(pSession, iCmd, pData, pProcess);
741
742 supdrvSessionRelease(pSession);
743 return rc;
744}
745
746
747#ifndef VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV
748/**
749 * Alternative Device I/O Control entry point on hosts with SMAP support.
750 *
751 * @returns Darwin for slow IOCtls and VBox status code for the fast ones.
752 * @param Dev The device number (major+minor).
753 * @param iCmd The IOCtl command.
754 * @param pData Pointer to the data (if any it's a SUPDRVIOCTLDATA (kernel copy)).
755 * @param fFlags Flag saying we're a character device (like we didn't know already).
756 * @param pProcess The process issuing this request.
757 */
758static int VBoxDrvDarwinIOCtlSMAP(dev_t Dev, u_long iCmd, caddr_t pData, int fFlags, struct proc *pProcess)
759{
760 /*
761 * Allow VBox R0 code to touch R3 memory. Setting the AC bit disables the
762 * SMAP check.
763 */
764 RTCCUINTREG fSavedEfl = ASMAddFlags(X86_EFL_AC);
765
766 int rc = VBoxDrvDarwinIOCtl(Dev, iCmd, pData, fFlags, pProcess);
767
768# if defined(VBOX_STRICT) || defined(VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV)
769 /*
770 * Before we restore AC and the rest of EFLAGS, check if the IOCtl handler code
771 * accidentially modified it or some other important flag.
772 */
773 if (RT_UNLIKELY( (ASMGetFlags() & (X86_EFL_AC | X86_EFL_IF | X86_EFL_DF | X86_EFL_IOPL))
774 != ((fSavedEfl & (X86_EFL_AC | X86_EFL_IF | X86_EFL_DF | X86_EFL_IOPL)) | X86_EFL_AC) ))
775 {
776 char szTmp[48];
777 RTStrPrintf(szTmp, sizeof(szTmp), "iCmd=%#x: %#x->%#x!", iCmd, (uint32_t)fSavedEfl, (uint32_t)ASMGetFlags());
778 supdrvBadContext(&g_DevExt, "SUPDrv-darwin.cpp", __LINE__, szTmp);
779 }
780# endif
781
782 ASMSetFlags(fSavedEfl);
783 return rc;
784}
785#endif /* VBOX_WITHOUT_EFLAGS_AC_SET_IN_VBOXDRV */
786
787
788/**
789 * Worker for VBoxDrvDarwinIOCtl that takes the slow IOCtl functions.
790 *
791 * @returns Darwin errno.
792 *
793 * @param pSession The session.
794 * @param iCmd The IOCtl command.
795 * @param pData Pointer to the kernel copy of the SUPDRVIOCTLDATA buffer.
796 * @param pProcess The calling process.
797 */
798static int VBoxDrvDarwinIOCtlSlow(PSUPDRVSESSION pSession, u_long iCmd, caddr_t pData, struct proc *pProcess)
799{
800 RT_NOREF(pProcess);
801 LogFlow(("VBoxDrvDarwinIOCtlSlow: pSession=%p iCmd=%p pData=%p pProcess=%p\n", pSession, iCmd, pData, pProcess));
802
803
804 /*
805 * Buffered or unbuffered?
806 */
807 PSUPREQHDR pHdr;
808 user_addr_t pUser = 0;
809 void *pvPageBuf = NULL;
810 uint32_t cbReq = IOCPARM_LEN(iCmd);
811 if ((IOC_DIRMASK & iCmd) == IOC_INOUT)
812 {
813 pHdr = (PSUPREQHDR)pData;
814 if (RT_UNLIKELY(cbReq < sizeof(*pHdr)))
815 {
816 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: cbReq=%#x < %#x; iCmd=%#lx\n", cbReq, (int)sizeof(*pHdr), iCmd));
817 return EINVAL;
818 }
819 if (RT_UNLIKELY((pHdr->fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
820 {
821 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: bad magic fFlags=%#x; iCmd=%#lx\n", pHdr->fFlags, iCmd));
822 return EINVAL;
823 }
824 if (RT_UNLIKELY( RT_MAX(pHdr->cbIn, pHdr->cbOut) != cbReq
825 || pHdr->cbIn < sizeof(*pHdr)
826 || pHdr->cbOut < sizeof(*pHdr)))
827 {
828 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: max(%#x,%#x) != %#x; iCmd=%#lx\n", pHdr->cbIn, pHdr->cbOut, cbReq, iCmd));
829 return EINVAL;
830 }
831 }
832 else if ((IOC_DIRMASK & iCmd) == IOC_VOID && !cbReq)
833 {
834 /*
835 * Get the header and figure out how much we're gonna have to read.
836 */
837 IPRT_DARWIN_SAVE_EFL_AC();
838 SUPREQHDR Hdr;
839 pUser = (user_addr_t)*(void **)pData;
840 int rc = copyin(pUser, &Hdr, sizeof(Hdr));
841 if (RT_UNLIKELY(rc))
842 {
843 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: copyin(%llx,Hdr,) -> %#x; iCmd=%#lx\n", (unsigned long long)pUser, rc, iCmd));
844 IPRT_DARWIN_RESTORE_EFL_AC();
845 return rc;
846 }
847 if (RT_UNLIKELY((Hdr.fFlags & SUPREQHDR_FLAGS_MAGIC_MASK) != SUPREQHDR_FLAGS_MAGIC))
848 {
849 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: bad magic fFlags=%#x; iCmd=%#lx\n", Hdr.fFlags, iCmd));
850 IPRT_DARWIN_RESTORE_EFL_AC();
851 return EINVAL;
852 }
853 cbReq = RT_MAX(Hdr.cbIn, Hdr.cbOut);
854 if (RT_UNLIKELY( Hdr.cbIn < sizeof(Hdr)
855 || Hdr.cbOut < sizeof(Hdr)
856 || cbReq > _1M*16))
857 {
858 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: max(%#x,%#x); iCmd=%#lx\n", Hdr.cbIn, Hdr.cbOut, iCmd));
859 IPRT_DARWIN_RESTORE_EFL_AC();
860 return EINVAL;
861 }
862
863 /*
864 * Allocate buffer and copy in the data.
865 */
866 pHdr = (PSUPREQHDR)RTMemTmpAlloc(cbReq);
867 if (!pHdr)
868 pvPageBuf = pHdr = (PSUPREQHDR)IOMallocAligned(RT_ALIGN_Z(cbReq, PAGE_SIZE), 8);
869 if (RT_UNLIKELY(!pHdr))
870 {
871 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: failed to allocate buffer of %d bytes; iCmd=%#lx\n", cbReq, iCmd));
872 IPRT_DARWIN_RESTORE_EFL_AC();
873 return ENOMEM;
874 }
875 rc = copyin(pUser, pHdr, Hdr.cbIn);
876 if (RT_UNLIKELY(rc))
877 {
878 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: copyin(%llx,%p,%#x) -> %#x; iCmd=%#lx\n",
879 (unsigned long long)pUser, pHdr, Hdr.cbIn, rc, iCmd));
880 if (pvPageBuf)
881 IOFreeAligned(pvPageBuf, RT_ALIGN_Z(cbReq, PAGE_SIZE));
882 else
883 RTMemTmpFree(pHdr);
884 IPRT_DARWIN_RESTORE_EFL_AC();
885 return rc;
886 }
887 if (Hdr.cbIn < cbReq)
888 RT_BZERO((uint8_t *)pHdr + Hdr.cbIn, cbReq - Hdr.cbIn);
889 IPRT_DARWIN_RESTORE_EFL_AC();
890 }
891 else
892 {
893 Log(("VBoxDrvDarwinIOCtlSlow: huh? cbReq=%#x iCmd=%#lx\n", cbReq, iCmd));
894 return EINVAL;
895 }
896
897 /*
898 * Process the IOCtl.
899 */
900 int rc = supdrvIOCtl(iCmd, &g_DevExt, pSession, pHdr, cbReq);
901 if (RT_LIKELY(!rc))
902 {
903 /*
904 * If not buffered, copy back the buffer before returning.
905 */
906 if (pUser)
907 {
908 IPRT_DARWIN_SAVE_EFL_AC();
909 uint32_t cbOut = pHdr->cbOut;
910 if (cbOut > cbReq)
911 {
912 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: too much output! %#x > %#x; uCmd=%#lx!\n", cbOut, cbReq, iCmd));
913 cbOut = cbReq;
914 }
915 rc = copyout(pHdr, pUser, cbOut);
916 if (RT_UNLIKELY(rc))
917 OSDBGPRINT(("VBoxDrvDarwinIOCtlSlow: copyout(%p,%llx,%#x) -> %d; uCmd=%#lx!\n",
918 pHdr, (unsigned long long)pUser, cbOut, rc, iCmd));
919
920 /* cleanup */
921 if (pvPageBuf)
922 IOFreeAligned(pvPageBuf, RT_ALIGN_Z(cbReq, PAGE_SIZE));
923 else
924 RTMemTmpFree(pHdr);
925 IPRT_DARWIN_RESTORE_EFL_AC();
926 }
927 }
928 else
929 {
930 /*
931 * The request failed, just clean up.
932 */
933 if (pUser)
934 {
935 if (pvPageBuf)
936 {
937 IPRT_DARWIN_SAVE_EFL_AC();
938 IOFreeAligned(pvPageBuf, RT_ALIGN_Z(cbReq, PAGE_SIZE));
939 IPRT_DARWIN_RESTORE_EFL_AC();
940 }
941 else
942 RTMemTmpFree(pHdr);
943 }
944
945 Log(("VBoxDrvDarwinIOCtlSlow: pid=%d iCmd=%lx pData=%p failed, rc=%d\n", proc_pid(pProcess), iCmd, (void *)pData, rc));
946 rc = EINVAL;
947 }
948
949 Log2(("VBoxDrvDarwinIOCtlSlow: returns %d\n", rc));
950 return rc;
951}
952
953
954/**
955 * The SUPDRV IDC entry point.
956 *
957 * @returns VBox status code, see supdrvIDC.
958 * @param uReq The request code.
959 * @param pReq The request.
960 */
961DECLEXPORT(int) VBOXCALL SUPDrvDarwinIDC(uint32_t uReq, PSUPDRVIDCREQHDR pReq)
962{
963 PSUPDRVSESSION pSession;
964
965 /*
966 * Some quick validations.
967 */
968 if (RT_UNLIKELY(!RT_VALID_PTR(pReq)))
969 return VERR_INVALID_POINTER;
970
971 pSession = pReq->pSession;
972 if (pSession)
973 {
974 if (RT_UNLIKELY(!RT_VALID_PTR(pSession)))
975 return VERR_INVALID_PARAMETER;
976 if (RT_UNLIKELY(pSession->pDevExt != &g_DevExt))
977 return VERR_INVALID_PARAMETER;
978 }
979 else if (RT_UNLIKELY(uReq != SUPDRV_IDC_REQ_CONNECT))
980 return VERR_INVALID_PARAMETER;
981
982 /*
983 * Do the job.
984 */
985 return supdrvIDC(uReq, &g_DevExt, pSession, pReq);
986}
987
988
989void VBOXCALL supdrvOSCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
990{
991 NOREF(pDevExt);
992 NOREF(pSession);
993}
994
995
996void VBOXCALL supdrvOSSessionHashTabInserted(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
997{
998 NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
999}
1000
1001
1002void VBOXCALL supdrvOSSessionHashTabRemoved(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
1003{
1004 NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
1005}
1006
1007
1008/**
1009 * Initializes any OS specific object creator fields.
1010 */
1011void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
1012{
1013 NOREF(pObj);
1014 NOREF(pSession);
1015}
1016
1017
1018/**
1019 * Checks if the session can access the object.
1020 *
1021 * @returns true if a decision has been made.
1022 * @returns false if the default access policy should be applied.
1023 *
1024 * @param pObj The object in question.
1025 * @param pSession The session wanting to access the object.
1026 * @param pszObjName The object name, can be NULL.
1027 * @param prc Where to store the result when returning true.
1028 */
1029bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char *pszObjName, int *prc)
1030{
1031 NOREF(pObj);
1032 NOREF(pSession);
1033 NOREF(pszObjName);
1034 NOREF(prc);
1035 return false;
1036}
1037
1038/**
1039 * Callback for blah blah blah.
1040 */
1041IOReturn VBoxDrvDarwinSleepHandler(void * /* pvTarget */, void *pvRefCon, UInt32 uMessageType,
1042 IOService *pProvider, void *pvMsgArg, vm_size_t cbMsgArg)
1043{
1044 RT_NOREF(pProvider, pvMsgArg, cbMsgArg);
1045 LogFlow(("VBoxDrv: Got sleep/wake notice. Message type was %x\n", uMessageType));
1046
1047 if (uMessageType == kIOMessageSystemWillSleep)
1048 RTPowerSignalEvent(RTPOWEREVENT_SUSPEND);
1049 else if (uMessageType == kIOMessageSystemHasPoweredOn)
1050 RTPowerSignalEvent(RTPOWEREVENT_RESUME);
1051
1052 acknowledgeSleepWakeNotification(pvRefCon);
1053
1054 return 0;
1055}
1056
1057
1058#ifdef VBOX_WITH_HOST_VMX
1059/**
1060 * For cleaning up the mess we left behind on Yosemite with 4.3.28 and earlier.
1061 *
1062 * We ASSUME VT-x is supported by the CPU.
1063 *
1064 * @param idCpu Unused.
1065 * @param pvUser1 Unused.
1066 * @param pvUser2 Unused.
1067 */
1068static DECLCALLBACK(void) vboxdrvDarwinVmxEnableFix(RTCPUID idCpu, void *pvUser1, void *pvUser2)
1069{
1070 RT_NOREF(idCpu, pvUser1, pvUser2);
1071 RTCCUINTREG uCr4 = ASMGetCR4();
1072 if (!(uCr4 & X86_CR4_VMXE))
1073 {
1074 uCr4 |= X86_CR4_VMXE;
1075 ASMSetCR4(uCr4);
1076 }
1077}
1078#endif
1079
1080
1081/**
1082 * @copydoc SUPR0EnableVTx
1083 */
1084int VBOXCALL supdrvOSEnableVTx(bool fEnable)
1085{
1086#ifdef VBOX_WITH_HOST_VMX
1087 int rc;
1088 if ( version_major >= 10 /* 10 = 10.6.x = Snow Leopard */
1089# ifdef VBOX_WITH_RAW_MODE
1090 && g_pfnVmxSuspend
1091 && g_pfnVmxResume
1092 && g_pVmxUseCount
1093# endif
1094 )
1095 {
1096 IPRT_DARWIN_SAVE_EFL_AC();
1097 if (fEnable)
1098 {
1099 /*
1100 * We screwed up on Yosemite and didn't notice that we weren't
1101 * calling host_vmxon. CR4.VMXE may therefore have been disabled
1102 * by us. So, first time around we make sure it's set so we won't
1103 * crash in the pre-4.3.28/5.0RC1 upgrade scenario.
1104 * See @bugref{7907}.
1105 */
1106 static bool volatile g_fDoneCleanup = false;
1107 if (!g_fDoneCleanup)
1108 {
1109 if (version_major == 14 /* 14 = 10.10 = yosemite */)
1110 {
1111 uint32_t fCaps;
1112 rc = supdrvQueryVTCapsInternal(&fCaps);
1113 if (RT_SUCCESS(rc))
1114 {
1115 if (fCaps & SUPVTCAPS_VT_X)
1116 rc = RTMpOnAll(vboxdrvDarwinVmxEnableFix, NULL, NULL);
1117 else
1118 rc = VERR_VMX_NO_VMX;
1119 }
1120 if (RT_FAILURE(rc))
1121 {
1122 IPRT_DARWIN_RESTORE_EFL_AC();
1123 return rc;
1124 }
1125 }
1126 g_fDoneCleanup = true;
1127 }
1128
1129 /*
1130 * Call the kernel.
1131 */
1132 AssertLogRelMsg(!g_pVmxUseCount || *g_pVmxUseCount >= 0,
1133 ("vmx_use_count=%d (@ %p, expected it to be a positive number\n",
1134 *g_pVmxUseCount, g_pVmxUseCount));
1135
1136 rc = host_vmxon(false /* exclusive */);
1137 if (rc == VMX_OK)
1138 rc = VINF_SUCCESS;
1139 else if (rc == VMX_UNSUPPORTED)
1140 rc = VERR_VMX_NO_VMX;
1141 else if (rc == VMX_INUSE)
1142 rc = VERR_VMX_IN_VMX_ROOT_MODE;
1143 else /* shouldn't happen, but just in case. */
1144 {
1145 LogRel(("host_vmxon returned %d\n", rc));
1146 rc = VERR_UNRESOLVED_ERROR;
1147 }
1148 LogRel(("VBoxDrv: host_vmxon -> vmx_use_count=%d rc=%Rrc\n", *g_pVmxUseCount, rc));
1149 }
1150 else
1151 {
1152 AssertLogRelMsgReturn(!g_pVmxUseCount || *g_pVmxUseCount >= 1,
1153 ("vmx_use_count=%d (@ %p, expected it to be a non-zero positive number\n",
1154 *g_pVmxUseCount, g_pVmxUseCount),
1155 VERR_WRONG_ORDER);
1156 host_vmxoff();
1157 rc = VINF_SUCCESS;
1158 LogRel(("VBoxDrv: host_vmxoff -> vmx_use_count=%d\n", *g_pVmxUseCount));
1159 }
1160 IPRT_DARWIN_RESTORE_EFL_AC();
1161 }
1162 else
1163 {
1164 /* In 10.5.x the host_vmxon is severely broken! Don't use it, it will
1165 frequnetly panic the host. */
1166 rc = VERR_NOT_SUPPORTED;
1167 }
1168 return rc;
1169#else
1170 return VERR_NOT_SUPPORTED;
1171#endif
1172}
1173
1174
1175/**
1176 * @copydoc SUPR0SuspendVTxOnCpu
1177 */
1178bool VBOXCALL supdrvOSSuspendVTxOnCpu(void)
1179{
1180#ifdef VBOX_WITH_HOST_VMX
1181 /*
1182 * Consult the VMX usage counter, don't try suspend if not enabled.
1183 *
1184 * Note! The host_vmxon/off code is still race prone since, but this is
1185 * currently the best we can do without always enable VMX when
1186 * loading the driver.
1187 */
1188 if ( g_pVmxUseCount
1189 && *g_pVmxUseCount > 0)
1190 {
1191 IPRT_DARWIN_SAVE_EFL_AC();
1192 g_pfnVmxSuspend();
1193 IPRT_DARWIN_RESTORE_EFL_AC();
1194 return true;
1195 }
1196 return false;
1197#else
1198 return false;
1199#endif
1200}
1201
1202
1203/**
1204 * @copydoc SUPR0ResumeVTxOnCpu
1205 */
1206void VBOXCALL supdrvOSResumeVTxOnCpu(bool fSuspended)
1207{
1208#ifdef VBOX_WITH_HOST_VMX
1209 /*
1210 * Don't consult the counter here, the state knows better.
1211 * We're executing with interrupts disabled and anyone racing us with
1212 * disabling VT-x will be waiting in the rendezvous code.
1213 */
1214 if ( fSuspended
1215 && g_pfnVmxResume)
1216 {
1217 IPRT_DARWIN_SAVE_EFL_AC();
1218 g_pfnVmxResume();
1219 IPRT_DARWIN_RESTORE_EFL_AC();
1220 }
1221 else
1222 Assert(!fSuspended);
1223#else
1224 Assert(!fSuspended);
1225#endif
1226}
1227
1228
1229bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
1230{
1231 NOREF(pDevExt);
1232 return false;
1233}
1234
1235
1236bool VBOXCALL supdrvOSAreCpusOfflinedOnSuspend(void)
1237{
1238 /** @todo verify this. */
1239 return false;
1240}
1241
1242
1243bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
1244{
1245 return false;
1246}
1247
1248
1249#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1250
1251/**
1252 * @callback_method_impl{FNRTLDRIMPORT}
1253 */
1254static DECLCALLBACK(int) supdrvDarwinLdrOpenImportCallback(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol,
1255 unsigned uSymbol, PRTLDRADDR pValue, void *pvUser)
1256{
1257 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser;
1258
1259 /*
1260 * First consult the VMMR0 module if there is one fully loaded.
1261 * This is necessary as VMMR0 may overload assertion and logger symbols.
1262 */
1263 if (pDevExt->pvVMMR0)
1264 for (PSUPDRVLDRIMAGE pImage = pDevExt->pLdrImages; pImage; pImage = pImage->pNext)
1265 if (pImage->pvImage == pDevExt->pvVMMR0)
1266 {
1267 if ( pImage->uState == SUP_IOCTL_LDR_LOAD
1268 && pImage->hLdrMod != NIL_RTLDRMOD)
1269 {
1270 int rc = RTLdrGetSymbolEx(pImage->hLdrMod, pImage->pvImage, (uintptr_t)pImage->pvImage,
1271 UINT32_MAX, pszSymbol, pValue);
1272 if (RT_SUCCESS(rc))
1273 return VINF_SUCCESS;
1274 }
1275 break;
1276 }
1277
1278 /*
1279 * Then we consult the SUPDrv export table.
1280 */
1281 uintptr_t uValue = 0;
1282 int rc = supdrvLdrGetExportedSymbol(pszSymbol, &uValue);
1283 if (RT_SUCCESS(rc))
1284 {
1285 *pValue = uValue;
1286 return VINF_SUCCESS;
1287 }
1288
1289 /*
1290 * Failed.
1291 */
1292 printf("VBoxDrv: Unable to resolve symbol '%s'.\n", pszSymbol);
1293 RT_NOREF(hLdrMod, pszModule, uSymbol);
1294 return VERR_SYMBOL_NOT_FOUND;
1295}
1296
1297
1298/**
1299 * @callback_method_impl{FNRTCRPKCS7VERIFYCERTCALLBACK,
1300 * Verify that the signing certificate is sane.}
1301 */
1302static DECLCALLBACK(int) supdrvDarwinLdrOpenVerifyCertificatCallback(PCRTCRX509CERTIFICATE pCert, RTCRX509CERTPATHS hCertPaths,
1303 uint32_t fFlags, void *pvUser, PRTERRINFO pErrInfo)
1304{
1305 RT_NOREF(pvUser); //PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser;
1306# ifdef DEBUG_bird
1307 printf("supdrvDarwinLdrOpenVerifyCertificatCallback: pCert=%p hCertPaths=%p\n", (void *)pCert, (void *)hCertPaths);
1308# endif
1309
1310# if 0
1311 /*
1312 * Test signing certificates normally doesn't have all the necessary
1313 * features required below. So, treat them as special cases.
1314 */
1315 if ( hCertPaths == NIL_RTCRX509CERTPATHS
1316 && RTCrX509Name_Compare(&pCert->TbsCertificate.Issuer, &pCert->TbsCertificate.Subject) == 0)
1317 {
1318 RTMsgInfo("Test signed.\n");
1319 return VINF_SUCCESS;
1320 }
1321# endif
1322
1323 /*
1324 * Standard code signing capabilites required.
1325 */
1326 int rc = RTCrPkcs7VerifyCertCallbackCodeSigning(pCert, hCertPaths, fFlags, NULL, pErrInfo);
1327 if ( RT_SUCCESS(rc)
1328 && (fFlags & RTCRPKCS7VCC_F_SIGNED_DATA))
1329 {
1330 uint32_t cDevIdApp = 0;
1331 uint32_t cDevIdKext = 0;
1332 uint32_t cDevIdMacDev = 0;
1333 for (uint32_t i = 0; i < pCert->TbsCertificate.T3.Extensions.cItems; i++)
1334 {
1335 PCRTCRX509EXTENSION pExt = pCert->TbsCertificate.T3.Extensions.papItems[i];
1336 if (RTAsn1ObjId_CompareWithString(&pExt->ExtnId, RTCR_APPLE_CS_DEVID_APPLICATION_OID) == 0)
1337 {
1338 cDevIdApp++;
1339 if (!pExt->Critical.fValue)
1340 rc = RTErrInfoSetF(pErrInfo, VERR_GENERAL_FAILURE,
1341 "Dev ID Application certificate extension is not flagged critical");
1342 }
1343 else if (RTAsn1ObjId_CompareWithString(&pExt->ExtnId, RTCR_APPLE_CS_DEVID_KEXT_OID) == 0)
1344 {
1345 cDevIdKext++;
1346 if (!pExt->Critical.fValue)
1347 rc = RTErrInfoSetF(pErrInfo, VERR_GENERAL_FAILURE,
1348 "Dev ID kext certificate extension is not flagged critical");
1349 }
1350 else if (RTAsn1ObjId_CompareWithString(&pExt->ExtnId, RTCR_APPLE_CS_DEVID_MAC_SW_DEV_OID) == 0)
1351 {
1352 cDevIdMacDev++;
1353 if (!pExt->Critical.fValue)
1354 rc = RTErrInfoSetF(pErrInfo, VERR_GENERAL_FAILURE,
1355 "Dev ID MAC SW dev certificate extension is not flagged critical");
1356 }
1357 }
1358# ifdef VBOX_WITH_DARWIN_R0_TEST_SIGN
1359 /*
1360 * Mac application software development certs do not have the usually required extensions.
1361 */
1362 if (cDevIdMacDev)
1363 {
1364 cDevIdApp++;
1365 cDevIdKext++;
1366 }
1367# endif
1368 if (cDevIdApp == 0)
1369 rc = RTErrInfoSetF(pErrInfo, VERR_GENERAL_FAILURE,
1370 "Certificate is missing the 'Dev ID Application' extension");
1371 if (cDevIdKext == 0)
1372 rc = RTErrInfoSetF(pErrInfo, VERR_GENERAL_FAILURE,
1373 "Certificate is missing the 'Dev ID kext' extension");
1374 }
1375
1376 return rc;
1377}
1378
1379
1380/**
1381 * @callback_method_impl{FNRTLDRVALIDATESIGNEDDATA}
1382 */
1383static DECLCALLBACK(int) supdrvDarwinLdrOpenVerifyCallback(RTLDRMOD hLdrMod, PCRTLDRSIGNATUREINFO pInfo,
1384 PRTERRINFO pErrInfo, void *pvUser)
1385{
1386 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser;
1387 RT_NOREF_PV(hLdrMod);
1388
1389 switch (pInfo->enmType)
1390 {
1391 case RTLDRSIGNATURETYPE_PKCS7_SIGNED_DATA:
1392 if (pInfo->pvExternalData)
1393 {
1394 PCRTCRPKCS7CONTENTINFO pContentInfo = (PCRTCRPKCS7CONTENTINFO)pInfo->pvSignature;
1395 RTTIMESPEC ValidationTime;
1396 RTTimeNow(&ValidationTime);
1397
1398 return RTCrPkcs7VerifySignedDataWithExternalData(pContentInfo,
1399 RTCRPKCS7VERIFY_SD_F_COUNTER_SIGNATURE_SIGNING_TIME_ONLY
1400 | RTCRPKCS7VERIFY_SD_F_ALWAYS_USE_SIGNING_TIME_IF_PRESENT
1401 | RTCRPKCS7VERIFY_SD_F_ALWAYS_USE_MS_TIMESTAMP_IF_PRESENT,
1402 pDevExt->hAdditionalStore, pDevExt->hRootStore, &ValidationTime,
1403 supdrvDarwinLdrOpenVerifyCertificatCallback, pDevExt,
1404 pInfo->pvExternalData, pInfo->cbExternalData, pErrInfo);
1405 }
1406 return RTErrInfoSetF(pErrInfo, VERR_NOT_SUPPORTED, "Expected external data with signature!");
1407
1408 default:
1409 return RTErrInfoSetF(pErrInfo, VERR_NOT_SUPPORTED, "Unsupported signature type: %d", pInfo->enmType);
1410 }
1411}
1412
1413#endif /* VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION */
1414
1415int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
1416{
1417#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1418 /*
1419 * Initialize our members.
1420 */
1421 pImage->hLdrMod = NIL_RTLDRMOD;
1422 pImage->hMemAlloc = NIL_RTR0MEMOBJ;
1423
1424 /*
1425 * We have to double buffer the file to be avoid a potential race between
1426 * validation and actual image loading. This could be eliminated later by
1427 * baking the image validation into the RTLdrGetBits operation.
1428 *
1429 * Note! After calling RTLdrOpenInMemory, pvFile is owned by the loader and will be
1430 * freed via the RTFileReadAllFree callback when the loader module is closed.
1431 */
1432 void *pvFile = NULL;
1433 size_t cbFile = 0;
1434 int rc = RTFileReadAllEx(pszFilename, 0, _32M, RTFILE_RDALL_O_DENY_WRITE, &pvFile, &cbFile);
1435 if (RT_SUCCESS(rc))
1436 {
1437 PRTERRINFOSTATIC pErrInfo = (PRTERRINFOSTATIC)RTMemTmpAlloc(sizeof(RTERRINFOSTATIC));
1438 RTLDRMOD hLdrMod = NIL_RTLDRMOD;
1439 rc = RTLdrOpenInMemory(pszFilename, 0 /*fFlags*/, RTLDRARCH_HOST, cbFile,
1440 NULL /*pfnRead*/, RTFileReadAllFree, pvFile,
1441 &hLdrMod, pErrInfo ? RTErrInfoInitStatic(pErrInfo) : NULL);
1442 if (RT_SUCCESS(rc))
1443 {
1444 /*
1445 * Validate the image.
1446 */
1447 rc = RTLdrVerifySignature(hLdrMod, supdrvDarwinLdrOpenVerifyCallback, pDevExt,
1448 pErrInfo ? RTErrInfoInitStatic(pErrInfo) : NULL);
1449 if (RT_SUCCESS(rc))
1450 {
1451 /*
1452 * Allocate memory for the object and load it into it.
1453 */
1454 size_t cbImage = RTLdrSize(hLdrMod);
1455 if (cbImage == pImage->cbImageBits)
1456 {
1457 RTR0MEMOBJ hMemAlloc;
1458 rc = RTR0MemObjAllocPage(&hMemAlloc, cbImage, true /*fExecutable*/);
1459 if (RT_SUCCESS(rc))
1460 {
1461 void *pvImageBits = RTR0MemObjAddress(hMemAlloc);
1462 rc = RTLdrGetBits(hLdrMod, pvImageBits, (uintptr_t)pvImageBits,
1463 supdrvDarwinLdrOpenImportCallback, pDevExt);
1464 if (RT_SUCCESS(rc))
1465 {
1466 /*
1467 * Commit.
1468 */
1469 pImage->hMemAlloc = hMemAlloc;
1470 pImage->hLdrMod = hLdrMod;
1471 pImage->pvImage = pvImageBits;
1472 RTMemTmpFree(pErrInfo);
1473 /** @todo Call RTLdrDone. */
1474 kprintf("VBoxDrv: Loaded %s at %p\n", pImage->szName, pvImageBits);
1475 return VINF_SUCCESS;
1476 }
1477
1478 RTR0MemObjFree(hMemAlloc, true /*fFreeMappings*/);
1479 }
1480 else
1481 printf("VBoxDrv: Failed to allocate %u bytes for %s: %d\n", (unsigned)cbImage, pszFilename, rc);
1482 }
1483 else
1484 {
1485 printf("VBoxDrv: Image size mismatch for %s: %#x, ring-3 says %#x\n",
1486 pszFilename, (unsigned)cbImage, (unsigned)pImage->cbImageBits);
1487 rc = VERR_LDR_MISMATCH_NATIVE;
1488 }
1489 }
1490 else if (pErrInfo && RTErrInfoIsSet(&pErrInfo->Core))
1491 printf("VBoxDrv: RTLdrVerifySignature(%s) failed: %d - %s\n", pszFilename, rc, pErrInfo->Core.pszMsg);
1492 else
1493 printf("VBoxDrv: RTLdrVerifySignature(%s) failed: %d\n", pszFilename, rc);
1494 RTLdrClose(hLdrMod);
1495 }
1496 else if (pErrInfo && RTErrInfoIsSet(&pErrInfo->Core))
1497 printf("VBoxDrv: RTLdrOpenInMemory(%s) failed: %d - %s\n", pszFilename, rc, pErrInfo->Core.pszMsg);
1498 else
1499 printf("VBoxDrv: RTLdrOpenInMemory(%s) failed: %d\n", pszFilename, rc);
1500 RTMemTmpFree(pErrInfo);
1501 }
1502 return rc;
1503#else /* !VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION */
1504 NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
1505 return VERR_NOT_SUPPORTED;
1506#endif /* !VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION */
1507}
1508
1509
1510#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1511/**
1512 * @callback_method_impl{FNRTLDRENUMSYMS,
1513 * Worker for supdrvOSLdrValidatePointer.
1514 */
1515static DECLCALLBACK(int) supdrvDarwinLdrValidatePointerCallback(RTLDRMOD hLdrMod, const char *pszSymbol, unsigned uSymbol,
1516 RTLDRADDR Value, void *pvUser)
1517{
1518 RT_NOREF(hLdrMod, pszSymbol, uSymbol);
1519 if (Value == (uintptr_t)pvUser)
1520 return VINF_CALLBACK_RETURN;
1521 return VINF_SUCCESS;
1522}
1523#endif
1524
1525
1526int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv,
1527 const uint8_t *pbImageBits, const char *pszSymbol)
1528{
1529#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1530 AssertReturn(pImage->hLdrMod != NIL_RTLDRMOD, VERR_INVALID_STATE);
1531
1532 /*
1533 * If we've got a symbol name, just to a lookup and compare addresses.
1534 */
1535 int rc;
1536 if (RT_C_IS_UPPER(*pszSymbol))
1537 {
1538 RTLDRADDR uValueFound;
1539 rc = RTLdrGetSymbolEx(pImage->hLdrMod, pImage->pvImage, (uintptr_t)pImage->pvImage, UINT32_MAX, pszSymbol, &uValueFound);
1540 if (RT_SUCCESS(rc))
1541 {
1542 if (uValueFound == (uintptr_t)pv)
1543 rc = VINF_SUCCESS;
1544 else
1545 {
1546 SUPR0Printf("SUPDrv: Different exports found for %s in %s: %RTptr, expected %p\n",
1547 pszSymbol, pImage->szName, (RTUINTPTR)uValueFound, pv);
1548 rc = VERR_LDR_BAD_FIXUP;
1549 }
1550 }
1551 else
1552 SUPR0Printf("SUPDrv: No export named %s (%p) in %s!\n", pszSymbol, pv, pImage->szName);
1553 }
1554 /*
1555 * Otherwise do a symbol enumeration and look for the entrypoint.
1556 */
1557 else
1558 {
1559 rc = RTLdrEnumSymbols(pImage->hLdrMod, 0 /*fFlags*/, pImage->pvImage, (uintptr_t)pImage->pvImage,
1560 supdrvDarwinLdrValidatePointerCallback, pv);
1561 if (rc == VINF_CALLBACK_RETURN)
1562 rc = VINF_SUCCESS;
1563 else if (RT_SUCCESS(rc))
1564 {
1565 SUPR0Printf("SUPDrv: No export with address %p (%s) in %s!\n", pv, pszSymbol, pImage->szName);
1566 rc = VERR_NOT_FOUND;
1567 }
1568 else
1569 SUPR0Printf("SUPDrv: RTLdrEnumSymbols failed on %s: %Rrc\n", pImage->szName, rc);
1570 }
1571 RT_NOREF(pDevExt, pbImageBits);
1572 return rc;
1573#else
1574 NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits); NOREF(pszSymbol);
1575 return VERR_NOT_SUPPORTED;
1576#endif
1577}
1578
1579
1580int VBOXCALL supdrvOSLdrQuerySymbol(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage,
1581 const char *pszSymbol, size_t cchSymbol, void **ppvSymbol)
1582{
1583#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1584 /*
1585 * Just hand the problem to RTLdrGetSymbolEx.
1586 */
1587 RTLDRADDR uValueFound;
1588 int rc = RTLdrGetSymbolEx(pImage->hLdrMod, pImage->pvImage, (uintptr_t)pImage->pvImage, UINT32_MAX, pszSymbol, &uValueFound);
1589 if (RT_SUCCESS(rc))
1590 {
1591 *ppvSymbol = (void *)(uintptr_t)uValueFound;
1592 return VINF_SUCCESS;
1593 }
1594 RT_NOREF(pDevExt, cchSymbol);
1595 return rc;
1596
1597#else
1598 RT_NOREF(pDevExt, pImage, pszSymbol, cchSymbol, ppvSymbol);
1599 return VERR_WRONG_ORDER;
1600#endif
1601}
1602
1603
1604int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
1605{
1606#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1607 /* State paranoia. */
1608 AssertReturn(pImage->hLdrMod != NIL_RTLDRMOD, VERR_INVALID_STATE);
1609 AssertReturn(pImage->hMemAlloc != NIL_RTR0MEMOBJ, VERR_INVALID_STATE);
1610 AssertReturn(pImage->pvImage, VERR_INVALID_STATE);
1611
1612 /*
1613 * We should get an identical match with ring-3 here, so the code here is
1614 * trivial in comparision to SUPDrv-win.cpp.
1615 */
1616 if (!memcmp(pImage->pvImage, pbImageBits, pImage->cbImageBits))
1617 return VINF_SUCCESS;
1618
1619 /*
1620 * Try show what when wrong (code is copied from supdrvNtCompare).
1621 */
1622 uint32_t cbLeft = pImage->cbImageBits;
1623 const uint8_t *pbNativeBits = (const uint8_t *)pImage->pvImage;
1624 for (size_t off = 0; cbLeft > 0; off++, cbLeft--)
1625 if (pbNativeBits[off] != pbImageBits[off])
1626 {
1627 /* Note! We need to copy image bits into a temporary stack buffer here as we'd
1628 otherwise risk overwriting them while formatting the error message. */
1629 uint8_t abBytes[64];
1630 memcpy(abBytes, &pbImageBits[off], RT_MIN(64, cbLeft));
1631 supdrvLdrLoadError(VERR_LDR_MISMATCH_NATIVE, pReq,
1632 "Mismatch at %#x (%p) of %s loaded at %p:\n"
1633 "ring-0: %.*Rhxs\n"
1634 "ring-3: %.*Rhxs",
1635 off, &pbNativeBits[off], pImage->szName, pImage->pvImage,
1636 RT_MIN(64, cbLeft), &pbNativeBits[off],
1637 RT_MIN(64, cbLeft), &abBytes[0]);
1638 printf("SUPDrv: %s\n", pReq->u.Out.szError);
1639 break;
1640 }
1641
1642 RT_NOREF(pDevExt);
1643 return VERR_LDR_MISMATCH_NATIVE;
1644
1645#else
1646 NOREF(pDevExt); NOREF(pImage); NOREF(pbImageBits); NOREF(pReq);
1647 return VERR_NOT_SUPPORTED;
1648#endif
1649}
1650
1651
1652void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1653{
1654#ifdef VBOX_WITH_DARWIN_R0_DARWIN_IMAGE_VERIFICATION
1655 if (pImage->hLdrMod != NIL_RTLDRMOD)
1656 {
1657 int rc = RTLdrClose(pImage->hLdrMod);
1658 AssertRC(rc);
1659 pImage->hLdrMod = NIL_RTLDRMOD;
1660 }
1661 if (pImage->hMemAlloc != NIL_RTR0MEMOBJ)
1662 {
1663 RTR0MemObjFree(pImage->hMemAlloc, true /*fFreeMappings*/);
1664 pImage->hMemAlloc = NIL_RTR0MEMOBJ;
1665 }
1666 NOREF(pDevExt);
1667#else
1668 NOREF(pDevExt); NOREF(pImage);
1669#endif
1670}
1671
1672
1673void VBOXCALL supdrvOSLdrNotifyLoaded(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1674{
1675 NOREF(pDevExt); NOREF(pImage);
1676}
1677
1678
1679void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
1680{
1681#if 1
1682 NOREF(pDevExt); NOREF(pImage); NOREF(pszFilename);
1683#else
1684 /*
1685 * Try store the image load address in NVRAM so we can retrived it on panic.
1686 * Note! This only works if you're root! - Acutally, it doesn't work at all at the moment. FIXME!
1687 */
1688 IORegistryEntry *pEntry = IORegistryEntry::fromPath("/options", gIODTPlane);
1689 if (pEntry)
1690 {
1691 char szVar[80];
1692 RTStrPrintf(szVar, sizeof(szVar), "vboximage"/*-%s*/, pImage->szName);
1693 char szValue[48];
1694 RTStrPrintf(szValue, sizeof(szValue), "%#llx,%#llx", (uint64_t)(uintptr_t)pImage->pvImage,
1695 (uint64_t)(uintptr_t)pImage->pvImage + pImage->cbImageBits - 1);
1696 bool fRc = pEntry->setProperty(szVar, szValue); NOREF(fRc);
1697 pEntry->release();
1698 SUPR0Printf("fRc=%d '%s'='%s'\n", fRc, szVar, szValue);
1699 }
1700 /*else
1701 SUPR0Printf("failed to find /options in gIODTPlane\n");*/
1702#endif
1703}
1704
1705
1706void VBOXCALL supdrvOSLdrNotifyUnloaded(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1707{
1708 NOREF(pDevExt); NOREF(pImage);
1709}
1710
1711
1712void VBOXCALL supdrvOSLdrRetainWrapperModule(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1713{
1714 RT_NOREF(pDevExt, pImage);
1715 AssertFailed();
1716}
1717
1718
1719void VBOXCALL supdrvOSLdrReleaseWrapperModule(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1720{
1721 RT_NOREF(pDevExt, pImage);
1722 AssertFailed();
1723}
1724
1725
1726#ifdef SUPDRV_WITH_MSR_PROBER
1727
1728typedef struct SUPDRVDARWINMSRARGS
1729{
1730 RTUINT64U uValue;
1731 uint32_t uMsr;
1732 int rc;
1733} SUPDRVDARWINMSRARGS, *PSUPDRVDARWINMSRARGS;
1734
1735/**
1736 * On CPU worker for supdrvOSMsrProberRead.
1737 *
1738 * @param idCpu Ignored.
1739 * @param pvUser1 Pointer to a SUPDRVDARWINMSRARGS.
1740 * @param pvUser2 Ignored.
1741 */
1742static DECLCALLBACK(void) supdrvDarwinMsrProberReadOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
1743{
1744 PSUPDRVDARWINMSRARGS pArgs = (PSUPDRVDARWINMSRARGS)pvUser1;
1745 if (g_pfnRdMsr64Carefully)
1746 pArgs->rc = g_pfnRdMsr64Carefully(pArgs->uMsr, &pArgs->uValue.u);
1747 else if (g_pfnRdMsrCarefully)
1748 pArgs->rc = g_pfnRdMsrCarefully(pArgs->uMsr, &pArgs->uValue.s.Lo, &pArgs->uValue.s.Hi);
1749 else
1750 pArgs->rc = 2;
1751 NOREF(idCpu); NOREF(pvUser2);
1752}
1753
1754
1755int VBOXCALL supdrvOSMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue)
1756{
1757 if (!g_pfnRdMsr64Carefully && !g_pfnRdMsrCarefully)
1758 return VERR_NOT_SUPPORTED;
1759
1760 SUPDRVDARWINMSRARGS Args;
1761 Args.uMsr = uMsr;
1762 Args.uValue.u = 0;
1763 Args.rc = -1;
1764
1765 if (idCpu == NIL_RTCPUID)
1766 {
1767 IPRT_DARWIN_SAVE_EFL_AC();
1768 supdrvDarwinMsrProberReadOnCpu(idCpu, &Args, NULL);
1769 IPRT_DARWIN_RESTORE_EFL_AC();
1770 }
1771 else
1772 {
1773 int rc = RTMpOnSpecific(idCpu, supdrvDarwinMsrProberReadOnCpu, &Args, NULL);
1774 if (RT_FAILURE(rc))
1775 return rc;
1776 }
1777
1778 if (Args.rc)
1779 return VERR_ACCESS_DENIED;
1780 *puValue = Args.uValue.u;
1781 return VINF_SUCCESS;
1782}
1783
1784
1785/**
1786 * On CPU worker for supdrvOSMsrProberWrite.
1787 *
1788 * @param idCpu Ignored.
1789 * @param pvUser1 Pointer to a SUPDRVDARWINMSRARGS.
1790 * @param pvUser2 Ignored.
1791 */
1792static DECLCALLBACK(void) supdrvDarwinMsrProberWriteOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
1793{
1794 PSUPDRVDARWINMSRARGS pArgs = (PSUPDRVDARWINMSRARGS)pvUser1;
1795 if (g_pfnWrMsr64Carefully)
1796 pArgs->rc = g_pfnWrMsr64Carefully(pArgs->uMsr, pArgs->uValue.u);
1797 else
1798 pArgs->rc = 2;
1799 NOREF(idCpu); NOREF(pvUser2);
1800}
1801
1802
1803int VBOXCALL supdrvOSMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue)
1804{
1805 if (!g_pfnWrMsr64Carefully)
1806 return VERR_NOT_SUPPORTED;
1807
1808 SUPDRVDARWINMSRARGS Args;
1809 Args.uMsr = uMsr;
1810 Args.uValue.u = uValue;
1811 Args.rc = -1;
1812
1813 if (idCpu == NIL_RTCPUID)
1814 {
1815 IPRT_DARWIN_SAVE_EFL_AC();
1816 supdrvDarwinMsrProberWriteOnCpu(idCpu, &Args, NULL);
1817 IPRT_DARWIN_RESTORE_EFL_AC();
1818 }
1819 else
1820 {
1821 int rc = RTMpOnSpecific(idCpu, supdrvDarwinMsrProberWriteOnCpu, &Args, NULL);
1822 if (RT_FAILURE(rc))
1823 return rc;
1824 }
1825
1826 if (Args.rc)
1827 return VERR_ACCESS_DENIED;
1828 return VINF_SUCCESS;
1829}
1830
1831
1832/**
1833 * Worker for supdrvOSMsrProberModify.
1834 */
1835static DECLCALLBACK(void) supdrvDarwinMsrProberModifyOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
1836{
1837 RT_NOREF(idCpu, pvUser2);
1838 PSUPMSRPROBER pReq = (PSUPMSRPROBER)pvUser1;
1839 register uint32_t uMsr = pReq->u.In.uMsr;
1840 bool const fFaster = pReq->u.In.enmOp == SUPMSRPROBEROP_MODIFY_FASTER;
1841 uint64_t uBefore;
1842 uint64_t uWritten;
1843 uint64_t uAfter;
1844 int rcBefore, rcWrite, rcAfter, rcRestore;
1845 RTCCUINTREG fOldFlags;
1846
1847 /* Initialize result variables. */
1848 uBefore = uWritten = uAfter = 0;
1849 rcWrite = rcAfter = rcRestore = -1;
1850
1851 /*
1852 * Do the job.
1853 */
1854 fOldFlags = ASMIntDisableFlags();
1855 ASMCompilerBarrier(); /* paranoia */
1856 if (!fFaster)
1857 ASMWriteBackAndInvalidateCaches();
1858
1859 rcBefore = g_pfnRdMsr64Carefully(uMsr, &uBefore);
1860 if (rcBefore >= 0)
1861 {
1862 register uint64_t uRestore = uBefore;
1863 uWritten = uRestore;
1864 uWritten &= pReq->u.In.uArgs.Modify.fAndMask;
1865 uWritten |= pReq->u.In.uArgs.Modify.fOrMask;
1866
1867 rcWrite = g_pfnWrMsr64Carefully(uMsr, uWritten);
1868 rcAfter = g_pfnRdMsr64Carefully(uMsr, &uAfter);
1869 rcRestore = g_pfnWrMsr64Carefully(uMsr, uRestore);
1870
1871 if (!fFaster)
1872 {
1873 ASMWriteBackAndInvalidateCaches();
1874 ASMReloadCR3();
1875 ASMNopPause();
1876 }
1877 }
1878
1879 ASMCompilerBarrier(); /* paranoia */
1880 ASMSetFlags(fOldFlags);
1881
1882 /*
1883 * Write out the results.
1884 */
1885 pReq->u.Out.uResults.Modify.uBefore = uBefore;
1886 pReq->u.Out.uResults.Modify.uWritten = uWritten;
1887 pReq->u.Out.uResults.Modify.uAfter = uAfter;
1888 pReq->u.Out.uResults.Modify.fBeforeGp = rcBefore != 0;
1889 pReq->u.Out.uResults.Modify.fModifyGp = rcWrite != 0;
1890 pReq->u.Out.uResults.Modify.fAfterGp = rcAfter != 0;
1891 pReq->u.Out.uResults.Modify.fRestoreGp = rcRestore != 0;
1892 RT_ZERO(pReq->u.Out.uResults.Modify.afReserved);
1893}
1894
1895
1896int VBOXCALL supdrvOSMsrProberModify(RTCPUID idCpu, PSUPMSRPROBER pReq)
1897{
1898 if (!g_pfnWrMsr64Carefully || !g_pfnRdMsr64Carefully)
1899 return VERR_NOT_SUPPORTED;
1900 if (idCpu == NIL_RTCPUID)
1901 {
1902 IPRT_DARWIN_SAVE_EFL_AC();
1903 supdrvDarwinMsrProberModifyOnCpu(idCpu, pReq, NULL);
1904 IPRT_DARWIN_RESTORE_EFL_AC();
1905 return VINF_SUCCESS;
1906 }
1907 return RTMpOnSpecific(idCpu, supdrvDarwinMsrProberModifyOnCpu, pReq, NULL);
1908}
1909
1910#endif /* SUPDRV_WITH_MSR_PROBER */
1911
1912/**
1913 * Resume Bluetooth keyboard.
1914 * If there is no Bluetooth keyboard device connected to the system we just ignore this.
1915 */
1916static void supdrvDarwinResumeBluetoothKbd(void)
1917{
1918 OSDictionary *pDictionary = IOService::serviceMatching("AppleBluetoothHIDKeyboard");
1919 if (pDictionary)
1920 {
1921 OSIterator *pIter;
1922 IOBluetoothHIDDriver *pDriver;
1923
1924 pIter = IOService::getMatchingServices(pDictionary);
1925 if (pIter)
1926 {
1927 while ((pDriver = (IOBluetoothHIDDriver *)pIter->getNextObject()))
1928 if (pDriver->isKeyboard())
1929 (void)pDriver->hidControl(IOBTHID_CONTROL_EXIT_SUSPEND);
1930
1931 pIter->release();
1932 }
1933 pDictionary->release();
1934 }
1935}
1936
1937/**
1938 * Resume built-in keyboard on MacBook Air and Pro hosts.
1939 * If there is no built-in keyboard device attached to the system we just ignore this.
1940 */
1941static void supdrvDarwinResumeBuiltinKbd(void)
1942{
1943 /** @todo macbook pro 16 w/ 10.15.5 as the "Apple Internal Keyboard /
1944 * Trackpad" hooked up to "HID Relay" / "AppleUserUSBHostHIDDevice"
1945 * and "AppleUserUSBHostHIDDevice" among other things, but not
1946 * "AppleUSBTCKeyboard". This change is probably older than 10.15,
1947 * given that IOUSBHIDDriver not is present in the 10.11 SDK. */
1948#if MAC_OS_X_VERSION_MIN_REQUIRED < 101100
1949 /*
1950 * AppleUSBTCKeyboard KEXT is responsible for built-in keyboard management.
1951 * We resume keyboard by accessing to its IOService.
1952 */
1953 OSDictionary *pDictionary = IOService::serviceMatching("AppleUSBTCKeyboard");
1954 if (pDictionary)
1955 {
1956 OSIterator *pIter;
1957 IOUSBHIDDriver *pDriver;
1958
1959 pIter = IOService::getMatchingServices(pDictionary);
1960 if (pIter)
1961 {
1962 while ((pDriver = (IOUSBHIDDriver *)pIter->getNextObject()))
1963 if (pDriver->IsPortSuspended())
1964 pDriver->SuspendPort(false, 0);
1965
1966 pIter->release();
1967 }
1968 pDictionary->release();
1969 }
1970#endif
1971}
1972
1973
1974/**
1975 * Resume suspended keyboard devices (if any).
1976 */
1977int VBOXCALL supdrvDarwinResumeSuspendedKbds(void)
1978{
1979 IPRT_DARWIN_SAVE_EFL_AC();
1980 supdrvDarwinResumeBuiltinKbd();
1981 supdrvDarwinResumeBluetoothKbd();
1982 IPRT_DARWIN_RESTORE_EFL_AC();
1983 return 0;
1984}
1985
1986
1987/**
1988 * Converts an IPRT error code to a darwin error code.
1989 *
1990 * @returns corresponding darwin error code.
1991 * @param rc IPRT status code.
1992 */
1993static int VBoxDrvDarwinErr2DarwinErr(int rc)
1994{
1995 switch (rc)
1996 {
1997 case VINF_SUCCESS: return 0;
1998 case VERR_GENERAL_FAILURE: return EACCES;
1999 case VERR_INVALID_PARAMETER: return EINVAL;
2000 case VERR_INVALID_MAGIC: return EILSEQ;
2001 case VERR_INVALID_HANDLE: return ENXIO;
2002 case VERR_INVALID_POINTER: return EFAULT;
2003 case VERR_LOCK_FAILED: return ENOLCK;
2004 case VERR_ALREADY_LOADED: return EEXIST;
2005 case VERR_PERMISSION_DENIED: return EPERM;
2006 case VERR_VERSION_MISMATCH: return ENOSYS;
2007 }
2008
2009 return EPERM;
2010}
2011
2012
2013/**
2014 * Check if the CPU has SMAP support.
2015 */
2016static bool vboxdrvDarwinCpuHasSMAP(void)
2017{
2018 uint32_t uMaxId, uEAX, uEBX, uECX, uEDX;
2019 ASMCpuId(0, &uMaxId, &uEBX, &uECX, &uEDX);
2020 if ( RTX86IsValidStdRange(uMaxId)
2021 && uMaxId >= 0x00000007)
2022 {
2023 ASMCpuId_Idx_ECX(0x00000007, 0, &uEAX, &uEBX, &uECX, &uEDX);
2024 if (uEBX & X86_CPUID_STEXT_FEATURE_EBX_SMAP)
2025 return true;
2026 }
2027#ifdef VBOX_WITH_EFLAGS_AC_SET_IN_VBOXDRV
2028 return true;
2029#else
2030 return false;
2031#endif
2032}
2033
2034
2035RTDECL(int) SUPR0PrintfV(const char *pszFormat, va_list va)
2036{
2037 IPRT_DARWIN_SAVE_EFL_AC();
2038
2039 char szMsg[512];
2040 RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
2041 szMsg[sizeof(szMsg) - 1] = '\0';
2042
2043 printf("%s", szMsg);
2044 kprintf("%s", szMsg);
2045
2046 IPRT_DARWIN_RESTORE_EFL_AC();
2047 return 0;
2048}
2049
2050
2051SUPR0DECL(uint32_t) SUPR0GetKernelFeatures(void)
2052{
2053 return g_fKernelFeatures;
2054}
2055
2056
2057SUPR0DECL(bool) SUPR0FpuBegin(bool fCtxHook)
2058{
2059 RT_NOREF(fCtxHook);
2060 return false;
2061}
2062
2063
2064SUPR0DECL(void) SUPR0FpuEnd(bool fCtxHook)
2065{
2066 RT_NOREF(fCtxHook);
2067}
2068
2069/*
2070 *
2071 * org_virtualbox_SupDrv
2072 *
2073 * - IOService diff resync -
2074 * - IOService diff resync -
2075 * - IOService diff resync -
2076 *
2077 */
2078
2079
2080/**
2081 * Initialize the object.
2082 */
2083bool org_virtualbox_SupDrv::init(OSDictionary *pDictionary)
2084{
2085 LogFlow(("IOService::init([%p], %p)\n", this, pDictionary));
2086 if (IOService::init(pDictionary))
2087 {
2088 /* init members. */
2089 return true;
2090 }
2091 return false;
2092}
2093
2094
2095/**
2096 * Free the object.
2097 */
2098void org_virtualbox_SupDrv::free(void)
2099{
2100 LogFlow(("IOService::free([%p])\n", this));
2101 IOService::free();
2102}
2103
2104
2105/**
2106 * Check if it's ok to start this service.
2107 * It's always ok by us, so it's up to IOService to decide really.
2108 */
2109IOService *org_virtualbox_SupDrv::probe(IOService *pProvider, SInt32 *pi32Score)
2110{
2111 LogFlow(("IOService::probe([%p])\n", this));
2112 return IOService::probe(pProvider, pi32Score);
2113}
2114
2115
2116/**
2117 * Start this service.
2118 */
2119bool org_virtualbox_SupDrv::start(IOService *pProvider)
2120{
2121 LogFlow(("org_virtualbox_SupDrv::start([%p])\n", this));
2122
2123 if (IOService::start(pProvider))
2124 {
2125 /* register the service. */
2126 registerService();
2127 return true;
2128 }
2129 return false;
2130}
2131
2132
2133/**
2134 * Stop this service.
2135 */
2136void org_virtualbox_SupDrv::stop(IOService *pProvider)
2137{
2138 LogFlow(("org_virtualbox_SupDrv::stop([%p], %p)\n", this, pProvider));
2139 IOService::stop(pProvider);
2140}
2141
2142
2143/**
2144 * Termination request.
2145 *
2146 * @return true if we're ok with shutting down now, false if we're not.
2147 * @param fOptions Flags.
2148 */
2149bool org_virtualbox_SupDrv::terminate(IOOptionBits fOptions)
2150{
2151 bool fRc;
2152 LogFlow(("org_virtualbox_SupDrv::terminate: reference_count=%d g_cSessions=%d (fOptions=%#x)\n",
2153 KMOD_INFO_NAME.reference_count, ASMAtomicUoReadS32(&g_cSessions), fOptions));
2154 if ( KMOD_INFO_NAME.reference_count != 0
2155 || ASMAtomicUoReadS32(&g_cSessions))
2156 fRc = false;
2157 else
2158 fRc = IOService::terminate(fOptions);
2159 LogFlow(("org_virtualbox_SupDrv::terminate: returns %d\n", fRc));
2160 return fRc;
2161}
2162
2163
2164/*
2165 *
2166 * org_virtualbox_SupDrvClient
2167 *
2168 */
2169
2170
2171/**
2172 * Initializer called when the client opens the service.
2173 */
2174bool org_virtualbox_SupDrvClient::initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type)
2175{
2176 LogFlow(("org_virtualbox_SupDrvClient::initWithTask([%p], %#x, %p, %#x) (cur pid=%d proc=%p)\n",
2177 this, OwningTask, pvSecurityId, u32Type, RTProcSelf(), RTR0ProcHandleSelf()));
2178 AssertMsg((RTR0PROCESS)OwningTask == RTR0ProcHandleSelf(), ("%p %p\n", OwningTask, RTR0ProcHandleSelf()));
2179
2180 if (!OwningTask)
2181 return false;
2182
2183 if (u32Type != SUP_DARWIN_IOSERVICE_COOKIE)
2184 {
2185 VBOX_RETRIEVE_CUR_PROC_NAME(szProcName);
2186 LogRelMax(10,("org_virtualbox_SupDrvClient::initWithTask: Bad cookie %#x (%s)\n", u32Type, szProcName));
2187 return false;
2188 }
2189
2190 if (IOUserClient::initWithTask(OwningTask, pvSecurityId , u32Type))
2191 {
2192 /*
2193 * In theory we have to call task_reference() to make sure that the task is
2194 * valid during the lifetime of this object. The pointer is only used to check
2195 * for the context this object is called in though and never dereferenced
2196 * or passed to anything which might, so we just skip this step.
2197 */
2198 m_Task = OwningTask;
2199 m_pSession = NULL;
2200 m_pProvider = NULL;
2201 return true;
2202 }
2203 return false;
2204}
2205
2206
2207/**
2208 * Start the client service.
2209 */
2210bool org_virtualbox_SupDrvClient::start(IOService *pProvider)
2211{
2212 LogFlow(("org_virtualbox_SupDrvClient::start([%p], %p) (cur pid=%d proc=%p)\n",
2213 this, pProvider, RTProcSelf(), RTR0ProcHandleSelf() ));
2214 AssertMsgReturn((RTR0PROCESS)m_Task == RTR0ProcHandleSelf(),
2215 ("%p %p\n", m_Task, RTR0ProcHandleSelf()),
2216 false);
2217
2218 if (IOUserClient::start(pProvider))
2219 {
2220 m_pProvider = OSDynamicCast(org_virtualbox_SupDrv, pProvider);
2221 if (m_pProvider)
2222 {
2223 Assert(!m_pSession);
2224
2225 /*
2226 * Create a new session.
2227 */
2228 int rc = supdrvCreateSession(&g_DevExt, true /* fUser */, false /*fUnrestricted*/, &m_pSession);
2229 if (RT_SUCCESS(rc))
2230 {
2231 m_pSession->fOpened = false;
2232 /* The Uid, Gid and fUnrestricted fields are set on open. */
2233
2234 /*
2235 * Insert it into the hash table, checking that there isn't
2236 * already one for this process first. (One session per proc!)
2237 */
2238 unsigned iHash = SESSION_HASH(m_pSession->Process);
2239 RTSpinlockAcquire(g_Spinlock);
2240
2241 PSUPDRVSESSION pCur = g_apSessionHashTab[iHash];
2242 while (pCur && pCur->Process != m_pSession->Process)
2243 pCur = pCur->pNextHash;
2244 if (!pCur)
2245 {
2246 m_pSession->pNextHash = g_apSessionHashTab[iHash];
2247 g_apSessionHashTab[iHash] = m_pSession;
2248 m_pSession->pvSupDrvClient = this;
2249 ASMAtomicIncS32(&g_cSessions);
2250 rc = VINF_SUCCESS;
2251 }
2252 else
2253 rc = VERR_ALREADY_LOADED;
2254
2255 RTSpinlockRelease(g_Spinlock);
2256 if (RT_SUCCESS(rc))
2257 {
2258 Log(("org_virtualbox_SupDrvClient::start: created session %p for pid %d\n", m_pSession, (int)RTProcSelf()));
2259 return true;
2260 }
2261
2262 LogFlow(("org_virtualbox_SupDrvClient::start: already got a session for this process (%p)\n", pCur));
2263 supdrvSessionRelease(m_pSession);
2264 }
2265
2266 m_pSession = NULL;
2267 LogFlow(("org_virtualbox_SupDrvClient::start: rc=%Rrc from supdrvCreateSession\n", rc));
2268 }
2269 else
2270 LogFlow(("org_virtualbox_SupDrvClient::start: %p isn't org_virtualbox_SupDrv\n", pProvider));
2271 }
2272 return false;
2273}
2274
2275
2276/**
2277 * Common worker for clientClose and VBoxDrvDarwinClose.
2278 */
2279/* static */ void org_virtualbox_SupDrvClient::sessionClose(RTPROCESS Process)
2280{
2281 /*
2282 * Find the session and remove it from the hash table.
2283 *
2284 * Note! Only one session per process. (Both start() and
2285 * VBoxDrvDarwinOpen makes sure this is so.)
2286 */
2287 const unsigned iHash = SESSION_HASH(Process);
2288 RTSpinlockAcquire(g_Spinlock);
2289 PSUPDRVSESSION pSession = g_apSessionHashTab[iHash];
2290 if (pSession)
2291 {
2292 if (pSession->Process == Process)
2293 {
2294 g_apSessionHashTab[iHash] = pSession->pNextHash;
2295 pSession->pNextHash = NULL;
2296 ASMAtomicDecS32(&g_cSessions);
2297 }
2298 else
2299 {
2300 PSUPDRVSESSION pPrev = pSession;
2301 pSession = pSession->pNextHash;
2302 while (pSession)
2303 {
2304 if (pSession->Process == Process)
2305 {
2306 pPrev->pNextHash = pSession->pNextHash;
2307 pSession->pNextHash = NULL;
2308 ASMAtomicDecS32(&g_cSessions);
2309 break;
2310 }
2311
2312 /* next */
2313 pPrev = pSession;
2314 pSession = pSession->pNextHash;
2315 }
2316 }
2317 }
2318 RTSpinlockRelease(g_Spinlock);
2319 if (!pSession)
2320 {
2321 Log(("SupDrvClient::sessionClose: pSession == NULL, pid=%d; freed already?\n", (int)Process));
2322 return;
2323 }
2324
2325 /*
2326 * Remove it from the client object.
2327 */
2328 org_virtualbox_SupDrvClient *pThis = (org_virtualbox_SupDrvClient *)pSession->pvSupDrvClient;
2329 pSession->pvSupDrvClient = NULL;
2330 if (pThis)
2331 {
2332 Assert(pThis->m_pSession == pSession);
2333 pThis->m_pSession = NULL;
2334 }
2335
2336 /*
2337 * Close the session.
2338 */
2339 supdrvSessionRelease(pSession);
2340}
2341
2342
2343/**
2344 * Client exits normally.
2345 */
2346IOReturn org_virtualbox_SupDrvClient::clientClose(void)
2347{
2348 LogFlow(("org_virtualbox_SupDrvClient::clientClose([%p]) (cur pid=%d proc=%p)\n", this, RTProcSelf(), RTR0ProcHandleSelf()));
2349 AssertMsg((RTR0PROCESS)m_Task == RTR0ProcHandleSelf(), ("%p %p\n", m_Task, RTR0ProcHandleSelf()));
2350
2351 /*
2352 * Clean up the session if it's still around.
2353 *
2354 * We cannot rely 100% on close, and in the case of a dead client
2355 * we'll end up hanging inside vm_map_remove() if we postpone it.
2356 */
2357 if (m_pSession)
2358 {
2359 sessionClose(RTProcSelf());
2360 Assert(!m_pSession);
2361 }
2362
2363 m_pProvider = NULL;
2364 terminate();
2365
2366 return kIOReturnSuccess;
2367}
2368
2369
2370/**
2371 * The client exits abnormally / forgets to do cleanups. (logging)
2372 */
2373IOReturn org_virtualbox_SupDrvClient::clientDied(void)
2374{
2375 LogFlow(("IOService::clientDied([%p]) m_Task=%p R0Process=%p Process=%d\n", this, m_Task, RTR0ProcHandleSelf(), RTProcSelf()));
2376
2377 /* IOUserClient::clientDied() calls clientClose, so we'll just do the work there. */
2378 return IOUserClient::clientDied();
2379}
2380
2381
2382/**
2383 * Terminate the service (initiate the destruction). (logging)
2384 */
2385bool org_virtualbox_SupDrvClient::terminate(IOOptionBits fOptions)
2386{
2387 LogFlow(("IOService::terminate([%p], %#x)\n", this, fOptions));
2388 return IOUserClient::terminate(fOptions);
2389}
2390
2391
2392/**
2393 * The final stage of the client service destruction. (logging)
2394 */
2395bool org_virtualbox_SupDrvClient::finalize(IOOptionBits fOptions)
2396{
2397 LogFlow(("IOService::finalize([%p], %#x)\n", this, fOptions));
2398 return IOUserClient::finalize(fOptions);
2399}
2400
2401
2402/**
2403 * Stop the client service. (logging)
2404 */
2405void org_virtualbox_SupDrvClient::stop(IOService *pProvider)
2406{
2407 LogFlow(("IOService::stop([%p])\n", this));
2408 IOUserClient::stop(pProvider);
2409}
2410
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use