/*
* Allocate a new console device and a tty to handle console ioctls.
*/
int
nullcons_newdev(struct consdev *cn)
{
int error;
int bmajor = -1, cmajor = -1;
if ((cn == NULL) || (cn->cn_pri != CN_NULL) || (cn->cn_dev != NODEV))
return 0;
/*
* Attach no-op device to the device list.
*/
error = devsw_attach("nullcn", NULL, &bmajor, &nullcn_devsw, &cmajor);
if (error != 0)
return error;
/*
* Allocate tty (mostly to have sane ioctl()).
*/
nulltty = tty_alloc();
nulltty->t_dev = makedev(cmajor, 0);
tty_attach(nulltty);
cn->cn_dev = nulltty->t_dev;
return 0;
}
static int
npf_init(void)
{
#ifdef _MODULE
devmajor_t bmajor = NODEVMAJOR, cmajor = NODEVMAJOR;
#endif
int error = 0;
npf_stats_percpu = percpu_alloc(NPF_STATS_SIZE);
npf_sysctl = NULL;
npf_bpf_sysinit();
npf_worker_sysinit();
npf_tableset_sysinit();
npf_session_sysinit();
npf_nat_sysinit();
npf_alg_sysinit();
npf_ext_sysinit();
/* Load empty configuration. */
npf_pfil_register(true);
npf_config_init();
#ifdef _MODULE
/* Attach /dev/npf device. */
error = devsw_attach("npf", NULL, &bmajor, &npf_cdevsw, &cmajor);
if (error) {
/* It will call devsw_detach(), which is safe. */
(void)npf_fini();
}
#endif
return error;
}
static int
cir_modcmd(modcmd_t cmd, void *opaque)
{
int error = 0;
#ifdef _MODULE
int bmaj = -1, cmaj = -1;
#endif
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
error = config_init_component(cfdriver_ioconf_cir,
cfattach_ioconf_cir, cfdata_ioconf_cir);
if (error)
return error;
error = devsw_attach("cir", NULL, &bmaj, &cir_cdevsw, &cmaj);
if (error)
config_fini_component(cfdriver_ioconf_cir,
cfattach_ioconf_cir, cfdata_ioconf_cir);
#endif
return error;
case MODULE_CMD_FINI:
#ifdef _MODULE
devsw_detach(NULL, &cir_cdevsw);
return config_fini_component(cfdriver_ioconf_cir,
cfattach_ioconf_cir, cfdata_ioconf_cir);
#endif
return error;
default:
return ENOTTY;
}
}
static int
cgd_modcmd(modcmd_t cmd, void *arg)
{
int error = 0;
#ifdef _MODULE
devmajor_t bmajor = -1, cmajor = -1;
#endif
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
error = config_cfdriver_attach(&cgd_cd);
if (error)
break;
error = config_cfattach_attach(cgd_cd.cd_name, &cgd_ca);
if (error) {
config_cfdriver_detach(&cgd_cd);
aprint_error("%s: unable to register cfattach\n",
cgd_cd.cd_name);
break;
}
error = devsw_attach("cgd", &cgd_bdevsw, &bmajor,
&cgd_cdevsw, &cmajor);
if (error) {
config_cfattach_detach(cgd_cd.cd_name, &cgd_ca);
config_cfdriver_detach(&cgd_cd);
break;
}
#endif
break;
case MODULE_CMD_FINI:
#ifdef _MODULE
error = config_cfattach_detach(cgd_cd.cd_name, &cgd_ca);
if (error)
break;
config_cfdriver_detach(&cgd_cd);
devsw_detach(&cgd_bdevsw, &cgd_cdevsw);
#endif
break;
case MODULE_CMD_STAT:
return ENOTTY;
default:
return ENOTTY;
}
return error;
}
static int
fss_modcmd(modcmd_t cmd, void *arg)
{
devmajor_t bmajor = -1, cmajor = -1;
int error = 0;
switch (cmd) {
case MODULE_CMD_INIT:
mutex_init(&fss_device_lock, MUTEX_DEFAULT, IPL_NONE);
error = config_cfdriver_attach(&fss_cd);
if (error) {
mutex_destroy(&fss_device_lock);
break;
}
error = config_cfattach_attach(fss_cd.cd_name, &fss_ca);
if (error) {
config_cfdriver_detach(&fss_cd);
mutex_destroy(&fss_device_lock);
break;
}
error = devsw_attach(fss_cd.cd_name,
&fss_bdevsw, &bmajor, &fss_cdevsw, &cmajor);
if (error == EEXIST)
error = 0;
if (error) {
config_cfattach_detach(fss_cd.cd_name, &fss_ca);
config_cfdriver_detach(&fss_cd);
mutex_destroy(&fss_device_lock);
break;
}
break;
case MODULE_CMD_FINI:
error = config_cfattach_detach(fss_cd.cd_name, &fss_ca);
if (error)
break;
config_cfdriver_detach(&fss_cd);
devsw_detach(&fss_bdevsw, &fss_cdevsw);
mutex_destroy(&fss_device_lock);
break;
default:
error = ENOTTY;
break;
}
return error;
}
static void
tapinit(void)
{
int error = config_cfattach_attach(tap_cd.cd_name, &tap_ca);
if (error) {
aprint_error("%s: unable to register cfattach\n",
tap_cd.cd_name);
(void)config_cfdriver_detach(&tap_cd);
return;
}
if_clone_attach(&tap_cloners);
sysctl_tap_setup(&tap_sysctl_clog);
#ifdef _MODULE
devsw_attach("tap", NULL, &tap_bmajor, &tap_cdevsw, &tap_cmajor);
#endif
}
static int
sdt_modcmd(modcmd_t cmd, void *data)
{
int bmajor = -1, cmajor = -1;
switch (cmd) {
case MODULE_CMD_INIT:
sdt_load(NULL);
return devsw_attach("sdt", NULL, &bmajor,
&sdt_cdevsw, &cmajor);
case MODULE_CMD_FINI:
sdt_unload();
return devsw_detach(NULL, &sdt_cdevsw);
default:
return ENOTTY;
}
}
int
rump_devnull_init()
{
devmajor_t null_bmaj, null_cmaj;
int error;
null_bmaj = null_cmaj = NODEVMAJOR;
error = devsw_attach("null", NULL, &null_bmaj, &null_cdevsw,&null_cmaj);
KASSERT(error || null_cmaj == 2);
error = rump_vfs_makeonedevnode(S_IFCHR,
"/dev/null", null_cmaj, DEV_NULL);
if (error)
return error;
return rump_vfs_makeonedevnode(S_IFCHR,
"/dev/zero", null_cmaj, DEV_ZERO);
}
static int
vnd_modcmd(modcmd_t cmd, void *arg)
{
int bmajor = -1, cmajor = -1, error = 0;
switch (cmd) {
case MODULE_CMD_INIT:
error = config_cfdriver_attach(&vnd_cd);
if (error)
break;
error = config_cfattach_attach(vnd_cd.cd_name, &vnd_ca);
if (error) {
config_cfdriver_detach(&vnd_cd);
aprint_error("%s: unable to register cfattach\n",
vnd_cd.cd_name);
break;
}
error = devsw_attach("vnd", &vnd_bdevsw, &bmajor,
&vnd_cdevsw, &cmajor);
if (error) {
config_cfattach_detach(vnd_cd.cd_name, &vnd_ca);
config_cfdriver_detach(&vnd_cd);
break;
}
break;
case MODULE_CMD_FINI:
error = config_cfattach_detach(vnd_cd.cd_name, &vnd_ca);
if (error)
break;
config_cfdriver_detach(&vnd_cd);
devsw_detach(&vnd_bdevsw, &vnd_cdevsw);
break;
case MODULE_CMD_STAT:
return ENOTTY;
default:
return ENOTTY;
}
return error;
}
int
sysmon_init(void)
{
int error;
#ifdef _MODULE
devmajor_t bmajor, cmajor;
#endif
error = RUN_ONCE(&once_sm, sm_init_once);
#ifdef _MODULE
mutex_enter(&sysmon_minor_mtx);
if (!sm_is_attached) {
bmajor = cmajor = -1;
error = devsw_attach("sysmon", NULL, &bmajor,
&sysmon_cdevsw, &cmajor);
sm_is_attached = (error != 0);
}
mutex_exit(&sysmon_minor_mtx);
#endif
return error;
}
static int
iscsi_modcmd(modcmd_t cmd, void *arg)
{
#ifdef _MODULE
devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
int error;
#endif
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
error = config_cfdriver_attach(&iscsi_cd);
if (error) {
return error;
}
error = config_cfattach_attach(iscsi_cd.cd_name, &iscsi_ca);
if (error) {
config_cfdriver_detach(&iscsi_cd);
aprint_error("%s: unable to register cfattach\n",
iscsi_cd.cd_name);
return error;
}
error = config_cfdata_attach(iscsi_cfdata, 1);
if (error) {
aprint_error("%s: unable to attach cfdata\n",
iscsi_cd.cd_name);
config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca);
config_cfdriver_detach(&iscsi_cd);
return error;
}
error = devsw_attach(iscsi_cd.cd_name, NULL, &bmajor,
&iscsi_cdevsw, &cmajor);
if (error) {
aprint_error("%s: unable to register devsw\n",
iscsi_cd.cd_name);
config_cfdata_detach(iscsi_cfdata);
config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca);
config_cfdriver_detach(&iscsi_cd);
return error;
}
if (config_attach_pseudo(iscsi_cfdata) == NULL) {
aprint_error("%s: config_attach_pseudo failed\n",
iscsi_cd.cd_name);
config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca);
config_cfdriver_detach(&iscsi_cd);
return ENXIO;
}
#endif
return 0;
break;
case MODULE_CMD_FINI:
#ifdef _MODULE
error = config_cfdata_detach(iscsi_cfdata);
if (error)
return error;
config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca);
config_cfdriver_detach(&iscsi_cd);
devsw_detach(NULL, &iscsi_cdevsw);
#endif
return 0;
break;
case MODULE_CMD_AUTOUNLOAD:
return EBUSY;
break;
default:
return ENOTTY;
break;
}
}
/* New module handle routine */
static int
dm_modcmd(modcmd_t cmd, void *arg)
{
#ifdef _MODULE
int error, bmajor, cmajor;
error = 0;
bmajor = -1;
cmajor = -1;
switch (cmd) {
case MODULE_CMD_INIT:
error = config_cfdriver_attach(&dm_cd);
if (error)
break;
error = config_cfattach_attach(dm_cd.cd_name, &dm_ca);
if (error) {
aprint_error("%s: unable to register cfattach\n",
dm_cd.cd_name);
return error;
}
error = devsw_attach(dm_cd.cd_name, &dm_bdevsw, &bmajor,
&dm_cdevsw, &cmajor);
if (error == EEXIST)
error = 0;
if (error) {
config_cfattach_detach(dm_cd.cd_name, &dm_ca);
config_cfdriver_detach(&dm_cd);
break;
}
dm_doinit();
break;
case MODULE_CMD_FINI:
/*
* Disable unloading of dm module if there are any devices
* defined in driver. This is probably too strong we need
* to disable auto-unload only if there is mounted dm device
* present.
*/
if (dm_dev_counter > 0)
return EBUSY;
error = dmdestroy();
if (error)
break;
config_cfdriver_detach(&dm_cd);
devsw_detach(&dm_bdevsw, &dm_cdevsw);
break;
case MODULE_CMD_STAT:
return ENOTTY;
default:
return ENOTTY;
}
return error;
#else
return ENOTTY;
#endif
}
