The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_bus.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 1997,1998,2003 Doug Rabson
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: head/sys/kern/subr_bus.c 345965 2019-04-05 19:31:26Z kib $");
   31 
   32 #include "opt_bus.h"
   33 #include "opt_ddb.h"
   34 
   35 #include <sys/param.h>
   36 #include <sys/conf.h>
   37 #include <sys/eventhandler.h>
   38 #include <sys/filio.h>
   39 #include <sys/lock.h>
   40 #include <sys/kernel.h>
   41 #include <sys/kobj.h>
   42 #include <sys/limits.h>
   43 #include <sys/malloc.h>
   44 #include <sys/module.h>
   45 #include <sys/mutex.h>
   46 #include <sys/poll.h>
   47 #include <sys/priv.h>
   48 #include <sys/proc.h>
   49 #include <sys/condvar.h>
   50 #include <sys/queue.h>
   51 #include <machine/bus.h>
   52 #include <sys/random.h>
   53 #include <sys/rman.h>
   54 #include <sys/sbuf.h>
   55 #include <sys/selinfo.h>
   56 #include <sys/signalvar.h>
   57 #include <sys/smp.h>
   58 #include <sys/sysctl.h>
   59 #include <sys/systm.h>
   60 #include <sys/uio.h>
   61 #include <sys/bus.h>
   62 #include <sys/cpuset.h>
   63 
   64 #include <net/vnet.h>
   65 
   66 #include <machine/cpu.h>
   67 #include <machine/stdarg.h>
   68 
   69 #include <vm/uma.h>
   70 #include <vm/vm.h>
   71 
   72 #include <ddb/ddb.h>
   73 
   74 SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW, NULL, NULL);
   75 SYSCTL_ROOT_NODE(OID_AUTO, dev, CTLFLAG_RW, NULL, NULL);
   76 
   77 /*
   78  * Used to attach drivers to devclasses.
   79  */
   80 typedef struct driverlink *driverlink_t;
   81 struct driverlink {
   82         kobj_class_t    driver;
   83         TAILQ_ENTRY(driverlink) link;   /* list of drivers in devclass */
   84         int             pass;
   85         int             flags;
   86 #define DL_DEFERRED_PROBE       1       /* Probe deferred on this */
   87         TAILQ_ENTRY(driverlink) passlink;
   88 };
   89 
   90 /*
   91  * Forward declarations
   92  */
   93 typedef TAILQ_HEAD(devclass_list, devclass) devclass_list_t;
   94 typedef TAILQ_HEAD(driver_list, driverlink) driver_list_t;
   95 typedef TAILQ_HEAD(device_list, device) device_list_t;
   96 
   97 struct devclass {
   98         TAILQ_ENTRY(devclass) link;
   99         devclass_t      parent;         /* parent in devclass hierarchy */
  100         driver_list_t   drivers;     /* bus devclasses store drivers for bus */
  101         char            *name;
  102         device_t        *devices;       /* array of devices indexed by unit */
  103         int             maxunit;        /* size of devices array */
  104         int             flags;
  105 #define DC_HAS_CHILDREN         1
  106 
  107         struct sysctl_ctx_list sysctl_ctx;
  108         struct sysctl_oid *sysctl_tree;
  109 };
  110 
  111 /**
  112  * @brief Implementation of device.
  113  */
  114 struct device {
  115         /*
  116          * A device is a kernel object. The first field must be the
  117          * current ops table for the object.
  118          */
  119         KOBJ_FIELDS;
  120 
  121         /*
  122          * Device hierarchy.
  123          */
  124         TAILQ_ENTRY(device)     link;   /**< list of devices in parent */
  125         TAILQ_ENTRY(device)     devlink; /**< global device list membership */
  126         device_t        parent;         /**< parent of this device  */
  127         device_list_t   children;       /**< list of child devices */
  128 
  129         /*
  130          * Details of this device.
  131          */
  132         driver_t        *driver;        /**< current driver */
  133         devclass_t      devclass;       /**< current device class */
  134         int             unit;           /**< current unit number */
  135         char*           nameunit;       /**< name+unit e.g. foodev0 */
  136         char*           desc;           /**< driver specific description */
  137         int             busy;           /**< count of calls to device_busy() */
  138         device_state_t  state;          /**< current device state  */
  139         uint32_t        devflags;       /**< api level flags for device_get_flags() */
  140         u_int           flags;          /**< internal device flags  */
  141         u_int   order;                  /**< order from device_add_child_ordered() */
  142         void    *ivars;                 /**< instance variables  */
  143         void    *softc;                 /**< current driver's variables  */
  144 
  145         struct sysctl_ctx_list sysctl_ctx; /**< state for sysctl variables  */
  146         struct sysctl_oid *sysctl_tree; /**< state for sysctl variables */
  147 };
  148 
  149 static MALLOC_DEFINE(M_BUS, "bus", "Bus data structures");
  150 static MALLOC_DEFINE(M_BUS_SC, "bus-sc", "Bus data structures, softc");
  151 
  152 EVENTHANDLER_LIST_DEFINE(device_attach);
  153 EVENTHANDLER_LIST_DEFINE(device_detach);
  154 EVENTHANDLER_LIST_DEFINE(dev_lookup);
  155 
  156 static void devctl2_init(void);
  157 static bool device_frozen;
  158 
  159 #define DRIVERNAME(d)   ((d)? d->name : "no driver")
  160 #define DEVCLANAME(d)   ((d)? d->name : "no devclass")
  161 
  162 #ifdef BUS_DEBUG
  163 
  164 static int bus_debug = 1;
  165 SYSCTL_INT(_debug, OID_AUTO, bus_debug, CTLFLAG_RWTUN, &bus_debug, 0,
  166     "Bus debug level");
  167 
  168 #define PDEBUG(a)       if (bus_debug) {printf("%s:%d: ", __func__, __LINE__), printf a; printf("\n");}
  169 #define DEVICENAME(d)   ((d)? device_get_name(d): "no device")
  170 
  171 /**
  172  * Produce the indenting, indent*2 spaces plus a '.' ahead of that to
  173  * prevent syslog from deleting initial spaces
  174  */
  175 #define indentprintf(p) do { int iJ; printf("."); for (iJ=0; iJ<indent; iJ++) printf("  "); printf p ; } while (0)
  176 
  177 static void print_device_short(device_t dev, int indent);
  178 static void print_device(device_t dev, int indent);
  179 void print_device_tree_short(device_t dev, int indent);
  180 void print_device_tree(device_t dev, int indent);
  181 static void print_driver_short(driver_t *driver, int indent);
  182 static void print_driver(driver_t *driver, int indent);
  183 static void print_driver_list(driver_list_t drivers, int indent);
  184 static void print_devclass_short(devclass_t dc, int indent);
  185 static void print_devclass(devclass_t dc, int indent);
  186 void print_devclass_list_short(void);
  187 void print_devclass_list(void);
  188 
  189 #else
  190 /* Make the compiler ignore the function calls */
  191 #define PDEBUG(a)                       /* nop */
  192 #define DEVICENAME(d)                   /* nop */
  193 
  194 #define print_device_short(d,i)         /* nop */
  195 #define print_device(d,i)               /* nop */
  196 #define print_device_tree_short(d,i)    /* nop */
  197 #define print_device_tree(d,i)          /* nop */
  198 #define print_driver_short(d,i)         /* nop */
  199 #define print_driver(d,i)               /* nop */
  200 #define print_driver_list(d,i)          /* nop */
  201 #define print_devclass_short(d,i)       /* nop */
  202 #define print_devclass(d,i)             /* nop */
  203 #define print_devclass_list_short()     /* nop */
  204 #define print_devclass_list()           /* nop */
  205 #endif
  206 
  207 /*
  208  * dev sysctl tree
  209  */
  210 
  211 enum {
  212         DEVCLASS_SYSCTL_PARENT,
  213 };
  214 
  215 static int
  216 devclass_sysctl_handler(SYSCTL_HANDLER_ARGS)
  217 {
  218         devclass_t dc = (devclass_t)arg1;
  219         const char *value;
  220 
  221         switch (arg2) {
  222         case DEVCLASS_SYSCTL_PARENT:
  223                 value = dc->parent ? dc->parent->name : "";
  224                 break;
  225         default:
  226                 return (EINVAL);
  227         }
  228         return (SYSCTL_OUT_STR(req, value));
  229 }
  230 
  231 static void
  232 devclass_sysctl_init(devclass_t dc)
  233 {
  234 
  235         if (dc->sysctl_tree != NULL)
  236                 return;
  237         sysctl_ctx_init(&dc->sysctl_ctx);
  238         dc->sysctl_tree = SYSCTL_ADD_NODE(&dc->sysctl_ctx,
  239             SYSCTL_STATIC_CHILDREN(_dev), OID_AUTO, dc->name,
  240             CTLFLAG_RD, NULL, "");
  241         SYSCTL_ADD_PROC(&dc->sysctl_ctx, SYSCTL_CHILDREN(dc->sysctl_tree),
  242             OID_AUTO, "%parent", CTLTYPE_STRING | CTLFLAG_RD,
  243             dc, DEVCLASS_SYSCTL_PARENT, devclass_sysctl_handler, "A",
  244             "parent class");
  245 }
  246 
  247 enum {
  248         DEVICE_SYSCTL_DESC,
  249         DEVICE_SYSCTL_DRIVER,
  250         DEVICE_SYSCTL_LOCATION,
  251         DEVICE_SYSCTL_PNPINFO,
  252         DEVICE_SYSCTL_PARENT,
  253 };
  254 
  255 static int
  256 device_sysctl_handler(SYSCTL_HANDLER_ARGS)
  257 {
  258         device_t dev = (device_t)arg1;
  259         const char *value;
  260         char *buf;
  261         int error;
  262 
  263         buf = NULL;
  264         switch (arg2) {
  265         case DEVICE_SYSCTL_DESC:
  266                 value = dev->desc ? dev->desc : "";
  267                 break;
  268         case DEVICE_SYSCTL_DRIVER:
  269                 value = dev->driver ? dev->driver->name : "";
  270                 break;
  271         case DEVICE_SYSCTL_LOCATION:
  272                 value = buf = malloc(1024, M_BUS, M_WAITOK | M_ZERO);
  273                 bus_child_location_str(dev, buf, 1024);
  274                 break;
  275         case DEVICE_SYSCTL_PNPINFO:
  276                 value = buf = malloc(1024, M_BUS, M_WAITOK | M_ZERO);
  277                 bus_child_pnpinfo_str(dev, buf, 1024);
  278                 break;
  279         case DEVICE_SYSCTL_PARENT:
  280                 value = dev->parent ? dev->parent->nameunit : "";
  281                 break;
  282         default:
  283                 return (EINVAL);
  284         }
  285         error = SYSCTL_OUT_STR(req, value);
  286         if (buf != NULL)
  287                 free(buf, M_BUS);
  288         return (error);
  289 }
  290 
  291 static void
  292 device_sysctl_init(device_t dev)
  293 {
  294         devclass_t dc = dev->devclass;
  295         int domain;
  296 
  297         if (dev->sysctl_tree != NULL)
  298                 return;
  299         devclass_sysctl_init(dc);
  300         sysctl_ctx_init(&dev->sysctl_ctx);
  301         dev->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&dev->sysctl_ctx,
  302             SYSCTL_CHILDREN(dc->sysctl_tree), OID_AUTO,
  303             dev->nameunit + strlen(dc->name),
  304             CTLFLAG_RD, NULL, "", "device_index");
  305         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  306             OID_AUTO, "%desc", CTLTYPE_STRING | CTLFLAG_RD,
  307             dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A",
  308             "device description");
  309         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  310             OID_AUTO, "%driver", CTLTYPE_STRING | CTLFLAG_RD,
  311             dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A",
  312             "device driver name");
  313         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  314             OID_AUTO, "%location", CTLTYPE_STRING | CTLFLAG_RD,
  315             dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A",
  316             "device location relative to parent");
  317         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  318             OID_AUTO, "%pnpinfo", CTLTYPE_STRING | CTLFLAG_RD,
  319             dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A",
  320             "device identification");
  321         SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
  322             OID_AUTO, "%parent", CTLTYPE_STRING | CTLFLAG_RD,
  323             dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A",
  324             "parent device");
  325         if (bus_get_domain(dev, &domain) == 0)
  326                 SYSCTL_ADD_INT(&dev->sysctl_ctx,
  327                     SYSCTL_CHILDREN(dev->sysctl_tree), OID_AUTO, "%domain",
  328                     CTLFLAG_RD, NULL, domain, "NUMA domain");
  329 }
  330 
  331 static void
  332 device_sysctl_update(device_t dev)
  333 {
  334         devclass_t dc = dev->devclass;
  335 
  336         if (dev->sysctl_tree == NULL)
  337                 return;
  338         sysctl_rename_oid(dev->sysctl_tree, dev->nameunit + strlen(dc->name));
  339 }
  340 
  341 static void
  342 device_sysctl_fini(device_t dev)
  343 {
  344         if (dev->sysctl_tree == NULL)
  345                 return;
  346         sysctl_ctx_free(&dev->sysctl_ctx);
  347         dev->sysctl_tree = NULL;
  348 }
  349 
  350 /*
  351  * /dev/devctl implementation
  352  */
  353 
  354 /*
  355  * This design allows only one reader for /dev/devctl.  This is not desirable
  356  * in the long run, but will get a lot of hair out of this implementation.
  357  * Maybe we should make this device a clonable device.
  358  *
  359  * Also note: we specifically do not attach a device to the device_t tree
  360  * to avoid potential chicken and egg problems.  One could argue that all
  361  * of this belongs to the root node.  One could also further argue that the
  362  * sysctl interface that we have not might more properly be an ioctl
  363  * interface, but at this stage of the game, I'm not inclined to rock that
  364  * boat.
  365  *
  366  * I'm also not sure that the SIGIO support is done correctly or not, as
  367  * I copied it from a driver that had SIGIO support that likely hasn't been
  368  * tested since 3.4 or 2.2.8!
  369  */
  370 
  371 /* Deprecated way to adjust queue length */
  372 static int sysctl_devctl_disable(SYSCTL_HANDLER_ARGS);
  373 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_disable, CTLTYPE_INT | CTLFLAG_RWTUN |
  374     CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_disable, "I",
  375     "devctl disable -- deprecated");
  376 
  377 #define DEVCTL_DEFAULT_QUEUE_LEN 1000
  378 static int sysctl_devctl_queue(SYSCTL_HANDLER_ARGS);
  379 static int devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN;
  380 SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_queue, CTLTYPE_INT | CTLFLAG_RWTUN |
  381     CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_queue, "I", "devctl queue length");
  382 
  383 static d_open_t         devopen;
  384 static d_close_t        devclose;
  385 static d_read_t         devread;
  386 static d_ioctl_t        devioctl;
  387 static d_poll_t         devpoll;
  388 static d_kqfilter_t     devkqfilter;
  389 
  390 static struct cdevsw dev_cdevsw = {
  391         .d_version =    D_VERSION,
  392         .d_open =       devopen,
  393         .d_close =      devclose,
  394         .d_read =       devread,
  395         .d_ioctl =      devioctl,
  396         .d_poll =       devpoll,
  397         .d_kqfilter =   devkqfilter,
  398         .d_name =       "devctl",
  399 };
  400 
  401 struct dev_event_info
  402 {
  403         char *dei_data;
  404         TAILQ_ENTRY(dev_event_info) dei_link;
  405 };
  406 
  407 TAILQ_HEAD(devq, dev_event_info);
  408 
  409 static struct dev_softc
  410 {
  411         int     inuse;
  412         int     nonblock;
  413         int     queued;
  414         int     async;
  415         struct mtx mtx;
  416         struct cv cv;
  417         struct selinfo sel;
  418         struct devq devq;
  419         struct sigio *sigio;
  420 } devsoftc;
  421 
  422 static void     filt_devctl_detach(struct knote *kn);
  423 static int      filt_devctl_read(struct knote *kn, long hint);
  424 
  425 struct filterops devctl_rfiltops = {
  426         .f_isfd = 1,
  427         .f_detach = filt_devctl_detach,
  428         .f_event = filt_devctl_read,
  429 };
  430 
  431 static struct cdev *devctl_dev;
  432 
  433 static void
  434 devinit(void)
  435 {
  436         devctl_dev = make_dev_credf(MAKEDEV_ETERNAL, &dev_cdevsw, 0, NULL,
  437             UID_ROOT, GID_WHEEL, 0600, "devctl");
  438         mtx_init(&devsoftc.mtx, "dev mtx", "devd", MTX_DEF);
  439         cv_init(&devsoftc.cv, "dev cv");
  440         TAILQ_INIT(&devsoftc.devq);
  441         knlist_init_mtx(&devsoftc.sel.si_note, &devsoftc.mtx);
  442         devctl2_init();
  443 }
  444 
  445 static int
  446 devopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
  447 {
  448 
  449         mtx_lock(&devsoftc.mtx);
  450         if (devsoftc.inuse) {
  451                 mtx_unlock(&devsoftc.mtx);
  452                 return (EBUSY);
  453         }
  454         /* move to init */
  455         devsoftc.inuse = 1;
  456         mtx_unlock(&devsoftc.mtx);
  457         return (0);
  458 }
  459 
  460 static int
  461 devclose(struct cdev *dev, int fflag, int devtype, struct thread *td)
  462 {
  463 
  464         mtx_lock(&devsoftc.mtx);
  465         devsoftc.inuse = 0;
  466         devsoftc.nonblock = 0;
  467         devsoftc.async = 0;
  468         cv_broadcast(&devsoftc.cv);
  469         funsetown(&devsoftc.sigio);
  470         mtx_unlock(&devsoftc.mtx);
  471         return (0);
  472 }
  473 
  474 /*
  475  * The read channel for this device is used to report changes to
  476  * userland in realtime.  We are required to free the data as well as
  477  * the n1 object because we allocate them separately.  Also note that
  478  * we return one record at a time.  If you try to read this device a
  479  * character at a time, you will lose the rest of the data.  Listening
  480  * programs are expected to cope.
  481  */
  482 static int
  483 devread(struct cdev *dev, struct uio *uio, int ioflag)
  484 {
  485         struct dev_event_info *n1;
  486         int rv;
  487 
  488         mtx_lock(&devsoftc.mtx);
  489         while (TAILQ_EMPTY(&devsoftc.devq)) {
  490                 if (devsoftc.nonblock) {
  491                         mtx_unlock(&devsoftc.mtx);
  492                         return (EAGAIN);
  493                 }
  494                 rv = cv_wait_sig(&devsoftc.cv, &devsoftc.mtx);
  495                 if (rv) {
  496                         /*
  497                          * Need to translate ERESTART to EINTR here? -- jake
  498                          */
  499                         mtx_unlock(&devsoftc.mtx);
  500                         return (rv);
  501                 }
  502         }
  503         n1 = TAILQ_FIRST(&devsoftc.devq);
  504         TAILQ_REMOVE(&devsoftc.devq, n1, dei_link);
  505         devsoftc.queued--;
  506         mtx_unlock(&devsoftc.mtx);
  507         rv = uiomove(n1->dei_data, strlen(n1->dei_data), uio);
  508         free(n1->dei_data, M_BUS);
  509         free(n1, M_BUS);
  510         return (rv);
  511 }
  512 
  513 static  int
  514 devioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
  515 {
  516         switch (cmd) {
  517 
  518         case FIONBIO:
  519                 if (*(int*)data)
  520                         devsoftc.nonblock = 1;
  521                 else
  522                         devsoftc.nonblock = 0;
  523                 return (0);
  524         case FIOASYNC:
  525                 if (*(int*)data)
  526                         devsoftc.async = 1;
  527                 else
  528                         devsoftc.async = 0;
  529                 return (0);
  530         case FIOSETOWN:
  531                 return fsetown(*(int *)data, &devsoftc.sigio);
  532         case FIOGETOWN:
  533                 *(int *)data = fgetown(&devsoftc.sigio);
  534                 return (0);
  535 
  536                 /* (un)Support for other fcntl() calls. */
  537         case FIOCLEX:
  538         case FIONCLEX:
  539         case FIONREAD:
  540         default:
  541                 break;
  542         }
  543         return (ENOTTY);
  544 }
  545 
  546 static  int
  547 devpoll(struct cdev *dev, int events, struct thread *td)
  548 {
  549         int     revents = 0;
  550 
  551         mtx_lock(&devsoftc.mtx);
  552         if (events & (POLLIN | POLLRDNORM)) {
  553                 if (!TAILQ_EMPTY(&devsoftc.devq))
  554                         revents = events & (POLLIN | POLLRDNORM);
  555                 else
  556                         selrecord(td, &devsoftc.sel);
  557         }
  558         mtx_unlock(&devsoftc.mtx);
  559 
  560         return (revents);
  561 }
  562 
  563 static int
  564 devkqfilter(struct cdev *dev, struct knote *kn)
  565 {
  566         int error;
  567 
  568         if (kn->kn_filter == EVFILT_READ) {
  569                 kn->kn_fop = &devctl_rfiltops;
  570                 knlist_add(&devsoftc.sel.si_note, kn, 0);
  571                 error = 0;
  572         } else
  573                 error = EINVAL;
  574         return (error);
  575 }
  576 
  577 static void
  578 filt_devctl_detach(struct knote *kn)
  579 {
  580 
  581         knlist_remove(&devsoftc.sel.si_note, kn, 0);
  582 }
  583 
  584 static int
  585 filt_devctl_read(struct knote *kn, long hint)
  586 {
  587         kn->kn_data = devsoftc.queued;
  588         return (kn->kn_data != 0);
  589 }
  590 
  591 /**
  592  * @brief Return whether the userland process is running
  593  */
  594 boolean_t
  595 devctl_process_running(void)
  596 {
  597         return (devsoftc.inuse == 1);
  598 }
  599 
  600 /**
  601  * @brief Queue data to be read from the devctl device
  602  *
  603  * Generic interface to queue data to the devctl device.  It is
  604  * assumed that @p data is properly formatted.  It is further assumed
  605  * that @p data is allocated using the M_BUS malloc type.
  606  */
  607 void
  608 devctl_queue_data_f(char *data, int flags)
  609 {
  610         struct dev_event_info *n1 = NULL, *n2 = NULL;
  611 
  612         if (strlen(data) == 0)
  613                 goto out;
  614         if (devctl_queue_length == 0)
  615                 goto out;
  616         n1 = malloc(sizeof(*n1), M_BUS, flags);
  617         if (n1 == NULL)
  618                 goto out;
  619         n1->dei_data = data;
  620         mtx_lock(&devsoftc.mtx);
  621         if (devctl_queue_length == 0) {
  622                 mtx_unlock(&devsoftc.mtx);
  623                 free(n1->dei_data, M_BUS);
  624                 free(n1, M_BUS);
  625                 return;
  626         }
  627         /* Leave at least one spot in the queue... */
  628         while (devsoftc.queued > devctl_queue_length - 1) {
  629                 n2 = TAILQ_FIRST(&devsoftc.devq);
  630                 TAILQ_REMOVE(&devsoftc.devq, n2, dei_link);
  631                 free(n2->dei_data, M_BUS);
  632                 free(n2, M_BUS);
  633                 devsoftc.queued--;
  634         }
  635         TAILQ_INSERT_TAIL(&devsoftc.devq, n1, dei_link);
  636         devsoftc.queued++;
  637         cv_broadcast(&devsoftc.cv);
  638         KNOTE_LOCKED(&devsoftc.sel.si_note, 0);
  639         mtx_unlock(&devsoftc.mtx);
  640         selwakeup(&devsoftc.sel);
  641         if (devsoftc.async && devsoftc.sigio != NULL)
  642                 pgsigio(&devsoftc.sigio, SIGIO, 0);
  643         return;
  644 out:
  645         /*
  646          * We have to free data on all error paths since the caller
  647          * assumes it will be free'd when this item is dequeued.
  648          */
  649         free(data, M_BUS);
  650         return;
  651 }
  652 
  653 void
  654 devctl_queue_data(char *data)
  655 {
  656 
  657         devctl_queue_data_f(data, M_NOWAIT);
  658 }
  659 
  660 /**
  661  * @brief Send a 'notification' to userland, using standard ways
  662  */
  663 void
  664 devctl_notify_f(const char *system, const char *subsystem, const char *type,
  665     const char *data, int flags)
  666 {
  667         int len = 0;
  668         char *msg;
  669 
  670         if (system == NULL)
  671                 return;         /* BOGUS!  Must specify system. */
  672         if (subsystem == NULL)
  673                 return;         /* BOGUS!  Must specify subsystem. */
  674         if (type == NULL)
  675                 return;         /* BOGUS!  Must specify type. */
  676         len += strlen(" system=") + strlen(system);
  677         len += strlen(" subsystem=") + strlen(subsystem);
  678         len += strlen(" type=") + strlen(type);
  679         /* add in the data message plus newline. */
  680         if (data != NULL)
  681                 len += strlen(data);
  682         len += 3;       /* '!', '\n', and NUL */
  683         msg = malloc(len, M_BUS, flags);
  684         if (msg == NULL)
  685                 return;         /* Drop it on the floor */
  686         if (data != NULL)
  687                 snprintf(msg, len, "!system=%s subsystem=%s type=%s %s\n",
  688                     system, subsystem, type, data);
  689         else
  690                 snprintf(msg, len, "!system=%s subsystem=%s type=%s\n",
  691                     system, subsystem, type);
  692         devctl_queue_data_f(msg, flags);
  693 }
  694 
  695 void
  696 devctl_notify(const char *system, const char *subsystem, const char *type,
  697     const char *data)
  698 {
  699 
  700         devctl_notify_f(system, subsystem, type, data, M_NOWAIT);
  701 }
  702 
  703 /*
  704  * Common routine that tries to make sending messages as easy as possible.
  705  * We allocate memory for the data, copy strings into that, but do not
  706  * free it unless there's an error.  The dequeue part of the driver should
  707  * free the data.  We don't send data when the device is disabled.  We do
  708  * send data, even when we have no listeners, because we wish to avoid
  709  * races relating to startup and restart of listening applications.
  710  *
  711  * devaddq is designed to string together the type of event, with the
  712  * object of that event, plus the plug and play info and location info
  713  * for that event.  This is likely most useful for devices, but less
  714  * useful for other consumers of this interface.  Those should use
  715  * the devctl_queue_data() interface instead.
  716  */
  717 static void
  718 devaddq(const char *type, const char *what, device_t dev)
  719 {
  720         char *data = NULL;
  721         char *loc = NULL;
  722         char *pnp = NULL;
  723         const char *parstr;
  724 
  725         if (!devctl_queue_length)/* Rare race, but lost races safely discard */
  726                 return;
  727         data = malloc(1024, M_BUS, M_NOWAIT);
  728         if (data == NULL)
  729                 goto bad;
  730 
  731         /* get the bus specific location of this device */
  732         loc = malloc(1024, M_BUS, M_NOWAIT);
  733         if (loc == NULL)
  734                 goto bad;
  735         *loc = '\0';
  736         bus_child_location_str(dev, loc, 1024);
  737 
  738         /* Get the bus specific pnp info of this device */
  739         pnp = malloc(1024, M_BUS, M_NOWAIT);
  740         if (pnp == NULL)
  741                 goto bad;
  742         *pnp = '\0';
  743         bus_child_pnpinfo_str(dev, pnp, 1024);
  744 
  745         /* Get the parent of this device, or / if high enough in the tree. */
  746         if (device_get_parent(dev) == NULL)
  747                 parstr = ".";   /* Or '/' ? */
  748         else
  749                 parstr = device_get_nameunit(device_get_parent(dev));
  750         /* String it all together. */
  751         snprintf(data, 1024, "%s%s at %s %s on %s\n", type, what, loc, pnp,
  752           parstr);
  753         free(loc, M_BUS);
  754         free(pnp, M_BUS);
  755         devctl_queue_data(data);
  756         return;
  757 bad:
  758         free(pnp, M_BUS);
  759         free(loc, M_BUS);
  760         free(data, M_BUS);
  761         return;
  762 }
  763 
  764 /*
  765  * A device was added to the tree.  We are called just after it successfully
  766  * attaches (that is, probe and attach success for this device).  No call
  767  * is made if a device is merely parented into the tree.  See devnomatch
  768  * if probe fails.  If attach fails, no notification is sent (but maybe
  769  * we should have a different message for this).
  770  */
  771 static void
  772 devadded(device_t dev)
  773 {
  774         devaddq("+", device_get_nameunit(dev), dev);
  775 }
  776 
  777 /*
  778  * A device was removed from the tree.  We are called just before this
  779  * happens.
  780  */
  781 static void
  782 devremoved(device_t dev)
  783 {
  784         devaddq("-", device_get_nameunit(dev), dev);
  785 }
  786 
  787 /*
  788  * Called when there's no match for this device.  This is only called
  789  * the first time that no match happens, so we don't keep getting this
  790  * message.  Should that prove to be undesirable, we can change it.
  791  * This is called when all drivers that can attach to a given bus
  792  * decline to accept this device.  Other errors may not be detected.
  793  */
  794 static void
  795 devnomatch(device_t dev)
  796 {
  797         devaddq("?", "", dev);
  798 }
  799 
  800 static int
  801 sysctl_devctl_disable(SYSCTL_HANDLER_ARGS)
  802 {
  803         struct dev_event_info *n1;
  804         int dis, error;
  805 
  806         dis = (devctl_queue_length == 0);
  807         error = sysctl_handle_int(oidp, &dis, 0, req);
  808         if (error || !req->newptr)
  809                 return (error);
  810         if (mtx_initialized(&devsoftc.mtx))
  811                 mtx_lock(&devsoftc.mtx);
  812         if (dis) {
  813                 while (!TAILQ_EMPTY(&devsoftc.devq)) {
  814                         n1 = TAILQ_FIRST(&devsoftc.devq);
  815                         TAILQ_REMOVE(&devsoftc.devq, n1, dei_link);
  816                         free(n1->dei_data, M_BUS);
  817                         free(n1, M_BUS);
  818                 }
  819                 devsoftc.queued = 0;
  820                 devctl_queue_length = 0;
  821         } else {
  822                 devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN;
  823         }
  824         if (mtx_initialized(&devsoftc.mtx))
  825                 mtx_unlock(&devsoftc.mtx);
  826         return (0);
  827 }
  828 
  829 static int
  830 sysctl_devctl_queue(SYSCTL_HANDLER_ARGS)
  831 {
  832         struct dev_event_info *n1;
  833         int q, error;
  834 
  835         q = devctl_queue_length;
  836         error = sysctl_handle_int(oidp, &q, 0, req);
  837         if (error || !req->newptr)
  838                 return (error);
  839         if (q < 0)
  840                 return (EINVAL);
  841         if (mtx_initialized(&devsoftc.mtx))
  842                 mtx_lock(&devsoftc.mtx);
  843         devctl_queue_length = q;
  844         while (devsoftc.queued > devctl_queue_length) {
  845                 n1 = TAILQ_FIRST(&devsoftc.devq);
  846                 TAILQ_REMOVE(&devsoftc.devq, n1, dei_link);
  847                 free(n1->dei_data, M_BUS);
  848                 free(n1, M_BUS);
  849                 devsoftc.queued--;
  850         }
  851         if (mtx_initialized(&devsoftc.mtx))
  852                 mtx_unlock(&devsoftc.mtx);
  853         return (0);
  854 }
  855 
  856 /**
  857  * @brief safely quotes strings that might have double quotes in them.
  858  *
  859  * The devctl protocol relies on quoted strings having matching quotes.
  860  * This routine quotes any internal quotes so the resulting string
  861  * is safe to pass to snprintf to construct, for example pnp info strings.
  862  * Strings are always terminated with a NUL, but may be truncated if longer
  863  * than @p len bytes after quotes.
  864  *
  865  * @param sb    sbuf to place the characters into
  866  * @param src   Original buffer.
  867  */
  868 void
  869 devctl_safe_quote_sb(struct sbuf *sb, const char *src)
  870 {
  871 
  872         while (*src != '\0') {
  873                 if (*src == '"' || *src == '\\')
  874                         sbuf_putc(sb, '\\');
  875                 sbuf_putc(sb, *src++);
  876         }
  877 }
  878 
  879 /* End of /dev/devctl code */
  880 
  881 static TAILQ_HEAD(,device)      bus_data_devices;
  882 static int bus_data_generation = 1;
  883 
  884 static kobj_method_t null_methods[] = {
  885         KOBJMETHOD_END
  886 };
  887 
  888 DEFINE_CLASS(null, null_methods, 0);
  889 
  890 /*
  891  * Bus pass implementation
  892  */
  893 
  894 static driver_list_t passes = TAILQ_HEAD_INITIALIZER(passes);
  895 int bus_current_pass = BUS_PASS_ROOT;
  896 
  897 /**
  898  * @internal
  899  * @brief Register the pass level of a new driver attachment
  900  *
  901  * Register a new driver attachment's pass level.  If no driver
  902  * attachment with the same pass level has been added, then @p new
  903  * will be added to the global passes list.
  904  *
  905  * @param new           the new driver attachment
  906  */
  907 static void
  908 driver_register_pass(struct driverlink *new)
  909 {
  910         struct driverlink *dl;
  911 
  912         /* We only consider pass numbers during boot. */
  913         if (bus_current_pass == BUS_PASS_DEFAULT)
  914                 return;
  915 
  916         /*
  917          * Walk the passes list.  If we already know about this pass
  918          * then there is nothing to do.  If we don't, then insert this
  919          * driver link into the list.
  920          */
  921         TAILQ_FOREACH(dl, &passes, passlink) {
  922                 if (dl->pass < new->pass)
  923                         continue;
  924                 if (dl->pass == new->pass)
  925                         return;
  926                 TAILQ_INSERT_BEFORE(dl, new, passlink);
  927                 return;
  928         }
  929         TAILQ_INSERT_TAIL(&passes, new, passlink);
  930 }
  931 
  932 /**
  933  * @brief Raise the current bus pass
  934  *
  935  * Raise the current bus pass level to @p pass.  Call the BUS_NEW_PASS()
  936  * method on the root bus to kick off a new device tree scan for each
  937  * new pass level that has at least one driver.
  938  */
  939 void
  940 bus_set_pass(int pass)
  941 {
  942         struct driverlink *dl;
  943 
  944         if (bus_current_pass > pass)
  945                 panic("Attempt to lower bus pass level");
  946 
  947         TAILQ_FOREACH(dl, &passes, passlink) {
  948                 /* Skip pass values below the current pass level. */
  949                 if (dl->pass <= bus_current_pass)
  950                         continue;
  951 
  952                 /*
  953                  * Bail once we hit a driver with a pass level that is
  954                  * too high.
  955                  */
  956                 if (dl->pass > pass)
  957                         break;
  958 
  959                 /*
  960                  * Raise the pass level to the next level and rescan
  961                  * the tree.
  962                  */
  963                 bus_current_pass = dl->pass;
  964                 BUS_NEW_PASS(root_bus);
  965         }
  966 
  967         /*
  968          * If there isn't a driver registered for the requested pass,
  969          * then bus_current_pass might still be less than 'pass'.  Set
  970          * it to 'pass' in that case.
  971          */
  972         if (bus_current_pass < pass)
  973                 bus_current_pass = pass;
  974         KASSERT(bus_current_pass == pass, ("Failed to update bus pass level"));
  975 }
  976 
  977 /*
  978  * Devclass implementation
  979  */
  980 
  981 static devclass_list_t devclasses = TAILQ_HEAD_INITIALIZER(devclasses);
  982 
  983 /**
  984  * @internal
  985  * @brief Find or create a device class
  986  *
  987  * If a device class with the name @p classname exists, return it,
  988  * otherwise if @p create is non-zero create and return a new device
  989  * class.
  990  *
  991  * If @p parentname is non-NULL, the parent of the devclass is set to
  992  * the devclass of that name.
  993  *
  994  * @param classname     the devclass name to find or create
  995  * @param parentname    the parent devclass name or @c NULL
  996  * @param create        non-zero to create a devclass
  997  */
  998 static devclass_t
  999 devclass_find_internal(const char *classname, const char *parentname,
 1000                        int create)
 1001 {
 1002         devclass_t dc;
 1003 
 1004         PDEBUG(("looking for %s", classname));
 1005         if (!classname)
 1006                 return (NULL);
 1007 
 1008         TAILQ_FOREACH(dc, &devclasses, link) {
 1009                 if (!strcmp(dc->name, classname))
 1010                         break;
 1011         }
 1012 
 1013         if (create && !dc) {
 1014                 PDEBUG(("creating %s", classname));
 1015                 dc = malloc(sizeof(struct devclass) + strlen(classname) + 1,
 1016                     M_BUS, M_NOWAIT | M_ZERO);
 1017                 if (!dc)
 1018                         return (NULL);
 1019                 dc->parent = NULL;
 1020                 dc->name = (char*) (dc + 1);
 1021                 strcpy(dc->name, classname);
 1022                 TAILQ_INIT(&dc->drivers);
 1023                 TAILQ_INSERT_TAIL(&devclasses, dc, link);
 1024 
 1025                 bus_data_generation_update();
 1026         }
 1027 
 1028         /*
 1029          * If a parent class is specified, then set that as our parent so
 1030          * that this devclass will support drivers for the parent class as
 1031          * well.  If the parent class has the same name don't do this though
 1032          * as it creates a cycle that can trigger an infinite loop in
 1033          * device_probe_child() if a device exists for which there is no
 1034          * suitable driver.
 1035          */
 1036         if (parentname && dc && !dc->parent &&
 1037             strcmp(classname, parentname) != 0) {
 1038                 dc->parent = devclass_find_internal(parentname, NULL, TRUE);
 1039                 dc->parent->flags |= DC_HAS_CHILDREN;
 1040         }
 1041 
 1042         return (dc);
 1043 }
 1044 
 1045 /**
 1046  * @brief Create a device class
 1047  *
 1048  * If a device class with the name @p classname exists, return it,
 1049  * otherwise create and return a new device class.
 1050  *
 1051  * @param classname     the devclass name to find or create
 1052  */
 1053 devclass_t
 1054 devclass_create(const char *classname)
 1055 {
 1056         return (devclass_find_internal(classname, NULL, TRUE));
 1057 }
 1058 
 1059 /**
 1060  * @brief Find a device class
 1061  *
 1062  * If a device class with the name @p classname exists, return it,
 1063  * otherwise return @c NULL.
 1064  *
 1065  * @param classname     the devclass name to find
 1066  */
 1067 devclass_t
 1068 devclass_find(const char *classname)
 1069 {
 1070         return (devclass_find_internal(classname, NULL, FALSE));
 1071 }
 1072 
 1073 /**
 1074  * @brief Register that a device driver has been added to a devclass
 1075  *
 1076  * Register that a device driver has been added to a devclass.  This
 1077  * is called by devclass_add_driver to accomplish the recursive
 1078  * notification of all the children classes of dc, as well as dc.
 1079  * Each layer will have BUS_DRIVER_ADDED() called for all instances of
 1080  * the devclass.
 1081  *
 1082  * We do a full search here of the devclass list at each iteration
 1083  * level to save storing children-lists in the devclass structure.  If
 1084  * we ever move beyond a few dozen devices doing this, we may need to
 1085  * reevaluate...
 1086  *
 1087  * @param dc            the devclass to edit
 1088  * @param driver        the driver that was just added
 1089  */
 1090 static void
 1091 devclass_driver_added(devclass_t dc, driver_t *driver)
 1092 {
 1093         devclass_t parent;
 1094         int i;
 1095 
 1096         /*
 1097          * Call BUS_DRIVER_ADDED for any existing buses in this class.
 1098          */
 1099         for (i = 0; i < dc->maxunit; i++)
 1100                 if (dc->devices[i] && device_is_attached(dc->devices[i]))
 1101                         BUS_DRIVER_ADDED(dc->devices[i], driver);
 1102 
 1103         /*
 1104          * Walk through the children classes.  Since we only keep a
 1105          * single parent pointer around, we walk the entire list of
 1106          * devclasses looking for children.  We set the
 1107          * DC_HAS_CHILDREN flag when a child devclass is created on
 1108          * the parent, so we only walk the list for those devclasses
 1109          * that have children.
 1110          */
 1111         if (!(dc->flags & DC_HAS_CHILDREN))
 1112                 return;
 1113         parent = dc;
 1114         TAILQ_FOREACH(dc, &devclasses, link) {
 1115                 if (dc->parent == parent)
 1116                         devclass_driver_added(dc, driver);
 1117         }
 1118 }
 1119 
 1120 /**
 1121  * @brief Add a device driver to a device class
 1122  *
 1123  * Add a device driver to a devclass. This is normally called
 1124  * automatically by DRIVER_MODULE(). The BUS_DRIVER_ADDED() method of
 1125  * all devices in the devclass will be called to allow them to attempt
 1126  * to re-probe any unmatched children.
 1127  *
 1128  * @param dc            the devclass to edit
 1129  * @param driver        the driver to register
 1130  */
 1131 int
 1132 devclass_add_driver(devclass_t dc, driver_t *driver, int pass, devclass_t *dcp)
 1133 {
 1134         driverlink_t dl;
 1135         const char *parentname;
 1136 
 1137         PDEBUG(("%s", DRIVERNAME(driver)));
 1138 
 1139         /* Don't allow invalid pass values. */
 1140         if (pass <= BUS_PASS_ROOT)
 1141                 return (EINVAL);
 1142 
 1143         dl = malloc(sizeof *dl, M_BUS, M_NOWAIT|M_ZERO);
 1144         if (!dl)
 1145                 return (ENOMEM);
 1146 
 1147         /*
 1148          * Compile the driver's methods. Also increase the reference count
 1149          * so that the class doesn't get freed when the last instance
 1150          * goes. This means we can safely use static methods and avoids a
 1151          * double-free in devclass_delete_driver.
 1152          */
 1153         kobj_class_compile((kobj_class_t) driver);
 1154 
 1155         /*
 1156          * If the driver has any base classes, make the
 1157          * devclass inherit from the devclass of the driver's
 1158          * first base class. This will allow the system to
 1159          * search for drivers in both devclasses for children
 1160          * of a device using this driver.
 1161          */
 1162         if (driver->baseclasses)
 1163                 parentname = driver->baseclasses[0]->name;
 1164         else
 1165                 parentname = NULL;
 1166         *dcp = devclass_find_internal(driver->name, parentname, TRUE);
 1167 
 1168         dl->driver = driver;
 1169         TAILQ_INSERT_TAIL(&dc->drivers, dl, link);
 1170         driver->refs++;         /* XXX: kobj_mtx */
 1171         dl->pass = pass;
 1172         driver_register_pass(dl);
 1173 
 1174         if (device_frozen) {
 1175                 dl->flags |= DL_DEFERRED_PROBE;
 1176         } else {
 1177                 devclass_driver_added(dc, driver);
 1178         }
 1179         bus_data_generation_update();
 1180         return (0);
 1181 }
 1182 
 1183 /**
 1184  * @brief Register that a device driver has been deleted from a devclass
 1185  *
 1186  * Register that a device driver has been removed from a devclass.
 1187  * This is called by devclass_delete_driver to accomplish the
 1188  * recursive notification of all the children classes of busclass, as
 1189  * well as busclass.  Each layer will attempt to detach the driver
 1190  * from any devices that are children of the bus's devclass.  The function
 1191  * will return an error if a device fails to detach.
 1192  *
 1193  * We do a full search here of the devclass list at each iteration
 1194  * level to save storing children-lists in the devclass structure.  If
 1195  * we ever move beyond a few dozen devices doing this, we may need to
 1196  * reevaluate...
 1197  *
 1198  * @param busclass      the devclass of the parent bus
 1199  * @param dc            the devclass of the driver being deleted
 1200  * @param driver        the driver being deleted
 1201  */
 1202 static int
 1203 devclass_driver_deleted(devclass_t busclass, devclass_t dc, driver_t *driver)
 1204 {
 1205         devclass_t parent;
 1206         device_t dev;
 1207         int error, i;
 1208 
 1209         /*
 1210          * Disassociate from any devices.  We iterate through all the
 1211          * devices in the devclass of the driver and detach any which are
 1212          * using the driver and which have a parent in the devclass which
 1213          * we are deleting from.
 1214          *
 1215          * Note that since a driver can be in multiple devclasses, we
 1216          * should not detach devices which are not children of devices in
 1217          * the affected devclass.
 1218          *
 1219          * If we're frozen, we don't generate NOMATCH events. Mark to
 1220          * generate later.
 1221          */
 1222         for (i = 0; i < dc->maxunit; i++) {
 1223                 if (dc->devices[i]) {
 1224                         dev = dc->devices[i];
 1225                         if (dev->driver == driver && dev->parent &&
 1226                             dev->parent->devclass == busclass) {
 1227                                 if ((error = device_detach(dev)) != 0)
 1228                                         return (error);
 1229                                 if (device_frozen) {
 1230                                         dev->flags &= ~DF_DONENOMATCH;
 1231                                         dev->flags |= DF_NEEDNOMATCH;
 1232                                 } else {
 1233                                         BUS_PROBE_NOMATCH(dev->parent, dev);
 1234                                         devnomatch(dev);
 1235                                         dev->flags |= DF_DONENOMATCH;
 1236                                 }
 1237                         }
 1238                 }
 1239         }
 1240 
 1241         /*
 1242          * Walk through the children classes.  Since we only keep a
 1243          * single parent pointer around, we walk the entire list of
 1244          * devclasses looking for children.  We set the
 1245          * DC_HAS_CHILDREN flag when a child devclass is created on
 1246          * the parent, so we only walk the list for those devclasses
 1247          * that have children.
 1248          */
 1249         if (!(busclass->flags & DC_HAS_CHILDREN))
 1250                 return (0);
 1251         parent = busclass;
 1252         TAILQ_FOREACH(busclass, &devclasses, link) {
 1253                 if (busclass->parent == parent) {
 1254                         error = devclass_driver_deleted(busclass, dc, driver);
 1255                         if (error)
 1256                                 return (error);
 1257                 }
 1258         }
 1259         return (0);
 1260 }
 1261 
 1262 /**
 1263  * @brief Delete a device driver from a device class
 1264  *
 1265  * Delete a device driver from a devclass. This is normally called
 1266  * automatically by DRIVER_MODULE().
 1267  *
 1268  * If the driver is currently attached to any devices,
 1269  * devclass_delete_driver() will first attempt to detach from each
 1270  * device. If one of the detach calls fails, the driver will not be
 1271  * deleted.
 1272  *
 1273  * @param dc            the devclass to edit
 1274  * @param driver        the driver to unregister
 1275  */
 1276 int
 1277 devclass_delete_driver(devclass_t busclass, driver_t *driver)
 1278 {
 1279         devclass_t dc = devclass_find(driver->name);
 1280         driverlink_t dl;
 1281         int error;
 1282 
 1283         PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
 1284 
 1285         if (!dc)
 1286                 return (0);
 1287 
 1288         /*
 1289          * Find the link structure in the bus' list of drivers.
 1290          */
 1291         TAILQ_FOREACH(dl, &busclass->drivers, link) {
 1292                 if (dl->driver == driver)
 1293                         break;
 1294         }
 1295 
 1296         if (!dl) {
 1297                 PDEBUG(("%s not found in %s list", driver->name,
 1298                     busclass->name));
 1299                 return (ENOENT);
 1300         }
 1301 
 1302         error = devclass_driver_deleted(busclass, dc, driver);
 1303         if (error != 0)
 1304                 return (error);
 1305 
 1306         TAILQ_REMOVE(&busclass->drivers, dl, link);
 1307         free(dl, M_BUS);
 1308 
 1309         /* XXX: kobj_mtx */
 1310         driver->refs--;
 1311         if (driver->refs == 0)
 1312                 kobj_class_free((kobj_class_t) driver);
 1313 
 1314         bus_data_generation_update();
 1315         return (0);
 1316 }
 1317 
 1318 /**
 1319  * @brief Quiesces a set of device drivers from a device class
 1320  *
 1321  * Quiesce a device driver from a devclass. This is normally called
 1322  * automatically by DRIVER_MODULE().
 1323  *
 1324  * If the driver is currently attached to any devices,
 1325  * devclass_quiesece_driver() will first attempt to quiesce each
 1326  * device.
 1327  *
 1328  * @param dc            the devclass to edit
 1329  * @param driver        the driver to unregister
 1330  */
 1331 static int
 1332 devclass_quiesce_driver(devclass_t busclass, driver_t *driver)
 1333 {
 1334         devclass_t dc = devclass_find(driver->name);
 1335         driverlink_t dl;
 1336         device_t dev;
 1337         int i;
 1338         int error;
 1339 
 1340         PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
 1341 
 1342         if (!dc)
 1343                 return (0);
 1344 
 1345         /*
 1346          * Find the link structure in the bus' list of drivers.
 1347          */
 1348         TAILQ_FOREACH(dl, &busclass->drivers, link) {
 1349                 if (dl->driver == driver)
 1350                         break;
 1351         }
 1352 
 1353         if (!dl) {
 1354                 PDEBUG(("%s not found in %s list", driver->name,
 1355                     busclass->name));
 1356                 return (ENOENT);
 1357         }
 1358 
 1359         /*
 1360          * Quiesce all devices.  We iterate through all the devices in
 1361          * the devclass of the driver and quiesce any which are using
 1362          * the driver and which have a parent in the devclass which we
 1363          * are quiescing.
 1364          *
 1365          * Note that since a driver can be in multiple devclasses, we
 1366          * should not quiesce devices which are not children of
 1367          * devices in the affected devclass.
 1368          */
 1369         for (i = 0; i < dc->maxunit; i++) {
 1370                 if (dc->devices[i]) {
 1371                         dev = dc->devices[i];
 1372                         if (dev->driver == driver && dev->parent &&
 1373                             dev->parent->devclass == busclass) {
 1374                                 if ((error = device_quiesce(dev)) != 0)
 1375                                         return (error);
 1376                         }
 1377                 }
 1378         }
 1379 
 1380         return (0);
 1381 }
 1382 
 1383 /**
 1384  * @internal
 1385  */
 1386 static driverlink_t
 1387 devclass_find_driver_internal(devclass_t dc, const char *classname)
 1388 {
 1389         driverlink_t dl;
 1390 
 1391         PDEBUG(("%s in devclass %s", classname, DEVCLANAME(dc)));
 1392 
 1393         TAILQ_FOREACH(dl, &dc->drivers, link) {
 1394                 if (!strcmp(dl->driver->name, classname))
 1395                         return (dl);
 1396         }
 1397 
 1398         PDEBUG(("not found"));
 1399         return (NULL);
 1400 }
 1401 
 1402 /**
 1403  * @brief Return the name of the devclass
 1404  */
 1405 const char *
 1406 devclass_get_name(devclass_t dc)
 1407 {
 1408         return (dc->name);
 1409 }
 1410 
 1411 /**
 1412  * @brief Find a device given a unit number
 1413  *
 1414  * @param dc            the devclass to search
 1415  * @param unit          the unit number to search for
 1416  *
 1417  * @returns             the device with the given unit number or @c
 1418  *                      NULL if there is no such device
 1419  */
 1420 device_t
 1421 devclass_get_device(devclass_t dc, int unit)
 1422 {
 1423         if (dc == NULL || unit < 0 || unit >= dc->maxunit)
 1424                 return (NULL);
 1425         return (dc->devices[unit]);
 1426 }
 1427 
 1428 /**
 1429  * @brief Find the softc field of a device given a unit number
 1430  *
 1431  * @param dc            the devclass to search
 1432  * @param unit          the unit number to search for
 1433  *
 1434  * @returns             the softc field of the device with the given
 1435  *                      unit number or @c NULL if there is no such
 1436  *                      device
 1437  */
 1438 void *
 1439 devclass_get_softc(devclass_t dc, int unit)
 1440 {
 1441         device_t dev;
 1442 
 1443         dev = devclass_get_device(dc, unit);
 1444         if (!dev)
 1445                 return (NULL);
 1446 
 1447         return (device_get_softc(dev));
 1448 }
 1449 
 1450 /**
 1451  * @brief Get a list of devices in the devclass
 1452  *
 1453  * An array containing a list of all the devices in the given devclass
 1454  * is allocated and returned in @p *devlistp. The number of devices
 1455  * in the array is returned in @p *devcountp. The caller should free
 1456  * the array using @c free(p, M_TEMP), even if @p *devcountp is 0.
 1457  *
 1458  * @param dc            the devclass to examine
 1459  * @param devlistp      points at location for array pointer return
 1460  *                      value
 1461  * @param devcountp     points at location for array size return value
 1462  *
 1463  * @retval 0            success
 1464  * @retval ENOMEM       the array allocation failed
 1465  */
 1466 int
 1467 devclass_get_devices(devclass_t dc, device_t **devlistp, int *devcountp)
 1468 {
 1469         int count, i;
 1470         device_t *list;
 1471 
 1472         count = devclass_get_count(dc);
 1473         list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
 1474         if (!list)
 1475                 return (ENOMEM);
 1476 
 1477         count = 0;
 1478         for (i = 0; i < dc->maxunit; i++) {
 1479                 if (dc->devices[i]) {
 1480                         list[count] = dc->devices[i];
 1481                         count++;
 1482                 }
 1483         }
 1484 
 1485         *devlistp = list;
 1486         *devcountp = count;
 1487 
 1488         return (0);
 1489 }
 1490 
 1491 /**
 1492  * @brief Get a list of drivers in the devclass
 1493  *
 1494  * An array containing a list of pointers to all the drivers in the
 1495  * given devclass is allocated and returned in @p *listp.  The number
 1496  * of drivers in the array is returned in @p *countp. The caller should
 1497  * free the array using @c free(p, M_TEMP).
 1498  *
 1499  * @param dc            the devclass to examine
 1500  * @param listp         gives location for array pointer return value
 1501  * @param countp        gives location for number of array elements
 1502  *                      return value
 1503  *
 1504  * @retval 0            success
 1505  * @retval ENOMEM       the array allocation failed
 1506  */
 1507 int
 1508 devclass_get_drivers(devclass_t dc, driver_t ***listp, int *countp)
 1509 {
 1510         driverlink_t dl;
 1511         driver_t **list;
 1512         int count;
 1513 
 1514         count = 0;
 1515         TAILQ_FOREACH(dl, &dc->drivers, link)
 1516                 count++;
 1517         list = malloc(count * sizeof(driver_t *), M_TEMP, M_NOWAIT);
 1518         if (list == NULL)
 1519                 return (ENOMEM);
 1520 
 1521         count = 0;
 1522         TAILQ_FOREACH(dl, &dc->drivers, link) {
 1523                 list[count] = dl->driver;
 1524                 count++;
 1525         }
 1526         *listp = list;
 1527         *countp = count;
 1528 
 1529         return (0);
 1530 }
 1531 
 1532 /**
 1533  * @brief Get the number of devices in a devclass
 1534  *
 1535  * @param dc            the devclass to examine
 1536  */
 1537 int
 1538 devclass_get_count(devclass_t dc)
 1539 {
 1540         int count, i;
 1541 
 1542         count = 0;
 1543         for (i = 0; i < dc->maxunit; i++)
 1544                 if (dc->devices[i])
 1545                         count++;
 1546         return (count);
 1547 }
 1548 
 1549 /**
 1550  * @brief Get the maximum unit number used in a devclass
 1551  *
 1552  * Note that this is one greater than the highest currently-allocated
 1553  * unit.  If a null devclass_t is passed in, -1 is returned to indicate
 1554  * that not even the devclass has been allocated yet.
 1555  *
 1556  * @param dc            the devclass to examine
 1557  */
 1558 int
 1559 devclass_get_maxunit(devclass_t dc)
 1560 {
 1561         if (dc == NULL)
 1562                 return (-1);
 1563         return (dc->maxunit);
 1564 }
 1565 
 1566 /**
 1567  * @brief Find a free unit number in a devclass
 1568  *
 1569  * This function searches for the first unused unit number greater
 1570  * that or equal to @p unit.
 1571  *
 1572  * @param dc            the devclass to examine
 1573  * @param unit          the first unit number to check
 1574  */
 1575 int
 1576 devclass_find_free_unit(devclass_t dc, int unit)
 1577 {
 1578         if (dc == NULL)
 1579                 return (unit);
 1580         while (unit < dc->maxunit && dc->devices[unit] != NULL)
 1581                 unit++;
 1582         return (unit);
 1583 }
 1584 
 1585 /**
 1586  * @brief Set the parent of a devclass
 1587  *
 1588  * The parent class is normally initialised automatically by
 1589  * DRIVER_MODULE().
 1590  *
 1591  * @param dc            the devclass to edit
 1592  * @param pdc           the new parent devclass
 1593  */
 1594 void
 1595 devclass_set_parent(devclass_t dc, devclass_t pdc)
 1596 {
 1597         dc->parent = pdc;
 1598 }
 1599 
 1600 /**
 1601  * @brief Get the parent of a devclass
 1602  *
 1603  * @param dc            the devclass to examine
 1604  */
 1605 devclass_t
 1606 devclass_get_parent(devclass_t dc)
 1607 {
 1608         return (dc->parent);
 1609 }
 1610 
 1611 struct sysctl_ctx_list *
 1612 devclass_get_sysctl_ctx(devclass_t dc)
 1613 {
 1614         return (&dc->sysctl_ctx);
 1615 }
 1616 
 1617 struct sysctl_oid *
 1618 devclass_get_sysctl_tree(devclass_t dc)
 1619 {
 1620         return (dc->sysctl_tree);
 1621 }
 1622 
 1623 /**
 1624  * @internal
 1625  * @brief Allocate a unit number
 1626  *
 1627  * On entry, @p *unitp is the desired unit number (or @c -1 if any
 1628  * will do). The allocated unit number is returned in @p *unitp.
 1629 
 1630  * @param dc            the devclass to allocate from
 1631  * @param unitp         points at the location for the allocated unit
 1632  *                      number
 1633  *
 1634  * @retval 0            success
 1635  * @retval EEXIST       the requested unit number is already allocated
 1636  * @retval ENOMEM       memory allocation failure
 1637  */
 1638 static int
 1639 devclass_alloc_unit(devclass_t dc, device_t dev, int *unitp)
 1640 {
 1641         const char *s;
 1642         int unit = *unitp;
 1643 
 1644         PDEBUG(("unit %d in devclass %s", unit, DEVCLANAME(dc)));
 1645 
 1646         /* Ask the parent bus if it wants to wire this device. */
 1647         if (unit == -1)
 1648                 BUS_HINT_DEVICE_UNIT(device_get_parent(dev), dev, dc->name,
 1649                     &unit);
 1650 
 1651         /* If we were given a wired unit number, check for existing device */
 1652         /* XXX imp XXX */
 1653         if (unit != -1) {
 1654                 if (unit >= 0 && unit < dc->maxunit &&
 1655                     dc->devices[unit] != NULL) {
 1656                         if (bootverbose)
 1657                                 printf("%s: %s%d already exists; skipping it\n",
 1658                                     dc->name, dc->name, *unitp);
 1659                         return (EEXIST);
 1660                 }
 1661         } else {
 1662                 /* Unwired device, find the next available slot for it */
 1663                 unit = 0;
 1664                 for (unit = 0;; unit++) {
 1665                         /* If there is an "at" hint for a unit then skip it. */
 1666                         if (resource_string_value(dc->name, unit, "at", &s) ==
 1667                             0)
 1668                                 continue;
 1669 
 1670                         /* If this device slot is already in use, skip it. */
 1671                         if (unit < dc->maxunit && dc->devices[unit] != NULL)
 1672                                 continue;
 1673 
 1674                         break;
 1675                 }
 1676         }
 1677 
 1678         /*
 1679          * We've selected a unit beyond the length of the table, so let's
 1680          * extend the table to make room for all units up to and including
 1681          * this one.
 1682          */
 1683         if (unit >= dc->maxunit) {
 1684                 device_t *newlist, *oldlist;
 1685                 int newsize;
 1686 
 1687                 oldlist = dc->devices;
 1688                 newsize = roundup((unit + 1), MINALLOCSIZE / sizeof(device_t));
 1689                 newlist = malloc(sizeof(device_t) * newsize, M_BUS, M_NOWAIT);
 1690                 if (!newlist)
 1691                         return (ENOMEM);
 1692                 if (oldlist != NULL)
 1693                         bcopy(oldlist, newlist, sizeof(device_t) * dc->maxunit);
 1694                 bzero(newlist + dc->maxunit,
 1695                     sizeof(device_t) * (newsize - dc->maxunit));
 1696                 dc->devices = newlist;
 1697                 dc->maxunit = newsize;
 1698                 if (oldlist != NULL)
 1699                         free(oldlist, M_BUS);
 1700         }
 1701         PDEBUG(("now: unit %d in devclass %s", unit, DEVCLANAME(dc)));
 1702 
 1703         *unitp = unit;
 1704         return (0);
 1705 }
 1706 
 1707 /**
 1708  * @internal
 1709  * @brief Add a device to a devclass
 1710  *
 1711  * A unit number is allocated for the device (using the device's
 1712  * preferred unit number if any) and the device is registered in the
 1713  * devclass. This allows the device to be looked up by its unit
 1714  * number, e.g. by decoding a dev_t minor number.
 1715  *
 1716  * @param dc            the devclass to add to
 1717  * @param dev           the device to add
 1718  *
 1719  * @retval 0            success
 1720  * @retval EEXIST       the requested unit number is already allocated
 1721  * @retval ENOMEM       memory allocation failure
 1722  */
 1723 static int
 1724 devclass_add_device(devclass_t dc, device_t dev)
 1725 {
 1726         int buflen, error;
 1727 
 1728         PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
 1729 
 1730         buflen = snprintf(NULL, 0, "%s%d$", dc->name, INT_MAX);
 1731         if (buflen < 0)
 1732                 return (ENOMEM);
 1733         dev->nameunit = malloc(buflen, M_BUS, M_NOWAIT|M_ZERO);
 1734         if (!dev->nameunit)
 1735                 return (ENOMEM);
 1736 
 1737         if ((error = devclass_alloc_unit(dc, dev, &dev->unit)) != 0) {
 1738                 free(dev->nameunit, M_BUS);
 1739                 dev->nameunit = NULL;
 1740                 return (error);
 1741         }
 1742         dc->devices[dev->unit] = dev;
 1743         dev->devclass = dc;
 1744         snprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit);
 1745 
 1746         return (0);
 1747 }
 1748 
 1749 /**
 1750  * @internal
 1751  * @brief Delete a device from a devclass
 1752  *
 1753  * The device is removed from the devclass's device list and its unit
 1754  * number is freed.
 1755 
 1756  * @param dc            the devclass to delete from
 1757  * @param dev           the device to delete
 1758  *
 1759  * @retval 0            success
 1760  */
 1761 static int
 1762 devclass_delete_device(devclass_t dc, device_t dev)
 1763 {
 1764         if (!dc || !dev)
 1765                 return (0);
 1766 
 1767         PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
 1768 
 1769         if (dev->devclass != dc || dc->devices[dev->unit] != dev)
 1770                 panic("devclass_delete_device: inconsistent device class");
 1771         dc->devices[dev->unit] = NULL;
 1772         if (dev->flags & DF_WILDCARD)
 1773                 dev->unit = -1;
 1774         dev->devclass = NULL;
 1775         free(dev->nameunit, M_BUS);
 1776         dev->nameunit = NULL;
 1777 
 1778         return (0);
 1779 }
 1780 
 1781 /**
 1782  * @internal
 1783  * @brief Make a new device and add it as a child of @p parent
 1784  *
 1785  * @param parent        the parent of the new device
 1786  * @param name          the devclass name of the new device or @c NULL
 1787  *                      to leave the devclass unspecified
 1788  * @parem unit          the unit number of the new device of @c -1 to
 1789  *                      leave the unit number unspecified
 1790  *
 1791  * @returns the new device
 1792  */
 1793 static device_t
 1794 make_device(device_t parent, const char *name, int unit)
 1795 {
 1796         device_t dev;
 1797         devclass_t dc;
 1798 
 1799         PDEBUG(("%s at %s as unit %d", name, DEVICENAME(parent), unit));
 1800 
 1801         if (name) {
 1802                 dc = devclass_find_internal(name, NULL, TRUE);
 1803                 if (!dc) {
 1804                         printf("make_device: can't find device class %s\n",
 1805                             name);
 1806                         return (NULL);
 1807                 }
 1808         } else {
 1809                 dc = NULL;
 1810         }
 1811 
 1812         dev = malloc(sizeof(*dev), M_BUS, M_NOWAIT|M_ZERO);
 1813         if (!dev)
 1814                 return (NULL);
 1815 
 1816         dev->parent = parent;
 1817         TAILQ_INIT(&dev->children);
 1818         kobj_init((kobj_t) dev, &null_class);
 1819         dev->driver = NULL;
 1820         dev->devclass = NULL;
 1821         dev->unit = unit;
 1822         dev->nameunit = NULL;
 1823         dev->desc = NULL;
 1824         dev->busy = 0;
 1825         dev->devflags = 0;
 1826         dev->flags = DF_ENABLED;
 1827         dev->order = 0;
 1828         if (unit == -1)
 1829                 dev->flags |= DF_WILDCARD;
 1830         if (name) {
 1831                 dev->flags |= DF_FIXEDCLASS;
 1832                 if (devclass_add_device(dc, dev)) {
 1833                         kobj_delete((kobj_t) dev, M_BUS);
 1834                         return (NULL);
 1835                 }
 1836         }
 1837         if (parent != NULL && device_has_quiet_children(parent))
 1838                 dev->flags |= DF_QUIET | DF_QUIET_CHILDREN;
 1839         dev->ivars = NULL;
 1840         dev->softc = NULL;
 1841 
 1842         dev->state = DS_NOTPRESENT;
 1843 
 1844         TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink);
 1845         bus_data_generation_update();
 1846 
 1847         return (dev);
 1848 }
 1849 
 1850 /**
 1851  * @internal
 1852  * @brief Print a description of a device.
 1853  */
 1854 static int
 1855 device_print_child(device_t dev, device_t child)
 1856 {
 1857         int retval = 0;
 1858 
 1859         if (device_is_alive(child))
 1860                 retval += BUS_PRINT_CHILD(dev, child);
 1861         else
 1862                 retval += device_printf(child, " not found\n");
 1863 
 1864         return (retval);
 1865 }
 1866 
 1867 /**
 1868  * @brief Create a new device
 1869  *
 1870  * This creates a new device and adds it as a child of an existing
 1871  * parent device. The new device will be added after the last existing
 1872  * child with order zero.
 1873  *
 1874  * @param dev           the device which will be the parent of the
 1875  *                      new child device
 1876  * @param name          devclass name for new device or @c NULL if not
 1877  *                      specified
 1878  * @param unit          unit number for new device or @c -1 if not
 1879  *                      specified
 1880  *
 1881  * @returns             the new device
 1882  */
 1883 device_t
 1884 device_add_child(device_t dev, const char *name, int unit)
 1885 {
 1886         return (device_add_child_ordered(dev, 0, name, unit));
 1887 }
 1888 
 1889 /**
 1890  * @brief Create a new device
 1891  *
 1892  * This creates a new device and adds it as a child of an existing
 1893  * parent device. The new device will be added after the last existing
 1894  * child with the same order.
 1895  *
 1896  * @param dev           the device which will be the parent of the
 1897  *                      new child device
 1898  * @param order         a value which is used to partially sort the
 1899  *                      children of @p dev - devices created using
 1900  *                      lower values of @p order appear first in @p
 1901  *                      dev's list of children
 1902  * @param name          devclass name for new device or @c NULL if not
 1903  *                      specified
 1904  * @param unit          unit number for new device or @c -1 if not
 1905  *                      specified
 1906  *
 1907  * @returns             the new device
 1908  */
 1909 device_t
 1910 device_add_child_ordered(device_t dev, u_int order, const char *name, int unit)
 1911 {
 1912         device_t child;
 1913         device_t place;
 1914 
 1915         PDEBUG(("%s at %s with order %u as unit %d",
 1916             name, DEVICENAME(dev), order, unit));
 1917         KASSERT(name != NULL || unit == -1,
 1918             ("child device with wildcard name and specific unit number"));
 1919 
 1920         child = make_device(dev, name, unit);
 1921         if (child == NULL)
 1922                 return (child);
 1923         child->order = order;
 1924 
 1925         TAILQ_FOREACH(place, &dev->children, link) {
 1926                 if (place->order > order)
 1927                         break;
 1928         }
 1929 
 1930         if (place) {
 1931                 /*
 1932                  * The device 'place' is the first device whose order is
 1933                  * greater than the new child.
 1934                  */
 1935                 TAILQ_INSERT_BEFORE(place, child, link);
 1936         } else {
 1937                 /*
 1938                  * The new child's order is greater or equal to the order of
 1939                  * any existing device. Add the child to the tail of the list.
 1940                  */
 1941                 TAILQ_INSERT_TAIL(&dev->children, child, link);
 1942         }
 1943 
 1944         bus_data_generation_update();
 1945         return (child);
 1946 }
 1947 
 1948 /**
 1949  * @brief Delete a device
 1950  *
 1951  * This function deletes a device along with all of its children. If
 1952  * the device currently has a driver attached to it, the device is
 1953  * detached first using device_detach().
 1954  *
 1955  * @param dev           the parent device
 1956  * @param child         the device to delete
 1957  *
 1958  * @retval 0            success
 1959  * @retval non-zero     a unit error code describing the error
 1960  */
 1961 int
 1962 device_delete_child(device_t dev, device_t child)
 1963 {
 1964         int error;
 1965         device_t grandchild;
 1966 
 1967         PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev)));
 1968 
 1969         /* detach parent before deleting children, if any */
 1970         if ((error = device_detach(child)) != 0)
 1971                 return (error);
 1972         
 1973         /* remove children second */
 1974         while ((grandchild = TAILQ_FIRST(&child->children)) != NULL) {
 1975                 error = device_delete_child(child, grandchild);
 1976                 if (error)
 1977                         return (error);
 1978         }
 1979 
 1980         if (child->devclass)
 1981                 devclass_delete_device(child->devclass, child);
 1982         if (child->parent)
 1983                 BUS_CHILD_DELETED(dev, child);
 1984         TAILQ_REMOVE(&dev->children, child, link);
 1985         TAILQ_REMOVE(&bus_data_devices, child, devlink);
 1986         kobj_delete((kobj_t) child, M_BUS);
 1987 
 1988         bus_data_generation_update();
 1989         return (0);
 1990 }
 1991 
 1992 /**
 1993  * @brief Delete all children devices of the given device, if any.
 1994  *
 1995  * This function deletes all children devices of the given device, if
 1996  * any, using the device_delete_child() function for each device it
 1997  * finds. If a child device cannot be deleted, this function will
 1998  * return an error code.
 1999  *
 2000  * @param dev           the parent device
 2001  *
 2002  * @retval 0            success
 2003  * @retval non-zero     a device would not detach
 2004  */
 2005 int
 2006 device_delete_children(device_t dev)
 2007 {
 2008         device_t child;
 2009         int error;
 2010 
 2011         PDEBUG(("Deleting all children of %s", DEVICENAME(dev)));
 2012 
 2013         error = 0;
 2014 
 2015         while ((child = TAILQ_FIRST(&dev->children)) != NULL) {
 2016                 error = device_delete_child(dev, child);
 2017                 if (error) {
 2018                         PDEBUG(("Failed deleting %s", DEVICENAME(child)));
 2019                         break;
 2020                 }
 2021         }
 2022         return (error);
 2023 }
 2024 
 2025 /**
 2026  * @brief Find a device given a unit number
 2027  *
 2028  * This is similar to devclass_get_devices() but only searches for
 2029  * devices which have @p dev as a parent.
 2030  *
 2031  * @param dev           the parent device to search
 2032  * @param unit          the unit number to search for.  If the unit is -1,
 2033  *                      return the first child of @p dev which has name
 2034  *                      @p classname (that is, the one with the lowest unit.)
 2035  *
 2036  * @returns             the device with the given unit number or @c
 2037  *                      NULL if there is no such device
 2038  */
 2039 device_t
 2040 device_find_child(device_t dev, const char *classname, int unit)
 2041 {
 2042         devclass_t dc;
 2043         device_t child;
 2044 
 2045         dc = devclass_find(classname);
 2046         if (!dc)
 2047                 return (NULL);
 2048 
 2049         if (unit != -1) {
 2050                 child = devclass_get_device(dc, unit);
 2051                 if (child && child->parent == dev)
 2052                         return (child);
 2053         } else {
 2054                 for (unit = 0; unit < devclass_get_maxunit(dc); unit++) {
 2055                         child = devclass_get_device(dc, unit);
 2056                         if (child && child->parent == dev)
 2057                                 return (child);
 2058                 }
 2059         }
 2060         return (NULL);
 2061 }
 2062 
 2063 /**
 2064  * @internal
 2065  */
 2066 static driverlink_t
 2067 first_matching_driver(devclass_t dc, device_t dev)
 2068 {
 2069         if (dev->devclass)
 2070                 return (devclass_find_driver_internal(dc, dev->devclass->name));
 2071         return (TAILQ_FIRST(&dc->drivers));
 2072 }
 2073 
 2074 /**
 2075  * @internal
 2076  */
 2077 static driverlink_t
 2078 next_matching_driver(devclass_t dc, device_t dev, driverlink_t last)
 2079 {
 2080         if (dev->devclass) {
 2081                 driverlink_t dl;
 2082                 for (dl = TAILQ_NEXT(last, link); dl; dl = TAILQ_NEXT(dl, link))
 2083                         if (!strcmp(dev->devclass->name, dl->driver->name))
 2084                                 return (dl);
 2085                 return (NULL);
 2086         }
 2087         return (TAILQ_NEXT(last, link));
 2088 }
 2089 
 2090 /**
 2091  * @internal
 2092  */
 2093 int
 2094 device_probe_child(device_t dev, device_t child)
 2095 {
 2096         devclass_t dc;
 2097         driverlink_t best = NULL;
 2098         driverlink_t dl;
 2099         int result, pri = 0;
 2100         int hasclass = (child->devclass != NULL);
 2101 
 2102         GIANT_REQUIRED;
 2103 
 2104         dc = dev->devclass;
 2105         if (!dc)
 2106                 panic("device_probe_child: parent device has no devclass");
 2107 
 2108         /*
 2109          * If the state is already probed, then return.  However, don't
 2110          * return if we can rebid this object.
 2111          */
 2112         if (child->state == DS_ALIVE && (child->flags & DF_REBID) == 0)
 2113                 return (0);
 2114 
 2115         for (; dc; dc = dc->parent) {
 2116                 for (dl = first_matching_driver(dc, child);
 2117                      dl;
 2118                      dl = next_matching_driver(dc, child, dl)) {
 2119                         /* If this driver's pass is too high, then ignore it. */
 2120                         if (dl->pass > bus_current_pass)
 2121                                 continue;
 2122 
 2123                         PDEBUG(("Trying %s", DRIVERNAME(dl->driver)));
 2124                         result = device_set_driver(child, dl->driver);
 2125                         if (result == ENOMEM)
 2126                                 return (result);
 2127                         else if (result != 0)
 2128                                 continue;
 2129                         if (!hasclass) {
 2130                                 if (device_set_devclass(child,
 2131                                     dl->driver->name) != 0) {
 2132                                         char const * devname =
 2133                                             device_get_name(child);
 2134                                         if (devname == NULL)
 2135                                                 devname = "(unknown)";
 2136                                         printf("driver bug: Unable to set "
 2137                                             "devclass (class: %s "
 2138                                             "devname: %s)\n",
 2139                                             dl->driver->name,
 2140                                             devname);
 2141                                         (void)device_set_driver(child, NULL);
 2142                                         continue;
 2143                                 }
 2144                         }
 2145 
 2146                         /* Fetch any flags for the device before probing. */
 2147                         resource_int_value(dl->driver->name, child->unit,
 2148                             "flags", &child->devflags);
 2149 
 2150                         result = DEVICE_PROBE(child);
 2151 
 2152                         /* Reset flags and devclass before the next probe. */
 2153                         child->devflags = 0;
 2154                         if (!hasclass)
 2155                                 (void)device_set_devclass(child, NULL);
 2156 
 2157                         /*
 2158                          * If the driver returns SUCCESS, there can be
 2159                          * no higher match for this device.
 2160                          */
 2161                         if (result == 0) {
 2162                                 best = dl;
 2163                                 pri = 0;
 2164                                 break;
 2165                         }
 2166 
 2167                         /*
 2168                          * Reset DF_QUIET in case this driver doesn't
 2169                          * end up as the best driver.
 2170                          */
 2171                         device_verbose(child);
 2172 
 2173                         /*
 2174                          * Probes that return BUS_PROBE_NOWILDCARD or lower
 2175                          * only match on devices whose driver was explicitly
 2176                          * specified.
 2177                          */
 2178                         if (result <= BUS_PROBE_NOWILDCARD &&
 2179                             !(child->flags & DF_FIXEDCLASS)) {
 2180                                 result = ENXIO;
 2181                         }
 2182 
 2183                         /*
 2184                          * The driver returned an error so it
 2185                          * certainly doesn't match.
 2186                          */
 2187                         if (result > 0) {
 2188                                 (void)device_set_driver(child, NULL);
 2189                                 continue;
 2190                         }
 2191 
 2192                         /*
 2193                          * A priority lower than SUCCESS, remember the
 2194                          * best matching driver. Initialise the value
 2195                          * of pri for the first match.
 2196                          */
 2197                         if (best == NULL || result > pri) {
 2198                                 best = dl;
 2199                                 pri = result;
 2200                                 continue;
 2201                         }
 2202                 }
 2203                 /*
 2204                  * If we have an unambiguous match in this devclass,
 2205                  * don't look in the parent.
 2206                  */
 2207                 if (best && pri == 0)
 2208                         break;
 2209         }
 2210 
 2211         /*
 2212          * If we found a driver, change state and initialise the devclass.
 2213          */
 2214         /* XXX What happens if we rebid and got no best? */
 2215         if (best) {
 2216                 /*
 2217                  * If this device was attached, and we were asked to
 2218                  * rescan, and it is a different driver, then we have
 2219                  * to detach the old driver and reattach this new one.
 2220                  * Note, we don't have to check for DF_REBID here
 2221                  * because if the state is > DS_ALIVE, we know it must
 2222                  * be.
 2223                  *
 2224                  * This assumes that all DF_REBID drivers can have
 2225                  * their probe routine called at any time and that
 2226                  * they are idempotent as well as completely benign in
 2227                  * normal operations.
 2228                  *
 2229                  * We also have to make sure that the detach
 2230                  * succeeded, otherwise we fail the operation (or
 2231                  * maybe it should just fail silently?  I'm torn).
 2232                  */
 2233                 if (child->state > DS_ALIVE && best->driver != child->driver)
 2234                         if ((result = device_detach(dev)) != 0)
 2235                                 return (result);
 2236 
 2237                 /* Set the winning driver, devclass, and flags. */
 2238                 if (!child->devclass) {
 2239                         result = device_set_devclass(child, best->driver->name);
 2240                         if (result != 0)
 2241                                 return (result);
 2242                 }
 2243                 result = device_set_driver(child, best->driver);
 2244                 if (result != 0)
 2245                         return (result);
 2246                 resource_int_value(best->driver->name, child->unit,
 2247                     "flags", &child->devflags);
 2248 
 2249                 if (pri < 0) {
 2250                         /*
 2251                          * A bit bogus. Call the probe method again to make
 2252                          * sure that we have the right description.
 2253                          */
 2254                         DEVICE_PROBE(child);
 2255 #if 0
 2256                         child->flags |= DF_REBID;
 2257 #endif
 2258                 } else
 2259                         child->flags &= ~DF_REBID;
 2260                 child->state = DS_ALIVE;
 2261 
 2262                 bus_data_generation_update();
 2263                 return (0);
 2264         }
 2265 
 2266         return (ENXIO);
 2267 }
 2268 
 2269 /**
 2270  * @brief Return the parent of a device
 2271  */
 2272 device_t
 2273 device_get_parent(device_t dev)
 2274 {
 2275         return (dev->parent);
 2276 }
 2277 
 2278 /**
 2279  * @brief Get a list of children of a device
 2280  *
 2281  * An array containing a list of all the children of the given device
 2282  * is allocated and returned in @p *devlistp. The number of devices
 2283  * in the array is returned in @p *devcountp. The caller should free
 2284  * the array using @c free(p, M_TEMP).
 2285  *
 2286  * @param dev           the device to examine
 2287  * @param devlistp      points at location for array pointer return
 2288  *                      value
 2289  * @param devcountp     points at location for array size return value
 2290  *
 2291  * @retval 0            success
 2292  * @retval ENOMEM       the array allocation failed
 2293  */
 2294 int
 2295 device_get_children(device_t dev, device_t **devlistp, int *devcountp)
 2296 {
 2297         int count;
 2298         device_t child;
 2299         device_t *list;
 2300 
 2301         count = 0;
 2302         TAILQ_FOREACH(child, &dev->children, link) {
 2303                 count++;
 2304         }
 2305         if (count == 0) {
 2306                 *devlistp = NULL;
 2307                 *devcountp = 0;
 2308                 return (0);
 2309         }
 2310 
 2311         list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
 2312         if (!list)
 2313                 return (ENOMEM);
 2314 
 2315         count = 0;
 2316         TAILQ_FOREACH(child, &dev->children, link) {
 2317                 list[count] = child;
 2318                 count++;
 2319         }
 2320 
 2321         *devlistp = list;
 2322         *devcountp = count;
 2323 
 2324         return (0);
 2325 }
 2326 
 2327 /**
 2328  * @brief Return the current driver for the device or @c NULL if there
 2329  * is no driver currently attached
 2330  */
 2331 driver_t *
 2332 device_get_driver(device_t dev)
 2333 {
 2334         return (dev->driver);
 2335 }
 2336 
 2337 /**
 2338  * @brief Return the current devclass for the device or @c NULL if
 2339  * there is none.
 2340  */
 2341 devclass_t
 2342 device_get_devclass(device_t dev)
 2343 {
 2344         return (dev->devclass);
 2345 }
 2346 
 2347 /**
 2348  * @brief Return the name of the device's devclass or @c NULL if there
 2349  * is none.
 2350  */
 2351 const char *
 2352 device_get_name(device_t dev)
 2353 {
 2354         if (dev != NULL && dev->devclass)
 2355                 return (devclass_get_name(dev->devclass));
 2356         return (NULL);
 2357 }
 2358 
 2359 /**
 2360  * @brief Return a string containing the device's devclass name
 2361  * followed by an ascii representation of the device's unit number
 2362  * (e.g. @c "foo2").
 2363  */
 2364 const char *
 2365 device_get_nameunit(device_t dev)
 2366 {
 2367         return (dev->nameunit);
 2368 }
 2369 
 2370 /**
 2371  * @brief Return the device's unit number.
 2372  */
 2373 int
 2374 device_get_unit(device_t dev)
 2375 {
 2376         return (dev->unit);
 2377 }
 2378 
 2379 /**
 2380  * @brief Return the device's description string
 2381  */
 2382 const char *
 2383 device_get_desc(device_t dev)
 2384 {
 2385         return (dev->desc);
 2386 }
 2387 
 2388 /**
 2389  * @brief Return the device's flags
 2390  */
 2391 uint32_t
 2392 device_get_flags(device_t dev)
 2393 {
 2394         return (dev->devflags);
 2395 }
 2396 
 2397 struct sysctl_ctx_list *
 2398 device_get_sysctl_ctx(device_t dev)
 2399 {
 2400         return (&dev->sysctl_ctx);
 2401 }
 2402 
 2403 struct sysctl_oid *
 2404 device_get_sysctl_tree(device_t dev)
 2405 {
 2406         return (dev->sysctl_tree);
 2407 }
 2408 
 2409 /**
 2410  * @brief Print the name of the device followed by a colon and a space
 2411  *
 2412  * @returns the number of characters printed
 2413  */
 2414 int
 2415 device_print_prettyname(device_t dev)
 2416 {
 2417         const char *name = device_get_name(dev);
 2418 
 2419         if (name == NULL)
 2420                 return (printf("unknown: "));
 2421         return (printf("%s%d: ", name, device_get_unit(dev)));
 2422 }
 2423 
 2424 /**
 2425  * @brief Print the name of the device followed by a colon, a space
 2426  * and the result of calling vprintf() with the value of @p fmt and
 2427  * the following arguments.
 2428  *
 2429  * @returns the number of characters printed
 2430  */
 2431 int
 2432 device_printf(device_t dev, const char * fmt, ...)
 2433 {
 2434         va_list ap;
 2435         int retval;
 2436 
 2437         retval = device_print_prettyname(dev);
 2438         va_start(ap, fmt);
 2439         retval += vprintf(fmt, ap);
 2440         va_end(ap);
 2441         return (retval);
 2442 }
 2443 
 2444 /**
 2445  * @internal
 2446  */
 2447 static void
 2448 device_set_desc_internal(device_t dev, const char* desc, int copy)
 2449 {
 2450         if (dev->desc && (dev->flags & DF_DESCMALLOCED)) {
 2451                 free(dev->desc, M_BUS);
 2452                 dev->flags &= ~DF_DESCMALLOCED;
 2453                 dev->desc = NULL;
 2454         }
 2455 
 2456         if (copy && desc) {
 2457                 dev->desc = malloc(strlen(desc) + 1, M_BUS, M_NOWAIT);
 2458                 if (dev->desc) {
 2459                         strcpy(dev->desc, desc);
 2460                         dev->flags |= DF_DESCMALLOCED;
 2461                 }
 2462         } else {
 2463                 /* Avoid a -Wcast-qual warning */
 2464                 dev->desc = (char *)(uintptr_t) desc;
 2465         }
 2466 
 2467         bus_data_generation_update();
 2468 }
 2469 
 2470 /**
 2471  * @brief Set the device's description
 2472  *
 2473  * The value of @c desc should be a string constant that will not
 2474  * change (at least until the description is changed in a subsequent
 2475  * call to device_set_desc() or device_set_desc_copy()).
 2476  */
 2477 void
 2478 device_set_desc(device_t dev, const char* desc)
 2479 {
 2480         device_set_desc_internal(dev, desc, FALSE);
 2481 }
 2482 
 2483 /**
 2484  * @brief Set the device's description
 2485  *
 2486  * The string pointed to by @c desc is copied. Use this function if
 2487  * the device description is generated, (e.g. with sprintf()).
 2488  */
 2489 void
 2490 device_set_desc_copy(device_t dev, const char* desc)
 2491 {
 2492         device_set_desc_internal(dev, desc, TRUE);
 2493 }
 2494 
 2495 /**
 2496  * @brief Set the device's flags
 2497  */
 2498 void
 2499 device_set_flags(device_t dev, uint32_t flags)
 2500 {
 2501         dev->devflags = flags;
 2502 }
 2503 
 2504 /**
 2505  * @brief Return the device's softc field
 2506  *
 2507  * The softc is allocated and zeroed when a driver is attached, based
 2508  * on the size field of the driver.
 2509  */
 2510 void *
 2511 device_get_softc(device_t dev)
 2512 {
 2513         return (dev->softc);
 2514 }
 2515 
 2516 /**
 2517  * @brief Set the device's softc field
 2518  *
 2519  * Most drivers do not need to use this since the softc is allocated
 2520  * automatically when the driver is attached.
 2521  */
 2522 void
 2523 device_set_softc(device_t dev, void *softc)
 2524 {
 2525         if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC))
 2526                 free(dev->softc, M_BUS_SC);
 2527         dev->softc = softc;
 2528         if (dev->softc)
 2529                 dev->flags |= DF_EXTERNALSOFTC;
 2530         else
 2531                 dev->flags &= ~DF_EXTERNALSOFTC;
 2532 }
 2533 
 2534 /**
 2535  * @brief Free claimed softc
 2536  *
 2537  * Most drivers do not need to use this since the softc is freed
 2538  * automatically when the driver is detached.
 2539  */
 2540 void
 2541 device_free_softc(void *softc)
 2542 {
 2543         free(softc, M_BUS_SC);
 2544 }
 2545 
 2546 /**
 2547  * @brief Claim softc
 2548  *
 2549  * This function can be used to let the driver free the automatically
 2550  * allocated softc using "device_free_softc()". This function is
 2551  * useful when the driver is refcounting the softc and the softc
 2552  * cannot be freed when the "device_detach" method is called.
 2553  */
 2554 void
 2555 device_claim_softc(device_t dev)
 2556 {
 2557         if (dev->softc)
 2558                 dev->flags |= DF_EXTERNALSOFTC;
 2559         else
 2560                 dev->flags &= ~DF_EXTERNALSOFTC;
 2561 }
 2562 
 2563 /**
 2564  * @brief Get the device's ivars field
 2565  *
 2566  * The ivars field is used by the parent device to store per-device
 2567  * state (e.g. the physical location of the device or a list of
 2568  * resources).
 2569  */
 2570 void *
 2571 device_get_ivars(device_t dev)
 2572 {
 2573 
 2574         KASSERT(dev != NULL, ("device_get_ivars(NULL, ...)"));
 2575         return (dev->ivars);
 2576 }
 2577 
 2578 /**
 2579  * @brief Set the device's ivars field
 2580  */
 2581 void
 2582 device_set_ivars(device_t dev, void * ivars)
 2583 {
 2584 
 2585         KASSERT(dev != NULL, ("device_set_ivars(NULL, ...)"));
 2586         dev->ivars = ivars;
 2587 }
 2588 
 2589 /**
 2590  * @brief Return the device's state
 2591  */
 2592 device_state_t
 2593 device_get_state(device_t dev)
 2594 {
 2595         return (dev->state);
 2596 }
 2597 
 2598 /**
 2599  * @brief Set the DF_ENABLED flag for the device
 2600  */
 2601 void
 2602 device_enable(device_t dev)
 2603 {
 2604         dev->flags |= DF_ENABLED;
 2605 }
 2606 
 2607 /**
 2608  * @brief Clear the DF_ENABLED flag for the device
 2609  */
 2610 void
 2611 device_disable(device_t dev)
 2612 {
 2613         dev->flags &= ~DF_ENABLED;
 2614 }
 2615 
 2616 /**
 2617  * @brief Increment the busy counter for the device
 2618  */
 2619 void
 2620 device_busy(device_t dev)
 2621 {
 2622         if (dev->state < DS_ATTACHING)
 2623                 panic("device_busy: called for unattached device");
 2624         if (dev->busy == 0 && dev->parent)
 2625                 device_busy(dev->parent);
 2626         dev->busy++;
 2627         if (dev->state == DS_ATTACHED)
 2628                 dev->state = DS_BUSY;
 2629 }
 2630 
 2631 /**
 2632  * @brief Decrement the busy counter for the device
 2633  */
 2634 void
 2635 device_unbusy(device_t dev)
 2636 {
 2637         if (dev->busy != 0 && dev->state != DS_BUSY &&
 2638             dev->state != DS_ATTACHING)
 2639                 panic("device_unbusy: called for non-busy device %s",
 2640                     device_get_nameunit(dev));
 2641         dev->busy--;
 2642         if (dev->busy == 0) {
 2643                 if (dev->parent)
 2644                         device_unbusy(dev->parent);
 2645                 if (dev->state == DS_BUSY)
 2646                         dev->state = DS_ATTACHED;
 2647         }
 2648 }
 2649 
 2650 /**
 2651  * @brief Set the DF_QUIET flag for the device
 2652  */
 2653 void
 2654 device_quiet(device_t dev)
 2655 {
 2656         dev->flags |= DF_QUIET;
 2657 }
 2658 
 2659 /**
 2660  * @brief Set the DF_QUIET_CHILDREN flag for the device
 2661  */
 2662 void
 2663 device_quiet_children(device_t dev)
 2664 {
 2665         dev->flags |= DF_QUIET_CHILDREN;
 2666 }
 2667 
 2668 /**
 2669  * @brief Clear the DF_QUIET flag for the device
 2670  */
 2671 void
 2672 device_verbose(device_t dev)
 2673 {
 2674         dev->flags &= ~DF_QUIET;
 2675 }
 2676 
 2677 /**
 2678  * @brief Return non-zero if the DF_QUIET_CHIDLREN flag is set on the device
 2679  */
 2680 int
 2681 device_has_quiet_children(device_t dev)
 2682 {
 2683         return ((dev->flags & DF_QUIET_CHILDREN) != 0);
 2684 }
 2685 
 2686 /**
 2687  * @brief Return non-zero if the DF_QUIET flag is set on the device
 2688  */
 2689 int
 2690 device_is_quiet(device_t dev)
 2691 {
 2692         return ((dev->flags & DF_QUIET) != 0);
 2693 }
 2694 
 2695 /**
 2696  * @brief Return non-zero if the DF_ENABLED flag is set on the device
 2697  */
 2698 int
 2699 device_is_enabled(device_t dev)
 2700 {
 2701         return ((dev->flags & DF_ENABLED) != 0);
 2702 }
 2703 
 2704 /**
 2705  * @brief Return non-zero if the device was successfully probed
 2706  */
 2707 int
 2708 device_is_alive(device_t dev)
 2709 {
 2710         return (dev->state >= DS_ALIVE);
 2711 }
 2712 
 2713 /**
 2714  * @brief Return non-zero if the device currently has a driver
 2715  * attached to it
 2716  */
 2717 int
 2718 device_is_attached(device_t dev)
 2719 {
 2720         return (dev->state >= DS_ATTACHED);
 2721 }
 2722 
 2723 /**
 2724  * @brief Return non-zero if the device is currently suspended.
 2725  */
 2726 int
 2727 device_is_suspended(device_t dev)
 2728 {
 2729         return ((dev->flags & DF_SUSPENDED) != 0);
 2730 }
 2731 
 2732 /**
 2733  * @brief Set the devclass of a device
 2734  * @see devclass_add_device().
 2735  */
 2736 int
 2737 device_set_devclass(device_t dev, const char *classname)
 2738 {
 2739         devclass_t dc;
 2740         int error;
 2741 
 2742         if (!classname) {
 2743                 if (dev->devclass)
 2744                         devclass_delete_device(dev->devclass, dev);
 2745                 return (0);
 2746         }
 2747 
 2748         if (dev->devclass) {
 2749                 printf("device_set_devclass: device class already set\n");
 2750                 return (EINVAL);
 2751         }
 2752 
 2753         dc = devclass_find_internal(classname, NULL, TRUE);
 2754         if (!dc)
 2755                 return (ENOMEM);
 2756 
 2757         error = devclass_add_device(dc, dev);
 2758 
 2759         bus_data_generation_update();
 2760         return (error);
 2761 }
 2762 
 2763 /**
 2764  * @brief Set the devclass of a device and mark the devclass fixed.
 2765  * @see device_set_devclass()
 2766  */
 2767 int
 2768 device_set_devclass_fixed(device_t dev, const char *classname)
 2769 {
 2770         int error;
 2771 
 2772         if (classname == NULL)
 2773                 return (EINVAL);
 2774 
 2775         error = device_set_devclass(dev, classname);
 2776         if (error)
 2777                 return (error);
 2778         dev->flags |= DF_FIXEDCLASS;
 2779         return (0);
 2780 }
 2781 
 2782 /**
 2783  * @brief Query the device to determine if it's of a fixed devclass
 2784  * @see device_set_devclass_fixed()
 2785  */
 2786 bool
 2787 device_is_devclass_fixed(device_t dev)
 2788 {
 2789         return ((dev->flags & DF_FIXEDCLASS) != 0);
 2790 }
 2791 
 2792 /**
 2793  * @brief Set the driver of a device
 2794  *
 2795  * @retval 0            success
 2796  * @retval EBUSY        the device already has a driver attached
 2797  * @retval ENOMEM       a memory allocation failure occurred
 2798  */
 2799 int
 2800 device_set_driver(device_t dev, driver_t *driver)
 2801 {
 2802         if (dev->state >= DS_ATTACHED)
 2803                 return (EBUSY);
 2804 
 2805         if (dev->driver == driver)
 2806                 return (0);
 2807 
 2808         if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) {
 2809                 free(dev->softc, M_BUS_SC);
 2810                 dev->softc = NULL;
 2811         }
 2812         device_set_desc(dev, NULL);
 2813         kobj_delete((kobj_t) dev, NULL);
 2814         dev->driver = driver;
 2815         if (driver) {
 2816                 kobj_init((kobj_t) dev, (kobj_class_t) driver);
 2817                 if (!(dev->flags & DF_EXTERNALSOFTC) && driver->size > 0) {
 2818                         dev->softc = malloc(driver->size, M_BUS_SC,
 2819                             M_NOWAIT | M_ZERO);
 2820                         if (!dev->softc) {
 2821                                 kobj_delete((kobj_t) dev, NULL);
 2822                                 kobj_init((kobj_t) dev, &null_class);
 2823                                 dev->driver = NULL;
 2824                                 return (ENOMEM);
 2825                         }
 2826                 }
 2827         } else {
 2828                 kobj_init((kobj_t) dev, &null_class);
 2829         }
 2830 
 2831         bus_data_generation_update();
 2832         return (0);
 2833 }
 2834 
 2835 /**
 2836  * @brief Probe a device, and return this status.
 2837  *
 2838  * This function is the core of the device autoconfiguration
 2839  * system. Its purpose is to select a suitable driver for a device and
 2840  * then call that driver to initialise the hardware appropriately. The
 2841  * driver is selected by calling the DEVICE_PROBE() method of a set of
 2842  * candidate drivers and then choosing the driver which returned the
 2843  * best value. This driver is then attached to the device using
 2844  * device_attach().
 2845  *
 2846  * The set of suitable drivers is taken from the list of drivers in
 2847  * the parent device's devclass. If the device was originally created
 2848  * with a specific class name (see device_add_child()), only drivers
 2849  * with that name are probed, otherwise all drivers in the devclass
 2850  * are probed. If no drivers return successful probe values in the
 2851  * parent devclass, the search continues in the parent of that
 2852  * devclass (see devclass_get_parent()) if any.
 2853  *
 2854  * @param dev           the device to initialise
 2855  *
 2856  * @retval 0            success
 2857  * @retval ENXIO        no driver was found
 2858  * @retval ENOMEM       memory allocation failure
 2859  * @retval non-zero     some other unix error code
 2860  * @retval -1           Device already attached
 2861  */
 2862 int
 2863 device_probe(device_t dev)
 2864 {
 2865         int error;
 2866 
 2867         GIANT_REQUIRED;
 2868 
 2869         if (dev->state >= DS_ALIVE && (dev->flags & DF_REBID) == 0)
 2870                 return (-1);
 2871 
 2872         if (!(dev->flags & DF_ENABLED)) {
 2873                 if (bootverbose && device_get_name(dev) != NULL) {
 2874                         device_print_prettyname(dev);
 2875                         printf("not probed (disabled)\n");
 2876                 }
 2877                 return (-1);
 2878         }
 2879         if ((error = device_probe_child(dev->parent, dev)) != 0) {
 2880                 if (bus_current_pass == BUS_PASS_DEFAULT &&
 2881                     !(dev->flags & DF_DONENOMATCH)) {
 2882                         BUS_PROBE_NOMATCH(dev->parent, dev);
 2883                         devnomatch(dev);
 2884                         dev->flags |= DF_DONENOMATCH;
 2885                 }
 2886                 return (error);
 2887         }
 2888         return (0);
 2889 }
 2890 
 2891 /**
 2892  * @brief Probe a device and attach a driver if possible
 2893  *
 2894  * calls device_probe() and attaches if that was successful.
 2895  */
 2896 int
 2897 device_probe_and_attach(device_t dev)
 2898 {
 2899         int error;
 2900 
 2901         GIANT_REQUIRED;
 2902 
 2903         error = device_probe(dev);
 2904         if (error == -1)
 2905                 return (0);
 2906         else if (error != 0)
 2907                 return (error);
 2908 
 2909         CURVNET_SET_QUIET(vnet0);
 2910         error = device_attach(dev);
 2911         CURVNET_RESTORE();
 2912         return error;
 2913 }
 2914 
 2915 /**
 2916  * @brief Attach a device driver to a device
 2917  *
 2918  * This function is a wrapper around the DEVICE_ATTACH() driver
 2919  * method. In addition to calling DEVICE_ATTACH(), it initialises the
 2920  * device's sysctl tree, optionally prints a description of the device
 2921  * and queues a notification event for user-based device management
 2922  * services.
 2923  *
 2924  * Normally this function is only called internally from
 2925  * device_probe_and_attach().
 2926  *
 2927  * @param dev           the device to initialise
 2928  *
 2929  * @retval 0            success
 2930  * @retval ENXIO        no driver was found
 2931  * @retval ENOMEM       memory allocation failure
 2932  * @retval non-zero     some other unix error code
 2933  */
 2934 int
 2935 device_attach(device_t dev)
 2936 {
 2937         uint64_t attachtime;
 2938         uint16_t attachentropy;
 2939         int error;
 2940 
 2941         if (resource_disabled(dev->driver->name, dev->unit)) {
 2942                 device_disable(dev);
 2943                 if (bootverbose)
 2944                          device_printf(dev, "disabled via hints entry\n");
 2945                 return (ENXIO);
 2946         }
 2947 
 2948         device_sysctl_init(dev);
 2949         if (!device_is_quiet(dev))
 2950                 device_print_child(dev->parent, dev);
 2951         attachtime = get_cyclecount();
 2952         dev->state = DS_ATTACHING;
 2953         if ((error = DEVICE_ATTACH(dev)) != 0) {
 2954                 printf("device_attach: %s%d attach returned %d\n",
 2955                     dev->driver->name, dev->unit, error);
 2956                 if (!(dev->flags & DF_FIXEDCLASS))
 2957                         devclass_delete_device(dev->devclass, dev);
 2958                 (void)device_set_driver(dev, NULL);
 2959                 device_sysctl_fini(dev);
 2960                 KASSERT(dev->busy == 0, ("attach failed but busy"));
 2961                 dev->state = DS_NOTPRESENT;
 2962                 return (error);
 2963         }
 2964         dev->flags |= DF_ATTACHED_ONCE;
 2965         /* We only need the low bits of this time, but ranges from tens to thousands
 2966          * have been seen, so keep 2 bytes' worth.
 2967          */
 2968         attachentropy = (uint16_t)(get_cyclecount() - attachtime);
 2969         random_harvest_direct(&attachentropy, sizeof(attachentropy), RANDOM_ATTACH);
 2970         device_sysctl_update(dev);
 2971         if (dev->busy)
 2972                 dev->state = DS_BUSY;
 2973         else
 2974                 dev->state = DS_ATTACHED;
 2975         dev->flags &= ~DF_DONENOMATCH;
 2976         EVENTHANDLER_DIRECT_INVOKE(device_attach, dev);
 2977         devadded(dev);
 2978         return (0);
 2979 }
 2980 
 2981 /**
 2982  * @brief Detach a driver from a device
 2983  *
 2984  * This function is a wrapper around the DEVICE_DETACH() driver
 2985  * method. If the call to DEVICE_DETACH() succeeds, it calls
 2986  * BUS_CHILD_DETACHED() for the parent of @p dev, queues a
 2987  * notification event for user-based device management services and
 2988  * cleans up the device's sysctl tree.
 2989  *
 2990  * @param dev           the device to un-initialise
 2991  *
 2992  * @retval 0            success
 2993  * @retval ENXIO        no driver was found
 2994  * @retval ENOMEM       memory allocation failure
 2995  * @retval non-zero     some other unix error code
 2996  */
 2997 int
 2998 device_detach(device_t dev)
 2999 {
 3000         int error;
 3001 
 3002         GIANT_REQUIRED;
 3003 
 3004         PDEBUG(("%s", DEVICENAME(dev)));
 3005         if (dev->state == DS_BUSY)
 3006                 return (EBUSY);
 3007         if (dev->state == DS_ATTACHING) {
 3008                 device_printf(dev, "device in attaching state! Deferring detach.\n");
 3009                 return (EBUSY);
 3010         }
 3011         if (dev->state != DS_ATTACHED)
 3012                 return (0);
 3013 
 3014         EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, EVHDEV_DETACH_BEGIN);
 3015         if ((error = DEVICE_DETACH(dev)) != 0) {
 3016                 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev,
 3017                     EVHDEV_DETACH_FAILED);
 3018                 return (error);
 3019         } else {
 3020                 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev,
 3021                     EVHDEV_DETACH_COMPLETE);
 3022         }
 3023         devremoved(dev);
 3024         if (!device_is_quiet(dev))
 3025                 device_printf(dev, "detached\n");
 3026         if (dev->parent)
 3027                 BUS_CHILD_DETACHED(dev->parent, dev);
 3028 
 3029         if (!(dev->flags & DF_FIXEDCLASS))
 3030                 devclass_delete_device(dev->devclass, dev);
 3031 
 3032         device_verbose(dev);
 3033         dev->state = DS_NOTPRESENT;
 3034         (void)device_set_driver(dev, NULL);
 3035         device_sysctl_fini(dev);
 3036 
 3037         return (0);
 3038 }
 3039 
 3040 /**
 3041  * @brief Tells a driver to quiesce itself.
 3042  *
 3043  * This function is a wrapper around the DEVICE_QUIESCE() driver
 3044  * method. If the call to DEVICE_QUIESCE() succeeds.
 3045  *
 3046  * @param dev           the device to quiesce
 3047  *
 3048  * @retval 0            success
 3049  * @retval ENXIO        no driver was found
 3050  * @retval ENOMEM       memory allocation failure
 3051  * @retval non-zero     some other unix error code
 3052  */
 3053 int
 3054 device_quiesce(device_t dev)
 3055 {
 3056 
 3057         PDEBUG(("%s", DEVICENAME(dev)));
 3058         if (dev->state == DS_BUSY)
 3059                 return (EBUSY);
 3060         if (dev->state != DS_ATTACHED)
 3061                 return (0);
 3062 
 3063         return (DEVICE_QUIESCE(dev));
 3064 }
 3065 
 3066 /**
 3067  * @brief Notify a device of system shutdown
 3068  *
 3069  * This function calls the DEVICE_SHUTDOWN() driver method if the
 3070  * device currently has an attached driver.
 3071  *
 3072  * @returns the value returned by DEVICE_SHUTDOWN()
 3073  */
 3074 int
 3075 device_shutdown(device_t dev)
 3076 {
 3077         if (dev->state < DS_ATTACHED)
 3078                 return (0);
 3079         return (DEVICE_SHUTDOWN(dev));
 3080 }
 3081 
 3082 /**
 3083  * @brief Set the unit number of a device
 3084  *
 3085  * This function can be used to override the unit number used for a
 3086  * device (e.g. to wire a device to a pre-configured unit number).
 3087  */
 3088 int
 3089 device_set_unit(device_t dev, int unit)
 3090 {
 3091         devclass_t dc;
 3092         int err;
 3093 
 3094         dc = device_get_devclass(dev);
 3095         if (unit < dc->maxunit && dc->devices[unit])
 3096                 return (EBUSY);
 3097         err = devclass_delete_device(dc, dev);
 3098         if (err)
 3099                 return (err);
 3100         dev->unit = unit;
 3101         err = devclass_add_device(dc, dev);
 3102         if (err)
 3103                 return (err);
 3104 
 3105         bus_data_generation_update();
 3106         return (0);
 3107 }
 3108 
 3109 /*======================================*/
 3110 /*
 3111  * Some useful method implementations to make life easier for bus drivers.
 3112  */
 3113 
 3114 void
 3115 resource_init_map_request_impl(struct resource_map_request *args, size_t sz)
 3116 {
 3117 
 3118         bzero(args, sz);
 3119         args->size = sz;
 3120         args->memattr = VM_MEMATTR_UNCACHEABLE;
 3121 }
 3122 
 3123 /**
 3124  * @brief Initialise a resource list.
 3125  *
 3126  * @param rl            the resource list to initialise
 3127  */
 3128 void
 3129 resource_list_init(struct resource_list *rl)
 3130 {
 3131         STAILQ_INIT(rl);
 3132 }
 3133 
 3134 /**
 3135  * @brief Reclaim memory used by a resource list.
 3136  *
 3137  * This function frees the memory for all resource entries on the list
 3138  * (if any).
 3139  *
 3140  * @param rl            the resource list to free
 3141  */
 3142 void
 3143 resource_list_free(struct resource_list *rl)
 3144 {
 3145         struct resource_list_entry *rle;
 3146 
 3147         while ((rle = STAILQ_FIRST(rl)) != NULL) {
 3148                 if (rle->res)
 3149                         panic("resource_list_free: resource entry is busy");
 3150                 STAILQ_REMOVE_HEAD(rl, link);
 3151                 free(rle, M_BUS);
 3152         }
 3153 }
 3154 
 3155 /**
 3156  * @brief Add a resource entry.
 3157  *
 3158  * This function adds a resource entry using the given @p type, @p
 3159  * start, @p end and @p count values. A rid value is chosen by
 3160  * searching sequentially for the first unused rid starting at zero.
 3161  *
 3162  * @param rl            the resource list to edit
 3163  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3164  * @param start         the start address of the resource
 3165  * @param end           the end address of the resource
 3166  * @param count         XXX end-start+1
 3167  */
 3168 int
 3169 resource_list_add_next(struct resource_list *rl, int type, rman_res_t start,
 3170     rman_res_t end, rman_res_t count)
 3171 {
 3172         int rid;
 3173 
 3174         rid = 0;
 3175         while (resource_list_find(rl, type, rid) != NULL)
 3176                 rid++;
 3177         resource_list_add(rl, type, rid, start, end, count);
 3178         return (rid);
 3179 }
 3180 
 3181 /**
 3182  * @brief Add or modify a resource entry.
 3183  *
 3184  * If an existing entry exists with the same type and rid, it will be
 3185  * modified using the given values of @p start, @p end and @p
 3186  * count. If no entry exists, a new one will be created using the
 3187  * given values.  The resource list entry that matches is then returned.
 3188  *
 3189  * @param rl            the resource list to edit
 3190  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3191  * @param rid           the resource identifier
 3192  * @param start         the start address of the resource
 3193  * @param end           the end address of the resource
 3194  * @param count         XXX end-start+1
 3195  */
 3196 struct resource_list_entry *
 3197 resource_list_add(struct resource_list *rl, int type, int rid,
 3198     rman_res_t start, rman_res_t end, rman_res_t count)
 3199 {
 3200         struct resource_list_entry *rle;
 3201 
 3202         rle = resource_list_find(rl, type, rid);
 3203         if (!rle) {
 3204                 rle = malloc(sizeof(struct resource_list_entry), M_BUS,
 3205                     M_NOWAIT);
 3206                 if (!rle)
 3207                         panic("resource_list_add: can't record entry");
 3208                 STAILQ_INSERT_TAIL(rl, rle, link);
 3209                 rle->type = type;
 3210                 rle->rid = rid;
 3211                 rle->res = NULL;
 3212                 rle->flags = 0;
 3213         }
 3214 
 3215         if (rle->res)
 3216                 panic("resource_list_add: resource entry is busy");
 3217 
 3218         rle->start = start;
 3219         rle->end = end;
 3220         rle->count = count;
 3221         return (rle);
 3222 }
 3223 
 3224 /**
 3225  * @brief Determine if a resource entry is busy.
 3226  *
 3227  * Returns true if a resource entry is busy meaning that it has an
 3228  * associated resource that is not an unallocated "reserved" resource.
 3229  *
 3230  * @param rl            the resource list to search
 3231  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3232  * @param rid           the resource identifier
 3233  *
 3234  * @returns Non-zero if the entry is busy, zero otherwise.
 3235  */
 3236 int
 3237 resource_list_busy(struct resource_list *rl, int type, int rid)
 3238 {
 3239         struct resource_list_entry *rle;
 3240 
 3241         rle = resource_list_find(rl, type, rid);
 3242         if (rle == NULL || rle->res == NULL)
 3243                 return (0);
 3244         if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == RLE_RESERVED) {
 3245                 KASSERT(!(rman_get_flags(rle->res) & RF_ACTIVE),
 3246                     ("reserved resource is active"));
 3247                 return (0);
 3248         }
 3249         return (1);
 3250 }
 3251 
 3252 /**
 3253  * @brief Determine if a resource entry is reserved.
 3254  *
 3255  * Returns true if a resource entry is reserved meaning that it has an
 3256  * associated "reserved" resource.  The resource can either be
 3257  * allocated or unallocated.
 3258  *
 3259  * @param rl            the resource list to search
 3260  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3261  * @param rid           the resource identifier
 3262  *
 3263  * @returns Non-zero if the entry is reserved, zero otherwise.
 3264  */
 3265 int
 3266 resource_list_reserved(struct resource_list *rl, int type, int rid)
 3267 {
 3268         struct resource_list_entry *rle;
 3269 
 3270         rle = resource_list_find(rl, type, rid);
 3271         if (rle != NULL && rle->flags & RLE_RESERVED)
 3272                 return (1);
 3273         return (0);
 3274 }
 3275 
 3276 /**
 3277  * @brief Find a resource entry by type and rid.
 3278  *
 3279  * @param rl            the resource list to search
 3280  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3281  * @param rid           the resource identifier
 3282  *
 3283  * @returns the resource entry pointer or NULL if there is no such
 3284  * entry.
 3285  */
 3286 struct resource_list_entry *
 3287 resource_list_find(struct resource_list *rl, int type, int rid)
 3288 {
 3289         struct resource_list_entry *rle;
 3290 
 3291         STAILQ_FOREACH(rle, rl, link) {
 3292                 if (rle->type == type && rle->rid == rid)
 3293                         return (rle);
 3294         }
 3295         return (NULL);
 3296 }
 3297 
 3298 /**
 3299  * @brief Delete a resource entry.
 3300  *
 3301  * @param rl            the resource list to edit
 3302  * @param type          the resource entry type (e.g. SYS_RES_MEMORY)
 3303  * @param rid           the resource identifier
 3304  */
 3305 void
 3306 resource_list_delete(struct resource_list *rl, int type, int rid)
 3307 {
 3308         struct resource_list_entry *rle = resource_list_find(rl, type, rid);
 3309 
 3310         if (rle) {
 3311                 if (rle->res != NULL)
 3312                         panic("resource_list_delete: resource has not been released");
 3313                 STAILQ_REMOVE(rl, rle, resource_list_entry, link);
 3314                 free(rle, M_BUS);
 3315         }
 3316 }
 3317 
 3318 /**
 3319  * @brief Allocate a reserved resource
 3320  *
 3321  * This can be used by buses to force the allocation of resources
 3322  * that are always active in the system even if they are not allocated
 3323  * by a driver (e.g. PCI BARs).  This function is usually called when
 3324  * adding a new child to the bus.  The resource is allocated from the
 3325  * parent bus when it is reserved.  The resource list entry is marked
 3326  * with RLE_RESERVED to note that it is a reserved resource.
 3327  *
 3328  * Subsequent attempts to allocate the resource with
 3329  * resource_list_alloc() will succeed the first time and will set
 3330  * RLE_ALLOCATED to note that it has been allocated.  When a reserved
 3331  * resource that has been allocated is released with
 3332  * resource_list_release() the resource RLE_ALLOCATED is cleared, but
 3333  * the actual resource remains allocated.  The resource can be released to
 3334  * the parent bus by calling resource_list_unreserve().
 3335  *
 3336  * @param rl            the resource list to allocate from
 3337  * @param bus           the parent device of @p child
 3338  * @param child         the device for which the resource is being reserved
 3339  * @param type          the type of resource to allocate
 3340  * @param rid           a pointer to the resource identifier
 3341  * @param start         hint at the start of the resource range - pass
 3342  *                      @c 0 for any start address
 3343  * @param end           hint at the end of the resource range - pass
 3344  *                      @c ~0 for any end address
 3345  * @param count         hint at the size of range required - pass @c 1
 3346  *                      for any size
 3347  * @param flags         any extra flags to control the resource
 3348  *                      allocation - see @c RF_XXX flags in
 3349  *                      <sys/rman.h> for details
 3350  *
 3351  * @returns             the resource which was allocated or @c NULL if no
 3352  *                      resource could be allocated
 3353  */
 3354 struct resource *
 3355 resource_list_reserve(struct resource_list *rl, device_t bus, device_t child,
 3356     int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 3357 {
 3358         struct resource_list_entry *rle = NULL;
 3359         int passthrough = (device_get_parent(child) != bus);
 3360         struct resource *r;
 3361 
 3362         if (passthrough)
 3363                 panic(
 3364     "resource_list_reserve() should only be called for direct children");
 3365         if (flags & RF_ACTIVE)
 3366                 panic(
 3367     "resource_list_reserve() should only reserve inactive resources");
 3368 
 3369         r = resource_list_alloc(rl, bus, child, type, rid, start, end, count,
 3370             flags);
 3371         if (r != NULL) {
 3372                 rle = resource_list_find(rl, type, *rid);
 3373                 rle->flags |= RLE_RESERVED;
 3374         }
 3375         return (r);
 3376 }
 3377 
 3378 /**
 3379  * @brief Helper function for implementing BUS_ALLOC_RESOURCE()
 3380  *
 3381  * Implement BUS_ALLOC_RESOURCE() by looking up a resource from the list
 3382  * and passing the allocation up to the parent of @p bus. This assumes
 3383  * that the first entry of @c device_get_ivars(child) is a struct
 3384  * resource_list. This also handles 'passthrough' allocations where a
 3385  * child is a remote descendant of bus by passing the allocation up to
 3386  * the parent of bus.
 3387  *
 3388  * Typically, a bus driver would store a list of child resources
 3389  * somewhere in the child device's ivars (see device_get_ivars()) and
 3390  * its implementation of BUS_ALLOC_RESOURCE() would find that list and
 3391  * then call resource_list_alloc() to perform the allocation.
 3392  *
 3393  * @param rl            the resource list to allocate from
 3394  * @param bus           the parent device of @p child
 3395  * @param child         the device which is requesting an allocation
 3396  * @param type          the type of resource to allocate
 3397  * @param rid           a pointer to the resource identifier
 3398  * @param start         hint at the start of the resource range - pass
 3399  *                      @c 0 for any start address
 3400  * @param end           hint at the end of the resource range - pass
 3401  *                      @c ~0 for any end address
 3402  * @param count         hint at the size of range required - pass @c 1
 3403  *                      for any size
 3404  * @param flags         any extra flags to control the resource
 3405  *                      allocation - see @c RF_XXX flags in
 3406  *                      <sys/rman.h> for details
 3407  *
 3408  * @returns             the resource which was allocated or @c NULL if no
 3409  *                      resource could be allocated
 3410  */
 3411 struct resource *
 3412 resource_list_alloc(struct resource_list *rl, device_t bus, device_t child,
 3413     int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 3414 {
 3415         struct resource_list_entry *rle = NULL;
 3416         int passthrough = (device_get_parent(child) != bus);
 3417         int isdefault = RMAN_IS_DEFAULT_RANGE(start, end);
 3418 
 3419         if (passthrough) {
 3420                 return (BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
 3421                     type, rid, start, end, count, flags));
 3422         }
 3423 
 3424         rle = resource_list_find(rl, type, *rid);
 3425 
 3426         if (!rle)
 3427                 return (NULL);          /* no resource of that type/rid */
 3428 
 3429         if (rle->res) {
 3430                 if (rle->flags & RLE_RESERVED) {
 3431                         if (rle->flags & RLE_ALLOCATED)
 3432                                 return (NULL);
 3433                         if ((flags & RF_ACTIVE) &&
 3434                             bus_activate_resource(child, type, *rid,
 3435                             rle->res) != 0)
 3436                                 return (NULL);
 3437                         rle->flags |= RLE_ALLOCATED;
 3438                         return (rle->res);
 3439                 }
 3440                 device_printf(bus,
 3441                     "resource entry %#x type %d for child %s is busy\n", *rid,
 3442                     type, device_get_nameunit(child));
 3443                 return (NULL);
 3444         }
 3445 
 3446         if (isdefault) {
 3447                 start = rle->start;
 3448                 count = ulmax(count, rle->count);
 3449                 end = ulmax(rle->end, start + count - 1);
 3450         }
 3451 
 3452         rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
 3453             type, rid, start, end, count, flags);
 3454 
 3455         /*
 3456          * Record the new range.
 3457          */
 3458         if (rle->res) {
 3459                 rle->start = rman_get_start(rle->res);
 3460                 rle->end = rman_get_end(rle->res);
 3461                 rle->count = count;
 3462         }
 3463 
 3464         return (rle->res);
 3465 }
 3466 
 3467 /**
 3468  * @brief Helper function for implementing BUS_RELEASE_RESOURCE()
 3469  *
 3470  * Implement BUS_RELEASE_RESOURCE() using a resource list. Normally
 3471  * used with resource_list_alloc().
 3472  *
 3473  * @param rl            the resource list which was allocated from
 3474  * @param bus           the parent device of @p child
 3475  * @param child         the device which is requesting a release
 3476  * @param type          the type of resource to release
 3477  * @param rid           the resource identifier
 3478  * @param res           the resource to release
 3479  *
 3480  * @retval 0            success
 3481  * @retval non-zero     a standard unix error code indicating what
 3482  *                      error condition prevented the operation
 3483  */
 3484 int
 3485 resource_list_release(struct resource_list *rl, device_t bus, device_t child,
 3486     int type, int rid, struct resource *res)
 3487 {
 3488         struct resource_list_entry *rle = NULL;
 3489         int passthrough = (device_get_parent(child) != bus);
 3490         int error;
 3491 
 3492         if (passthrough) {
 3493                 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
 3494                     type, rid, res));
 3495         }
 3496 
 3497         rle = resource_list_find(rl, type, rid);
 3498 
 3499         if (!rle)
 3500                 panic("resource_list_release: can't find resource");
 3501         if (!rle->res)
 3502                 panic("resource_list_release: resource entry is not busy");
 3503         if (rle->flags & RLE_RESERVED) {
 3504                 if (rle->flags & RLE_ALLOCATED) {
 3505                         if (rman_get_flags(res) & RF_ACTIVE) {
 3506                                 error = bus_deactivate_resource(child, type,
 3507                                     rid, res);
 3508                                 if (error)
 3509                                         return (error);
 3510                         }
 3511                         rle->flags &= ~RLE_ALLOCATED;
 3512                         return (0);
 3513                 }
 3514                 return (EINVAL);
 3515         }
 3516 
 3517         error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
 3518             type, rid, res);
 3519         if (error)
 3520                 return (error);
 3521 
 3522         rle->res = NULL;
 3523         return (0);
 3524 }
 3525 
 3526 /**
 3527  * @brief Release all active resources of a given type
 3528  *
 3529  * Release all active resources of a specified type.  This is intended
 3530  * to be used to cleanup resources leaked by a driver after detach or
 3531  * a failed attach.
 3532  *
 3533  * @param rl            the resource list which was allocated from
 3534  * @param bus           the parent device of @p child
 3535  * @param child         the device whose active resources are being released
 3536  * @param type          the type of resources to release
 3537  *
 3538  * @retval 0            success
 3539  * @retval EBUSY        at least one resource was active
 3540  */
 3541 int
 3542 resource_list_release_active(struct resource_list *rl, device_t bus,
 3543     device_t child, int type)
 3544 {
 3545         struct resource_list_entry *rle;
 3546         int error, retval;
 3547 
 3548         retval = 0;
 3549         STAILQ_FOREACH(rle, rl, link) {
 3550                 if (rle->type != type)
 3551                         continue;
 3552                 if (rle->res == NULL)
 3553                         continue;
 3554                 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) ==
 3555                     RLE_RESERVED)
 3556                         continue;
 3557                 retval = EBUSY;
 3558                 error = resource_list_release(rl, bus, child, type,
 3559                     rman_get_rid(rle->res), rle->res);
 3560                 if (error != 0)
 3561                         device_printf(bus,
 3562                             "Failed to release active resource: %d\n", error);
 3563         }
 3564         return (retval);
 3565 }
 3566 
 3567 
 3568 /**
 3569  * @brief Fully release a reserved resource
 3570  *
 3571  * Fully releases a resource reserved via resource_list_reserve().
 3572  *
 3573  * @param rl            the resource list which was allocated from
 3574  * @param bus           the parent device of @p child
 3575  * @param child         the device whose reserved resource is being released
 3576  * @param type          the type of resource to release
 3577  * @param rid           the resource identifier
 3578  * @param res           the resource to release
 3579  *
 3580  * @retval 0            success
 3581  * @retval non-zero     a standard unix error code indicating what
 3582  *                      error condition prevented the operation
 3583  */
 3584 int
 3585 resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child,
 3586     int type, int rid)
 3587 {
 3588         struct resource_list_entry *rle = NULL;
 3589         int passthrough = (device_get_parent(child) != bus);
 3590 
 3591         if (passthrough)
 3592                 panic(
 3593     "resource_list_unreserve() should only be called for direct children");
 3594 
 3595         rle = resource_list_find(rl, type, rid);
 3596 
 3597         if (!rle)
 3598                 panic("resource_list_unreserve: can't find resource");
 3599         if (!(rle->flags & RLE_RESERVED))
 3600                 return (EINVAL);
 3601         if (rle->flags & RLE_ALLOCATED)
 3602                 return (EBUSY);
 3603         rle->flags &= ~RLE_RESERVED;
 3604         return (resource_list_release(rl, bus, child, type, rid, rle->res));
 3605 }
 3606 
 3607 /**
 3608  * @brief Print a description of resources in a resource list
 3609  *
 3610  * Print all resources of a specified type, for use in BUS_PRINT_CHILD().
 3611  * The name is printed if at least one resource of the given type is available.
 3612  * The format is used to print resource start and end.
 3613  *
 3614  * @param rl            the resource list to print
 3615  * @param name          the name of @p type, e.g. @c "memory"
 3616  * @param type          type type of resource entry to print
 3617  * @param format        printf(9) format string to print resource
 3618  *                      start and end values
 3619  *
 3620  * @returns             the number of characters printed
 3621  */
 3622 int
 3623 resource_list_print_type(struct resource_list *rl, const char *name, int type,
 3624     const char *format)
 3625 {
 3626         struct resource_list_entry *rle;
 3627         int printed, retval;
 3628 
 3629         printed = 0;
 3630         retval = 0;
 3631         /* Yes, this is kinda cheating */
 3632         STAILQ_FOREACH(rle, rl, link) {
 3633                 if (rle->type == type) {
 3634                         if (printed == 0)
 3635                                 retval += printf(" %s ", name);
 3636                         else
 3637                                 retval += printf(",");
 3638                         printed++;
 3639                         retval += printf(format, rle->start);
 3640                         if (rle->count > 1) {
 3641                                 retval += printf("-");
 3642                                 retval += printf(format, rle->start +
 3643                                                  rle->count - 1);
 3644                         }
 3645                 }
 3646         }
 3647         return (retval);
 3648 }
 3649 
 3650 /**
 3651  * @brief Releases all the resources in a list.
 3652  *
 3653  * @param rl            The resource list to purge.
 3654  *
 3655  * @returns             nothing
 3656  */
 3657 void
 3658 resource_list_purge(struct resource_list *rl)
 3659 {
 3660         struct resource_list_entry *rle;
 3661 
 3662         while ((rle = STAILQ_FIRST(rl)) != NULL) {
 3663                 if (rle->res)
 3664                         bus_release_resource(rman_get_device(rle->res),
 3665                             rle->type, rle->rid, rle->res);
 3666                 STAILQ_REMOVE_HEAD(rl, link);
 3667                 free(rle, M_BUS);
 3668         }
 3669 }
 3670 
 3671 device_t
 3672 bus_generic_add_child(device_t dev, u_int order, const char *name, int unit)
 3673 {
 3674 
 3675         return (device_add_child_ordered(dev, order, name, unit));
 3676 }
 3677 
 3678 /**
 3679  * @brief Helper function for implementing DEVICE_PROBE()
 3680  *
 3681  * This function can be used to help implement the DEVICE_PROBE() for
 3682  * a bus (i.e. a device which has other devices attached to it). It
 3683  * calls the DEVICE_IDENTIFY() method of each driver in the device's
 3684  * devclass.
 3685  */
 3686 int
 3687 bus_generic_probe(device_t dev)
 3688 {
 3689         devclass_t dc = dev->devclass;
 3690         driverlink_t dl;
 3691 
 3692         TAILQ_FOREACH(dl, &dc->drivers, link) {
 3693                 /*
 3694                  * If this driver's pass is too high, then ignore it.
 3695                  * For most drivers in the default pass, this will
 3696                  * never be true.  For early-pass drivers they will
 3697                  * only call the identify routines of eligible drivers
 3698                  * when this routine is called.  Drivers for later
 3699                  * passes should have their identify routines called
 3700                  * on early-pass buses during BUS_NEW_PASS().
 3701                  */
 3702                 if (dl->pass > bus_current_pass)
 3703                         continue;
 3704                 DEVICE_IDENTIFY(dl->driver, dev);
 3705         }
 3706 
 3707         return (0);
 3708 }
 3709 
 3710 /**
 3711  * @brief Helper function for implementing DEVICE_ATTACH()
 3712  *
 3713  * This function can be used to help implement the DEVICE_ATTACH() for
 3714  * a bus. It calls device_probe_and_attach() for each of the device's
 3715  * children.
 3716  */
 3717 int
 3718 bus_generic_attach(device_t dev)
 3719 {
 3720         device_t child;
 3721 
 3722         TAILQ_FOREACH(child, &dev->children, link) {
 3723                 device_probe_and_attach(child);
 3724         }
 3725 
 3726         return (0);
 3727 }
 3728 
 3729 /**
 3730  * @brief Helper function for implementing DEVICE_DETACH()
 3731  *
 3732  * This function can be used to help implement the DEVICE_DETACH() for
 3733  * a bus. It calls device_detach() for each of the device's
 3734  * children.
 3735  */
 3736 int
 3737 bus_generic_detach(device_t dev)
 3738 {
 3739         device_t child;
 3740         int error;
 3741 
 3742         if (dev->state != DS_ATTACHED)
 3743                 return (EBUSY);
 3744 
 3745         /*
 3746          * Detach children in the reverse order.
 3747          * See bus_generic_suspend for details.
 3748          */
 3749         TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
 3750                 if ((error = device_detach(child)) != 0)
 3751                         return (error);
 3752         }
 3753 
 3754         return (0);
 3755 }
 3756 
 3757 /**
 3758  * @brief Helper function for implementing DEVICE_SHUTDOWN()
 3759  *
 3760  * This function can be used to help implement the DEVICE_SHUTDOWN()
 3761  * for a bus. It calls device_shutdown() for each of the device's
 3762  * children.
 3763  */
 3764 int
 3765 bus_generic_shutdown(device_t dev)
 3766 {
 3767         device_t child;
 3768 
 3769         /*
 3770          * Shut down children in the reverse order.
 3771          * See bus_generic_suspend for details.
 3772          */
 3773         TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
 3774                 device_shutdown(child);
 3775         }
 3776 
 3777         return (0);
 3778 }
 3779 
 3780 /**
 3781  * @brief Default function for suspending a child device.
 3782  *
 3783  * This function is to be used by a bus's DEVICE_SUSPEND_CHILD().
 3784  */
 3785 int
 3786 bus_generic_suspend_child(device_t dev, device_t child)
 3787 {
 3788         int     error;
 3789 
 3790         error = DEVICE_SUSPEND(child);
 3791 
 3792         if (error == 0)
 3793                 child->flags |= DF_SUSPENDED;
 3794 
 3795         return (error);
 3796 }
 3797 
 3798 /**
 3799  * @brief Default function for resuming a child device.
 3800  *
 3801  * This function is to be used by a bus's DEVICE_RESUME_CHILD().
 3802  */
 3803 int
 3804 bus_generic_resume_child(device_t dev, device_t child)
 3805 {
 3806 
 3807         DEVICE_RESUME(child);
 3808         child->flags &= ~DF_SUSPENDED;
 3809 
 3810         return (0);
 3811 }
 3812 
 3813 /**
 3814  * @brief Helper function for implementing DEVICE_SUSPEND()
 3815  *
 3816  * This function can be used to help implement the DEVICE_SUSPEND()
 3817  * for a bus. It calls DEVICE_SUSPEND() for each of the device's
 3818  * children. If any call to DEVICE_SUSPEND() fails, the suspend
 3819  * operation is aborted and any devices which were suspended are
 3820  * resumed immediately by calling their DEVICE_RESUME() methods.
 3821  */
 3822 int
 3823 bus_generic_suspend(device_t dev)
 3824 {
 3825         int             error;
 3826         device_t        child;
 3827 
 3828         /*
 3829          * Suspend children in the reverse order.
 3830          * For most buses all children are equal, so the order does not matter.
 3831          * Other buses, such as acpi, carefully order their child devices to
 3832          * express implicit dependencies between them.  For such buses it is
 3833          * safer to bring down devices in the reverse order.
 3834          */
 3835         TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
 3836                 error = BUS_SUSPEND_CHILD(dev, child);
 3837                 if (error != 0) {
 3838                         child = TAILQ_NEXT(child, link);
 3839                         if (child != NULL) {
 3840                                 TAILQ_FOREACH_FROM(child, &dev->children, link)
 3841                                         BUS_RESUME_CHILD(dev, child);
 3842                         }
 3843                         return (error);
 3844                 }
 3845         }
 3846         return (0);
 3847 }
 3848 
 3849 /**
 3850  * @brief Helper function for implementing DEVICE_RESUME()
 3851  *
 3852  * This function can be used to help implement the DEVICE_RESUME() for
 3853  * a bus. It calls DEVICE_RESUME() on each of the device's children.
 3854  */
 3855 int
 3856 bus_generic_resume(device_t dev)
 3857 {
 3858         device_t        child;
 3859 
 3860         TAILQ_FOREACH(child, &dev->children, link) {
 3861                 BUS_RESUME_CHILD(dev, child);
 3862                 /* if resume fails, there's nothing we can usefully do... */
 3863         }
 3864         return (0);
 3865 }
 3866 
 3867 
 3868 /**
 3869  * @brief Helper function for implementing BUS_RESET_POST
 3870  *
 3871  * Bus can use this function to implement common operations of
 3872  * re-attaching or resuming the children after the bus itself was
 3873  * reset, and after restoring bus-unique state of children.
 3874  *
 3875  * @param dev   The bus
 3876  * #param flags DEVF_RESET_*
 3877  */
 3878 int
 3879 bus_helper_reset_post(device_t dev, int flags)
 3880 {
 3881         device_t child;
 3882         int error, error1;
 3883 
 3884         error = 0;
 3885         TAILQ_FOREACH(child, &dev->children,link) {
 3886                 BUS_RESET_POST(dev, child);
 3887                 error1 = (flags & DEVF_RESET_DETACH) != 0 ?
 3888                     device_probe_and_attach(child) :
 3889                     BUS_RESUME_CHILD(dev, child);
 3890                 if (error == 0 && error1 != 0)
 3891                         error = error1;
 3892         }
 3893         return (error);
 3894 }
 3895 
 3896 static void
 3897 bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags)
 3898 {
 3899 
 3900         child = TAILQ_NEXT(child, link);
 3901         if (child == NULL)
 3902                 return;
 3903         TAILQ_FOREACH_FROM(child, &dev->children,link) {
 3904                 BUS_RESET_POST(dev, child);
 3905                 if ((flags & DEVF_RESET_DETACH) != 0)
 3906                         device_probe_and_attach(child);
 3907                 else
 3908                         BUS_RESUME_CHILD(dev, child);
 3909         }
 3910 }
 3911 
 3912 /**
 3913  * @brief Helper function for implementing BUS_RESET_PREPARE
 3914  *
 3915  * Bus can use this function to implement common operations of
 3916  * detaching or suspending the children before the bus itself is
 3917  * reset, and then save bus-unique state of children that must
 3918  * persists around reset.
 3919  *
 3920  * @param dev   The bus
 3921  * #param flags DEVF_RESET_*
 3922  */
 3923 int
 3924 bus_helper_reset_prepare(device_t dev, int flags)
 3925 {
 3926         device_t child;
 3927         int error;
 3928 
 3929         if (dev->state != DS_ATTACHED)
 3930                 return (EBUSY);
 3931 
 3932         TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
 3933                 if ((flags & DEVF_RESET_DETACH) != 0) {
 3934                         error = device_get_state(child) == DS_ATTACHED ?
 3935                             device_detach(child) : 0;
 3936                 } else {
 3937                         error = BUS_SUSPEND_CHILD(dev, child);
 3938                 }
 3939                 if (error == 0) {
 3940                         error = BUS_RESET_PREPARE(dev, child);
 3941                         if (error != 0) {
 3942                                 if ((flags & DEVF_RESET_DETACH) != 0)
 3943                                         device_probe_and_attach(child);
 3944                                 else
 3945                                         BUS_RESUME_CHILD(dev, child);
 3946                         }
 3947                 }
 3948                 if (error != 0) {
 3949                         bus_helper_reset_prepare_rollback(dev, child, flags);
 3950                         return (error);
 3951                 }
 3952         }
 3953         return (0);
 3954 }
 3955 
 3956 
 3957 /**
 3958  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3959  *
 3960  * This function prints the first part of the ascii representation of
 3961  * @p child, including its name, unit and description (if any - see
 3962  * device_set_desc()).
 3963  *
 3964  * @returns the number of characters printed
 3965  */
 3966 int
 3967 bus_print_child_header(device_t dev, device_t child)
 3968 {
 3969         int     retval = 0;
 3970 
 3971         if (device_get_desc(child)) {
 3972                 retval += device_printf(child, "<%s>", device_get_desc(child));
 3973         } else {
 3974                 retval += printf("%s", device_get_nameunit(child));
 3975         }
 3976 
 3977         return (retval);
 3978 }
 3979 
 3980 /**
 3981  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3982  *
 3983  * This function prints the last part of the ascii representation of
 3984  * @p child, which consists of the string @c " on " followed by the
 3985  * name and unit of the @p dev.
 3986  *
 3987  * @returns the number of characters printed
 3988  */
 3989 int
 3990 bus_print_child_footer(device_t dev, device_t child)
 3991 {
 3992         return (printf(" on %s\n", device_get_nameunit(dev)));
 3993 }
 3994 
 3995 /**
 3996  * @brief Helper function for implementing BUS_PRINT_CHILD().
 3997  *
 3998  * This function prints out the VM domain for the given device.
 3999  *
 4000  * @returns the number of characters printed
 4001  */
 4002 int
 4003 bus_print_child_domain(device_t dev, device_t child)
 4004 {
 4005         int domain;
 4006 
 4007         /* No domain? Don't print anything */
 4008         if (BUS_GET_DOMAIN(dev, child, &domain) != 0)
 4009                 return (0);
 4010 
 4011         return (printf(" numa-domain %d", domain));
 4012 }
 4013 
 4014 /**
 4015  * @brief Helper function for implementing BUS_PRINT_CHILD().
 4016  *
 4017  * This function simply calls bus_print_child_header() followed by
 4018  * bus_print_child_footer().
 4019  *
 4020  * @returns the number of characters printed
 4021  */
 4022 int
 4023 bus_generic_print_child(device_t dev, device_t child)
 4024 {
 4025         int     retval = 0;
 4026 
 4027         retval += bus_print_child_header(dev, child);
 4028         retval += bus_print_child_domain(dev, child);
 4029         retval += bus_print_child_footer(dev, child);
 4030 
 4031         return (retval);
 4032 }
 4033 
 4034 /**
 4035  * @brief Stub function for implementing BUS_READ_IVAR().
 4036  *
 4037  * @returns ENOENT
 4038  */
 4039 int
 4040 bus_generic_read_ivar(device_t dev, device_t child, int index,
 4041     uintptr_t * result)
 4042 {
 4043         return (ENOENT);
 4044 }
 4045 
 4046 /**
 4047  * @brief Stub function for implementing BUS_WRITE_IVAR().
 4048  *
 4049  * @returns ENOENT
 4050  */
 4051 int
 4052 bus_generic_write_ivar(device_t dev, device_t child, int index,
 4053     uintptr_t value)
 4054 {
 4055         return (ENOENT);
 4056 }
 4057 
 4058 /**
 4059  * @brief Stub function for implementing BUS_GET_RESOURCE_LIST().
 4060  *
 4061  * @returns NULL
 4062  */
 4063 struct resource_list *
 4064 bus_generic_get_resource_list(device_t dev, device_t child)
 4065 {
 4066         return (NULL);
 4067 }
 4068 
 4069 /**
 4070  * @brief Helper function for implementing BUS_DRIVER_ADDED().
 4071  *
 4072  * This implementation of BUS_DRIVER_ADDED() simply calls the driver's
 4073  * DEVICE_IDENTIFY() method to allow it to add new children to the bus
 4074  * and then calls device_probe_and_attach() for each unattached child.
 4075  */
 4076 void
 4077 bus_generic_driver_added(device_t dev, driver_t *driver)
 4078 {
 4079         device_t child;
 4080 
 4081         DEVICE_IDENTIFY(driver, dev);
 4082         TAILQ_FOREACH(child, &dev->children, link) {
 4083                 if (child->state == DS_NOTPRESENT ||
 4084                     (child->flags & DF_REBID))
 4085                         device_probe_and_attach(child);
 4086         }
 4087 }
 4088 
 4089 /**
 4090  * @brief Helper function for implementing BUS_NEW_PASS().
 4091  *
 4092  * This implementing of BUS_NEW_PASS() first calls the identify
 4093  * routines for any drivers that probe at the current pass.  Then it
 4094  * walks the list of devices for this bus.  If a device is already
 4095  * attached, then it calls BUS_NEW_PASS() on that device.  If the
 4096  * device is not already attached, it attempts to attach a driver to
 4097  * it.
 4098  */
 4099 void
 4100 bus_generic_new_pass(device_t dev)
 4101 {
 4102         driverlink_t dl;
 4103         devclass_t dc;
 4104         device_t child;
 4105 
 4106         dc = dev->devclass;
 4107         TAILQ_FOREACH(dl, &dc->drivers, link) {
 4108                 if (dl->pass == bus_current_pass)
 4109                         DEVICE_IDENTIFY(dl->driver, dev);
 4110         }
 4111         TAILQ_FOREACH(child, &dev->children, link) {
 4112                 if (child->state >= DS_ATTACHED)
 4113                         BUS_NEW_PASS(child);
 4114                 else if (child->state == DS_NOTPRESENT)
 4115                         device_probe_and_attach(child);
 4116         }
 4117 }
 4118 
 4119 /**
 4120  * @brief Helper function for implementing BUS_SETUP_INTR().
 4121  *
 4122  * This simple implementation of BUS_SETUP_INTR() simply calls the
 4123  * BUS_SETUP_INTR() method of the parent of @p dev.
 4124  */
 4125 int
 4126 bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq,
 4127     int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,
 4128     void **cookiep)
 4129 {
 4130         /* Propagate up the bus hierarchy until someone handles it. */
 4131         if (dev->parent)
 4132                 return (BUS_SETUP_INTR(dev->parent, child, irq, flags,
 4133                     filter, intr, arg, cookiep));
 4134         return (EINVAL);
 4135 }
 4136 
 4137 /**
 4138  * @brief Helper function for implementing BUS_TEARDOWN_INTR().
 4139  *
 4140  * This simple implementation of BUS_TEARDOWN_INTR() simply calls the
 4141  * BUS_TEARDOWN_INTR() method of the parent of @p dev.
 4142  */
 4143 int
 4144 bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq,
 4145     void *cookie)
 4146 {
 4147         /* Propagate up the bus hierarchy until someone handles it. */
 4148         if (dev->parent)
 4149                 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie));
 4150         return (EINVAL);
 4151 }
 4152 
 4153 /**
 4154  * @brief Helper function for implementing BUS_SUSPEND_INTR().
 4155  *
 4156  * This simple implementation of BUS_SUSPEND_INTR() simply calls the
 4157  * BUS_SUSPEND_INTR() method of the parent of @p dev.
 4158  */
 4159 int
 4160 bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq)
 4161 {
 4162         /* Propagate up the bus hierarchy until someone handles it. */
 4163         if (dev->parent)
 4164                 return (BUS_SUSPEND_INTR(dev->parent, child, irq));
 4165         return (EINVAL);
 4166 }
 4167 
 4168 /**
 4169  * @brief Helper function for implementing BUS_RESUME_INTR().
 4170  *
 4171  * This simple implementation of BUS_RESUME_INTR() simply calls the
 4172  * BUS_RESUME_INTR() method of the parent of @p dev.
 4173  */
 4174 int
 4175 bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq)
 4176 {
 4177         /* Propagate up the bus hierarchy until someone handles it. */
 4178         if (dev->parent)
 4179                 return (BUS_RESUME_INTR(dev->parent, child, irq));
 4180         return (EINVAL);
 4181 }
 4182 
 4183 /**
 4184  * @brief Helper function for implementing BUS_ADJUST_RESOURCE().
 4185  *
 4186  * This simple implementation of BUS_ADJUST_RESOURCE() simply calls the
 4187  * BUS_ADJUST_RESOURCE() method of the parent of @p dev.
 4188  */
 4189 int
 4190 bus_generic_adjust_resource(device_t dev, device_t child, int type,
 4191     struct resource *r, rman_res_t start, rman_res_t end)
 4192 {
 4193         /* Propagate up the bus hierarchy until someone handles it. */
 4194         if (dev->parent)
 4195                 return (BUS_ADJUST_RESOURCE(dev->parent, child, type, r, start,
 4196                     end));
 4197         return (EINVAL);
 4198 }
 4199 
 4200 /**
 4201  * @brief Helper function for implementing BUS_ALLOC_RESOURCE().
 4202  *
 4203  * This simple implementation of BUS_ALLOC_RESOURCE() simply calls the
 4204  * BUS_ALLOC_RESOURCE() method of the parent of @p dev.
 4205  */
 4206 struct resource *
 4207 bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
 4208     rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 4209 {
 4210         /* Propagate up the bus hierarchy until someone handles it. */
 4211         if (dev->parent)
 4212                 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid,
 4213                     start, end, count, flags));
 4214         return (NULL);
 4215 }
 4216 
 4217 /**
 4218  * @brief Helper function for implementing BUS_RELEASE_RESOURCE().
 4219  *
 4220  * This simple implementation of BUS_RELEASE_RESOURCE() simply calls the
 4221  * BUS_RELEASE_RESOURCE() method of the parent of @p dev.
 4222  */
 4223 int
 4224 bus_generic_release_resource(device_t dev, device_t child, int type, int rid,
 4225     struct resource *r)
 4226 {
 4227         /* Propagate up the bus hierarchy until someone handles it. */
 4228         if (dev->parent)
 4229                 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid,
 4230                     r));
 4231         return (EINVAL);
 4232 }
 4233 
 4234 /**
 4235  * @brief Helper function for implementing BUS_ACTIVATE_RESOURCE().
 4236  *
 4237  * This simple implementation of BUS_ACTIVATE_RESOURCE() simply calls the
 4238  * BUS_ACTIVATE_RESOURCE() method of the parent of @p dev.
 4239  */
 4240 int
 4241 bus_generic_activate_resource(device_t dev, device_t child, int type, int rid,
 4242     struct resource *r)
 4243 {
 4244         /* Propagate up the bus hierarchy until someone handles it. */
 4245         if (dev->parent)
 4246                 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid,
 4247                     r));
 4248         return (EINVAL);
 4249 }
 4250 
 4251 /**
 4252  * @brief Helper function for implementing BUS_DEACTIVATE_RESOURCE().
 4253  *
 4254  * This simple implementation of BUS_DEACTIVATE_RESOURCE() simply calls the
 4255  * BUS_DEACTIVATE_RESOURCE() method of the parent of @p dev.
 4256  */
 4257 int
 4258 bus_generic_deactivate_resource(device_t dev, device_t child, int type,
 4259     int rid, struct resource *r)
 4260 {
 4261         /* Propagate up the bus hierarchy until someone handles it. */
 4262         if (dev->parent)
 4263                 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid,
 4264                     r));
 4265         return (EINVAL);
 4266 }
 4267 
 4268 /**
 4269  * @brief Helper function for implementing BUS_MAP_RESOURCE().
 4270  *
 4271  * This simple implementation of BUS_MAP_RESOURCE() simply calls the
 4272  * BUS_MAP_RESOURCE() method of the parent of @p dev.
 4273  */
 4274 int
 4275 bus_generic_map_resource(device_t dev, device_t child, int type,
 4276     struct resource *r, struct resource_map_request *args,
 4277     struct resource_map *map)
 4278 {
 4279         /* Propagate up the bus hierarchy until someone handles it. */
 4280         if (dev->parent)
 4281                 return (BUS_MAP_RESOURCE(dev->parent, child, type, r, args,
 4282                     map));
 4283         return (EINVAL);
 4284 }
 4285 
 4286 /**
 4287  * @brief Helper function for implementing BUS_UNMAP_RESOURCE().
 4288  *
 4289  * This simple implementation of BUS_UNMAP_RESOURCE() simply calls the
 4290  * BUS_UNMAP_RESOURCE() method of the parent of @p dev.
 4291  */
 4292 int
 4293 bus_generic_unmap_resource(device_t dev, device_t child, int type,
 4294     struct resource *r, struct resource_map *map)
 4295 {
 4296         /* Propagate up the bus hierarchy until someone handles it. */
 4297         if (dev->parent)
 4298                 return (BUS_UNMAP_RESOURCE(dev->parent, child, type, r, map));
 4299         return (EINVAL);
 4300 }
 4301 
 4302 /**
 4303  * @brief Helper function for implementing BUS_BIND_INTR().
 4304  *
 4305  * This simple implementation of BUS_BIND_INTR() simply calls the
 4306  * BUS_BIND_INTR() method of the parent of @p dev.
 4307  */
 4308 int
 4309 bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq,
 4310     int cpu)
 4311 {
 4312 
 4313         /* Propagate up the bus hierarchy until someone handles it. */
 4314         if (dev->parent)
 4315                 return (BUS_BIND_INTR(dev->parent, child, irq, cpu));
 4316         return (EINVAL);
 4317 }
 4318 
 4319 /**
 4320  * @brief Helper function for implementing BUS_CONFIG_INTR().
 4321  *
 4322  * This simple implementation of BUS_CONFIG_INTR() simply calls the
 4323  * BUS_CONFIG_INTR() method of the parent of @p dev.
 4324  */
 4325 int
 4326 bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig,
 4327     enum intr_polarity pol)
 4328 {
 4329 
 4330         /* Propagate up the bus hierarchy until someone handles it. */
 4331         if (dev->parent)
 4332                 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol));
 4333         return (EINVAL);
 4334 }
 4335 
 4336 /**
 4337  * @brief Helper function for implementing BUS_DESCRIBE_INTR().
 4338  *
 4339  * This simple implementation of BUS_DESCRIBE_INTR() simply calls the
 4340  * BUS_DESCRIBE_INTR() method of the parent of @p dev.
 4341  */
 4342 int
 4343 bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq,
 4344     void *cookie, const char *descr)
 4345 {
 4346 
 4347         /* Propagate up the bus hierarchy until someone handles it. */
 4348         if (dev->parent)
 4349                 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie,
 4350                     descr));
 4351         return (EINVAL);
 4352 }
 4353 
 4354 /**
 4355  * @brief Helper function for implementing BUS_GET_CPUS().
 4356  *
 4357  * This simple implementation of BUS_GET_CPUS() simply calls the
 4358  * BUS_GET_CPUS() method of the parent of @p dev.
 4359  */
 4360 int
 4361 bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op,
 4362     size_t setsize, cpuset_t *cpuset)
 4363 {
 4364 
 4365         /* Propagate up the bus hierarchy until someone handles it. */
 4366         if (dev->parent != NULL)
 4367                 return (BUS_GET_CPUS(dev->parent, child, op, setsize, cpuset));
 4368         return (EINVAL);
 4369 }
 4370 
 4371 /**
 4372  * @brief Helper function for implementing BUS_GET_DMA_TAG().
 4373  *
 4374  * This simple implementation of BUS_GET_DMA_TAG() simply calls the
 4375  * BUS_GET_DMA_TAG() method of the parent of @p dev.
 4376  */
 4377 bus_dma_tag_t
 4378 bus_generic_get_dma_tag(device_t dev, device_t child)
 4379 {
 4380 
 4381         /* Propagate up the bus hierarchy until someone handles it. */
 4382         if (dev->parent != NULL)
 4383                 return (BUS_GET_DMA_TAG(dev->parent, child));
 4384         return (NULL);
 4385 }
 4386 
 4387 /**
 4388  * @brief Helper function for implementing BUS_GET_BUS_TAG().
 4389  *
 4390  * This simple implementation of BUS_GET_BUS_TAG() simply calls the
 4391  * BUS_GET_BUS_TAG() method of the parent of @p dev.
 4392  */
 4393 bus_space_tag_t
 4394 bus_generic_get_bus_tag(device_t dev, device_t child)
 4395 {
 4396 
 4397         /* Propagate up the bus hierarchy until someone handles it. */
 4398         if (dev->parent != NULL)
 4399                 return (BUS_GET_BUS_TAG(dev->parent, child));
 4400         return ((bus_space_tag_t)0);
 4401 }
 4402 
 4403 /**
 4404  * @brief Helper function for implementing BUS_GET_RESOURCE().
 4405  *
 4406  * This implementation of BUS_GET_RESOURCE() uses the
 4407  * resource_list_find() function to do most of the work. It calls
 4408  * BUS_GET_RESOURCE_LIST() to find a suitable resource list to
 4409  * search.
 4410  */
 4411 int
 4412 bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid,
 4413     rman_res_t *startp, rman_res_t *countp)
 4414 {
 4415         struct resource_list *          rl = NULL;
 4416         struct resource_list_entry *    rle = NULL;
 4417 
 4418         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4419         if (!rl)
 4420                 return (EINVAL);
 4421 
 4422         rle = resource_list_find(rl, type, rid);
 4423         if (!rle)
 4424                 return (ENOENT);
 4425 
 4426         if (startp)
 4427                 *startp = rle->start;
 4428         if (countp)
 4429                 *countp = rle->count;
 4430 
 4431         return (0);
 4432 }
 4433 
 4434 /**
 4435  * @brief Helper function for implementing BUS_SET_RESOURCE().
 4436  *
 4437  * This implementation of BUS_SET_RESOURCE() uses the
 4438  * resource_list_add() function to do most of the work. It calls
 4439  * BUS_GET_RESOURCE_LIST() to find a suitable resource list to
 4440  * edit.
 4441  */
 4442 int
 4443 bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid,
 4444     rman_res_t start, rman_res_t count)
 4445 {
 4446         struct resource_list *          rl = NULL;
 4447 
 4448         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4449         if (!rl)
 4450                 return (EINVAL);
 4451 
 4452         resource_list_add(rl, type, rid, start, (start + count - 1), count);
 4453 
 4454         return (0);
 4455 }
 4456 
 4457 /**
 4458  * @brief Helper function for implementing BUS_DELETE_RESOURCE().
 4459  *
 4460  * This implementation of BUS_DELETE_RESOURCE() uses the
 4461  * resource_list_delete() function to do most of the work. It calls
 4462  * BUS_GET_RESOURCE_LIST() to find a suitable resource list to
 4463  * edit.
 4464  */
 4465 void
 4466 bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid)
 4467 {
 4468         struct resource_list *          rl = NULL;
 4469 
 4470         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4471         if (!rl)
 4472                 return;
 4473 
 4474         resource_list_delete(rl, type, rid);
 4475 
 4476         return;
 4477 }
 4478 
 4479 /**
 4480  * @brief Helper function for implementing BUS_RELEASE_RESOURCE().
 4481  *
 4482  * This implementation of BUS_RELEASE_RESOURCE() uses the
 4483  * resource_list_release() function to do most of the work. It calls
 4484  * BUS_GET_RESOURCE_LIST() to find a suitable resource list.
 4485  */
 4486 int
 4487 bus_generic_rl_release_resource(device_t dev, device_t child, int type,
 4488     int rid, struct resource *r)
 4489 {
 4490         struct resource_list *          rl = NULL;
 4491 
 4492         if (device_get_parent(child) != dev)
 4493                 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
 4494                     type, rid, r));
 4495 
 4496         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4497         if (!rl)
 4498                 return (EINVAL);
 4499 
 4500         return (resource_list_release(rl, dev, child, type, rid, r));
 4501 }
 4502 
 4503 /**
 4504  * @brief Helper function for implementing BUS_ALLOC_RESOURCE().
 4505  *
 4506  * This implementation of BUS_ALLOC_RESOURCE() uses the
 4507  * resource_list_alloc() function to do most of the work. It calls
 4508  * BUS_GET_RESOURCE_LIST() to find a suitable resource list.
 4509  */
 4510 struct resource *
 4511 bus_generic_rl_alloc_resource(device_t dev, device_t child, int type,
 4512     int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
 4513 {
 4514         struct resource_list *          rl = NULL;
 4515 
 4516         if (device_get_parent(child) != dev)
 4517                 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
 4518                     type, rid, start, end, count, flags));
 4519 
 4520         rl = BUS_GET_RESOURCE_LIST(dev, child);
 4521         if (!rl)
 4522                 return (NULL);
 4523 
 4524         return (resource_list_alloc(rl, dev, child, type, rid,
 4525             start, end, count, flags));
 4526 }
 4527 
 4528 /**
 4529  * @brief Helper function for implementing BUS_CHILD_PRESENT().
 4530  *
 4531  * This simple implementation of BUS_CHILD_PRESENT() simply calls the
 4532  * BUS_CHILD_PRESENT() method of the parent of @p dev.
 4533  */
 4534 int
 4535 bus_generic_child_present(device_t dev, device_t child)
 4536 {
 4537         return (BUS_CHILD_PRESENT(device_get_parent(dev), dev));
 4538 }
 4539 
 4540 int
 4541 bus_generic_get_domain(device_t dev, device_t child, int *domain)
 4542 {
 4543 
 4544         if (dev->parent)
 4545                 return (BUS_GET_DOMAIN(dev->parent, dev, domain));
 4546 
 4547         return (ENOENT);
 4548 }
 4549 
 4550 /**
 4551  * @brief Helper function for implementing BUS_RESCAN().
 4552  *
 4553  * This null implementation of BUS_RESCAN() always fails to indicate
 4554  * the bus does not support rescanning.
 4555  */
 4556 int
 4557 bus_null_rescan(device_t dev)
 4558 {
 4559 
 4560         return (ENXIO);
 4561 }
 4562 
 4563 /*
 4564  * Some convenience functions to make it easier for drivers to use the
 4565  * resource-management functions.  All these really do is hide the
 4566  * indirection through the parent's method table, making for slightly
 4567  * less-wordy code.  In the future, it might make sense for this code
 4568  * to maintain some sort of a list of resources allocated by each device.
 4569  */
 4570 
 4571 int
 4572 bus_alloc_resources(device_t dev, struct resource_spec *rs,
 4573     struct resource **res)
 4574 {
 4575         int i;
 4576 
 4577         for (i = 0; rs[i].type != -1; i++)
 4578                 res[i] = NULL;
 4579         for (i = 0; rs[i].type != -1; i++) {
 4580                 res[i] = bus_alloc_resource_any(dev,
 4581                     rs[i].type, &rs[i].rid, rs[i].flags);
 4582                 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) {
 4583                         bus_release_resources(dev, rs, res);
 4584                         return (ENXIO);
 4585                 }
 4586         }
 4587         return (0);
 4588 }
 4589 
 4590 void
 4591 bus_release_resources(device_t dev, const struct resource_spec *rs,
 4592     struct resource **res)
 4593 {
 4594         int i;
 4595 
 4596         for (i = 0; rs[i].type != -1; i++)
 4597                 if (res[i] != NULL) {
 4598                         bus_release_resource(
 4599                             dev, rs[i].type, rs[i].rid, res[i]);
 4600                         res[i] = NULL;
 4601                 }
 4602 }
 4603 
 4604 /**
 4605  * @brief Wrapper function for BUS_ALLOC_RESOURCE().
 4606  *
 4607  * This function simply calls the BUS_ALLOC_RESOURCE() method of the
 4608  * parent of @p dev.
 4609  */
 4610 struct resource *
 4611 bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start,
 4612     rman_res_t end, rman_res_t count, u_int flags)
 4613 {
 4614         struct resource *res;
 4615 
 4616         if (dev->parent == NULL)
 4617                 return (NULL);
 4618         res = BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end,
 4619             count, flags);
 4620         return (res);
 4621 }
 4622 
 4623 /**
 4624  * @brief Wrapper function for BUS_ADJUST_RESOURCE().
 4625  *
 4626  * This function simply calls the BUS_ADJUST_RESOURCE() method of the
 4627  * parent of @p dev.
 4628  */
 4629 int
 4630 bus_adjust_resource(device_t dev, int type, struct resource *r, rman_res_t start,
 4631     rman_res_t end)
 4632 {
 4633         if (dev->parent == NULL)
 4634                 return (EINVAL);
 4635         return (BUS_ADJUST_RESOURCE(dev->parent, dev, type, r, start, end));
 4636 }
 4637 
 4638 /**
 4639  * @brief Wrapper function for BUS_ACTIVATE_RESOURCE().
 4640  *
 4641  * This function simply calls the BUS_ACTIVATE_RESOURCE() method of the
 4642  * parent of @p dev.
 4643  */
 4644 int
 4645 bus_activate_resource(device_t dev, int type, int rid, struct resource *r)
 4646 {
 4647         if (dev->parent == NULL)
 4648                 return (EINVAL);
 4649         return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
 4650 }
 4651 
 4652 /**
 4653  * @brief Wrapper function for BUS_DEACTIVATE_RESOURCE().
 4654  *
 4655  * This function simply calls the BUS_DEACTIVATE_RESOURCE() method of the
 4656  * parent of @p dev.
 4657  */
 4658 int
 4659 bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r)
 4660 {
 4661         if (dev->parent == NULL)
 4662                 return (EINVAL);
 4663         return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
 4664 }
 4665 
 4666 /**
 4667  * @brief Wrapper function for BUS_MAP_RESOURCE().
 4668  *
 4669  * This function simply calls the BUS_MAP_RESOURCE() method of the
 4670  * parent of @p dev.
 4671  */
 4672 int
 4673 bus_map_resource(device_t dev, int type, struct resource *r,
 4674     struct resource_map_request *args, struct resource_map *map)
 4675 {
 4676         if (dev->parent == NULL)
 4677                 return (EINVAL);
 4678         return (BUS_MAP_RESOURCE(dev->parent, dev, type, r, args, map));
 4679 }
 4680 
 4681 /**
 4682  * @brief Wrapper function for BUS_UNMAP_RESOURCE().
 4683  *
 4684  * This function simply calls the BUS_UNMAP_RESOURCE() method of the
 4685  * parent of @p dev.
 4686  */
 4687 int
 4688 bus_unmap_resource(device_t dev, int type, struct resource *r,
 4689     struct resource_map *map)
 4690 {
 4691         if (dev->parent == NULL)
 4692                 return (EINVAL);
 4693         return (BUS_UNMAP_RESOURCE(dev->parent, dev, type, r, map));
 4694 }
 4695 
 4696 /**
 4697  * @brief Wrapper function for BUS_RELEASE_RESOURCE().
 4698  *
 4699  * This function simply calls the BUS_RELEASE_RESOURCE() method of the
 4700  * parent of @p dev.
 4701  */
 4702 int
 4703 bus_release_resource(device_t dev, int type, int rid, struct resource *r)
 4704 {
 4705         int rv;
 4706 
 4707         if (dev->parent == NULL)
 4708                 return (EINVAL);
 4709         rv = BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r);
 4710         return (rv);
 4711 }
 4712 
 4713 /**
 4714  * @brief Wrapper function for BUS_SETUP_INTR().
 4715  *
 4716  * This function simply calls the BUS_SETUP_INTR() method of the
 4717  * parent of @p dev.
 4718  */
 4719 int
 4720 bus_setup_intr(device_t dev, struct resource *r, int flags,
 4721     driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep)
 4722 {
 4723         int error;
 4724 
 4725         if (dev->parent == NULL)
 4726                 return (EINVAL);
 4727         error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler,
 4728             arg, cookiep);
 4729         if (error != 0)
 4730                 return (error);
 4731         if (handler != NULL && !(flags & INTR_MPSAFE))
 4732                 device_printf(dev, "[GIANT-LOCKED]\n");
 4733         return (0);
 4734 }
 4735 
 4736 /**
 4737  * @brief Wrapper function for BUS_TEARDOWN_INTR().
 4738  *
 4739  * This function simply calls the BUS_TEARDOWN_INTR() method of the
 4740  * parent of @p dev.
 4741  */
 4742 int
 4743 bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
 4744 {
 4745         if (dev->parent == NULL)
 4746                 return (EINVAL);
 4747         return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie));
 4748 }
 4749 
 4750 /**
 4751  * @brief Wrapper function for BUS_SUSPEND_INTR().
 4752  *
 4753  * This function simply calls the BUS_SUSPEND_INTR() method of the
 4754  * parent of @p dev.
 4755  */
 4756 int
 4757 bus_suspend_intr(device_t dev, struct resource *r)
 4758 {
 4759         if (dev->parent == NULL)
 4760                 return (EINVAL);
 4761         return (BUS_SUSPEND_INTR(dev->parent, dev, r));
 4762 }
 4763 
 4764 /**
 4765  * @brief Wrapper function for BUS_RESUME_INTR().
 4766  *
 4767  * This function simply calls the BUS_RESUME_INTR() method of the
 4768  * parent of @p dev.
 4769  */
 4770 int
 4771 bus_resume_intr(device_t dev, struct resource *r)
 4772 {
 4773         if (dev->parent == NULL)
 4774                 return (EINVAL);
 4775         return (BUS_RESUME_INTR(dev->parent, dev, r));
 4776 }
 4777 
 4778 /**
 4779  * @brief Wrapper function for BUS_BIND_INTR().
 4780  *
 4781  * This function simply calls the BUS_BIND_INTR() method of the
 4782  * parent of @p dev.
 4783  */
 4784 int
 4785 bus_bind_intr(device_t dev, struct resource *r, int cpu)
 4786 {
 4787         if (dev->parent == NULL)
 4788                 return (EINVAL);
 4789         return (BUS_BIND_INTR(dev->parent, dev, r, cpu));
 4790 }
 4791 
 4792 /**
 4793  * @brief Wrapper function for BUS_DESCRIBE_INTR().
 4794  *
 4795  * This function first formats the requested description into a
 4796  * temporary buffer and then calls the BUS_DESCRIBE_INTR() method of
 4797  * the parent of @p dev.
 4798  */
 4799 int
 4800 bus_describe_intr(device_t dev, struct resource *irq, void *cookie,
 4801     const char *fmt, ...)
 4802 {
 4803         va_list ap;
 4804         char descr[MAXCOMLEN + 1];
 4805 
 4806         if (dev->parent == NULL)
 4807                 return (EINVAL);
 4808         va_start(ap, fmt);
 4809         vsnprintf(descr, sizeof(descr), fmt, ap);
 4810         va_end(ap);
 4811         return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr));
 4812 }
 4813 
 4814 /**
 4815  * @brief Wrapper function for BUS_SET_RESOURCE().
 4816  *
 4817  * This function simply calls the BUS_SET_RESOURCE() method of the
 4818  * parent of @p dev.
 4819  */
 4820 int
 4821 bus_set_resource(device_t dev, int type, int rid,
 4822     rman_res_t start, rman_res_t count)
 4823 {
 4824         return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4825             start, count));
 4826 }
 4827 
 4828 /**
 4829  * @brief Wrapper function for BUS_GET_RESOURCE().
 4830  *
 4831  * This function simply calls the BUS_GET_RESOURCE() method of the
 4832  * parent of @p dev.
 4833  */
 4834 int
 4835 bus_get_resource(device_t dev, int type, int rid,
 4836     rman_res_t *startp, rman_res_t *countp)
 4837 {
 4838         return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4839             startp, countp));
 4840 }
 4841 
 4842 /**
 4843  * @brief Wrapper function for BUS_GET_RESOURCE().
 4844  *
 4845  * This function simply calls the BUS_GET_RESOURCE() method of the
 4846  * parent of @p dev and returns the start value.
 4847  */
 4848 rman_res_t
 4849 bus_get_resource_start(device_t dev, int type, int rid)
 4850 {
 4851         rman_res_t start;
 4852         rman_res_t count;
 4853         int error;
 4854 
 4855         error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4856             &start, &count);
 4857         if (error)
 4858                 return (0);
 4859         return (start);
 4860 }
 4861 
 4862 /**
 4863  * @brief Wrapper function for BUS_GET_RESOURCE().
 4864  *
 4865  * This function simply calls the BUS_GET_RESOURCE() method of the
 4866  * parent of @p dev and returns the count value.
 4867  */
 4868 rman_res_t
 4869 bus_get_resource_count(device_t dev, int type, int rid)
 4870 {
 4871         rman_res_t start;
 4872         rman_res_t count;
 4873         int error;
 4874 
 4875         error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
 4876             &start, &count);
 4877         if (error)
 4878                 return (0);
 4879         return (count);
 4880 }
 4881 
 4882 /**
 4883  * @brief Wrapper function for BUS_DELETE_RESOURCE().
 4884  *
 4885  * This function simply calls the BUS_DELETE_RESOURCE() method of the
 4886  * parent of @p dev.
 4887  */
 4888 void
 4889 bus_delete_resource(device_t dev, int type, int rid)
 4890 {
 4891         BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid);
 4892 }
 4893 
 4894 /**
 4895  * @brief Wrapper function for BUS_CHILD_PRESENT().
 4896  *
 4897  * This function simply calls the BUS_CHILD_PRESENT() method of the
 4898  * parent of @p dev.
 4899  */
 4900 int
 4901 bus_child_present(device_t child)
 4902 {
 4903         return (BUS_CHILD_PRESENT(device_get_parent(child), child));
 4904 }
 4905 
 4906 /**
 4907  * @brief Wrapper function for BUS_CHILD_PNPINFO_STR().
 4908  *
 4909  * This function simply calls the BUS_CHILD_PNPINFO_STR() method of the
 4910  * parent of @p dev.
 4911  */
 4912 int
 4913 bus_child_pnpinfo_str(device_t child, char *buf, size_t buflen)
 4914 {
 4915         device_t parent;
 4916 
 4917         parent = device_get_parent(child);
 4918         if (parent == NULL) {
 4919                 *buf = '\0';
 4920                 return (0);
 4921         }
 4922         return (BUS_CHILD_PNPINFO_STR(parent, child, buf, buflen));
 4923 }
 4924 
 4925 /**
 4926  * @brief Wrapper function for BUS_CHILD_LOCATION_STR().
 4927  *
 4928  * This function simply calls the BUS_CHILD_LOCATION_STR() method of the
 4929  * parent of @p dev.
 4930  */
 4931 int
 4932 bus_child_location_str(device_t child, char *buf, size_t buflen)
 4933 {
 4934         device_t parent;
 4935 
 4936         parent = device_get_parent(child);
 4937         if (parent == NULL) {
 4938                 *buf = '\0';
 4939                 return (0);
 4940         }
 4941         return (BUS_CHILD_LOCATION_STR(parent, child, buf, buflen));
 4942 }
 4943 
 4944 /**
 4945  * @brief Wrapper function for BUS_GET_CPUS().
 4946  *
 4947  * This function simply calls the BUS_GET_CPUS() method of the
 4948  * parent of @p dev.
 4949  */
 4950 int
 4951 bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset)
 4952 {
 4953         device_t parent;
 4954 
 4955         parent = device_get_parent(dev);
 4956         if (parent == NULL)
 4957                 return (EINVAL);
 4958         return (BUS_GET_CPUS(parent, dev, op, setsize, cpuset));
 4959 }
 4960 
 4961 /**
 4962  * @brief Wrapper function for BUS_GET_DMA_TAG().
 4963  *
 4964  * This function simply calls the BUS_GET_DMA_TAG() method of the
 4965  * parent of @p dev.
 4966  */
 4967 bus_dma_tag_t
 4968 bus_get_dma_tag(device_t dev)
 4969 {
 4970         device_t parent;
 4971 
 4972         parent = device_get_parent(dev);
 4973         if (parent == NULL)
 4974                 return (NULL);
 4975         return (BUS_GET_DMA_TAG(parent, dev));
 4976 }
 4977 
 4978 /**
 4979  * @brief Wrapper function for BUS_GET_BUS_TAG().
 4980  *
 4981  * This function simply calls the BUS_GET_BUS_TAG() method of the
 4982  * parent of @p dev.
 4983  */
 4984 bus_space_tag_t
 4985 bus_get_bus_tag(device_t dev)
 4986 {
 4987         device_t parent;
 4988 
 4989         parent = device_get_parent(dev);
 4990         if (parent == NULL)
 4991                 return ((bus_space_tag_t)0);
 4992         return (BUS_GET_BUS_TAG(parent, dev));
 4993 }
 4994 
 4995 /**
 4996  * @brief Wrapper function for BUS_GET_DOMAIN().
 4997  *
 4998  * This function simply calls the BUS_GET_DOMAIN() method of the
 4999  * parent of @p dev.
 5000  */
 5001 int
 5002 bus_get_domain(device_t dev, int *domain)
 5003 {
 5004         return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain));
 5005 }
 5006 
 5007 /* Resume all devices and then notify userland that we're up again. */
 5008 static int
 5009 root_resume(device_t dev)
 5010 {
 5011         int error;
 5012 
 5013         error = bus_generic_resume(dev);
 5014         if (error == 0)
 5015                 devctl_notify("kern", "power", "resume", NULL);
 5016         return (error);
 5017 }
 5018 
 5019 static int
 5020 root_print_child(device_t dev, device_t child)
 5021 {
 5022         int     retval = 0;
 5023 
 5024         retval += bus_print_child_header(dev, child);
 5025         retval += printf("\n");
 5026 
 5027         return (retval);
 5028 }
 5029 
 5030 static int
 5031 root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
 5032     driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)
 5033 {
 5034         /*
 5035          * If an interrupt mapping gets to here something bad has happened.
 5036          */
 5037         panic("root_setup_intr");
 5038 }
 5039 
 5040 /*
 5041  * If we get here, assume that the device is permanent and really is
 5042  * present in the system.  Removable bus drivers are expected to intercept
 5043  * this call long before it gets here.  We return -1 so that drivers that
 5044  * really care can check vs -1 or some ERRNO returned higher in the food
 5045  * chain.
 5046  */
 5047 static int
 5048 root_child_present(device_t dev, device_t child)
 5049 {
 5050         return (-1);
 5051 }
 5052 
 5053 static int
 5054 root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize,
 5055     cpuset_t *cpuset)
 5056 {
 5057 
 5058         switch (op) {
 5059         case INTR_CPUS:
 5060                 /* Default to returning the set of all CPUs. */
 5061                 if (setsize != sizeof(cpuset_t))
 5062                         return (EINVAL);
 5063                 *cpuset = all_cpus;
 5064                 return (0);
 5065         default:
 5066                 return (EINVAL);
 5067         }
 5068 }
 5069 
 5070 static kobj_method_t root_methods[] = {
 5071         /* Device interface */
 5072         KOBJMETHOD(device_shutdown,     bus_generic_shutdown),
 5073         KOBJMETHOD(device_suspend,      bus_generic_suspend),
 5074         KOBJMETHOD(device_resume,       root_resume),
 5075 
 5076         /* Bus interface */
 5077         KOBJMETHOD(bus_print_child,     root_print_child),
 5078         KOBJMETHOD(bus_read_ivar,       bus_generic_read_ivar),
 5079         KOBJMETHOD(bus_write_ivar,      bus_generic_write_ivar),
 5080         KOBJMETHOD(bus_setup_intr,      root_setup_intr),
 5081         KOBJMETHOD(bus_child_present,   root_child_present),
 5082         KOBJMETHOD(bus_get_cpus,        root_get_cpus),
 5083 
 5084         KOBJMETHOD_END
 5085 };
 5086 
 5087 static driver_t root_driver = {
 5088         "root",
 5089         root_methods,
 5090         1,                      /* no softc */
 5091 };
 5092 
 5093 device_t        root_bus;
 5094 devclass_t      root_devclass;
 5095 
 5096 static int
 5097 root_bus_module_handler(module_t mod, int what, void* arg)
 5098 {
 5099         switch (what) {
 5100         case MOD_LOAD:
 5101                 TAILQ_INIT(&bus_data_devices);
 5102                 kobj_class_compile((kobj_class_t) &root_driver);
 5103                 root_bus = make_device(NULL, "root", 0);
 5104                 root_bus->desc = "System root bus";
 5105                 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver);
 5106                 root_bus->driver = &root_driver;
 5107                 root_bus->state = DS_ATTACHED;
 5108                 root_devclass = devclass_find_internal("root", NULL, FALSE);
 5109                 devinit();
 5110                 return (0);
 5111 
 5112         case MOD_SHUTDOWN:
 5113                 device_shutdown(root_bus);
 5114                 return (0);
 5115         default:
 5116                 return (EOPNOTSUPP);
 5117         }
 5118 
 5119         return (0);
 5120 }
 5121 
 5122 static moduledata_t root_bus_mod = {
 5123         "rootbus",
 5124         root_bus_module_handler,
 5125         NULL
 5126 };
 5127 DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
 5128 
 5129 /**
 5130  * @brief Automatically configure devices
 5131  *
 5132  * This function begins the autoconfiguration process by calling
 5133  * device_probe_and_attach() for each child of the @c root0 device.
 5134  */
 5135 void
 5136 root_bus_configure(void)
 5137 {
 5138 
 5139         PDEBUG(("."));
 5140 
 5141         /* Eventually this will be split up, but this is sufficient for now. */
 5142         bus_set_pass(BUS_PASS_DEFAULT);
 5143 }
 5144 
 5145 /**
 5146  * @brief Module handler for registering device drivers
 5147  *
 5148  * This module handler is used to automatically register device
 5149  * drivers when modules are loaded. If @p what is MOD_LOAD, it calls
 5150  * devclass_add_driver() for the driver described by the
 5151  * driver_module_data structure pointed to by @p arg
 5152  */
 5153 int
 5154 driver_module_handler(module_t mod, int what, void *arg)
 5155 {
 5156         struct driver_module_data *dmd;
 5157         devclass_t bus_devclass;
 5158         kobj_class_t driver;
 5159         int error, pass;
 5160 
 5161         dmd = (struct driver_module_data *)arg;
 5162         bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE);
 5163         error = 0;
 5164 
 5165         switch (what) {
 5166         case MOD_LOAD:
 5167                 if (dmd->dmd_chainevh)
 5168                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
 5169 
 5170                 pass = dmd->dmd_pass;
 5171                 driver = dmd->dmd_driver;
 5172                 PDEBUG(("Loading module: driver %s on bus %s (pass %d)",
 5173                     DRIVERNAME(driver), dmd->dmd_busname, pass));
 5174                 error = devclass_add_driver(bus_devclass, driver, pass,
 5175                     dmd->dmd_devclass);
 5176                 break;
 5177 
 5178         case MOD_UNLOAD:
 5179                 PDEBUG(("Unloading module: driver %s from bus %s",
 5180                     DRIVERNAME(dmd->dmd_driver),
 5181                     dmd->dmd_busname));
 5182                 error = devclass_delete_driver(bus_devclass,
 5183                     dmd->dmd_driver);
 5184 
 5185                 if (!error && dmd->dmd_chainevh)
 5186                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
 5187                 break;
 5188         case MOD_QUIESCE:
 5189                 PDEBUG(("Quiesce module: driver %s from bus %s",
 5190                     DRIVERNAME(dmd->dmd_driver),
 5191                     dmd->dmd_busname));
 5192                 error = devclass_quiesce_driver(bus_devclass,
 5193                     dmd->dmd_driver);
 5194 
 5195                 if (!error && dmd->dmd_chainevh)
 5196                         error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
 5197                 break;
 5198         default:
 5199                 error = EOPNOTSUPP;
 5200                 break;
 5201         }
 5202 
 5203         return (error);
 5204 }
 5205 
 5206 /**
 5207  * @brief Enumerate all hinted devices for this bus.
 5208  *
 5209  * Walks through the hints for this bus and calls the bus_hinted_child
 5210  * routine for each one it fines.  It searches first for the specific
 5211  * bus that's being probed for hinted children (eg isa0), and then for
 5212  * generic children (eg isa).
 5213  *
 5214  * @param       dev     bus device to enumerate
 5215  */
 5216 void
 5217 bus_enumerate_hinted_children(device_t bus)
 5218 {
 5219         int i;
 5220         const char *dname, *busname;
 5221         int dunit;
 5222 
 5223         /*
 5224          * enumerate all devices on the specific bus
 5225          */
 5226         busname = device_get_nameunit(bus);
 5227         i = 0;
 5228         while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0)
 5229                 BUS_HINTED_CHILD(bus, dname, dunit);
 5230 
 5231         /*
 5232          * and all the generic ones.
 5233          */
 5234         busname = device_get_name(bus);
 5235         i = 0;
 5236         while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0)
 5237                 BUS_HINTED_CHILD(bus, dname, dunit);
 5238 }
 5239 
 5240 #ifdef BUS_DEBUG
 5241 
 5242 /* the _short versions avoid iteration by not calling anything that prints
 5243  * more than oneliners. I love oneliners.
 5244  */
 5245 
 5246 static void
 5247 print_device_short(device_t dev, int indent)
 5248 {
 5249         if (!dev)
 5250                 return;
 5251 
 5252         indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s%s%s,%sivars,%ssoftc,busy=%d\n",
 5253             dev->unit, dev->desc,
 5254             (dev->parent? "":"no "),
 5255             (TAILQ_EMPTY(&dev->children)? "no ":""),
 5256             (dev->flags&DF_ENABLED? "enabled,":"disabled,"),
 5257             (dev->flags&DF_FIXEDCLASS? "fixed,":""),
 5258             (dev->flags&DF_WILDCARD? "wildcard,":""),
 5259             (dev->flags&DF_DESCMALLOCED? "descmalloced,":""),
 5260             (dev->flags&DF_REBID? "rebiddable,":""),
 5261             (dev->flags&DF_SUSPENDED? "suspended,":""),
 5262             (dev->ivars? "":"no "),
 5263             (dev->softc? "":"no "),
 5264             dev->busy));
 5265 }
 5266 
 5267 static void
 5268 print_device(device_t dev, int indent)
 5269 {
 5270         if (!dev)
 5271                 return;
 5272 
 5273         print_device_short(dev, indent);
 5274 
 5275         indentprintf(("Parent:\n"));
 5276         print_device_short(dev->parent, indent+1);
 5277         indentprintf(("Driver:\n"));
 5278         print_driver_short(dev->driver, indent+1);
 5279         indentprintf(("Devclass:\n"));
 5280         print_devclass_short(dev->devclass, indent+1);
 5281 }
 5282 
 5283 void
 5284 print_device_tree_short(device_t dev, int indent)
 5285 /* print the device and all its children (indented) */
 5286 {
 5287         device_t child;
 5288 
 5289         if (!dev)
 5290                 return;
 5291 
 5292         print_device_short(dev, indent);
 5293 
 5294         TAILQ_FOREACH(child, &dev->children, link) {
 5295                 print_device_tree_short(child, indent+1);
 5296         }
 5297 }
 5298 
 5299 void
 5300 print_device_tree(device_t dev, int indent)
 5301 /* print the device and all its children (indented) */
 5302 {
 5303         device_t child;
 5304 
 5305         if (!dev)
 5306                 return;
 5307 
 5308         print_device(dev, indent);
 5309 
 5310         TAILQ_FOREACH(child, &dev->children, link) {
 5311                 print_device_tree(child, indent+1);
 5312         }
 5313 }
 5314 
 5315 static void
 5316 print_driver_short(driver_t *driver, int indent)
 5317 {
 5318         if (!driver)
 5319                 return;
 5320 
 5321         indentprintf(("driver %s: softc size = %zd\n",
 5322             driver->name, driver->size));
 5323 }
 5324 
 5325 static void
 5326 print_driver(driver_t *driver, int indent)
 5327 {
 5328         if (!driver)
 5329                 return;
 5330 
 5331         print_driver_short(driver, indent);
 5332 }
 5333 
 5334 static void
 5335 print_driver_list(driver_list_t drivers, int indent)
 5336 {
 5337         driverlink_t driver;
 5338 
 5339         TAILQ_FOREACH(driver, &drivers, link) {
 5340                 print_driver(driver->driver, indent);
 5341         }
 5342 }
 5343 
 5344 static void
 5345 print_devclass_short(devclass_t dc, int indent)
 5346 {
 5347         if ( !dc )
 5348                 return;
 5349 
 5350         indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit));
 5351 }
 5352 
 5353 static void
 5354 print_devclass(devclass_t dc, int indent)
 5355 {
 5356         int i;
 5357 
 5358         if ( !dc )
 5359                 return;
 5360 
 5361         print_devclass_short(dc, indent);
 5362         indentprintf(("Drivers:\n"));
 5363         print_driver_list(dc->drivers, indent+1);
 5364 
 5365         indentprintf(("Devices:\n"));
 5366         for (i = 0; i < dc->maxunit; i++)
 5367                 if (dc->devices[i])
 5368                         print_device(dc->devices[i], indent+1);
 5369 }
 5370 
 5371 void
 5372 print_devclass_list_short(void)
 5373 {
 5374         devclass_t dc;
 5375 
 5376         printf("Short listing of devclasses, drivers & devices:\n");
 5377         TAILQ_FOREACH(dc, &devclasses, link) {
 5378                 print_devclass_short(dc, 0);
 5379         }
 5380 }
 5381 
 5382 void
 5383 print_devclass_list(void)
 5384 {
 5385         devclass_t dc;
 5386 
 5387         printf("Full listing of devclasses, drivers & devices:\n");
 5388         TAILQ_FOREACH(dc, &devclasses, link) {
 5389                 print_devclass(dc, 0);
 5390         }
 5391 }
 5392 
 5393 #endif
 5394 
 5395 /*
 5396  * User-space access to the device tree.
 5397  *
 5398  * We implement a small set of nodes:
 5399  *
 5400  * hw.bus                       Single integer read method to obtain the
 5401  *                              current generation count.
 5402  * hw.bus.devices               Reads the entire device tree in flat space.
 5403  * hw.bus.rman                  Resource manager interface
 5404  *
 5405  * We might like to add the ability to scan devclasses and/or drivers to
 5406  * determine what else is currently loaded/available.
 5407  */
 5408 
 5409 static int
 5410 sysctl_bus(SYSCTL_HANDLER_ARGS)
 5411 {
 5412         struct u_businfo        ubus;
 5413 
 5414         ubus.ub_version = BUS_USER_VERSION;
 5415         ubus.ub_generation = bus_data_generation;
 5416 
 5417         return (SYSCTL_OUT(req, &ubus, sizeof(ubus)));
 5418 }
 5419 SYSCTL_NODE(_hw_bus, OID_AUTO, info, CTLFLAG_RW, sysctl_bus,
 5420     "bus-related data");
 5421 
 5422 static int
 5423 sysctl_devices(SYSCTL_HANDLER_ARGS)
 5424 {
 5425         int                     *name = (int *)arg1;
 5426         u_int                   namelen = arg2;
 5427         int                     index;
 5428         device_t                dev;
 5429         struct u_device         *udev;
 5430         int                     error;
 5431         char                    *walker, *ep;
 5432 
 5433         if (namelen != 2)
 5434                 return (EINVAL);
 5435 
 5436         if (bus_data_generation_check(name[0]))
 5437                 return (EINVAL);
 5438 
 5439         index = name[1];
 5440 
 5441         /*
 5442          * Scan the list of devices, looking for the requested index.
 5443          */
 5444         TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
 5445                 if (index-- == 0)
 5446                         break;
 5447         }
 5448         if (dev == NULL)
 5449                 return (ENOENT);
 5450 
 5451         /*
 5452          * Populate the return item, careful not to overflow the buffer.
 5453          */
 5454         udev = malloc(sizeof(*udev), M_BUS, M_WAITOK | M_ZERO);
 5455         if (udev == NULL)
 5456                 return (ENOMEM);
 5457         udev->dv_handle = (uintptr_t)dev;
 5458         udev->dv_parent = (uintptr_t)dev->parent;
 5459         udev->dv_devflags = dev->devflags;
 5460         udev->dv_flags = dev->flags;
 5461         udev->dv_state = dev->state;
 5462         walker = udev->dv_fields;
 5463         ep = walker + sizeof(udev->dv_fields);
 5464 #define CP(src)                                         \
 5465         if ((src) == NULL)                              \
 5466                 *walker++ = '\0';                       \
 5467         else {                                          \
 5468                 strlcpy(walker, (src), ep - walker);    \
 5469                 walker += strlen(walker) + 1;           \
 5470         }                                               \
 5471         if (walker >= ep)                               \
 5472                 break;
 5473 
 5474         do {
 5475                 CP(dev->nameunit);
 5476                 CP(dev->desc);
 5477                 CP(dev->driver != NULL ? dev->driver->name : NULL);
 5478                 bus_child_pnpinfo_str(dev, walker, ep - walker);
 5479                 walker += strlen(walker) + 1;
 5480                 if (walker >= ep)
 5481                         break;
 5482                 bus_child_location_str(dev, walker, ep - walker);
 5483                 walker += strlen(walker) + 1;
 5484                 if (walker >= ep)
 5485                         break;
 5486                 *walker++ = '\0';
 5487         } while (0);
 5488 #undef CP
 5489         error = SYSCTL_OUT(req, udev, sizeof(*udev));
 5490         free(udev, M_BUS);
 5491         return (error);
 5492 }
 5493 
 5494 SYSCTL_NODE(_hw_bus, OID_AUTO, devices, CTLFLAG_RD, sysctl_devices,
 5495     "system device tree");
 5496 
 5497 int
 5498 bus_data_generation_check(int generation)
 5499 {
 5500         if (generation != bus_data_generation)
 5501                 return (1);
 5502 
 5503         /* XXX generate optimised lists here? */
 5504         return (0);
 5505 }
 5506 
 5507 void
 5508 bus_data_generation_update(void)
 5509 {
 5510         bus_data_generation++;
 5511 }
 5512 
 5513 int
 5514 bus_free_resource(device_t dev, int type, struct resource *r)
 5515 {
 5516         if (r == NULL)
 5517                 return (0);
 5518         return (bus_release_resource(dev, type, rman_get_rid(r), r));
 5519 }
 5520 
 5521 device_t
 5522 device_lookup_by_name(const char *name)
 5523 {
 5524         device_t dev;
 5525 
 5526         TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
 5527                 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0)
 5528                         return (dev);
 5529         }
 5530         return (NULL);
 5531 }
 5532 
 5533 /*
 5534  * /dev/devctl2 implementation.  The existing /dev/devctl device has
 5535  * implicit semantics on open, so it could not be reused for this.
 5536  * Another option would be to call this /dev/bus?
 5537  */
 5538 static int
 5539 find_device(struct devreq *req, device_t *devp)
 5540 {
 5541         device_t dev;
 5542 
 5543         /*
 5544          * First, ensure that the name is nul terminated.
 5545          */
 5546         if (memchr(req->dr_name, '\0', sizeof(req->dr_name)) == NULL)
 5547                 return (EINVAL);
 5548 
 5549         /*
 5550          * Second, try to find an attached device whose name matches
 5551          * 'name'.
 5552          */
 5553         dev = device_lookup_by_name(req->dr_name);
 5554         if (dev != NULL) {
 5555                 *devp = dev;
 5556                 return (0);
 5557         }
 5558 
 5559         /* Finally, give device enumerators a chance. */
 5560         dev = NULL;
 5561         EVENTHANDLER_DIRECT_INVOKE(dev_lookup, req->dr_name, &dev);
 5562         if (dev == NULL)
 5563                 return (ENOENT);
 5564         *devp = dev;
 5565         return (0);
 5566 }
 5567 
 5568 static bool
 5569 driver_exists(device_t bus, const char *driver)
 5570 {
 5571         devclass_t dc;
 5572 
 5573         for (dc = bus->devclass; dc != NULL; dc = dc->parent) {
 5574                 if (devclass_find_driver_internal(dc, driver) != NULL)
 5575                         return (true);
 5576         }
 5577         return (false);
 5578 }
 5579 
 5580 static void
 5581 device_gen_nomatch(device_t dev)
 5582 {
 5583         device_t child;
 5584 
 5585         if (dev->flags & DF_NEEDNOMATCH &&
 5586             dev->state == DS_NOTPRESENT) {
 5587                 BUS_PROBE_NOMATCH(dev->parent, dev);
 5588                 devnomatch(dev);
 5589                 dev->flags |= DF_DONENOMATCH;
 5590         }
 5591         dev->flags &= ~DF_NEEDNOMATCH;
 5592         TAILQ_FOREACH(child, &dev->children, link) {
 5593                 device_gen_nomatch(child);
 5594         }
 5595 }
 5596 
 5597 static void
 5598 device_do_deferred_actions(void)
 5599 {
 5600         devclass_t dc;
 5601         driverlink_t dl;
 5602 
 5603         /*
 5604          * Walk through the devclasses to find all the drivers we've tagged as
 5605          * deferred during the freeze and call the driver added routines. They
 5606          * have already been added to the lists in the background, so the driver
 5607          * added routines that trigger a probe will have all the right bidders
 5608          * for the probe auction.
 5609          */
 5610         TAILQ_FOREACH(dc, &devclasses, link) {
 5611                 TAILQ_FOREACH(dl, &dc->drivers, link) {
 5612                         if (dl->flags & DL_DEFERRED_PROBE) {
 5613                                 devclass_driver_added(dc, dl->driver);
 5614                                 dl->flags &= ~DL_DEFERRED_PROBE;
 5615                         }
 5616                 }
 5617         }
 5618 
 5619         /*
 5620          * We also defer no-match events during a freeze. Walk the tree and
 5621          * generate all the pent-up events that are still relevant.
 5622          */
 5623         device_gen_nomatch(root_bus);
 5624         bus_data_generation_update();
 5625 }
 5626 
 5627 static int
 5628 devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag,
 5629     struct thread *td)
 5630 {
 5631         struct devreq *req;
 5632         device_t dev;
 5633         int error, old;
 5634 
 5635         /* Locate the device to control. */
 5636         mtx_lock(&Giant);
 5637         req = (struct devreq *)data;
 5638         switch (cmd) {
 5639         case DEV_ATTACH:
 5640         case DEV_DETACH:
 5641         case DEV_ENABLE:
 5642         case DEV_DISABLE:
 5643         case DEV_SUSPEND:
 5644         case DEV_RESUME:
 5645         case DEV_SET_DRIVER:
 5646         case DEV_CLEAR_DRIVER:
 5647         case DEV_RESCAN:
 5648         case DEV_DELETE:
 5649         case DEV_RESET:
 5650                 error = priv_check(td, PRIV_DRIVER);
 5651                 if (error == 0)
 5652                         error = find_device(req, &dev);
 5653                 break;
 5654         case DEV_FREEZE:
 5655         case DEV_THAW:
 5656                 error = priv_check(td, PRIV_DRIVER);
 5657                 break;
 5658         default:
 5659                 error = ENOTTY;
 5660                 break;
 5661         }
 5662         if (error) {
 5663                 mtx_unlock(&Giant);
 5664                 return (error);
 5665         }
 5666 
 5667         /* Perform the requested operation. */
 5668         switch (cmd) {
 5669         case DEV_ATTACH:
 5670                 if (device_is_attached(dev) && (dev->flags & DF_REBID) == 0)
 5671                         error = EBUSY;
 5672                 else if (!device_is_enabled(dev))
 5673                         error = ENXIO;
 5674                 else
 5675                         error = device_probe_and_attach(dev);
 5676                 break;
 5677         case DEV_DETACH:
 5678                 if (!device_is_attached(dev)) {
 5679                         error = ENXIO;
 5680                         break;
 5681                 }
 5682                 if (!(req->dr_flags & DEVF_FORCE_DETACH)) {
 5683                         error = device_quiesce(dev);
 5684                         if (error)
 5685                                 break;
 5686                 }
 5687                 error = device_detach(dev);
 5688                 break;
 5689         case DEV_ENABLE:
 5690                 if (device_is_enabled(dev)) {
 5691                         error = EBUSY;
 5692                         break;
 5693                 }
 5694 
 5695                 /*
 5696                  * If the device has been probed but not attached (e.g.
 5697                  * when it has been disabled by a loader hint), just
 5698                  * attach the device rather than doing a full probe.
 5699                  */
 5700                 device_enable(dev);
 5701                 if (device_is_alive(dev)) {
 5702                         /*
 5703                          * If the device was disabled via a hint, clear
 5704                          * the hint.
 5705                          */
 5706                         if (resource_disabled(dev->driver->name, dev->unit))
 5707                                 resource_unset_value(dev->driver->name,
 5708                                     dev->unit, "disabled");
 5709                         error = device_attach(dev);
 5710                 } else
 5711                         error = device_probe_and_attach(dev);
 5712                 break;
 5713         case DEV_DISABLE:
 5714                 if (!device_is_enabled(dev)) {
 5715                         error = ENXIO;
 5716                         break;
 5717                 }
 5718 
 5719                 if (!(req->dr_flags & DEVF_FORCE_DETACH)) {
 5720                         error = device_quiesce(dev);
 5721                         if (error)
 5722                                 break;
 5723                 }
 5724 
 5725                 /*
 5726                  * Force DF_FIXEDCLASS on around detach to preserve
 5727                  * the existing name.
 5728                  */
 5729                 old = dev->flags;
 5730                 dev->flags |= DF_FIXEDCLASS;
 5731                 error = device_detach(dev);
 5732                 if (!(old & DF_FIXEDCLASS))
 5733                         dev->flags &= ~DF_FIXEDCLASS;
 5734                 if (error == 0)
 5735                         device_disable(dev);
 5736                 break;
 5737         case DEV_SUSPEND:
 5738                 if (device_is_suspended(dev)) {
 5739                         error = EBUSY;
 5740                         break;
 5741                 }
 5742                 if (device_get_parent(dev) == NULL) {
 5743                         error = EINVAL;
 5744                         break;
 5745                 }
 5746                 error = BUS_SUSPEND_CHILD(device_get_parent(dev), dev);
 5747                 break;
 5748         case DEV_RESUME:
 5749                 if (!device_is_suspended(dev)) {
 5750                         error = EINVAL;
 5751                         break;
 5752                 }
 5753                 if (device_get_parent(dev) == NULL) {
 5754                         error = EINVAL;
 5755                         break;
 5756                 }
 5757                 error = BUS_RESUME_CHILD(device_get_parent(dev), dev);
 5758                 break;
 5759         case DEV_SET_DRIVER: {
 5760                 devclass_t dc;
 5761                 char driver[128];
 5762 
 5763                 error = copyinstr(req->dr_data, driver, sizeof(driver), NULL);
 5764                 if (error)
 5765                         break;
 5766                 if (driver[0] == '\0') {
 5767                         error = EINVAL;
 5768                         break;
 5769                 }
 5770                 if (dev->devclass != NULL &&
 5771                     strcmp(driver, dev->devclass->name) == 0)
 5772                         /* XXX: Could possibly force DF_FIXEDCLASS on? */
 5773                         break;
 5774 
 5775                 /*
 5776                  * Scan drivers for this device's bus looking for at
 5777                  * least one matching driver.
 5778                  */
 5779                 if (dev->parent == NULL) {
 5780                         error = EINVAL;
 5781                         break;
 5782                 }
 5783                 if (!driver_exists(dev->parent, driver)) {
 5784                         error = ENOENT;
 5785                         break;
 5786                 }
 5787                 dc = devclass_create(driver);
 5788                 if (dc == NULL) {
 5789                         error = ENOMEM;
 5790                         break;
 5791                 }
 5792 
 5793                 /* Detach device if necessary. */
 5794                 if (device_is_attached(dev)) {
 5795                         if (req->dr_flags & DEVF_SET_DRIVER_DETACH)
 5796                                 error = device_detach(dev);
 5797                         else
 5798                                 error = EBUSY;
 5799                         if (error)
 5800                                 break;
 5801                 }
 5802 
 5803                 /* Clear any previously-fixed device class and unit. */
 5804                 if (dev->flags & DF_FIXEDCLASS)
 5805                         devclass_delete_device(dev->devclass, dev);
 5806                 dev->flags |= DF_WILDCARD;
 5807                 dev->unit = -1;
 5808 
 5809                 /* Force the new device class. */
 5810                 error = devclass_add_device(dc, dev);
 5811                 if (error)
 5812                         break;
 5813                 dev->flags |= DF_FIXEDCLASS;
 5814                 error = device_probe_and_attach(dev);
 5815                 break;
 5816         }
 5817         case DEV_CLEAR_DRIVER:
 5818                 if (!(dev->flags & DF_FIXEDCLASS)) {
 5819                         error = 0;
 5820                         break;
 5821                 }
 5822                 if (device_is_attached(dev)) {
 5823                         if (req->dr_flags & DEVF_CLEAR_DRIVER_DETACH)
 5824                                 error = device_detach(dev);
 5825                         else
 5826                                 error = EBUSY;
 5827                         if (error)
 5828                                 break;
 5829                 }
 5830 
 5831                 dev->flags &= ~DF_FIXEDCLASS;
 5832                 dev->flags |= DF_WILDCARD;
 5833                 devclass_delete_device(dev->devclass, dev);
 5834                 error = device_probe_and_attach(dev);
 5835                 break;
 5836         case DEV_RESCAN:
 5837                 if (!device_is_attached(dev)) {
 5838                         error = ENXIO;
 5839                         break;
 5840                 }
 5841                 error = BUS_RESCAN(dev);
 5842                 break;
 5843         case DEV_DELETE: {
 5844                 device_t parent;
 5845 
 5846                 parent = device_get_parent(dev);
 5847                 if (parent == NULL) {
 5848                         error = EINVAL;
 5849                         break;
 5850                 }
 5851                 if (!(req->dr_flags & DEVF_FORCE_DELETE)) {
 5852                         if (bus_child_present(dev) != 0) {
 5853                                 error = EBUSY;
 5854                                 break;
 5855                         }
 5856                 }
 5857                 
 5858                 error = device_delete_child(parent, dev);
 5859                 break;
 5860         }
 5861         case DEV_FREEZE:
 5862                 if (device_frozen)
 5863                         error = EBUSY;
 5864                 else
 5865                         device_frozen = true;
 5866                 break;
 5867         case DEV_THAW:
 5868                 if (!device_frozen)
 5869                         error = EBUSY;
 5870                 else {
 5871                         device_do_deferred_actions();
 5872                         device_frozen = false;
 5873                 }
 5874                 break;
 5875         case DEV_RESET:
 5876                 if ((req->dr_flags & ~(DEVF_RESET_DETACH)) != 0) {
 5877                         error = EINVAL;
 5878                         break;
 5879                 }
 5880                 error = BUS_RESET_CHILD(device_get_parent(dev), dev,
 5881                     req->dr_flags);
 5882                 break;
 5883         }
 5884         mtx_unlock(&Giant);
 5885         return (error);
 5886 }
 5887 
 5888 static struct cdevsw devctl2_cdevsw = {
 5889         .d_version =    D_VERSION,
 5890         .d_ioctl =      devctl2_ioctl,
 5891         .d_name =       "devctl2",
 5892 };
 5893 
 5894 static void
 5895 devctl2_init(void)
 5896 {
 5897 
 5898         make_dev_credf(MAKEDEV_ETERNAL, &devctl2_cdevsw, 0, NULL,
 5899             UID_ROOT, GID_WHEEL, 0600, "devctl2");
 5900 }
 5901 
 5902 /*
 5903  * APIs to manage deprecation and obsolescence.
 5904  */
 5905 static int obsolete_panic = 0;
 5906 SYSCTL_INT(_debug, OID_AUTO, obsolete_panic, CTLFLAG_RWTUN, &obsolete_panic, 0,
 5907     "Bus debug level");
 5908 /* 0 - don't panic, 1 - panic if already obsolete, 2 - panic if deprecated */
 5909 static void
 5910 gone_panic(int major, int running, const char *msg)
 5911 {
 5912 
 5913         switch (obsolete_panic)
 5914         {
 5915         case 0:
 5916                 return;
 5917         case 1:
 5918                 if (running < major)
 5919                         return;
 5920                 /* FALLTHROUGH */
 5921         default:
 5922                 panic("%s", msg);
 5923         }
 5924 }
 5925 
 5926 void
 5927 _gone_in(int major, const char *msg)
 5928 {
 5929 
 5930         gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg);
 5931         if (P_OSREL_MAJOR(__FreeBSD_version) >= major)
 5932                 printf("Obsolete code will removed soon: %s\n", msg);
 5933         else if (P_OSREL_MAJOR(__FreeBSD_version) + 1 == major)
 5934                 printf("Deprecated code (to be removed in FreeBSD %d): %s\n",
 5935                     major, msg);
 5936 }
 5937 
 5938 void
 5939 _gone_in_dev(device_t dev, int major, const char *msg)
 5940 {
 5941 
 5942         gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg);
 5943         if (P_OSREL_MAJOR(__FreeBSD_version) >= major)
 5944                 device_printf(dev,
 5945                     "Obsolete code will removed soon: %s\n", msg);
 5946         else if (P_OSREL_MAJOR(__FreeBSD_version) + 1 == major)
 5947                 device_printf(dev,
 5948                     "Deprecated code (to be removed in FreeBSD %d): %s\n",
 5949                     major, msg);
 5950 }
 5951 
 5952 #ifdef DDB
 5953 DB_SHOW_COMMAND(device, db_show_device)
 5954 {
 5955         device_t dev;
 5956 
 5957         if (!have_addr)
 5958                 return;
 5959 
 5960         dev = (device_t)addr;
 5961 
 5962         db_printf("name:    %s\n", device_get_nameunit(dev));
 5963         db_printf("  driver:  %s\n", DRIVERNAME(dev->driver));
 5964         db_printf("  class:   %s\n", DEVCLANAME(dev->devclass));
 5965         db_printf("  addr:    %p\n", dev);
 5966         db_printf("  parent:  %p\n", dev->parent);
 5967         db_printf("  softc:   %p\n", dev->softc);
 5968         db_printf("  ivars:   %p\n", dev->ivars);
 5969 }
 5970 
 5971 DB_SHOW_ALL_COMMAND(devices, db_show_all_devices)
 5972 {
 5973         device_t dev;
 5974 
 5975         TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
 5976                 db_show_device((db_expr_t)dev, true, count, modif);
 5977         }
 5978 }
 5979 #endif

Cache object: e41f06c726eb9d5d7da0e50a94092a98


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.