sys/kern/subr_bus.c

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