static int
zc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
zc_state_t *zcs;
int instance;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
instance = ddi_get_instance(dip);
if (ddi_soft_state_zalloc(zc_soft_state, instance) != DDI_SUCCESS)
return (DDI_FAILURE);
if ((ddi_create_minor_node(dip, ZCONS_SLAVE_NAME, S_IFCHR,
instance << 1 | ZC_SLAVE_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE) ||
(ddi_create_minor_node(dip, ZCONS_MASTER_NAME, S_IFCHR,
instance << 1 | ZC_MASTER_MINOR, DDI_PSEUDO, 0) == DDI_FAILURE)) {
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(zc_soft_state, instance);
return (DDI_FAILURE);
}
if ((zcs = ddi_get_soft_state(zc_soft_state, instance)) == NULL) {
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(zc_soft_state, instance);
return (DDI_FAILURE);
}
zcs->zc_devinfo = dip;
return (DDI_SUCCESS);
}
/*
* xpvtap_detach()
*/
static int
xpvtap_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
xpvtap_state_t *state;
int instance;
instance = ddi_get_instance(dip);
state = ddi_get_soft_state(xpvtap_statep, instance);
if (state == NULL) {
return (DDI_FAILURE);
}
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
default:
return (DDI_FAILURE);
}
xpvtap_user_thread_stop(state);
blk_ring_fini(&state->bt_guest_ring);
xpvtap_drv_fini(state);
ddi_remove_minor_node(dip, NULL);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
pseudonex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance;
pseudonex_state_t *pnx_state;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
/*
* Save the devi for this instance in the soft_state data.
*/
instance = ddi_get_instance(devi);
if (ddi_soft_state_zalloc(pseudonex_state, instance) != DDI_SUCCESS)
return (DDI_FAILURE);
pnx_state = ddi_get_soft_state(pseudonex_state, instance);
pnx_state->pnx_devi = devi;
if (ddi_create_minor_node(devi, "devctl", S_IFCHR, instance,
DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(pseudonex_state, instance);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
tcli_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
int instance = ddi_get_instance(devi);
struct dstate *dstatep;
int rval;
if (cmd != DDI_ATTACH)
return (DDI_SUCCESS);
if (ddi_soft_state_zalloc(dstates, instance) != DDI_SUCCESS) {
cmn_err(CE_CONT, "%s%d: can't allocate state\n",
ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
dstatep = ddi_get_soft_state(dstates, instance);
dstatep->dip = devi;
rval = ddi_create_minor_node(devi, "client", S_IFCHR,
(INST_TO_MINOR(instance)), DDI_PSEUDO, NULL);
if (rval == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
ddi_soft_state_free(dstates, instance);
cmn_err(CE_WARN, "%s%d: can't create minor nodes",
ddi_get_name(devi), instance);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
}
static int
sckm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
SCKM_DEBUG1(D_ATTACH, "in sckm_attach, cmd=%d", cmd);
switch (cmd) {
case DDI_ATTACH:
SCKM_DEBUG0(D_ATTACH, "sckm_attach: DDI_ATTACH");
if (ddi_create_minor_node(devi, "sckmdrv", S_IFCHR,
0, NULL, NULL) == DDI_FAILURE) {
cmn_err(CE_WARN, "ddi_create_minor_node failed");
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
sckm_devi = devi;
break;
case DDI_SUSPEND:
SCKM_DEBUG0(D_ATTACH, "sckm_attach: DDI_SUSPEND");
break;
default:
cmn_err(CE_WARN, "sckm_attach: bad cmd %d\n", cmd);
return (DDI_FAILURE);
}
SCKM_DEBUG0(D_ATTACH, "out sckm_attach (DDI_SUCCESS)");
return (DDI_SUCCESS);
}
static int
systrace_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);
}
systrace_probe = (void (*)())dtrace_probe;
membar_enter();
if (ddi_create_minor_node(devi, "systrace", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE ||
dtrace_register("syscall", &systrace_attr, DTRACE_PRIV_USER, NULL,
&systrace_pops, NULL, &systrace_id) != 0) {
systrace_probe = systrace_stub;
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
systrace_devi = devi;
return (DDI_SUCCESS);
}
static int
sdt_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
sdt_provider_t *prov;
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
for (prov = sdt_providers; prov->sdtp_name != NULL; prov++) {
if (prov->sdtp_id != DTRACE_PROVNONE) {
if (dtrace_unregister(prov->sdtp_id) != 0)
return (DDI_FAILURE);
prov->sdtp_id = DTRACE_PROVNONE;
}
}
ddi_remove_minor_node(devi, NULL);
return (DDI_SUCCESS);
}
static int
profile_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 (ddi_create_minor_node(devi, "profile", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE ||
dtrace_register("profile", &profile_attr,
DTRACE_PRIV_KERNEL | DTRACE_PRIV_USER, NULL,
&profile_pops, NULL, &profile_id) != 0) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
profile_max = ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
"profile-max-probes", PROFILE_MAX_DEFAULT);
ddi_report_dev(devi);
profile_devi = devi;
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
sdt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
#pragma unused(cmd)
sdt_provider_t *prov;
if (ddi_create_minor_node(devi, "sdt", S_IFCHR,
0, DDI_PSEUDO, 0) == DDI_FAILURE) {
cmn_err(CE_NOTE, "/dev/sdt couldn't create minor node");
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
sdt_devi = devi;
if (sdt_probetab_size == 0)
sdt_probetab_size = SDT_PROBETAB_SIZE;
sdt_probetab_mask = sdt_probetab_size - 1;
sdt_probetab =
kmem_zalloc(sdt_probetab_size * sizeof (sdt_probe_t *), KM_SLEEP);
dtrace_invop_add(sdt_invop);
for (prov = sdt_providers; prov->sdtp_name != NULL; prov++) {
if (dtrace_register(prov->sdtp_name, prov->sdtp_attr,
DTRACE_PRIV_KERNEL, NULL,
&sdt_pops, prov, &prov->sdtp_id) != 0) {
cmn_err(CE_WARN, "failed to register sdt provider %s",
prov->sdtp_name);
}
}
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
ippctl_detach(
dev_info_t *dip,
ddi_detach_cmd_t cmd)
{
switch (cmd) {
case DDI_DETACH:
break;
case DDI_PM_SUSPEND:
/*FALLTHRU*/
case DDI_SUSPEND:
/*FALLTHRU*/
default:
return (DDI_FAILURE);
}
DBG0(DBG_DEVOPS, "DDI_DETACH\n");
ASSERT(dip == ippctl_dip);
ddi_remove_minor_node(dip, NULL);
mutex_destroy(&ippctl_lock);
ippctl_dip = NULL;
return (DDI_SUCCESS);
}
static int
ipmi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
if (ipmi_found == B_FALSE)
return (DDI_SUCCESS);
if (!list_is_empty(&dev_list))
return (DDI_FAILURE);
/* poke the taskq so that it can terminate */
sc->ipmi_detaching = 1;
cv_signal(&sc->ipmi_request_added);
ddi_remove_minor_node(dip, NULL);
ipmi_dip = NULL;
taskq_destroy(sc->ipmi_kthread);
list_destroy(&dev_list);
id_space_destroy(minor_ids);
ipmi_attached = B_FALSE;
return (DDI_SUCCESS);
}
/**
* Detach entry point, to detach a device to the system or suspend it.
*
* @param pDip The module structure instance.
* @param enmCmd Attach type (ddi_attach_cmd_t)
*
* @return corresponding solaris error code.
*/
static int VBoxGuestSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd)
{
LogFlow((DEVICE_NAME "::Detach\n"));
switch (enmCmd)
{
case DDI_DETACH:
{
VBoxGuestSolarisRemoveIRQ(pDip);
ddi_regs_map_free(&g_PciIOHandle);
ddi_regs_map_free(&g_PciMMIOHandle);
ddi_remove_minor_node(pDip, NULL);
VBoxGuestDeleteDevExt(&g_DevExt);
g_pDip = NULL;
return DDI_SUCCESS;
}
case DDI_SUSPEND:
{
/** @todo implement suspend for guest driver. */
return DDI_SUCCESS;
}
default:
return DDI_FAILURE;
}
}
static int
lx_ptm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int err;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, LX_PTM_MINOR_NODE, S_IFCHR,
ddi_get_instance(dip), DDI_PSEUDO, 0) != DDI_SUCCESS)
return (DDI_FAILURE);
err = ldi_ident_from_dip(dip, &lps.lps_li);
if (err != 0) {
ddi_remove_minor_node(dip, ddi_get_name(dip));
return (DDI_FAILURE);
}
lps.lps_dip = dip;
lps.lps_pts_major = ddi_name_to_major(LP_PTS_DRV_NAME);
rw_init(&lps.lps_lh_rwlock, NULL, RW_DRIVER, NULL);
lps.lps_lh_count = 0;
lps.lps_lh_array = NULL;
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
tvhci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
int instance = ddi_get_instance(dip);
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
case DDI_PM_SUSPEND:
return (0); /* nothing to do */
default:
return (DDI_FAILURE);
}
if (mdi_vhci_unregister(dip, 0) != MDI_SUCCESS)
return (DDI_FAILURE);
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(tvhci_state, instance);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
mouse8042_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
struct mouse_state *state;
state = ddi_get_driver_private(dip);
switch (cmd) {
case DDI_SUSPEND:
/* Ignore all data from mouse8042_intr until we fully resume */
state->ready = 0;
return (DDI_SUCCESS);
case DDI_DETACH:
ddi_remove_intr(dip, 0, state->ms_iblock_cookie);
mouse8042_dip = NULL;
cv_destroy(&state->reset_cv);
mutex_destroy(&state->reset_mutex);
mutex_destroy(&state->ms_mutex);
ddi_prop_remove_all(dip);
ddi_regs_map_free(&state->ms_handle);
ddi_remove_minor_node(dip, NULL);
kmem_free(state, sizeof (struct mouse_state));
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static void
ppb_removechild(dev_info_t *dip)
{
ppb_devstate_t *ppb;
ppb = (ppb_devstate_t *)ddi_get_soft_state(ppb_state,
ddi_get_instance(ddi_get_parent(dip)));
if (PM_CAPABLE(ppb->ppb_pwr_p)) {
DEBUG2(DBG_PWR, ddi_get_parent(dip),
"UNINITCHILD: removing pwr_info for %s@%s\n",
ddi_node_name(dip), ddi_get_name_addr(dip));
pci_pwr_rm_info(ppb->ppb_pwr_p, dip);
}
ddi_set_name_addr(dip, NULL);
/*
* Strip the node to properly convert it back to prototype form
*/
ddi_remove_minor_node(dip, NULL);
impl_rem_dev_props(dip);
}
static int
lockstat_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 (ddi_create_minor_node(devi, "lockstat", S_IFCHR, 0,
DDI_PSEUDO, 0) == DDI_FAILURE ||
dtrace_register("lockstat", &lockstat_attr, DTRACE_PRIV_KERNEL,
NULL, &lockstat_pops, NULL, &lockstat_id) != 0) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
lockstat_probe = dtrace_probe;
membar_producer();
ddi_report_dev(devi);
lockstat_devi = devi;
return (DDI_SUCCESS);
}
static int
ncall_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
switch (cmd) {
case DDI_DETACH:
/*
* If still active, then refuse to detach.
*/
if (ncall_modules != NULL || ncall_active)
return (DDI_FAILURE);
/*
* Remove all minor nodes.
*/
ddi_remove_minor_node(dip, NULL);
ncall_dip = NULL;
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
sdt_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
sdt_provider_t *prov;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ddi_create_minor_node(devi, "sdt", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
ddi_report_dev(devi);
sdt_devi = devi;
for (prov = sdt_providers; prov->sdtp_name != NULL; prov++) {
if (dtrace_register(prov->sdtp_name, prov->sdtp_attr,
DTRACE_PRIV_KERNEL, NULL,
&sdt_pops, prov, &prov->sdtp_id) != 0) {
cmn_err(CE_WARN, "failed to register sdt provider %s",
prov->sdtp_name);
}
}
return (DDI_SUCCESS);
}
static void
ppb_removechild(dev_info_t *dip)
{
struct ddi_parent_private_data *pdptr;
ppb_devstate_t *ppb;
ppb = (ppb_devstate_t *)ddi_get_soft_state(ppb_state,
ddi_get_instance(ddi_get_parent(dip)));
if (ppb->parent_bus == PCIE_PCIECAP_DEV_TYPE_PCIE_DEV) {
pcie_fini_dom(dip);
pcie_fini_cfghdl(dip);
} else if ((pdptr = ddi_get_parent_data(dip)) != NULL) {
kmem_free(pdptr, (sizeof (*pdptr) + sizeof (struct intrspec)));
ddi_set_parent_data(dip, NULL);
}
ddi_set_name_addr(dip, NULL);
/*
* Strip the node to properly convert it back to prototype form
*/
ddi_remove_minor_node(dip, NULL);
impl_rem_dev_props(dip);
}
static int
tsalarm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
int inst;
struct tsalarm_softc *softc;
switch (cmd) {
case DDI_DETACH:
inst = ddi_get_instance(dip);
if ((softc = getsoftc(inst)) == NULL)
return (DDI_FAILURE);
/*
* Free the soft state and remove minor node added earlier.
*/
ddi_remove_minor_node(dip, NULL);
mutex_destroy(&softc->mutex);
ddi_soft_state_free(statep, inst);
return (DDI_SUCCESS);
case DDI_SUSPEND:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
gpio_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
int instance;
struct gpio_softc *softc;
switch (cmd) {
case DDI_DETACH:
instance = ddi_get_instance(dip);
DBG(dip, "detach: instance is %d", instance, 0, 0, 0, 0);
if ((softc = getsoftc(instance)) == NULL)
return (ENXIO);
mutex_destroy(&softc->gp_mutex);
ddi_regs_map_free(&softc->gp_handle);
ddi_soft_state_free(statep, instance);
ddi_remove_minor_node(dip, NULL);
return (DDI_SUCCESS);
case DDI_SUSPEND:
/* Nothing to do in the suspend case. */
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
dump_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
ddi_remove_minor_node(devi, NULL);
return (DDI_SUCCESS);
}
static void
fbt_cleanup(dev_info_t *devi)
{
dtrace_invop_remove(fbt_invop);
ddi_remove_minor_node(devi, NULL);
kmem_free(fbt_probetab, fbt_probetab_size * sizeof (fbt_probe_t *));
fbt_probetab = NULL;
fbt_probetab_mask = 0;
}
/*ARGSUSED*/
static int
logiattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int unit;
struct driver_minor_data *dmdp;
struct strmseinfo *logiptr = 0;
#ifdef LOGI_DEBUG
if (logi_debug) {
PRF("logiattach entry\n");
}
#endif
switch (cmd) {
case DDI_ATTACH:
unit = ddi_get_instance(dip);
for (dmdp = logi_minor_data; dmdp->name != NULL; dmdp++) {
if (ddi_create_minor_node(dip, dmdp->name, dmdp->type,
dmdp->minor, DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
ddi_prop_remove_all(dip);
#ifdef LOGI_DEBUG
if (logi_debug)
PRF("logiattach: "
"ddi_create_minor_node failed\n");
#endif
return (DDI_FAILURE);
}
}
logiunits[unit] = dip;
/* allocate and initialize state structure */
logiptr = kmem_zalloc(sizeof (struct strmseinfo), KM_SLEEP);
logiptr->state = 0; /* not opened */
ddi_set_driver_private(dip, logiptr);
if (ddi_add_intr(dip, (uint_t)0, &logiptr->iblock,
(ddi_idevice_cookie_t *)0, logiintr,
(caddr_t)logiptr) != DDI_SUCCESS) {
#ifdef LOGI_DEBUG
if (logi_debug)
PRF("logiattach: ddi_add_intr failed\n");
#endif
cmn_err(CE_WARN, "logi: cannot add intr\n");
return (DDI_FAILURE);
}
mutex_init(&logiptr->lock, NULL, MUTEX_DRIVER,
(void *)logiptr->iblock);
ddi_report_dev(dip);
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/*
* _mi_driver_detach()
*
* Description:
* Detach an interface to the system.
*/
static int
_mi_driver_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
if (cmd != DDI_DETACH) {
return (DDI_FAILURE);
}
ddi_remove_minor_node(dip, NULL);
_mi_dip = NULL;
return (DDI_SUCCESS);
}
static int
cryptoadm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
cryptoadm_dip = NULL;
ddi_remove_minor_node(dip, NULL);
return (DDI_SUCCESS);
}
static int
ipmi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
/* this driver only supports one device instance */
if (ddi_get_instance(dip) != 0) {
cmn_err(CE_WARN,
"!not attaching to non-zero device instance %d",
ddi_get_instance(dip));
return (DDI_FAILURE);
}
if (get_smbios_ipmi_info() == DDI_FAILURE)
return (DDI_FAILURE);
/*
* Support for the other types (SMIC, SSIF) should be added here.
*/
switch (sc->ipmi_io_type) {
case SMB_IPMI_T_KCS:
if (ipmi_kcs_attach(sc) != 0)
return (DDI_FAILURE);
break;
default:
return (DDI_FAILURE);
}
ipmi_found = B_TRUE;
if (ddi_create_minor_node(dip, "ipmi", S_IFCHR, 0, DDI_PSEUDO,
0) == DDI_FAILURE) {
cmn_err(CE_WARN, "!attach could not create minor node");
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
ipmi_dip = dip;
list_create(&dev_list, sizeof (ipmi_device_t),
offsetof(ipmi_device_t, ipmi_node));
/* Create ID space for open devs. ID 0 is reserved. */
minor_ids = id_space_create("ipmi_id_space", 1, 128);
if (ipmi_startup(sc) != B_TRUE) {
ipmi_cleanup(dip);
return (DDI_FAILURE);
}
ipmi_attached = B_TRUE;
return (DDI_SUCCESS);
}
static int
sad_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(devi, "user", S_IFCHR,
0, DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
if (ddi_create_priv_minor_node(devi, "admin", S_IFCHR,
1, DDI_PSEUDO, PRIVONLY_DEV, PRIV_SYS_CONFIG,
PRIV_SYS_CONFIG, 0666) == DDI_FAILURE) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
sad_dip = devi;
return (DDI_SUCCESS);
}
static int
rnd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, "random", S_IFCHR, DEVRANDOM,
DDI_PSEUDO, 0) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
if (ddi_create_minor_node(dip, "urandom", S_IFCHR, DEVURANDOM,
DDI_PSEUDO, 0) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
rnd_dip = dip;
return (DDI_SUCCESS);
}