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);
}
