/* $OpenBSD: subr_autoconf.c,v 1.97 2022/11/07 14:25:44 robert Exp $ */ /* $NetBSD: subr_autoconf.c,v 1.21 1996/04/04 06:06:18 cgd Exp $ */ /* * Copyright (c) 1992, 1993 * The Regents of the University of California. All rights reserved. * * This software was developed by the Computer Systems Engineering group * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and * contributed to Berkeley. * * All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Lawrence Berkeley Laboratories. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: Header: subr_autoconf.c,v 1.12 93/02/01 19:31:48 torek Exp (LBL) * * @(#)subr_autoconf.c 8.1 (Berkeley) 6/10/93 */ #include #include #include #include #include #include #include #include #include #include "hotplug.h" #include "mpath.h" /* * Autoconfiguration subroutines. */ /* * ioconf.c exports exactly two names: cfdata and cfroots. All system * devices and drivers are found via these tables. */ extern short cfroots[]; #define ROOT ((struct device *)NULL) struct matchinfo { cfmatch_t fn; struct device *parent; void *match, *aux; int indirect, pri; }; #ifndef AUTOCONF_VERBOSE #define AUTOCONF_VERBOSE 0 #endif /* AUTOCONF_VERBOSE */ int autoconf_verbose = AUTOCONF_VERBOSE; /* trace probe calls */ static void mapply(struct matchinfo *, struct cfdata *); struct deferred_config { TAILQ_ENTRY(deferred_config) dc_queue; struct device *dc_dev; void (*dc_func)(struct device *); }; TAILQ_HEAD(, deferred_config) deferred_config_queue; TAILQ_HEAD(, deferred_config) mountroot_config_queue; void *config_rootsearch(cfmatch_t, char *, void *); void config_process_deferred_children(struct device *); struct devicelist alldevs; /* list of all devices */ volatile int config_pending; /* semaphore for mountroot */ struct mutex autoconf_attdet_mtx = MUTEX_INITIALIZER(IPL_HIGH); /* * If > 0, devices are being attached and any thread which tries to * detach will sleep; if < 0 devices are being detached and any * thread which tries to attach will sleep. */ int autoconf_attdet; /* * Versioned state of the devices tree so that changes can be detected. */ unsigned int autoconf_serial = 0; /* * Initialize autoconfiguration data structures. This occurs before console * initialization as that might require use of this subsystem. Furthermore * this means that malloc et al. isn't yet available. */ void config_init(void) { TAILQ_INIT(&deferred_config_queue); TAILQ_INIT(&mountroot_config_queue); TAILQ_INIT(&alldevs); } /* * Apply the matching function and choose the best. This is used * a few times and we want to keep the code small. */ void mapply(struct matchinfo *m, struct cfdata *cf) { int pri; void *match; if (m->indirect) match = config_make_softc(m->parent, cf); else match = cf; if (autoconf_verbose) { printf(">>> probing for %s", cf->cf_driver->cd_name); if (cf->cf_fstate == FSTATE_STAR) printf("*\n"); else printf("%d\n", cf->cf_unit); } if (m->fn != NULL) pri = (*m->fn)(m->parent, match, m->aux); else { if (cf->cf_attach->ca_match == NULL) { panic("mapply: no match function for '%s' device", cf->cf_driver->cd_name); } pri = (*cf->cf_attach->ca_match)(m->parent, match, m->aux); } if (autoconf_verbose) printf(">>> %s probe returned %d\n", cf->cf_driver->cd_name, pri); if (pri > m->pri) { if (m->indirect && m->match) { cf = ((struct device *)m->match)->dv_cfdata; free(m->match, M_DEVBUF, cf->cf_attach->ca_devsize); } m->match = match; m->pri = pri; } else { if (m->indirect) free(match, M_DEVBUF, cf->cf_attach->ca_devsize); } } /* * Iterate over all potential children of some device, calling the given * function (default being the child's match function) for each one. * Nonzero returns are matches; the highest value returned is considered * the best match. Return the `found child' if we got a match, or NULL * otherwise. The `aux' pointer is simply passed on through. * * Note that this function is designed so that it can be used to apply * an arbitrary function to all potential children (its return value * can be ignored). */ void * config_search(cfmatch_t fn, struct device *parent, void *aux) { struct cfdata *cf; short *p; struct matchinfo m; m.fn = fn; m.parent = parent; m.match = NULL; m.aux = aux; m.indirect = parent && (parent->dv_cfdata->cf_driver->cd_mode & CD_INDIRECT); m.pri = 0; for (cf = cfdata; cf->cf_driver; cf++) { /* * Skip cf if no longer eligible, otherwise scan * through parents for one matching `parent', * and try match function. */ if (cf->cf_fstate == FSTATE_FOUND) continue; if (cf->cf_fstate == FSTATE_DNOTFOUND || cf->cf_fstate == FSTATE_DSTAR) continue; if (boothowto & RB_UNHIBERNATE) { if (cf->cf_driver->cd_mode & CD_SKIPHIBERNATE) continue; if (cf->cf_driver->cd_class == DV_IFNET) continue; if (cf->cf_driver->cd_class == DV_TAPE) continue; } for (p = cf->cf_parents; *p >= 0; p++) if (parent->dv_cfdata == &cfdata[*p]) mapply(&m, cf); } if (autoconf_verbose) { if (m.match) { if (m.indirect) cf = ((struct device *)m.match)->dv_cfdata; else cf = (struct cfdata *)m.match; printf(">>> %s probe won\n", cf->cf_driver->cd_name); } else printf(">>> no winning probe\n"); } return (m.match); } /* * Iterate over all potential children of some device, calling the given * function for each one. * * Note that this function is designed so that it can be used to apply * an arbitrary function to all potential children (its return value * can be ignored). */ void config_scan(cfscan_t fn, struct device *parent) { struct cfdata *cf; short *p; void *match; int indirect; indirect = parent && (parent->dv_cfdata->cf_driver->cd_mode & CD_INDIRECT); for (cf = cfdata; cf->cf_driver; cf++) { /* * Skip cf if no longer eligible, otherwise scan * through parents for one matching `parent', * and try match function. */ if (cf->cf_fstate == FSTATE_FOUND) continue; if (cf->cf_fstate == FSTATE_DNOTFOUND || cf->cf_fstate == FSTATE_DSTAR) continue; for (p = cf->cf_parents; *p >= 0; p++) if (parent->dv_cfdata == &cfdata[*p]) { match = indirect? config_make_softc(parent, cf) : (void *)cf; (*fn)(parent, match); } } } /* * Find the given root device. * This is much like config_search, but there is no parent. */ void * config_rootsearch(cfmatch_t fn, char *rootname, void *aux) { struct cfdata *cf; short *p; struct matchinfo m; m.fn = fn; m.parent = ROOT; m.match = NULL; m.aux = aux; m.indirect = 0; m.pri = 0; /* * Look at root entries for matching name. We do not bother * with found-state here since only one instance of each possible * root child should ever be searched. */ for (p = cfroots; *p >= 0; p++) { cf = &cfdata[*p]; if (cf->cf_fstate == FSTATE_DNOTFOUND || cf->cf_fstate == FSTATE_DSTAR) continue; if (strcmp(cf->cf_driver->cd_name, rootname) == 0) mapply(&m, cf); } return (m.match); } const char *msgs[3] = { "", " not configured\n", " unsupported\n" }; /* * The given `aux' argument describes a device that has been found * on the given parent, but not necessarily configured. Locate the * configuration data for that device (using the submatch function * provided, or using candidates' cd_match configuration driver * functions) and attach it, and return true. If the device was * not configured, call the given `print' function and return 0. */ struct device * config_found_sm(struct device *parent, void *aux, cfprint_t print, cfmatch_t submatch) { void *match; if ((match = config_search(submatch, parent, aux)) != NULL) return (config_attach(parent, match, aux, print)); if (print) printf("%s", msgs[(*print)(aux, parent->dv_xname)]); return (NULL); } /* * As above, but for root devices. */ struct device * config_rootfound(char *rootname, void *aux) { void *match; if ((match = config_rootsearch((cfmatch_t)NULL, rootname, aux)) != NULL) return (config_attach(ROOT, match, aux, (cfprint_t)NULL)); printf("root device %s not configured\n", rootname); return (NULL); } /* * Attach a found device. Allocates memory for device variables. */ struct device * config_attach(struct device *parent, void *match, void *aux, cfprint_t print) { struct cfdata *cf; struct device *dev; struct cfdriver *cd; const struct cfattach *ca; mtx_enter(&autoconf_attdet_mtx); while (autoconf_attdet < 0) msleep_nsec(&autoconf_attdet, &autoconf_attdet_mtx, PWAIT, "autoconf", INFSLP); autoconf_attdet++; mtx_leave(&autoconf_attdet_mtx); if (parent && (parent->dv_cfdata->cf_driver->cd_mode & CD_INDIRECT)) { dev = match; cf = dev->dv_cfdata; } else { cf = match; dev = config_make_softc(parent, cf); } cd = cf->cf_driver; ca = cf->cf_attach; KASSERT(cd->cd_devs != NULL); KASSERT(dev->dv_unit < cd->cd_ndevs); KASSERT(cd->cd_devs[dev->dv_unit] == NULL); cd->cd_devs[dev->dv_unit] = dev; /* * If this is a "STAR" device and we used the last unit, prepare for * another one. */ if (cf->cf_fstate == FSTATE_STAR) { if (dev->dv_unit == cf->cf_unit) cf->cf_unit++; } else cf->cf_fstate = FSTATE_FOUND; TAILQ_INSERT_TAIL(&alldevs, dev, dv_list); device_ref(dev); if (parent == ROOT) printf("%s at root", dev->dv_xname); else { printf("%s at %s", dev->dv_xname, parent->dv_xname); if (print) (void) (*print)(aux, NULL); } /* * Before attaching, clobber any unfound devices that are * otherwise identical, or bump the unit number on all starred * cfdata for this device. */ for (cf = cfdata; cf->cf_driver; cf++) { if (cf->cf_driver == cd && cf->cf_unit == dev->dv_unit) { if (cf->cf_fstate == FSTATE_NOTFOUND) cf->cf_fstate = FSTATE_FOUND; if (cf->cf_fstate == FSTATE_STAR) cf->cf_unit++; } } device_register(dev, aux); (*ca->ca_attach)(parent, dev, aux); config_process_deferred_children(dev); #if NHOTPLUG > 0 if (!cold) hotplug_device_attach(cd->cd_class, dev->dv_xname); #endif mtx_enter(&autoconf_attdet_mtx); if (--autoconf_attdet == 0) wakeup(&autoconf_attdet); autoconf_serial++; mtx_leave(&autoconf_attdet_mtx); return (dev); } struct device * config_make_softc(struct device *parent, struct cfdata *cf) { struct device *dev; struct cfdriver *cd; const struct cfattach *ca; cd = cf->cf_driver; ca = cf->cf_attach; if (ca->ca_devsize < sizeof(struct device)) panic("config_make_softc"); /* get memory for all device vars */ dev = malloc(ca->ca_devsize, M_DEVBUF, M_NOWAIT|M_ZERO); if (dev == NULL) panic("config_make_softc: allocation for device softc failed"); dev->dv_class = cd->cd_class; dev->dv_cfdata = cf; dev->dv_flags = DVF_ACTIVE; /* always initially active */ /* If this is a STAR device, search for a free unit number */ if (cf->cf_fstate == FSTATE_STAR) { for (dev->dv_unit = cf->cf_starunit1; dev->dv_unit < cf->cf_unit; dev->dv_unit++) if (cd->cd_ndevs == 0 || dev->dv_unit >= cd->cd_ndevs || cd->cd_devs[dev->dv_unit] == NULL) break; } else dev->dv_unit = cf->cf_unit; /* Build the device name into dv_xname. */ if (snprintf(dev->dv_xname, sizeof(dev->dv_xname), "%s%d", cd->cd_name, dev->dv_unit) >= sizeof(dev->dv_xname)) panic("config_make_softc: device name too long"); dev->dv_parent = parent; /* put this device in the devices array */ if (dev->dv_unit >= cd->cd_ndevs) { /* * Need to expand the array. */ int old = cd->cd_ndevs, new; void **nsp; if (old == 0) new = MINALLOCSIZE / sizeof(void *); else new = old * 2; while (new <= dev->dv_unit) new *= 2; cd->cd_ndevs = new; nsp = mallocarray(new, sizeof(void *), M_DEVBUF, M_NOWAIT|M_ZERO); if (nsp == NULL) panic("config_make_softc: %sing dev array", old != 0 ? "expand" : "creat"); if (old != 0) { bcopy(cd->cd_devs, nsp, old * sizeof(void *)); free(cd->cd_devs, M_DEVBUF, old * sizeof(void *)); } cd->cd_devs = nsp; } if (cd->cd_devs[dev->dv_unit]) panic("config_make_softc: duplicate %s", dev->dv_xname); dev->dv_ref = 1; return (dev); } /* * Detach a device. Optionally forced (e.g. because of hardware * removal) and quiet. Returns zero if successful, non-zero * (an error code) otherwise. * * Note that this code wants to be run from a process context, so * that the detach can sleep to allow processes which have a device * open to run and unwind their stacks. */ int config_detach(struct device *dev, int flags) { struct cfdata *cf; const struct cfattach *ca; struct cfdriver *cd; int rv = 0, i; #ifdef DIAGNOSTIC struct device *d; #endif #if NHOTPLUG > 0 char devname[16]; #endif mtx_enter(&autoconf_attdet_mtx); while (autoconf_attdet > 0) msleep_nsec(&autoconf_attdet, &autoconf_attdet_mtx, PWAIT, "autoconf", INFSLP); autoconf_attdet--; mtx_leave(&autoconf_attdet_mtx); #if NHOTPLUG > 0 strlcpy(devname, dev->dv_xname, sizeof(devname)); #endif cf = dev->dv_cfdata; #ifdef DIAGNOSTIC if (cf->cf_fstate != FSTATE_FOUND && cf->cf_fstate != FSTATE_STAR) panic("config_detach: bad device fstate"); #endif ca = cf->cf_attach; cd = cf->cf_driver; /* * Ensure the device is deactivated. If the device has an * activation entry point and DVF_ACTIVE is still set, the * device is busy, and the detach fails. */ rv = config_deactivate(dev); /* * Try to detach the device. If that's not possible, then * we either panic() (for the forced but failed case), or * return an error. */ if (rv == 0) { if (ca->ca_detach != NULL) rv = (*ca->ca_detach)(dev, flags); else rv = EOPNOTSUPP; } if (rv != 0) { if ((flags & DETACH_FORCE) == 0) goto done; else panic("config_detach: forced detach of %s failed (%d)", dev->dv_xname, rv); } /* * The device has now been successfully detached. */ #ifdef DIAGNOSTIC /* * Sanity: If you're successfully detached, you should have no * children. (Note that because children must be attached * after parents, we only need to search the latter part of * the list.) */ i = 0; for (d = TAILQ_NEXT(dev, dv_list); d != NULL; d = TAILQ_NEXT(d, dv_list)) { if (d->dv_parent == dev) { printf("config_detach: %s attached at %s\n", d->dv_xname, dev->dv_xname); i = 1; } } if (i != 0) panic("config_detach: detached device (%s) has children", dev->dv_xname); #endif /* * Mark cfdata to show that the unit can be reused, if possible. * Note that we can only re-use a starred unit number if the unit * being detached had the last assigned unit number. */ for (cf = cfdata; cf->cf_driver; cf++) { if (cf->cf_driver == cd) { if (cf->cf_fstate == FSTATE_FOUND && cf->cf_unit == dev->dv_unit) cf->cf_fstate = FSTATE_NOTFOUND; if (cf->cf_fstate == FSTATE_STAR && cf->cf_unit == dev->dv_unit + 1) cf->cf_unit--; } } /* * Unlink from device list. */ TAILQ_REMOVE(&alldevs, dev, dv_list); device_unref(dev); /* * Remove from cfdriver's array, tell the world, and free softc. */ cd->cd_devs[dev->dv_unit] = NULL; if ((flags & DETACH_QUIET) == 0) printf("%s detached\n", dev->dv_xname); device_unref(dev); /* * If the device now has no units in use, deallocate its softc array. */ for (i = 0; i < cd->cd_ndevs; i++) if (cd->cd_devs[i] != NULL) break; if (i == cd->cd_ndevs) { /* nothing found; deallocate */ free(cd->cd_devs, M_DEVBUF, cd->cd_ndevs * sizeof(void *)); cd->cd_devs = NULL; cd->cd_ndevs = 0; cf->cf_unit = 0; } #if NHOTPLUG > 0 if (!cold) hotplug_device_detach(cd->cd_class, devname); #endif /* * Return success. */ done: mtx_enter(&autoconf_attdet_mtx); if (++autoconf_attdet == 0) wakeup(&autoconf_attdet); autoconf_serial++; mtx_leave(&autoconf_attdet_mtx); return (rv); } int config_deactivate(struct device *dev) { int rv = 0, oflags = dev->dv_flags; if (dev->dv_flags & DVF_ACTIVE) { dev->dv_flags &= ~DVF_ACTIVE; rv = config_suspend(dev, DVACT_DEACTIVATE); if (rv) dev->dv_flags = oflags; } return (rv); } /* * Defer the configuration of the specified device until all * of its parent's devices have been attached. */ void config_defer(struct device *dev, void (*func)(struct device *)) { struct deferred_config *dc; if (dev->dv_parent == NULL) panic("config_defer: can't defer config of a root device"); #ifdef DIAGNOSTIC for (dc = TAILQ_FIRST(&deferred_config_queue); dc != NULL; dc = TAILQ_NEXT(dc, dc_queue)) { if (dc->dc_dev == dev) panic("config_defer: deferred twice"); } #endif if ((dc = malloc(sizeof(*dc), M_DEVBUF, M_NOWAIT)) == NULL) panic("config_defer: can't allocate defer structure"); dc->dc_dev = dev; dc->dc_func = func; TAILQ_INSERT_TAIL(&deferred_config_queue, dc, dc_queue); config_pending_incr(); } /* * Defer the configuration of the specified device until after * root file system is mounted. */ void config_mountroot(struct device *dev, void (*func)(struct device *)) { struct deferred_config *dc; /* * No need to defer if root file system is already mounted. */ if (rootvp != NULL) { (*func)(dev); return; } #ifdef DIAGNOSTIC for (dc = TAILQ_FIRST(&mountroot_config_queue); dc != NULL; dc = TAILQ_NEXT(dc, dc_queue)) { if (dc->dc_dev == dev) panic("config_mountroot: deferred twice"); } #endif if ((dc = malloc(sizeof(*dc), M_DEVBUF, M_NOWAIT)) == NULL) panic("config_mountroot: can't allocate defer structure"); dc->dc_dev = dev; dc->dc_func = func; TAILQ_INSERT_TAIL(&mountroot_config_queue, dc, dc_queue); } /* * Process the deferred configuration queue for a device. */ void config_process_deferred_children(struct device *parent) { struct deferred_config *dc, *ndc; for (dc = TAILQ_FIRST(&deferred_config_queue); dc != NULL; dc = ndc) { ndc = TAILQ_NEXT(dc, dc_queue); if (dc->dc_dev->dv_parent == parent) { TAILQ_REMOVE(&deferred_config_queue, dc, dc_queue); (*dc->dc_func)(dc->dc_dev); free(dc, M_DEVBUF, sizeof(*dc)); config_pending_decr(); } } } /* * Process the deferred configuration queue after the root file * system is mounted . */ void config_process_deferred_mountroot(void) { struct deferred_config *dc; while ((dc = TAILQ_FIRST(&mountroot_config_queue)) != NULL) { TAILQ_REMOVE(&mountroot_config_queue, dc, dc_queue); (*dc->dc_func)(dc->dc_dev); free(dc, M_DEVBUF, sizeof(*dc)); } } /* * Manipulate the config_pending semaphore. */ void config_pending_incr(void) { config_pending++; } void config_pending_decr(void) { #ifdef DIAGNOSTIC if (config_pending == 0) panic("config_pending_decr: config_pending == 0"); #endif config_pending--; if (config_pending == 0) wakeup((void *)&config_pending); } int config_detach_children(struct device *parent, int flags) { struct device *dev, *next_dev; int rv = 0; /* * The config_detach routine may sleep, meaning devices * may be added to the queue. However, all devices will * be added to the tail of the queue, the queue won't * be re-organized, and the subtree of parent here should be locked * for purposes of adding/removing children. * * Note that we can not afford trying to walk the device list * once - our ``next'' device might be a child of the device * we are about to detach, so it would disappear. * Just play it safe and restart from the parent. */ for (dev = TAILQ_LAST(&alldevs, devicelist); dev != NULL; dev = next_dev) { if (dev->dv_parent == parent) { if ((rv = config_detach(dev, flags)) != 0) return (rv); next_dev = TAILQ_LAST(&alldevs, devicelist); } else { next_dev = TAILQ_PREV(dev, devicelist, dv_list); } } return (0); } int config_suspend(struct device *dev, int act) { const struct cfattach *ca = dev->dv_cfdata->cf_attach; int r; device_ref(dev); if (ca->ca_activate) r = (*ca->ca_activate)(dev, act); else r = config_activate_children(dev, act); device_unref(dev); return (r); } int config_suspend_all(int act) { struct device *mainbus = device_mainbus(); struct device *mpath = device_mpath(); int rv = 0; switch (act) { case DVACT_QUIESCE: case DVACT_SUSPEND: case DVACT_POWERDOWN: if (mpath) { rv = config_suspend(mpath, act); if (rv) return rv; } if (mainbus) rv = config_suspend(mainbus, act); break; case DVACT_RESUME: case DVACT_WAKEUP: if (mainbus) { rv = config_suspend(mainbus, act); if (rv) return rv; } if (mpath) rv = config_suspend(mpath, act); break; } return (rv); } /* * Call the ca_activate for each of our children, letting each * decide whether they wish to do the same for their children * and more. */ int config_activate_children(struct device *parent, int act) { struct device *d; int rv = 0; for (d = TAILQ_NEXT(parent, dv_list); d != NULL; d = TAILQ_NEXT(d, dv_list)) { if (d->dv_parent != parent) continue; switch (act) { case DVACT_QUIESCE: case DVACT_SUSPEND: case DVACT_RESUME: case DVACT_WAKEUP: case DVACT_POWERDOWN: rv = config_suspend(d, act); break; case DVACT_DEACTIVATE: rv = config_deactivate(d); break; } if (rv == 0) continue; /* * Found a device that refuses the action. * If we were being asked to suspend, we can * try to resume all previous devices. */ #ifdef DIAGNOSTIC printf("config_activate_children: device %s failed %d\n", d->dv_xname, act); #endif if (act == DVACT_RESUME) printf("failing resume cannot be handled\n"); if (act == DVACT_POWERDOWN) return (rv); if (act != DVACT_SUSPEND) return (rv); d = TAILQ_PREV(d, devicelist, dv_list); for (; d != NULL && d != parent; d = TAILQ_PREV(d, devicelist, dv_list)) { if (d->dv_parent != parent) continue; printf("resume %s\n", d->dv_xname); config_suspend(d, DVACT_RESUME); } return (rv); } return (rv); } /* * Lookup a device in the cfdriver device array. Does not return a * device if it is not active. * * Increments ref count on the device by one, reflecting the * new reference created on the stack. * * Context: process only */ struct device * device_lookup(struct cfdriver *cd, int unit) { struct device *dv = NULL; if (unit >= 0 && unit < cd->cd_ndevs) dv = (struct device *)(cd->cd_devs[unit]); if (!dv) return (NULL); if (!(dv->dv_flags & DVF_ACTIVE)) dv = NULL; if (dv != NULL) device_ref(dv); return (dv); } struct device * device_mainbus(void) { extern struct cfdriver mainbus_cd; if (mainbus_cd.cd_ndevs < 1) return (NULL); return (mainbus_cd.cd_devs[0]); } struct device * device_mpath(void) { #if NMPATH > 0 extern struct cfdriver mpath_cd; if (mpath_cd.cd_ndevs < 1) return (NULL); return (mpath_cd.cd_devs[0]); #else return (NULL); #endif } /* * Increments the ref count on the device structure. The device * structure is freed when the ref count hits 0. * * Context: process or interrupt */ void device_ref(struct device *dv) { atomic_inc_int(&dv->dv_ref); } /* * Decrement the ref count on the device structure. * * free's the structure when the ref count hits zero. * * Context: process or interrupt */ void device_unref(struct device *dv) { const struct cfattach *ca; if (atomic_dec_int_nv(&dv->dv_ref) == 0) { ca = dv->dv_cfdata->cf_attach; free(dv, M_DEVBUF, ca->ca_devsize); } }