1015 lines
25 KiB
C
1015 lines
25 KiB
C
/* $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 <sys/param.h>
|
|
#include <sys/device.h>
|
|
#include <sys/hotplug.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/atomic.h>
|
|
#include <sys/reboot.h>
|
|
|
|
#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);
|
|
}
|
|
}
|