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