static void
i_log_devfs_instance_mod(void)
{
sysevent_t *ev;
sysevent_id_t eid;
static int sent_one = 0;
/*
* Prevent unnecessary event generation. Do not generate more than
* one event during boot.
*/
if (sent_one && !i_ddi_io_initialized())
return;
ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_INSTANCE_MOD, EP_DDI,
SE_NOSLEEP);
if (ev == NULL) {
return;
}
if (log_sysevent(ev, SE_NOSLEEP, &eid) != 0) {
cmn_err(CE_WARN, "i_log_devfs_instance_mod: failed to post "
"event");
} else {
sent_one = 1;
}
sysevent_free(ev);
}
void
wake_nvpflush_daemon()
{
clock_t nticks;
/*
* If the system isn't up yet
* don't even think about starting a flush.
*/
if (!i_ddi_io_initialized())
return;
mutex_enter(&nvpflush_lock);
if (nvpflush_daemon_active == 0) {
nvpflush_daemon_active = 1;
mutex_exit(&nvpflush_lock);
NVPDAEMON_DEBUG((CE_CONT, "starting nvpdaemon thread\n"));
nvpflush_thr_id = thread_create(NULL, 0,
(void (*)())nvpflush_daemon,
NULL, 0, &p0, TS_RUN, minclsyspri);
mutex_enter(&nvpflush_lock);
}
nticks = nvpflush_delay * TICKS_PER_SECOND;
nvpticks = ddi_get_lbolt() + nticks;
if (nvpflush_timer_busy == 0) {
nvpflush_timer_busy = 1;
mutex_exit(&nvpflush_lock);
nvpflush_id = timeout(nvpflush_timeout, NULL, nticks + 4);
} else
mutex_exit(&nvpflush_lock);
}
static int
e_devid_do_discovery(void)
{
ASSERT(mutex_owned(&devid_discovery_mutex));
if (i_ddi_io_initialized() == 0) {
if (devid_discovery_boot > 0) {
devid_discovery_boot--;
return (1);
}
} else {
if (devid_discovery_postboot_always > 0)
return (1);
if (devid_discovery_postboot > 0) {
devid_discovery_postboot--;
return (1);
}
if (devid_discovery_secs > 0) {
if ((ddi_get_lbolt() - devid_last_discovery) >
drv_usectohz(devid_discovery_secs * MICROSEC)) {
return (1);
}
}
}
DEVID_LOG_DISC((CE_CONT, "devid_discovery: no discovery\n"));
return (0);
}
/*
* Return success if discovery was attempted, to indicate
* that the desired device may now be available.
*/
int
e_ddi_devid_discovery(ddi_devid_t devid)
{
int flags;
int rval = DDI_SUCCESS;
mutex_enter(&devid_discovery_mutex);
if (devid_discovery_busy) {
DEVID_LOG_DISC((CE_CONT, "devid_discovery: busy\n"));
while (devid_discovery_busy) {
cv_wait(&devid_discovery_cv, &devid_discovery_mutex);
}
} else if (e_devid_do_discovery()) {
devid_discovery_busy = 1;
mutex_exit(&devid_discovery_mutex);
if (i_ddi_io_initialized() == 0) {
e_ddi_devid_hold_installed_driver(devid);
} else {
DEVID_LOG_DISC((CE_CONT,
"devid_discovery: ndi_devi_config\n"));
flags = NDI_DEVI_PERSIST | NDI_CONFIG | NDI_NO_EVENT;
if (i_ddi_io_initialized())
flags |= NDI_DRV_CONF_REPROBE;
(void) ndi_devi_config(ddi_root_node(), flags);
}
mutex_enter(&devid_discovery_mutex);
devid_discovery_busy = 0;
cv_broadcast(&devid_discovery_cv);
if (devid_discovery_secs > 0)
devid_last_discovery = ddi_get_lbolt();
DEVID_LOG_DISC((CE_CONT, "devid_discovery: done\n"));
} else {
rval = DDI_FAILURE;
DEVID_LOG_DISC((CE_CONT, "no devid discovery\n"));
}
mutex_exit(&devid_discovery_mutex);
return (rval);
}
void
i_ddi_start_flush_daemon(void)
{
ASSERT(i_ddi_io_initialized());
mutex_init(&nvpflush_lock, NULL, MUTEX_DRIVER, NULL);
cv_init(&nvpflush_cv, NULL, CV_DRIVER, NULL);
if ((NVF_IS_DIRTY(dcfd) && !devid_cache_write_disable) ||
(NVF_IS_DIRTY(sdevfd) && !sdevfd && sdev_cache_write_disable)) {
wake_nvpflush_daemon();
}
}
/*
* Lookup: filter out entries in the negative cache
* Return 1 if the lookup should not cause a reconfig.
*/
int
sdev_lookup_filter(sdev_node_t *dv, char *nm)
{
int n;
sdev_nc_list_t *ncl = sdev_ncache;
sdev_nc_node_t *lp;
char *path;
int rval = 0;
int changed = 0;
ASSERT(i_ddi_io_initialized());
ASSERT(SDEVTOV(dv)->v_type == VDIR);
if (sdev_nc_disable)
return (0);
n = strlen(dv->sdev_path) + strlen(nm) + 2;
path = kmem_alloc(n, KM_SLEEP);
(void) sprintf(path, "%s/%s", dv->sdev_path, nm);
rw_enter(&ncl->ncl_lock, RW_READER);
if ((lp = sdev_nc_findpath(ncl, path)) != NULL) {
sdcmn_err5(("%s/%s: lookup by %s cached, no reconfig\n",
dv->sdev_name, nm, curproc->p_user.u_comm));
if (sdev_nc_verbose) {
cmn_err(CE_CONT,
"?%s/%s: lookup by %s cached, no reconfig\n",
dv->sdev_name, nm, curproc->p_user.u_comm);
}
mutex_enter(&ncl->ncl_mutex);
lp->ncn_flags |= NCN_ACTIVE;
if (sdev_nc_expirecnt > 0 && lp->ncn_expirecnt > 0 &&
lp->ncn_expirecnt < sdev_nc_expirecnt) {
lp->ncn_expirecnt = sdev_nc_expirecnt;
ncl->ncl_flags |= NCL_LIST_DIRTY;
changed = 1;
}
mutex_exit(&ncl->ncl_mutex);
rval = 1;
}
rw_exit(&ncl->ncl_lock);
kmem_free(path, n);
if (changed)
sdev_nc_flush_boot_update();
return (rval);
}