int bdevsw_module_handler(module_t mod, int what, void* arg) { struct bdevsw_module_data* data = (struct bdevsw_module_data*) arg; int error; switch (what) { case MOD_LOAD: error = cdevsw_add(&data->cdev, data->cdevsw, NULL); if (!error) error = bdevsw_add(&data->bdev, data->cdevsw, NULL); if (!error && data->chainevh) error = data->chainevh(mod, what, data->chainarg); return error; case MOD_UNLOAD: if (data->chainevh) { error = data->chainevh(mod, what, data->chainarg); if (error) return error; } error = bdevsw_add(&data->bdev, NULL, NULL); if (!error) error = cdevsw_add(&data->cdev, NULL, NULL); return error; } if (data->chainevh) return data->chainevh(mod, what, data->chainarg); else return 0; }
/*---------------------------------------------------------------------------* * initialization at kernel load time *---------------------------------------------------------------------------*/ static void i4bctlinit(void *unused) { #if defined(__FreeBSD__) && __FreeBSD__ >= 4 cdevsw_add(&i4bctl_cdevsw); #else dev_t dev = makedev(CDEV_MAJOR, 0); cdevsw_add(&dev, &i4bctl_cdevsw, NULL); #endif }
void bpf_init(__unused void *unused) { #ifdef __APPLE__ int i; int maj; if (bpf_devsw_installed == 0) { bpf_devsw_installed = 1; bpf_mlock_grp_attr = lck_grp_attr_alloc_init(); bpf_mlock_grp = lck_grp_alloc_init("bpf", bpf_mlock_grp_attr); bpf_mlock_attr = lck_attr_alloc_init(); bpf_mlock = lck_mtx_alloc_init(bpf_mlock_grp, bpf_mlock_attr); if (bpf_mlock == 0) { printf("bpf_init: failed to allocate bpf_mlock\n"); bpf_devsw_installed = 0; return; } maj = cdevsw_add(CDEV_MAJOR, &bpf_cdevsw); if (maj == -1) { if (bpf_mlock) lck_mtx_free(bpf_mlock, bpf_mlock_grp); if (bpf_mlock_attr) lck_attr_free(bpf_mlock_attr); if (bpf_mlock_grp) lck_grp_free(bpf_mlock_grp); if (bpf_mlock_grp_attr) lck_grp_attr_free(bpf_mlock_grp_attr); bpf_mlock = NULL; bpf_mlock_attr = NULL; bpf_mlock_grp = NULL; bpf_mlock_grp_attr = NULL; bpf_devsw_installed = 0; printf("bpf_init: failed to allocate a major number!\n"); return; } for (i = 0 ; i < NBPFILTER; i++) bpf_make_dev_t(maj); } #else cdevsw_add(&bpf_cdevsw); #endif }
int ptmx_init( __unused int config_count) { /* * We start looking at slot 10, since there are inits that will * stomp explicit slots (e.g. vndevice stomps 1) below that. */ /* Get a major number for /dev/ptmx */ if ((ptmx_major = cdevsw_add(-15, &ptmx_cdev)) == -1) { printf("ptmx_init: failed to obtain /dev/ptmx major number\n"); return (ENOENT); } if (cdevsw_setkqueueok(ptmx_major, &ptmx_cdev, CDEVSW_IS_PTC) == -1) { panic("Failed to set flags on ptmx cdevsw entry."); } /* Get a major number for /dev/pts/nnn */ if ((ptsd_major = cdevsw_add(-15, &ptsd_cdev)) == -1) { (void)cdevsw_remove(ptmx_major, &ptmx_cdev); printf("ptmx_init: failed to obtain /dev/ptmx major number\n"); return (ENOENT); } if (cdevsw_setkqueueok(ptsd_major, &ptsd_cdev, CDEVSW_IS_PTS) == -1) { panic("Failed to set flags on ptmx cdevsw entry."); } /* Create the /dev/ptmx device {<major>,0} */ (void)devfs_make_node_clone(makedev(ptmx_major, 0), DEVFS_CHAR, UID_ROOT, GID_TTY, 0666, ptmx_clone, PTMX_TEMPLATE); _ptmx_driver.master = ptmx_major; _ptmx_driver.slave = ptsd_major; _ptmx_driver.fix_7828447 = 1; _ptmx_driver.fix_7070978 = 1; #if CONFIG_MACF _ptmx_driver.mac_notify = 1; #endif _ptmx_driver.open = &ptmx_get_ioctl; _ptmx_driver.free = &ptmx_free_ioctl; _ptmx_driver.name = &ptmx_get_name; _ptmx_driver.revoke = &ptsd_revoke_knotes; tty_dev_register(&_ptmx_driver); return (0); }
/** * Register VBoxGuest char device */ static int vgdrvDarwinCharDevInit(void) { int rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxGuestDarwin"); if (RT_SUCCESS(rc)) { /* * Registering ourselves as a character device. */ g_iMajorDeviceNo = cdevsw_add(-1, &g_DevCW); if (g_iMajorDeviceNo >= 0) { g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_SYS); if (g_hDevFsDeviceSys != NULL) { /* * Register a sleep/wakeup notification callback. */ g_pSleepNotifier = registerPrioritySleepWakeInterest(&vgdrvDarwinSleepHandler, &g_DevExt, NULL); if (g_pSleepNotifier != NULL) { return KMOD_RETURN_SUCCESS; } } } vgdrvDarwinCharDevRemove(); } return KMOD_RETURN_FAILURE; }
static int nsmb_dev_load(module_t mod, int cmd, void *arg) { int error = 0; switch (cmd) { case MOD_LOAD: error = smb_sm_init(); if (error) break; error = smb_iod_init(); if (error) { smb_sm_done(); break; } cdevsw_add(&nsmb_cdevsw); nsmb_dev_tag = EVENTHANDLER_REGISTER(dev_clone, nsmb_dev_clone, 0, 1000); printf("netsmb_dev: loaded\n"); break; case MOD_UNLOAD: smb_iod_done(); error = smb_sm_done(); error = 0; EVENTHANDLER_DEREGISTER(dev_clone, nsmb_dev_tag); cdevsw_remove(&nsmb_cdevsw); printf("netsmb_dev: unloaded\n"); break; default: error = EINVAL; break; } return error; }
static void i4b_drvinit(void *unused) { #if defined(__FreeBSD__) && __FreeBSD__ >= 4 cdevsw_add(&i4b_cdevsw); #else static int i4b_devsw_installed = 0; dev_t dev; if( ! i4b_devsw_installed ) { dev = makedev(CDEV_MAJOR,0); cdevsw_add(&dev,&i4b_cdevsw,NULL); i4b_devsw_installed = 1; } #endif }
// Driver entry point. Initializes globals and registers driver node in /dev. kern_return_t pmem_start(kmod_info_t * ki, void *d) { int error = 0; pmem_log("Loading /dev/%s driver", pmem_pmem_devname); // Memory allocations are tagged to prevent leaks pmem_tag = OSMalloc_Tagalloc(pmem_tagname, OSMT_DEFAULT); // Allocate one page for zero padding of illegal read requests pmem_zero_page = static_cast<uint8_t *>(OSMalloc(PAGE_SIZE, pmem_tag)); if (pmem_zero_page == NULL) { pmem_error("Failed to allocate memory for page buffer"); return pmem_cleanup(KERN_FAILURE); } bzero(pmem_zero_page, PAGE_SIZE); // Access the boot arguments through the platform export, // and parse the systems physical memory configuration. boot_args * ba = reinterpret_cast<boot_args *>(PE_state.bootArgs); pmem_physmem_size = ba->PhysicalMemorySize; pmem_mmap = reinterpret_cast<EfiMemoryRange *>(ba->MemoryMap + pmem_kernel_voffset); pmem_mmap_desc_size = ba->MemoryMapDescriptorSize; pmem_mmap_size = ba->MemoryMapSize; pmem_log("Size of physical memory:%lld", pmem_physmem_size); pmem_log("Size of physical pages:%d (PAGE_SHIFT=%d, PAGE_MASK=%#016x)", PAGE_SIZE, PAGE_SHIFT, PAGE_MASK); pmem_log("Phys. Memory map at:%#016llx (size:%lld desc_size:%d)", pmem_mmap, pmem_mmap_size, pmem_mmap_desc_size); pmem_log("Number of segments in memory map: %d", pmem_mmap_size / pmem_mmap_desc_size); // Install switch table pmem_devmajor = cdevsw_add(-1, &pmem_cdevsw); if (pmem_devmajor == -1) { pmem_error("Failed to create character device"); return pmem_cleanup(KERN_FAILURE); } // Create physical memory device file pmem_log("Adding node /dev/%s", pmem_pmem_devname); pmem_devpmemnode = devfs_make_node(makedev(pmem_devmajor, pmem_dev_pmem_minor), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0660, pmem_pmem_devname); if (pmem_devpmemnode == NULL) { pmem_error("Failed to create /dev/%s node", pmem_pmem_devname); return pmem_cleanup(KERN_FAILURE); } pmem_log("obtaining kernel dtb pointer"); __asm__ __volatile__("movq %%cr3, %0" :"=r"(pmem_dtb)); // Only bits 51-12 (inclusive) in cr3 are part of the dtb pointer pmem_dtb &= ~PAGE_MASK; pmem_log("kernel dtb: %#016llx", pmem_dtb); pmem_log("initializing pte_mmap module"); pmem_log("pmem driver loaded, physical memory available in /dev/%s", pmem_pmem_devname); return error; }
/*---------------------------------------------------------------------------* * initialization at kernel load time *---------------------------------------------------------------------------*/ static void i4bctlinit(void *unused) { dev_t dev; dev = makedev(CDEV_MAJOR, 0); cdevsw_add(&dev, &i4bctl_cdevsw, NULL); }
/*---------------------------------------------------------------------------* * initialization at kernel load time *---------------------------------------------------------------------------*/ PDEVSTATIC void i4btelinit(void *unused) { dev_t dev; dev = makedev(CDEV_MAJOR, 0); cdevsw_add(&dev, &i4btel_cdevsw, NULL); }
static void uk_drvinit(void *unused) { dev_t dev; if( ! uk_devsw_installed ) { dev = makedev(CDEV_MAJOR, 0); cdevsw_add(&dev,&uk_cdevsw, NULL); uk_devsw_installed = 1; } }
/* * note must call cdevsw_add before bdevsw_add due to d_bmaj hack. */ void cdevsw_add_generic(int bdev, int cdev, struct cdevsw *cdevsw) { dev_t dev; dev = makedev(cdev, 0); cdevsw_add(&dev, cdevsw, NULL); dev = makedev(bdev, 0); bdevsw_add(&dev, cdevsw, NULL); }
static void vfbattach(void *arg) { static int fb_devsw_installed = FALSE; if (!fb_devsw_installed) { cdevsw_add(&fb_cdevsw); fb_devsw_installed = TRUE; } }
static void mpc_attach(pcici_t tag, int unit) { dev_t cdev = makedev(CDEV_MAJOR, unit); if (!unit) cdevsw_add(&cdev, &mpcdevsw, NULL); mpc_dynamic_handler = NULL; pci_map_int(tag, mpc_interrupt_handler, NULL, &net_imask); }
static void iir_drvinit(void *unused) { GDT_DPRINTF(GDT_D_DEBUG, ("iir_drvinit()\n")); if (!iir_devsw_installed) { /* Add the I/O (data) channel */ cdevsw_add(&iir_cdevsw); iir_devsw_installed = 1; } }
static void dpt_drvinit(void *unused) { dev_t dev; if (!dpt_devsw_installed) { if (bootverbose) printf("DPT: RAID Manager driver, Version %d.%d.%d\n", DPT_CTL_RELEASE, DPT_CTL_VERSION, DPT_CTL_PATCH); /* Add the I/O (data) channel */ dev = makedev(CDEV_MAJOR, 0); cdevsw_add(&dev, &dpt_cdevsw, NULL); /* Add the Control (IOCTL) channel */ dev = makedev(CDEV_MAJOR, SCSI_CONTROL_MASK); cdevsw_add(&dev, &dpt_cdevsw, NULL); dpt_devsw_installed = 1; } dpt_get_sysinfo(); }
kern_return_t OsqueryStart(kmod_info_t *ki, void *d) { dbg_printf("Kernel module starting!\n"); // Restart the queue and setup queue locks. // This does not allocate, share, or set the queue buffer or buffer values. osquery_cqueue_setup(&osquery.cqueue); // Initialize the IOCTL (and more) device node. osquery.major_number = cdevsw_add(osquery.major_number, &osquery_cdevsw); if (osquery.major_number < 0) { dbg_printf("Could not get a major number!\n"); goto error_exit; } // Create the IOCTL (and more) device node. osquery.devfs = devfs_make_node(makedev(osquery.major_number, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0600, "osquery", 0); if (osquery.devfs == NULL) { dbg_printf("Could not get a devfs entry!\n"); goto error_exit; } // Set up the IOCTL and kernel API locks (not queue locks). setup_locks(); return KERN_SUCCESS; error_exit: // Upon error, remove the device node if it was allocated. if (osquery.devfs != NULL) { devfs_remove(osquery.devfs); osquery.devfs = NULL; } // Tear down device node data. if (!(osquery.major_number < 0)) { if (cdevsw_remove(osquery.major_number, &osquery_cdevsw) < 0) { panic("osquery kext: Cannot remove osquery from cdevsw"); } } // Reset the queue and remove the queue locks. osquery_cqueue_teardown(&osquery.cqueue); return KERN_FAILURE; }
/** * Start the kernel module. */ static kern_return_t VBoxNetAdpDarwinStart(struct kmod_info *pKModInfo, void *pvData) { int rc; /* * Initialize IPRT and find our module tag id. * (IPRT is shared with VBoxDrv, it creates the loggers.) */ rc = RTR0Init(0); if (RT_SUCCESS(rc)) { Log(("VBoxNetAdpDarwinStart\n")); rc = vboxNetAdpInit(); if (RT_SUCCESS(rc)) { g_nCtlDev = cdevsw_add(-1, &g_ChDev); if (g_nCtlDev < 0) { LogRel(("VBoxAdp: failed to register control device.")); rc = VERR_CANT_CREATE; } else { g_hCtlDev = devfs_make_node(makedev(g_nCtlDev, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0600, VBOXNETADP_CTL_DEV_NAME); if (!g_hCtlDev) { LogRel(("VBoxAdp: failed to create FS node for control device.")); rc = VERR_CANT_CREATE; } } } if (RT_SUCCESS(rc)) { LogRel(("VBoxAdpDrv: version " VBOX_VERSION_STRING " r%d\n", VBOX_SVN_REV)); return KMOD_RETURN_SUCCESS; } LogRel(("VBoxAdpDrv: failed to initialize device extension (rc=%d)\n", rc)); RTR0Term(); } else printf("VBoxAdpDrv: failed to initialize IPRT (rc=%d)\n", rc); return KMOD_RETURN_FAILURE; }
void lockstat_init( void ) { if (0 == gLockstatInited) { int majdevno = cdevsw_add(LOCKSTAT_MAJOR, &lockstat_cdevsw); if (majdevno < 0) { printf("lockstat_init: failed to allocate a major number!\n"); gLockstatInited = 0; return; } lockstat_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); gLockstatInited = 1; } else panic("lockstat_init: called twice!\n"); }
void profile_init( void ) { if (0 == gProfileInited) { int majdevno = cdevsw_add(PROFILE_MAJOR, &profile_cdevsw); if (majdevno < 0) { printf("profile_init: failed to allocate a major number!\n"); gProfileInited = 0; return; } profile_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); gProfileInited = 1; } else panic("profile_init: called twice!\n"); }
void fbt_init( void ) { if (0 == fbt_inited) { int majdevno = cdevsw_add(FBT_MAJOR, &fbt_cdevsw); if (majdevno < 0) { printf("fbt_init: failed to allocate a major number!\n"); return; } PE_parse_boot_argn("IgnoreFBTBlacklist", &ignore_fbt_blacklist, sizeof (ignore_fbt_blacklist)); fbt_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); fbt_inited = 1; /* Ensure this initialization occurs just one time. */ } else panic("fbt_init: called twice!\n"); }
// Driver entry point. Initializes globals and registers driver node in /dev. kern_return_t chipsec_start(kmod_info_t * ki, void *d) { int error = 0; pmem_log("Loading /dev/%s driver", chipsec_devname); // Memory allocations are tagged to prevent leaks pmem_tag = OSMalloc_Tagalloc(pmem_tagname, OSMT_DEFAULT); // Allocate one page for zero padding of illegal read requests pmem_zero_page = static_cast<uint8_t *>(OSMalloc(PAGE_SIZE, pmem_tag)); if (pmem_zero_page == NULL) { pmem_error("Failed to allocate memory for page buffer"); return pmem_cleanup(KERN_FAILURE); } bzero(pmem_zero_page, PAGE_SIZE); // Install the character device chipsec_dev_major = cdevsw_add(-1, &pmem_cdevsw); if (chipsec_dev_major == -1) { pmem_error("Failed to create character device"); return pmem_cleanup(KERN_FAILURE); } // Create physical memory device file pmem_log("Adding node /dev/%s", chipsec_devname); pmem_devpmemnode = devfs_make_node(makedev(chipsec_dev_major, chipsec_dev_minor), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0660, chipsec_devname); if (pmem_devpmemnode == NULL) { pmem_error("Failed to create /dev/%s node", chipsec_devname); return pmem_cleanup(KERN_FAILURE); } pmem_log("pmem driver loaded, physical memory available in /dev/%s", chipsec_devname); return error; }
kern_return_t OsqueryStart(kmod_info_t *ki, void *d) { dbg_printf("Kernel module starting!\n"); osquery_cqueue_setup(&osquery.cqueue); osquery.major_number = cdevsw_add(osquery.major_number, &osquery_cdevsw); if (osquery.major_number < 0) { dbg_printf("Could not get a major number!\n"); goto error_exit; } osquery.devfs = devfs_make_node(makedev(osquery.major_number, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0644, "osquery", 0); if (osquery.devfs == NULL) { dbg_printf("Could not get a devfs entry!\n"); goto error_exit; } setup_locks(); return KERN_SUCCESS; error_exit: if (osquery.devfs != NULL) { devfs_remove(osquery.devfs); osquery.devfs = NULL; } if (!(osquery.major_number < 0)) { if (cdevsw_remove(osquery.major_number, &osquery_cdevsw) < 0) { panic("osquery kext: Cannot remove osquery from cdevsw"); } } osquery_cqueue_teardown(&osquery.cqueue); return KERN_FAILURE; }
static int machtrace_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) { switch (cmd) { case DDI_ATTACH: break; case DDI_RESUME: return (DDI_SUCCESS); default: return (DDI_FAILURE); } #if !defined(__APPLE__) machtrace_probe = (void (*)())dtrace_probe; membar_enter(); if (ddi_create_minor_node(devi, "machtrace", S_IFCHR, 0, DDI_PSEUDO, NULL) == DDI_FAILURE || dtrace_register("mach_trap", &machtrace_attr, DTRACE_PRIV_USER, NULL, &machtrace_pops, NULL, &machtrace_id) != 0) { machtrace_probe = systrace_stub; #else machtrace_probe = dtrace_probe; membar_enter(); if (ddi_create_minor_node(devi, "machtrace", S_IFCHR, 0, DDI_PSEUDO, 0) == DDI_FAILURE || dtrace_register("mach_trap", &machtrace_attr, DTRACE_PRIV_USER, NULL, &machtrace_pops, NULL, &machtrace_id) != 0) { machtrace_probe = (void (*))&systrace_stub; #endif /* __APPLE__ */ ddi_remove_minor_node(devi, NULL); return (DDI_FAILURE); } ddi_report_dev(devi); machtrace_devi = devi; return (DDI_SUCCESS); } d_open_t _systrace_open; int _systrace_open(dev_t dev, int flags, int devtype, struct proc *p) { #pragma unused(dev,flags,devtype,p) return 0; } #define SYSTRACE_MAJOR -24 /* let the kernel pick the device number */ /* * A struct describing which functions will get invoked for certain * actions. */ static struct cdevsw systrace_cdevsw = { _systrace_open, /* open */ eno_opcl, /* close */ eno_rdwrt, /* read */ eno_rdwrt, /* write */ eno_ioctl, /* ioctl */ (stop_fcn_t *)nulldev, /* stop */ (reset_fcn_t *)nulldev, /* reset */ NULL, /* tty's */ eno_select, /* select */ eno_mmap, /* mmap */ eno_strat, /* strategy */ eno_getc, /* getc */ eno_putc, /* putc */ 0 /* type */ }; static int gSysTraceInited = 0; void systrace_init( void ); void systrace_init( void ) { if (0 == gSysTraceInited) { int majdevno = cdevsw_add(SYSTRACE_MAJOR, &systrace_cdevsw); if (majdevno < 0) { printf("systrace_init: failed to allocate a major number!\n"); gSysTraceInited = 0; return; } systrace_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); machtrace_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); gSysTraceInited = 1; } else panic("systrace_init: called twice!\n"); } #undef SYSTRACE_MAJOR #endif /* __APPLE__ */ static uint64_t systrace_getarg(void *arg, dtrace_id_t id, void *parg, int argno, int aframes) { #pragma unused(arg,id,parg,aframes) /* __APPLE__ */ uint64_t val = 0; syscall_arg_t *stack = (syscall_arg_t *)NULL; uthread_t uthread = (uthread_t)get_bsdthread_info(current_thread()); if (uthread) stack = (syscall_arg_t *)uthread->t_dtrace_syscall_args; if (!stack) return(0); DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); /* dtrace_probe arguments arg0 .. arg4 are 64bits wide */ val = (uint64_t)*(stack+argno); DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); return (val); }
/*---------------------------------------------------------------------------* * interface init routine *---------------------------------------------------------------------------*/ static void i4btrcinit(void *unused) { cdevsw_add(&i4btrc_cdevsw); }
static int gscprobe (struct isa_device *isdp) { int unit = isdp->id_unit; struct gsc_unit *scu = unittab + unit; int stb; struct gsc_geom geom = NEW_GEOM; static int once; if (!once++) cdevsw_add(&gsc_cdevsw); scu->flags = FLAG_DEBUG; lprintf(("gsc%d.probe " "on iobase 0x%03x, irq %d, drq %d, addr %p, size %d\n", unit, isdp->id_iobase, isdp->id_irq, isdp->id_drq, isdp->id_maddr, isdp->id_msize)); if ( isdp->id_iobase < 0 ) { lprintf(("gsc%d.probe: no iobase given\n", unit)); return PROBE_FAIL; } stb = inb( GSC_STAT(isdp->id_iobase) ); if (stb == FAIL) { lprintf(("gsc%d.probe: get status byte failed\n", unit)); return PROBE_FAIL; } scu->data = GSC_DATA(isdp->id_iobase); scu->stat = GSC_STAT(isdp->id_iobase); scu->ctrl = GSC_CTRL(isdp->id_iobase); scu->clrp = GSC_CLRP(isdp->id_iobase); outb(scu->clrp,stb); stb = inb(scu->stat); switch(stb & GSC_CNF_MASK) { case GSC_CNF_DMA1: lprintf(("gsc%d.probe: DMA 1\n", unit)); scu->channel = 1; break; case GSC_CNF_DMA3: lprintf(("gsc%d.probe: DMA 3\n", unit)); scu->channel = 3; break; case GSC_CNF_IRQ3: lprintf(("gsc%d.probe: IRQ 3\n", unit)); goto probe_noirq; case GSC_CNF_IRQ5: lprintf(("gsc%d.probe: IRQ 5\n", unit)); probe_noirq: lprintf(("gsc%d.probe: sorry, can't use IRQ yet\n", unit)); return PROBE_FAIL; default: lprintf(("gsc%d.probe: invalid status byte 0x%02x\n", unit, (u_char) stb)); return PROBE_FAIL; } if (isdp->id_drq < 0) isdp->id_drq = scu->channel; if (scu->channel != isdp->id_drq) { lprintf(("gsc%d.probe: drq mismatch: config: %d; hardware: %d\n", unit, isdp->id_drq, scu->channel)); return PROBE_FAIL; } geom.g_res = stb & GSC_RES_MASK; scu->geometry = lookup_geometry(geom, scu); if (scu->geometry == INVALID) { lprintf(("gsc%d.probe: geometry lookup failed\n", unit)); return PROBE_FAIL; } else { scu->ctrl_byte = geomtab[scu->geometry].s_res; outb(scu->ctrl, scu->ctrl_byte | GSC_POWER_ON); lprintf(("gsc%d.probe: status 0x%02x, %ddpi\n", unit, stb, geomtab[scu->geometry].dpi)); outb(scu->ctrl, scu->ctrl_byte & ~GSC_POWER_ON); } lprintf(("gsc%d.probe: ok\n", unit)); scu->flags &= ~FLAG_DEBUG; return PROBE_SUCCESS; }
void sdt_init( void ) { if (0 == gSDTInited) { int majdevno = cdevsw_add(SDT_MAJOR, &sdt_cdevsw); if (majdevno < 0) { printf("sdt_init: failed to allocate a major number!\n"); gSDTInited = 0; return; } if (dtrace_sdt_probes_restricted()) { return; } if (MH_MAGIC_KERNEL != _mh_execute_header.magic) { g_sdt_kernctl.mod_address = (vm_address_t)NULL; g_sdt_kernctl.mod_size = 0; } else { kernel_mach_header_t *mh; struct load_command *cmd; kernel_segment_command_t *orig_ts = NULL, *orig_le = NULL; struct symtab_command *orig_st = NULL; kernel_nlist_t *sym = NULL; char *strings; unsigned int i; g_sdt_mach_module.sdt_nprobes = 0; g_sdt_mach_module.sdt_probes = NULL; g_sdt_kernctl.mod_address = (vm_address_t)&g_sdt_mach_module; g_sdt_kernctl.mod_size = 0; strncpy((char *)&(g_sdt_kernctl.mod_modname), "mach_kernel", KMOD_MAX_NAME); g_sdt_kernctl.mod_next = NULL; g_sdt_kernctl.mod_stale = NULL; g_sdt_kernctl.mod_id = 0; g_sdt_kernctl.mod_loadcnt = 1; g_sdt_kernctl.mod_loaded = 1; g_sdt_kernctl.mod_flags = 0; g_sdt_kernctl.mod_nenabled = 0; mh = &_mh_execute_header; cmd = (struct load_command*) &mh[1]; for (i = 0; i < mh->ncmds; i++) { if (cmd->cmd == LC_SEGMENT_KERNEL) { kernel_segment_command_t *orig_sg = (kernel_segment_command_t *) cmd; if (LIT_STRNEQL(orig_sg->segname, SEG_TEXT)) orig_ts = orig_sg; else if (LIT_STRNEQL(orig_sg->segname, SEG_LINKEDIT)) orig_le = orig_sg; else if (LIT_STRNEQL(orig_sg->segname, "")) orig_ts = orig_sg; /* kexts have a single unnamed segment */ } else if (cmd->cmd == LC_SYMTAB) orig_st = (struct symtab_command *) cmd; cmd = (struct load_command *) ((uintptr_t) cmd + cmd->cmdsize); } if ((orig_ts == NULL) || (orig_st == NULL) || (orig_le == NULL)) return; sym = (kernel_nlist_t *)(orig_le->vmaddr + orig_st->symoff - orig_le->fileoff); strings = (char *)(orig_le->vmaddr + orig_st->stroff - orig_le->fileoff); for (i = 0; i < orig_st->nsyms; i++) { uint8_t n_type = sym[i].n_type & (N_TYPE | N_EXT); char *name = strings + sym[i].n_un.n_strx; const char *prev_name; unsigned long best; unsigned int j; /* Check that the symbol is a global and that it has a name. */ if (((N_SECT | N_EXT) != n_type && (N_ABS | N_EXT) != n_type)) continue; if (0 == sym[i].n_un.n_strx) /* iff a null, "", name. */ continue; /* Lop off omnipresent leading underscore. */ if (*name == '_') name += 1; if (strncmp(name, DTRACE_PROBE_PREFIX, sizeof(DTRACE_PROBE_PREFIX) - 1) == 0) { sdt_probedesc_t *sdpd = kmem_alloc(sizeof(sdt_probedesc_t), KM_SLEEP); int len = strlen(name) + 1; sdpd->sdpd_name = kmem_alloc(len, KM_SLEEP); strncpy(sdpd->sdpd_name, name, len); /* NUL termination is ensured. */ prev_name = "<unknown>"; best = 0; /* * Find the symbol immediately preceding the sdt probe site just discovered, * that symbol names the function containing the sdt probe. */ for (j = 0; j < orig_st->nsyms; j++) { uint8_t jn_type = sym[j].n_type & (N_TYPE | N_EXT); char *jname = strings + sym[j].n_un.n_strx; if (((N_SECT | N_EXT) != jn_type && (N_ABS | N_EXT) != jn_type)) continue; if (0 == sym[j].n_un.n_strx) /* iff a null, "", name. */ continue; if (*jname == '_') jname += 1; if (*(unsigned long *)sym[i].n_value <= (unsigned long)sym[j].n_value) continue; if ((unsigned long)sym[j].n_value > best) { best = (unsigned long)sym[j].n_value; prev_name = jname; } } sdpd->sdpd_func = kmem_alloc((len = strlen(prev_name) + 1), KM_SLEEP); strncpy(sdpd->sdpd_func, prev_name, len); /* NUL termination is ensured. */ sdpd->sdpd_offset = *(unsigned long *)sym[i].n_value; #if defined(__arm__) /* PR8353094 - mask off thumb-bit */ sdpd->sdpd_offset &= ~0x1U; #elif defined(__arm64__) sdpd->sdpd_offset &= ~0x1LU; #endif /* __arm__ */ #if 0 printf("sdt_init: sdpd_offset=0x%lx, n_value=0x%lx, name=%s\n", sdpd->sdpd_offset, *(unsigned long *)sym[i].n_value, name); #endif sdpd->sdpd_next = g_sdt_mach_module.sdt_probes; g_sdt_mach_module.sdt_probes = sdpd; } else { prev_name = name; } } } sdt_attach( (dev_info_t *)(uintptr_t)majdevno, DDI_ATTACH ); gSDTInited = 1; } else panic("sdt_init: called twice!\n"); }
/** * Start the kernel module. */ static kern_return_t VBoxDrvDarwinStart(struct kmod_info *pKModInfo, void *pvData) { int rc; #ifdef DEBUG printf("VBoxDrvDarwinStart\n"); #endif /* * Initialize IPRT. */ rc = RTR0Init(0); if (RT_SUCCESS(rc)) { /* * Initialize the device extension. */ rc = supdrvInitDevExt(&g_DevExt, sizeof(SUPDRVSESSION)); if (RT_SUCCESS(rc)) { /* * Initialize the session hash table. */ memset(g_apSessionHashTab, 0, sizeof(g_apSessionHashTab)); /* paranoia */ rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxDrvDarwin"); if (RT_SUCCESS(rc)) { /* * Registering ourselves as a character device. */ g_iMajorDeviceNo = cdevsw_add(-1, &g_DevCW); if (g_iMajorDeviceNo >= 0) { #ifdef VBOX_WITH_HARDENING g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0600, DEVICE_NAME_SYS); #else g_hDevFsDeviceSys = devfs_make_node(makedev(g_iMajorDeviceNo, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_SYS); #endif if (g_hDevFsDeviceSys) { g_hDevFsDeviceUsr = devfs_make_node(makedev(g_iMajorDeviceNo, 1), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666, DEVICE_NAME_USR); if (g_hDevFsDeviceUsr) { LogRel(("VBoxDrv: version " VBOX_VERSION_STRING " r%d; IOCtl version %#x; IDC version %#x; dev major=%d\n", VBOX_SVN_REV, SUPDRV_IOC_VERSION, SUPDRV_IDC_VERSION, g_iMajorDeviceNo)); /* Register a sleep/wakeup notification callback */ g_pSleepNotifier = registerPrioritySleepWakeInterest(&VBoxDrvDarwinSleepHandler, &g_DevExt, NULL); if (g_pSleepNotifier == NULL) LogRel(("VBoxDrv: register for sleep/wakeup events failed\n")); /* Find kernel symbols that are kind of optional. */ vboxdrvDarwinResolveSymbols(); return KMOD_RETURN_SUCCESS; } LogRel(("VBoxDrv: devfs_make_node(makedev(%d,1),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_USR)); devfs_remove(g_hDevFsDeviceSys); g_hDevFsDeviceSys = NULL; } else LogRel(("VBoxDrv: devfs_make_node(makedev(%d,0),,,,%s) failed\n", g_iMajorDeviceNo, DEVICE_NAME_SYS)); cdevsw_remove(g_iMajorDeviceNo, &g_DevCW); g_iMajorDeviceNo = -1; } else LogRel(("VBoxDrv: cdevsw_add failed (%d)\n", g_iMajorDeviceNo)); RTSpinlockDestroy(g_Spinlock); g_Spinlock = NIL_RTSPINLOCK; } else LogRel(("VBoxDrv: RTSpinlockCreate failed (rc=%d)\n", rc)); supdrvDeleteDevExt(&g_DevExt); } else printf("VBoxDrv: failed to initialize device extension (rc=%d)\n", rc); RTR0TermForced(); } else printf("VBoxDrv: failed to initialize IPRT (rc=%d)\n", rc); memset(&g_DevExt, 0, sizeof(g_DevExt)); return KMOD_RETURN_FAILURE; }
CdevMajorIniter::CdevMajorIniter(void) { majorNumber = cdevsw_add(-1, &cdevsw); }
static void wst_drvinit(void *unused) { cdevsw_add(&wst_cdevsw); }