FreeBSD kernel kern code
subr_bus.c
Go to the documentation of this file.
1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 1997,1998,2003 Doug Rabson
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD$");
31
32#include "opt_bus.h"
33#include "opt_ddb.h"
34
35#include <sys/param.h>
36#include <sys/conf.h>
37#include <sys/domainset.h>
38#include <sys/eventhandler.h>
39#include <sys/filio.h>
40#include <sys/lock.h>
41#include <sys/kernel.h>
42#include <sys/kobj.h>
43#include <sys/limits.h>
44#include <sys/malloc.h>
45#include <sys/module.h>
46#include <sys/mutex.h>
47#include <sys/poll.h>
48#include <sys/priv.h>
49#include <sys/proc.h>
50#include <sys/condvar.h>
51#include <sys/queue.h>
52#include <machine/bus.h>
53#include <sys/random.h>
54#include <sys/refcount.h>
55#include <sys/rman.h>
56#include <sys/sbuf.h>
57#include <sys/selinfo.h>
58#include <sys/signalvar.h>
59#include <sys/smp.h>
60#include <sys/sysctl.h>
61#include <sys/systm.h>
62#include <sys/uio.h>
63#include <sys/bus.h>
64#include <sys/cpuset.h>
65
66#include <net/vnet.h>
67
68#include <machine/cpu.h>
69#include <machine/stdarg.h>
70
71#include <vm/uma.h>
72#include <vm/vm.h>
73
74#include <ddb/ddb.h>
75
76SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
77 NULL);
78SYSCTL_ROOT_NODE(OID_AUTO, dev, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL,
79 NULL);
80
81/*
82 * Used to attach drivers to devclasses.
83 */
84typedef struct driverlink *driverlink_t;
85struct driverlink {
86 kobj_class_t driver;
87 TAILQ_ENTRY(driverlink) link; /* list of drivers in devclass */
88 int pass;
89 int flags;
90#define DL_DEFERRED_PROBE 1 /* Probe deferred on this */
91 TAILQ_ENTRY(driverlink) passlink;
92};
93
94/*
95 * Forward declarations
96 */
97typedef TAILQ_HEAD(devclass_list, devclass) devclass_list_t;
98typedef TAILQ_HEAD(driver_list, driverlink) driver_list_t;
99typedef TAILQ_HEAD(device_list, _device) device_list_t;
100
101struct devclass {
102 TAILQ_ENTRY(devclass) link;
103 devclass_t parent; /* parent in devclass hierarchy */
104 driver_list_t drivers; /* bus devclasses store drivers for bus */
105 char *name;
106 device_t *devices; /* array of devices indexed by unit */
107 int maxunit; /* size of devices array */
108 int flags;
109#define DC_HAS_CHILDREN 1
110
111 struct sysctl_ctx_list sysctl_ctx;
112 struct sysctl_oid *sysctl_tree;
113};
114
121struct _device {
122 /*
123 * A device is a kernel object. The first field must be the
124 * current ops table for the object.
125 */
126 KOBJ_FIELDS;
127
128 /*
129 * Device hierarchy.
130 */
131 TAILQ_ENTRY(_device) link;
132 TAILQ_ENTRY(_device) devlink;
133 device_t parent;
134 device_list_t children;
136 /*
137 * Details of this device.
138 */
139 driver_t *driver;
140 devclass_t devclass;
141 int unit;
142 char* nameunit;
143 char* desc;
144 u_int busy;
145 device_state_t state;
146 uint32_t devflags;
147 u_int flags;
148 u_int order;
149 void *ivars;
150 void *softc;
152 struct sysctl_ctx_list sysctl_ctx;
153 struct sysctl_oid *sysctl_tree;
154};
155
156static MALLOC_DEFINE(M_BUS, "bus", "Bus data structures");
157static MALLOC_DEFINE(M_BUS_SC, "bus-sc", "Bus data structures, softc");
158
159EVENTHANDLER_LIST_DEFINE(device_attach);
160EVENTHANDLER_LIST_DEFINE(device_detach);
161EVENTHANDLER_LIST_DEFINE(dev_lookup);
162
163static void devctl2_init(void);
164static bool device_frozen;
165
166#define DRIVERNAME(d) ((d)? d->name : "no driver")
167#define DEVCLANAME(d) ((d)? d->name : "no devclass")
168
169#ifdef BUS_DEBUG
170
171static int bus_debug = 1;
172SYSCTL_INT(_debug, OID_AUTO, bus_debug, CTLFLAG_RWTUN, &bus_debug, 0,
173 "Bus debug level");
174#define PDEBUG(a) if (bus_debug) {printf("%s:%d: ", __func__, __LINE__), printf a; printf("\n");}
175#define DEVICENAME(d) ((d)? device_get_name(d): "no device")
176
181#define indentprintf(p) do { int iJ; printf("."); for (iJ=0; iJ<indent; iJ++) printf(" "); printf p ; } while (0)
182
183static void print_device_short(device_t dev, int indent);
184static void print_device(device_t dev, int indent);
185void print_device_tree_short(device_t dev, int indent);
186void print_device_tree(device_t dev, int indent);
187static void print_driver_short(driver_t *driver, int indent);
188static void print_driver(driver_t *driver, int indent);
189static void print_driver_list(driver_list_t drivers, int indent);
190static void print_devclass_short(devclass_t dc, int indent);
191static void print_devclass(devclass_t dc, int indent);
192void print_devclass_list_short(void);
193void print_devclass_list(void);
194
195#else
196/* Make the compiler ignore the function calls */
197#define PDEBUG(a) /* nop */
198#define DEVICENAME(d) /* nop */
199
200#define print_device_short(d,i) /* nop */
201#define print_device(d,i) /* nop */
202#define print_device_tree_short(d,i) /* nop */
203#define print_device_tree(d,i) /* nop */
204#define print_driver_short(d,i) /* nop */
205#define print_driver(d,i) /* nop */
206#define print_driver_list(d,i) /* nop */
207#define print_devclass_short(d,i) /* nop */
208#define print_devclass(d,i) /* nop */
209#define print_devclass_list_short() /* nop */
210#define print_devclass_list() /* nop */
211#endif
212
213/*
214 * dev sysctl tree
215 */
216
217enum {
218 DEVCLASS_SYSCTL_PARENT,
219};
220
221static int
222devclass_sysctl_handler(SYSCTL_HANDLER_ARGS)
223{
224 devclass_t dc = (devclass_t)arg1;
225 const char *value;
226
227 switch (arg2) {
228 case DEVCLASS_SYSCTL_PARENT:
229 value = dc->parent ? dc->parent->name : "";
230 break;
231 default:
232 return (EINVAL);
233 }
234 return (SYSCTL_OUT_STR(req, value));
235}
236
237static void
238devclass_sysctl_init(devclass_t dc)
239{
240 if (dc->sysctl_tree != NULL)
241 return;
242 sysctl_ctx_init(&dc->sysctl_ctx);
243 dc->sysctl_tree = SYSCTL_ADD_NODE(&dc->sysctl_ctx,
244 SYSCTL_STATIC_CHILDREN(_dev), OID_AUTO, dc->name,
245 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
246 SYSCTL_ADD_PROC(&dc->sysctl_ctx, SYSCTL_CHILDREN(dc->sysctl_tree),
247 OID_AUTO, "%parent",
248 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
249 dc, DEVCLASS_SYSCTL_PARENT, devclass_sysctl_handler, "A",
250 "parent class");
251}
252
253enum {
254 DEVICE_SYSCTL_DESC,
255 DEVICE_SYSCTL_DRIVER,
256 DEVICE_SYSCTL_LOCATION,
257 DEVICE_SYSCTL_PNPINFO,
258 DEVICE_SYSCTL_PARENT,
259};
260
261static int
262device_sysctl_handler(SYSCTL_HANDLER_ARGS)
263{
264 struct sbuf sb;
265 device_t dev = (device_t)arg1;
266 int error;
267
268 sbuf_new_for_sysctl(&sb, NULL, 1024, req);
269 sbuf_clear_flags(&sb, SBUF_INCLUDENUL);
270 bus_topo_lock();
271 switch (arg2) {
272 case DEVICE_SYSCTL_DESC:
273 sbuf_cat(&sb, dev->desc ? dev->desc : "");
274 break;
275 case DEVICE_SYSCTL_DRIVER:
276 sbuf_cat(&sb, dev->driver ? dev->driver->name : "");
277 break;
278 case DEVICE_SYSCTL_LOCATION:
279 bus_child_location(dev, &sb);
280 break;
281 case DEVICE_SYSCTL_PNPINFO:
282 bus_child_pnpinfo(dev, &sb);
283 break;
284 case DEVICE_SYSCTL_PARENT:
285 sbuf_cat(&sb, dev->parent ? dev->parent->nameunit : "");
286 break;
287 default:
288 error = EINVAL;
289 goto out;
290 }
291 error = sbuf_finish(&sb);
292out:
293 bus_topo_unlock();
294 sbuf_delete(&sb);
295 return (error);
296}
297
298static void
299device_sysctl_init(device_t dev)
300{
301 devclass_t dc = dev->devclass;
302 int domain;
303
304 if (dev->sysctl_tree != NULL)
305 return;
306 devclass_sysctl_init(dc);
307 sysctl_ctx_init(&dev->sysctl_ctx);
308 dev->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&dev->sysctl_ctx,
309 SYSCTL_CHILDREN(dc->sysctl_tree), OID_AUTO,
310 dev->nameunit + strlen(dc->name),
311 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "", "device_index");
312 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
313 OID_AUTO, "%desc", CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
314 dev, DEVICE_SYSCTL_DESC, device_sysctl_handler, "A",
315 "device description");
316 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
317 OID_AUTO, "%driver",
318 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
319 dev, DEVICE_SYSCTL_DRIVER, device_sysctl_handler, "A",
320 "device driver name");
321 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
322 OID_AUTO, "%location",
323 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
324 dev, DEVICE_SYSCTL_LOCATION, device_sysctl_handler, "A",
325 "device location relative to parent");
326 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
327 OID_AUTO, "%pnpinfo",
328 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
329 dev, DEVICE_SYSCTL_PNPINFO, device_sysctl_handler, "A",
330 "device identification");
331 SYSCTL_ADD_PROC(&dev->sysctl_ctx, SYSCTL_CHILDREN(dev->sysctl_tree),
332 OID_AUTO, "%parent",
333 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
334 dev, DEVICE_SYSCTL_PARENT, device_sysctl_handler, "A",
335 "parent device");
336 if (bus_get_domain(dev, &domain) == 0)
337 SYSCTL_ADD_INT(&dev->sysctl_ctx,
338 SYSCTL_CHILDREN(dev->sysctl_tree), OID_AUTO, "%domain",
339 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, domain, "NUMA domain");
340}
341
342static void
343device_sysctl_update(device_t dev)
344{
345 devclass_t dc = dev->devclass;
346
347 if (dev->sysctl_tree == NULL)
348 return;
349 sysctl_rename_oid(dev->sysctl_tree, dev->nameunit + strlen(dc->name));
350}
351
352static void
353device_sysctl_fini(device_t dev)
354{
355 if (dev->sysctl_tree == NULL)
356 return;
357 sysctl_ctx_free(&dev->sysctl_ctx);
358 dev->sysctl_tree = NULL;
359}
360
361/*
362 * /dev/devctl implementation
363 */
364
365/*
366 * This design allows only one reader for /dev/devctl. This is not desirable
367 * in the long run, but will get a lot of hair out of this implementation.
368 * Maybe we should make this device a clonable device.
369 *
370 * Also note: we specifically do not attach a device to the device_t tree
371 * to avoid potential chicken and egg problems. One could argue that all
372 * of this belongs to the root node.
373 */
374
375#define DEVCTL_DEFAULT_QUEUE_LEN 1000
376static int sysctl_devctl_queue(SYSCTL_HANDLER_ARGS);
377static int devctl_queue_length = DEVCTL_DEFAULT_QUEUE_LEN;
378SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_queue, CTLTYPE_INT | CTLFLAG_RWTUN |
379 CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_queue, "I", "devctl queue length");
380
381static d_open_t devopen;
382static d_close_t devclose;
383static d_read_t devread;
384static d_ioctl_t devioctl;
385static d_poll_t devpoll;
386static d_kqfilter_t devkqfilter;
387
388static struct cdevsw dev_cdevsw = {
389 .d_version = D_VERSION,
390 .d_open = devopen,
391 .d_close = devclose,
392 .d_read = devread,
393 .d_ioctl = devioctl,
394 .d_poll = devpoll,
395 .d_kqfilter = devkqfilter,
396 .d_name = "devctl",
397};
398
399#define DEVCTL_BUFFER (1024 - sizeof(void *))
400struct dev_event_info {
401 STAILQ_ENTRY(dev_event_info) dei_link;
402 char dei_data[DEVCTL_BUFFER];
403};
404
405STAILQ_HEAD(devq, dev_event_info);
406
407static struct dev_softc {
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 uma_zone_t zone;
418} devsoftc;
419
420static void filt_devctl_detach(struct knote *kn);
421static int filt_devctl_read(struct knote *kn, long hint);
422
423struct filterops devctl_rfiltops = {
424 .f_isfd = 1,
425 .f_detach = filt_devctl_detach,
426 .f_event = filt_devctl_read,
427};
428
429static struct cdev *devctl_dev;
430
431static void
432devinit(void)
433{
434 int reserve;
435 uma_zone_t z;
436
437 devctl_dev = make_dev_credf(MAKEDEV_ETERNAL, &dev_cdevsw, 0, NULL,
438 UID_ROOT, GID_WHEEL, 0600, "devctl");
439 mtx_init(&devsoftc.mtx, "dev mtx", "devd", MTX_DEF);
440 cv_init(&devsoftc.cv, "dev cv");
441 STAILQ_INIT(&devsoftc.devq);
442 knlist_init_mtx(&devsoftc.sel.si_note, &devsoftc.mtx);
443 if (devctl_queue_length > 0) {
444 /*
445 * Allocate a zone for the messages. Preallocate 2% of these for
446 * a reserve. Allow only devctl_queue_length slabs to cap memory
447 * usage. The reserve usually allows coverage of surges of
448 * events during memory shortages. Normally we won't have to
449 * re-use events from the queue, but will in extreme shortages.
450 */
451 z = devsoftc.zone = uma_zcreate("DEVCTL",
452 sizeof(struct dev_event_info), NULL, NULL, NULL, NULL,
453 UMA_ALIGN_PTR, 0);
454 reserve = max(devctl_queue_length / 50, 100); /* 2% reserve */
455 uma_zone_set_max(z, devctl_queue_length);
456 uma_zone_set_maxcache(z, 0);
457 uma_zone_reserve(z, reserve);
458 uma_prealloc(z, reserve);
459 }
460 devctl2_init();
461}
462
463static int
464devopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
465{
466 mtx_lock(&devsoftc.mtx);
467 if (devsoftc.inuse) {
468 mtx_unlock(&devsoftc.mtx);
469 return (EBUSY);
470 }
471 /* move to init */
472 devsoftc.inuse = 1;
473 mtx_unlock(&devsoftc.mtx);
474 return (0);
475}
476
477static int
478devclose(struct cdev *dev, int fflag, int devtype, struct thread *td)
479{
480 mtx_lock(&devsoftc.mtx);
481 devsoftc.inuse = 0;
482 devsoftc.nonblock = 0;
483 devsoftc.async = 0;
484 cv_broadcast(&devsoftc.cv);
485 funsetown(&devsoftc.sigio);
486 mtx_unlock(&devsoftc.mtx);
487 return (0);
488}
489
490/*
491 * The read channel for this device is used to report changes to
492 * userland in realtime. We are required to free the data as well as
493 * the n1 object because we allocate them separately. Also note that
494 * we return one record at a time. If you try to read this device a
495 * character at a time, you will lose the rest of the data. Listening
496 * programs are expected to cope.
497 */
498static int
499devread(struct cdev *dev, struct uio *uio, int ioflag)
500{
501 struct dev_event_info *n1;
502 int rv;
503
504 mtx_lock(&devsoftc.mtx);
505 while (STAILQ_EMPTY(&devsoftc.devq)) {
506 if (devsoftc.nonblock) {
507 mtx_unlock(&devsoftc.mtx);
508 return (EAGAIN);
509 }
510 rv = cv_wait_sig(&devsoftc.cv, &devsoftc.mtx);
511 if (rv) {
512 /*
513 * Need to translate ERESTART to EINTR here? -- jake
514 */
515 mtx_unlock(&devsoftc.mtx);
516 return (rv);
517 }
518 }
519 n1 = STAILQ_FIRST(&devsoftc.devq);
520 STAILQ_REMOVE_HEAD(&devsoftc.devq, dei_link);
521 devsoftc.queued--;
522 mtx_unlock(&devsoftc.mtx);
523 rv = uiomove(n1->dei_data, strlen(n1->dei_data), uio);
524 uma_zfree(devsoftc.zone, n1);
525 return (rv);
526}
527
528static int
529devioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
530{
531 switch (cmd) {
532 case FIONBIO:
533 if (*(int*)data)
534 devsoftc.nonblock = 1;
535 else
536 devsoftc.nonblock = 0;
537 return (0);
538 case FIOASYNC:
539 if (*(int*)data)
540 devsoftc.async = 1;
541 else
542 devsoftc.async = 0;
543 return (0);
544 case FIOSETOWN:
545 return fsetown(*(int *)data, &devsoftc.sigio);
546 case FIOGETOWN:
547 *(int *)data = fgetown(&devsoftc.sigio);
548 return (0);
549
550 /* (un)Support for other fcntl() calls. */
551 case FIOCLEX:
552 case FIONCLEX:
553 case FIONREAD:
554 default:
555 break;
556 }
557 return (ENOTTY);
558}
559
560static int
561devpoll(struct cdev *dev, int events, struct thread *td)
562{
563 int revents = 0;
564
565 mtx_lock(&devsoftc.mtx);
566 if (events & (POLLIN | POLLRDNORM)) {
567 if (!STAILQ_EMPTY(&devsoftc.devq))
568 revents = events & (POLLIN | POLLRDNORM);
569 else
570 selrecord(td, &devsoftc.sel);
571 }
572 mtx_unlock(&devsoftc.mtx);
573
574 return (revents);
575}
576
577static int
578devkqfilter(struct cdev *dev, struct knote *kn)
579{
580 int error;
581
582 if (kn->kn_filter == EVFILT_READ) {
583 kn->kn_fop = &devctl_rfiltops;
584 knlist_add(&devsoftc.sel.si_note, kn, 0);
585 error = 0;
586 } else
587 error = EINVAL;
588 return (error);
589}
590
591static void
592filt_devctl_detach(struct knote *kn)
593{
594 knlist_remove(&devsoftc.sel.si_note, kn, 0);
595}
596
597static int
598filt_devctl_read(struct knote *kn, long hint)
599{
600 kn->kn_data = devsoftc.queued;
601 return (kn->kn_data != 0);
602}
603
607bool
608devctl_process_running(void)
609{
610 return (devsoftc.inuse == 1);
611}
612
613static struct dev_event_info *
614devctl_alloc_dei(void)
615{
616 struct dev_event_info *dei = NULL;
617
618 mtx_lock(&devsoftc.mtx);
619 if (devctl_queue_length == 0)
620 goto out;
621 dei = uma_zalloc(devsoftc.zone, M_NOWAIT);
622 if (dei == NULL)
623 dei = uma_zalloc(devsoftc.zone, M_NOWAIT | M_USE_RESERVE);
624 if (dei == NULL) {
625 /*
626 * Guard against no items in the queue. Normally, this won't
627 * happen, but if lots of events happen all at once and there's
628 * a chance we're out of allocated space but none have yet been
629 * queued when we get here, leaving nothing to steal. This can
630 * also happen with error injection. Fail safe by returning
631 * NULL in that case..
632 */
633 if (devsoftc.queued == 0)
634 goto out;
635 dei = STAILQ_FIRST(&devsoftc.devq);
636 STAILQ_REMOVE_HEAD(&devsoftc.devq, dei_link);
637 devsoftc.queued--;
638 }
639 MPASS(dei != NULL);
640 *dei->dei_data = '\0';
641out:
642 mtx_unlock(&devsoftc.mtx);
643 return (dei);
644}
645
646static struct dev_event_info *
647devctl_alloc_dei_sb(struct sbuf *sb)
648{
649 struct dev_event_info *dei;
650
651 dei = devctl_alloc_dei();
652 if (dei != NULL)
653 sbuf_new(sb, dei->dei_data, sizeof(dei->dei_data), SBUF_FIXEDLEN);
654 return (dei);
655}
656
657static void
658devctl_free_dei(struct dev_event_info *dei)
659{
660 uma_zfree(devsoftc.zone, dei);
661}
662
663static void
664devctl_queue(struct dev_event_info *dei)
665{
666 mtx_lock(&devsoftc.mtx);
667 STAILQ_INSERT_TAIL(&devsoftc.devq, dei, dei_link);
668 devsoftc.queued++;
669 cv_broadcast(&devsoftc.cv);
670 KNOTE_LOCKED(&devsoftc.sel.si_note, 0);
671 mtx_unlock(&devsoftc.mtx);
672 selwakeup(&devsoftc.sel);
673 if (devsoftc.async && devsoftc.sigio != NULL)
674 pgsigio(&devsoftc.sigio, SIGIO, 0);
675}
676
680void
681devctl_notify(const char *system, const char *subsystem, const char *type,
682 const char *data)
683{
684 struct dev_event_info *dei;
685 struct sbuf sb;
686
687 if (system == NULL || subsystem == NULL || type == NULL)
688 return;
689 dei = devctl_alloc_dei_sb(&sb);
690 if (dei == NULL)
691 return;
692 sbuf_cpy(&sb, "!system=");
693 sbuf_cat(&sb, system);
694 sbuf_cat(&sb, " subsystem=");
695 sbuf_cat(&sb, subsystem);
696 sbuf_cat(&sb, " type=");
697 sbuf_cat(&sb, type);
698 if (data != NULL) {
699 sbuf_putc(&sb, ' ');
700 sbuf_cat(&sb, data);
701 }
702 sbuf_putc(&sb, '\n');
703 if (sbuf_finish(&sb) != 0)
704 devctl_free_dei(dei); /* overflow -> drop it */
705 else
706 devctl_queue(dei);
707}
708
709/*
710 * Common routine that tries to make sending messages as easy as possible.
711 * We allocate memory for the data, copy strings into that, but do not
712 * free it unless there's an error. The dequeue part of the driver should
713 * free the data. We don't send data when the device is disabled. We do
714 * send data, even when we have no listeners, because we wish to avoid
715 * races relating to startup and restart of listening applications.
716 *
717 * devaddq is designed to string together the type of event, with the
718 * object of that event, plus the plug and play info and location info
719 * for that event. This is likely most useful for devices, but less
720 * useful for other consumers of this interface. Those should use
721 * the devctl_notify() interface instead.
722 *
723 * Output:
724 * ${type}${what} at $(location dev) $(pnp-info dev) on $(parent dev)
725 */
726static void
727devaddq(const char *type, const char *what, device_t dev)
728{
729 struct dev_event_info *dei;
730 const char *parstr;
731 struct sbuf sb;
732
733 dei = devctl_alloc_dei_sb(&sb);
734 if (dei == NULL)
735 return;
736 sbuf_cpy(&sb, type);
737 sbuf_cat(&sb, what);
738 sbuf_cat(&sb, " at ");
739
740 /* Add in the location */
741 bus_child_location(dev, &sb);
742 sbuf_putc(&sb, ' ');
743
744 /* Add in pnpinfo */
745 bus_child_pnpinfo(dev, &sb);
746
747 /* Get the parent of this device, or / if high enough in the tree. */
748 if (device_get_parent(dev) == NULL)
749 parstr = "."; /* Or '/' ? */
750 else
751 parstr = device_get_nameunit(device_get_parent(dev));
752 sbuf_cat(&sb, " on ");
753 sbuf_cat(&sb, parstr);
754 sbuf_putc(&sb, '\n');
755 if (sbuf_finish(&sb) != 0)
756 goto bad;
757 devctl_queue(dei);
758 return;
759bad:
760 devctl_free_dei(dei);
761}
762
763/*
764 * A device was added to the tree. We are called just after it successfully
765 * attaches (that is, probe and attach success for this device). No call
766 * is made if a device is merely parented into the tree. See devnomatch
767 * if probe fails. If attach fails, no notification is sent (but maybe
768 * we should have a different message for this).
769 */
770static void
771devadded(device_t dev)
772{
773 devaddq("+", device_get_nameunit(dev), dev);
774}
775
776/*
777 * A device was removed from the tree. We are called just before this
778 * happens.
779 */
780static void
781devremoved(device_t dev)
782{
783 devaddq("-", device_get_nameunit(dev), dev);
784}
785
786/*
787 * Called when there's no match for this device. This is only called
788 * the first time that no match happens, so we don't keep getting this
789 * message. Should that prove to be undesirable, we can change it.
790 * This is called when all drivers that can attach to a given bus
791 * decline to accept this device. Other errors may not be detected.
792 */
793static void
794devnomatch(device_t dev)
795{
796 devaddq("?", "", dev);
797}
798
799static int
800sysctl_devctl_queue(SYSCTL_HANDLER_ARGS)
801{
802 int q, error;
803
804 q = devctl_queue_length;
805 error = sysctl_handle_int(oidp, &q, 0, req);
806 if (error || !req->newptr)
807 return (error);
808 if (q < 0)
809 return (EINVAL);
810
811 /*
812 * When set as a tunable, we've not yet initialized the mutex.
813 * It is safe to just assign to devctl_queue_length and return
814 * as we're racing no one. We'll use whatever value set in
815 * devinit.
816 */
817 if (!mtx_initialized(&devsoftc.mtx)) {
818 devctl_queue_length = q;
819 return (0);
820 }
821
822 /*
823 * XXX It's hard to grow or shrink the UMA zone. Only allow
824 * disabling the queue size for the moment until underlying
825 * UMA issues can be sorted out.
826 */
827 if (q != 0)
828 return (EINVAL);
829 if (q == devctl_queue_length)
830 return (0);
831 mtx_lock(&devsoftc.mtx);
832 devctl_queue_length = 0;
833 uma_zdestroy(devsoftc.zone);
834 devsoftc.zone = 0;
835 mtx_unlock(&devsoftc.mtx);
836 return (0);
837}
838
849void
850devctl_safe_quote_sb(struct sbuf *sb, const char *src)
851{
852 while (*src != '\0') {
853 if (*src == '"' || *src == '\\')
854 sbuf_putc(sb, '\\');
855 sbuf_putc(sb, *src++);
856 }
857}
858
859/* End of /dev/devctl code */
860
861static struct device_list bus_data_devices;
862static int bus_data_generation = 1;
863
864static kobj_method_t null_methods[] = {
865 KOBJMETHOD_END
866};
867
868DEFINE_CLASS(null, null_methods, 0);
869
870void
871bus_topo_assert()
872{
873
874 GIANT_REQUIRED;
875}
876
877struct mtx *
878bus_topo_mtx(void)
879{
880
881 return (&Giant);
882}
883
884void
885bus_topo_lock(void)
886{
887
888 mtx_lock(bus_topo_mtx());
889}
890
891void
892bus_topo_unlock(void)
893{
894
895 mtx_unlock(bus_topo_mtx());
896}
897
898/*
899 * Bus pass implementation
900 */
901
902static driver_list_t passes = TAILQ_HEAD_INITIALIZER(passes);
903int bus_current_pass = BUS_PASS_ROOT;
904
915static void
916driver_register_pass(struct driverlink *new)
917{
918 struct driverlink *dl;
919
920 /* We only consider pass numbers during boot. */
921 if (bus_current_pass == BUS_PASS_DEFAULT)
922 return;
923
924 /*
925 * Walk the passes list. If we already know about this pass
926 * then there is nothing to do. If we don't, then insert this
927 * driver link into the list.
928 */
929 TAILQ_FOREACH(dl, &passes, passlink) {
930 if (dl->pass < new->pass)
931 continue;
932 if (dl->pass == new->pass)
933 return;
934 TAILQ_INSERT_BEFORE(dl, new, passlink);
935 return;
936 }
937 TAILQ_INSERT_TAIL(&passes, new, passlink);
938}
939
947void
948bus_set_pass(int pass)
949{
950 struct driverlink *dl;
951
952 if (bus_current_pass > pass)
953 panic("Attempt to lower bus pass level");
954
955 TAILQ_FOREACH(dl, &passes, passlink) {
956 /* Skip pass values below the current pass level. */
957 if (dl->pass <= bus_current_pass)
958 continue;
959
960 /*
961 * Bail once we hit a driver with a pass level that is
962 * too high.
963 */
964 if (dl->pass > pass)
965 break;
966
967 /*
968 * Raise the pass level to the next level and rescan
969 * the tree.
970 */
971 bus_current_pass = dl->pass;
972 BUS_NEW_PASS(root_bus);
973 }
974
975 /*
976 * If there isn't a driver registered for the requested pass,
977 * then bus_current_pass might still be less than 'pass'. Set
978 * it to 'pass' in that case.
979 */
980 if (bus_current_pass < pass)
981 bus_current_pass = pass;
982 KASSERT(bus_current_pass == pass, ("Failed to update bus pass level"));
983}
984
985/*
986 * Devclass implementation
987 */
988
989static devclass_list_t devclasses = TAILQ_HEAD_INITIALIZER(devclasses);
990
1006static devclass_t
1007devclass_find_internal(const char *classname, const char *parentname,
1008 int create)
1009{
1010 devclass_t dc;
1011
1012 PDEBUG(("looking for %s", classname));
1013 if (!classname)
1014 return (NULL);
1015
1016 TAILQ_FOREACH(dc, &devclasses, link) {
1017 if (!strcmp(dc->name, classname))
1018 break;
1019 }
1020
1021 if (create && !dc) {
1022 PDEBUG(("creating %s", classname));
1023 dc = malloc(sizeof(struct devclass) + strlen(classname) + 1,
1024 M_BUS, M_NOWAIT | M_ZERO);
1025 if (!dc)
1026 return (NULL);
1027 dc->parent = NULL;
1028 dc->name = (char*) (dc + 1);
1029 strcpy(dc->name, classname);
1030 TAILQ_INIT(&dc->drivers);
1031 TAILQ_INSERT_TAIL(&devclasses, dc, link);
1032
1033 bus_data_generation_update();
1034 }
1035
1036 /*
1037 * If a parent class is specified, then set that as our parent so
1038 * that this devclass will support drivers for the parent class as
1039 * well. If the parent class has the same name don't do this though
1040 * as it creates a cycle that can trigger an infinite loop in
1041 * device_probe_child() if a device exists for which there is no
1042 * suitable driver.
1043 */
1044 if (parentname && dc && !dc->parent &&
1045 strcmp(classname, parentname) != 0) {
1046 dc->parent = devclass_find_internal(parentname, NULL, TRUE);
1047 dc->parent->flags |= DC_HAS_CHILDREN;
1048 }
1049
1050 return (dc);
1051}
1052
1061devclass_t
1062devclass_create(const char *classname)
1063{
1064 return (devclass_find_internal(classname, NULL, TRUE));
1065}
1066
1075devclass_t
1076devclass_find(const char *classname)
1077{
1078 return (devclass_find_internal(classname, NULL, FALSE));
1079}
1080
1098static void
1099devclass_driver_added(devclass_t dc, driver_t *driver)
1100{
1101 devclass_t parent;
1102 int i;
1103
1104 /*
1105 * Call BUS_DRIVER_ADDED for any existing buses in this class.
1106 */
1107 for (i = 0; i < dc->maxunit; i++)
1108 if (dc->devices[i] && device_is_attached(dc->devices[i]))
1109 BUS_DRIVER_ADDED(dc->devices[i], driver);
1110
1111 /*
1112 * Walk through the children classes. Since we only keep a
1113 * single parent pointer around, we walk the entire list of
1114 * devclasses looking for children. We set the
1115 * DC_HAS_CHILDREN flag when a child devclass is created on
1116 * the parent, so we only walk the list for those devclasses
1117 * that have children.
1118 */
1119 if (!(dc->flags & DC_HAS_CHILDREN))
1120 return;
1121 parent = dc;
1122 TAILQ_FOREACH(dc, &devclasses, link) {
1123 if (dc->parent == parent)
1124 devclass_driver_added(dc, driver);
1125 }
1126}
1127
1139int
1140devclass_add_driver(devclass_t dc, driver_t *driver, int pass, devclass_t *dcp)
1141{
1142 driverlink_t dl;
1143 const char *parentname;
1144
1145 PDEBUG(("%s", DRIVERNAME(driver)));
1146
1147 /* Don't allow invalid pass values. */
1148 if (pass <= BUS_PASS_ROOT)
1149 return (EINVAL);
1150
1151 dl = malloc(sizeof *dl, M_BUS, M_NOWAIT|M_ZERO);
1152 if (!dl)
1153 return (ENOMEM);
1154
1155 /*
1156 * Compile the driver's methods. Also increase the reference count
1157 * so that the class doesn't get freed when the last instance
1158 * goes. This means we can safely use static methods and avoids a
1159 * double-free in devclass_delete_driver.
1160 */
1161 kobj_class_compile((kobj_class_t) driver);
1162
1163 /*
1164 * If the driver has any base classes, make the
1165 * devclass inherit from the devclass of the driver's
1166 * first base class. This will allow the system to
1167 * search for drivers in both devclasses for children
1168 * of a device using this driver.
1169 */
1170 if (driver->baseclasses)
1171 parentname = driver->baseclasses[0]->name;
1172 else
1173 parentname = NULL;
1174 *dcp = devclass_find_internal(driver->name, parentname, TRUE);
1175
1176 dl->driver = driver;
1177 TAILQ_INSERT_TAIL(&dc->drivers, dl, link);
1178 driver->refs++; /* XXX: kobj_mtx */
1179 dl->pass = pass;
1180 driver_register_pass(dl);
1181
1182 if (device_frozen) {
1183 dl->flags |= DL_DEFERRED_PROBE;
1184 } else {
1185 devclass_driver_added(dc, driver);
1186 }
1187 bus_data_generation_update();
1188 return (0);
1189}
1190
1210static int
1211devclass_driver_deleted(devclass_t busclass, devclass_t dc, driver_t *driver)
1212{
1213 devclass_t parent;
1214 device_t dev;
1215 int error, i;
1216
1217 /*
1218 * Disassociate from any devices. We iterate through all the
1219 * devices in the devclass of the driver and detach any which are
1220 * using the driver and which have a parent in the devclass which
1221 * we are deleting from.
1222 *
1223 * Note that since a driver can be in multiple devclasses, we
1224 * should not detach devices which are not children of devices in
1225 * the affected devclass.
1226 *
1227 * If we're frozen, we don't generate NOMATCH events. Mark to
1228 * generate later.
1229 */
1230 for (i = 0; i < dc->maxunit; i++) {
1231 if (dc->devices[i]) {
1232 dev = dc->devices[i];
1233 if (dev->driver == driver && dev->parent &&
1234 dev->parent->devclass == busclass) {
1235 if ((error = device_detach(dev)) != 0)
1236 return (error);
1237 if (device_frozen) {
1238 dev->flags &= ~DF_DONENOMATCH;
1239 dev->flags |= DF_NEEDNOMATCH;
1240 } else {
1241 BUS_PROBE_NOMATCH(dev->parent, dev);
1242 devnomatch(dev);
1243 dev->flags |= DF_DONENOMATCH;
1244 }
1245 }
1246 }
1247 }
1248
1249 /*
1250 * Walk through the children classes. Since we only keep a
1251 * single parent pointer around, we walk the entire list of
1252 * devclasses looking for children. We set the
1253 * DC_HAS_CHILDREN flag when a child devclass is created on
1254 * the parent, so we only walk the list for those devclasses
1255 * that have children.
1256 */
1257 if (!(busclass->flags & DC_HAS_CHILDREN))
1258 return (0);
1259 parent = busclass;
1260 TAILQ_FOREACH(busclass, &devclasses, link) {
1261 if (busclass->parent == parent) {
1262 error = devclass_driver_deleted(busclass, dc, driver);
1263 if (error)
1264 return (error);
1265 }
1266 }
1267 return (0);
1268}
1269
1284int
1285devclass_delete_driver(devclass_t busclass, driver_t *driver)
1286{
1287 devclass_t dc = devclass_find(driver->name);
1288 driverlink_t dl;
1289 int error;
1290
1291 PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
1292
1293 if (!dc)
1294 return (0);
1295
1296 /*
1297 * Find the link structure in the bus' list of drivers.
1298 */
1299 TAILQ_FOREACH(dl, &busclass->drivers, link) {
1300 if (dl->driver == driver)
1301 break;
1302 }
1303
1304 if (!dl) {
1305 PDEBUG(("%s not found in %s list", driver->name,
1306 busclass->name));
1307 return (ENOENT);
1308 }
1309
1310 error = devclass_driver_deleted(busclass, dc, driver);
1311 if (error != 0)
1312 return (error);
1313
1314 TAILQ_REMOVE(&busclass->drivers, dl, link);
1315 free(dl, M_BUS);
1316
1317 /* XXX: kobj_mtx */
1318 driver->refs--;
1319 if (driver->refs == 0)
1320 kobj_class_free((kobj_class_t) driver);
1321
1322 bus_data_generation_update();
1323 return (0);
1324}
1325
1339static int
1340devclass_quiesce_driver(devclass_t busclass, driver_t *driver)
1341{
1342 devclass_t dc = devclass_find(driver->name);
1343 driverlink_t dl;
1344 device_t dev;
1345 int i;
1346 int error;
1347
1348 PDEBUG(("%s from devclass %s", driver->name, DEVCLANAME(busclass)));
1349
1350 if (!dc)
1351 return (0);
1352
1353 /*
1354 * Find the link structure in the bus' list of drivers.
1355 */
1356 TAILQ_FOREACH(dl, &busclass->drivers, link) {
1357 if (dl->driver == driver)
1358 break;
1359 }
1360
1361 if (!dl) {
1362 PDEBUG(("%s not found in %s list", driver->name,
1363 busclass->name));
1364 return (ENOENT);
1365 }
1366
1367 /*
1368 * Quiesce all devices. We iterate through all the devices in
1369 * the devclass of the driver and quiesce any which are using
1370 * the driver and which have a parent in the devclass which we
1371 * are quiescing.
1372 *
1373 * Note that since a driver can be in multiple devclasses, we
1374 * should not quiesce devices which are not children of
1375 * devices in the affected devclass.
1376 */
1377 for (i = 0; i < dc->maxunit; i++) {
1378 if (dc->devices[i]) {
1379 dev = dc->devices[i];
1380 if (dev->driver == driver && dev->parent &&
1381 dev->parent->devclass == busclass) {
1382 if ((error = device_quiesce(dev)) != 0)
1383 return (error);
1384 }
1385 }
1386 }
1387
1388 return (0);
1389}
1390
1394static driverlink_t
1395devclass_find_driver_internal(devclass_t dc, const char *classname)
1396{
1397 driverlink_t dl;
1398
1399 PDEBUG(("%s in devclass %s", classname, DEVCLANAME(dc)));
1400
1401 TAILQ_FOREACH(dl, &dc->drivers, link) {
1402 if (!strcmp(dl->driver->name, classname))
1403 return (dl);
1404 }
1405
1406 PDEBUG(("not found"));
1407 return (NULL);
1408}
1409
1413const char *
1414devclass_get_name(devclass_t dc)
1415{
1416 return (dc->name);
1417}
1418
1428device_t
1429devclass_get_device(devclass_t dc, int unit)
1430{
1431 if (dc == NULL || unit < 0 || unit >= dc->maxunit)
1432 return (NULL);
1433 return (dc->devices[unit]);
1434}
1435
1446void *
1447devclass_get_softc(devclass_t dc, int unit)
1448{
1449 device_t dev;
1450
1451 dev = devclass_get_device(dc, unit);
1452 if (!dev)
1453 return (NULL);
1454
1455 return (device_get_softc(dev));
1456}
1457
1474int
1475devclass_get_devices(devclass_t dc, device_t **devlistp, int *devcountp)
1476{
1477 int count, i;
1478 device_t *list;
1479
1480 count = devclass_get_count(dc);
1481 list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
1482 if (!list)
1483 return (ENOMEM);
1484
1485 count = 0;
1486 for (i = 0; i < dc->maxunit; i++) {
1487 if (dc->devices[i]) {
1488 list[count] = dc->devices[i];
1489 count++;
1490 }
1491 }
1492
1493 *devlistp = list;
1494 *devcountp = count;
1495
1496 return (0);
1497}
1498
1515int
1516devclass_get_drivers(devclass_t dc, driver_t ***listp, int *countp)
1517{
1518 driverlink_t dl;
1519 driver_t **list;
1520 int count;
1521
1522 count = 0;
1523 TAILQ_FOREACH(dl, &dc->drivers, link)
1524 count++;
1525 list = malloc(count * sizeof(driver_t *), M_TEMP, M_NOWAIT);
1526 if (list == NULL)
1527 return (ENOMEM);
1528
1529 count = 0;
1530 TAILQ_FOREACH(dl, &dc->drivers, link) {
1531 list[count] = dl->driver;
1532 count++;
1533 }
1534 *listp = list;
1535 *countp = count;
1536
1537 return (0);
1538}
1539
1545int
1546devclass_get_count(devclass_t dc)
1547{
1548 int count, i;
1549
1550 count = 0;
1551 for (i = 0; i < dc->maxunit; i++)
1552 if (dc->devices[i])
1553 count++;
1554 return (count);
1555}
1556
1566int
1567devclass_get_maxunit(devclass_t dc)
1568{
1569 if (dc == NULL)
1570 return (-1);
1571 return (dc->maxunit);
1572}
1573
1583int
1584devclass_find_free_unit(devclass_t dc, int unit)
1585{
1586 if (dc == NULL)
1587 return (unit);
1588 while (unit < dc->maxunit && dc->devices[unit] != NULL)
1589 unit++;
1590 return (unit);
1591}
1592
1602void
1603devclass_set_parent(devclass_t dc, devclass_t pdc)
1604{
1605 dc->parent = pdc;
1606}
1607
1613devclass_t
1614devclass_get_parent(devclass_t dc)
1615{
1616 return (dc->parent);
1617}
1618
1619struct sysctl_ctx_list *
1620devclass_get_sysctl_ctx(devclass_t dc)
1621{
1622 return (&dc->sysctl_ctx);
1623}
1624
1625struct sysctl_oid *
1626devclass_get_sysctl_tree(devclass_t dc)
1627{
1628 return (dc->sysctl_tree);
1629}
1630
1646static int
1647devclass_alloc_unit(devclass_t dc, device_t dev, int *unitp)
1648{
1649 const char *s;
1650 int unit = *unitp;
1651
1652 PDEBUG(("unit %d in devclass %s", unit, DEVCLANAME(dc)));
1653
1654 /* Ask the parent bus if it wants to wire this device. */
1655 if (unit == -1)
1656 BUS_HINT_DEVICE_UNIT(device_get_parent(dev), dev, dc->name,
1657 &unit);
1658
1659 /* If we were given a wired unit number, check for existing device */
1660 /* XXX imp XXX */
1661 if (unit != -1) {
1662 if (unit >= 0 && unit < dc->maxunit &&
1663 dc->devices[unit] != NULL) {
1664 if (bootverbose)
1665 printf("%s: %s%d already exists; skipping it\n",
1666 dc->name, dc->name, *unitp);
1667 return (EEXIST);
1668 }
1669 } else {
1670 /* Unwired device, find the next available slot for it */
1671 unit = 0;
1672 for (unit = 0;; unit++) {
1673 /* If this device slot is already in use, skip it. */
1674 if (unit < dc->maxunit && dc->devices[unit] != NULL)
1675 continue;
1676
1677 /* If there is an "at" hint for a unit then skip it. */
1678 if (resource_string_value(dc->name, unit, "at", &s) ==
1679 0)
1680 continue;
1681
1682 break;
1683 }
1684 }
1685
1686 /*
1687 * We've selected a unit beyond the length of the table, so let's
1688 * extend the table to make room for all units up to and including
1689 * this one.
1690 */
1691 if (unit >= dc->maxunit) {
1692 device_t *newlist, *oldlist;
1693 int newsize;
1694
1695 oldlist = dc->devices;
1696 newsize = roundup((unit + 1),
1697 MAX(1, MINALLOCSIZE / sizeof(device_t)));
1698 newlist = malloc(sizeof(device_t) * newsize, M_BUS, M_NOWAIT);
1699 if (!newlist)
1700 return (ENOMEM);
1701 if (oldlist != NULL)
1702 bcopy(oldlist, newlist, sizeof(device_t) * dc->maxunit);
1703 bzero(newlist + dc->maxunit,
1704 sizeof(device_t) * (newsize - dc->maxunit));
1705 dc->devices = newlist;
1706 dc->maxunit = newsize;
1707 if (oldlist != NULL)
1708 free(oldlist, M_BUS);
1709 }
1710 PDEBUG(("now: unit %d in devclass %s", unit, DEVCLANAME(dc)));
1711
1712 *unitp = unit;
1713 return (0);
1714}
1715
1732static int
1733devclass_add_device(devclass_t dc, device_t dev)
1734{
1735 int buflen, error;
1736
1737 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
1738
1739 buflen = snprintf(NULL, 0, "%s%d$", dc->name, INT_MAX);
1740 if (buflen < 0)
1741 return (ENOMEM);
1742 dev->nameunit = malloc(buflen, M_BUS, M_NOWAIT|M_ZERO);
1743 if (!dev->nameunit)
1744 return (ENOMEM);
1745
1746 if ((error = devclass_alloc_unit(dc, dev, &dev->unit)) != 0) {
1747 free(dev->nameunit, M_BUS);
1748 dev->nameunit = NULL;
1749 return (error);
1750 }
1751 dc->devices[dev->unit] = dev;
1752 dev->devclass = dc;
1753 snprintf(dev->nameunit, buflen, "%s%d", dc->name, dev->unit);
1754
1755 return (0);
1756}
1757
1770static int
1771devclass_delete_device(devclass_t dc, device_t dev)
1772{
1773 if (!dc || !dev)
1774 return (0);
1775
1776 PDEBUG(("%s in devclass %s", DEVICENAME(dev), DEVCLANAME(dc)));
1777
1778 if (dev->devclass != dc || dc->devices[dev->unit] != dev)
1779 panic("devclass_delete_device: inconsistent device class");
1780 dc->devices[dev->unit] = NULL;
1781 if (dev->flags & DF_WILDCARD)
1782 dev->unit = -1;
1783 dev->devclass = NULL;
1784 free(dev->nameunit, M_BUS);
1785 dev->nameunit = NULL;
1786
1787 return (0);
1788}
1789
1802static device_t
1803make_device(device_t parent, const char *name, int unit)
1804{
1805 device_t dev;
1806 devclass_t dc;
1807
1808 PDEBUG(("%s at %s as unit %d", name, DEVICENAME(parent), unit));
1809
1810 if (name) {
1811 dc = devclass_find_internal(name, NULL, TRUE);
1812 if (!dc) {
1813 printf("make_device: can't find device class %s\n",
1814 name);
1815 return (NULL);
1816 }
1817 } else {
1818 dc = NULL;
1819 }
1820
1821 dev = malloc(sizeof(*dev), M_BUS, M_NOWAIT|M_ZERO);
1822 if (!dev)
1823 return (NULL);
1824
1825 dev->parent = parent;
1826 TAILQ_INIT(&dev->children);
1827 kobj_init((kobj_t) dev, &null_class);
1828 dev->driver = NULL;
1829 dev->devclass = NULL;
1830 dev->unit = unit;
1831 dev->nameunit = NULL;
1832 dev->desc = NULL;
1833 dev->busy = 0;
1834 dev->devflags = 0;
1835 dev->flags = DF_ENABLED;
1836 dev->order = 0;
1837 if (unit == -1)
1838 dev->flags |= DF_WILDCARD;
1839 if (name) {
1840 dev->flags |= DF_FIXEDCLASS;
1841 if (devclass_add_device(dc, dev)) {
1842 kobj_delete((kobj_t) dev, M_BUS);
1843 return (NULL);
1844 }
1845 }
1846 if (parent != NULL && device_has_quiet_children(parent))
1847 dev->flags |= DF_QUIET | DF_QUIET_CHILDREN;
1848 dev->ivars = NULL;
1849 dev->softc = NULL;
1850
1851 dev->state = DS_NOTPRESENT;
1852
1853 TAILQ_INSERT_TAIL(&bus_data_devices, dev, devlink);
1854 bus_data_generation_update();
1855
1856 return (dev);
1857}
1858
1863static int
1864device_print_child(device_t dev, device_t child)
1865{
1866 int retval = 0;
1867
1868 if (device_is_alive(child))
1869 retval += BUS_PRINT_CHILD(dev, child);
1870 else
1871 retval += device_printf(child, " not found\n");
1872
1873 return (retval);
1874}
1875
1892device_t
1893device_add_child(device_t dev, const char *name, int unit)
1894{
1895 return (device_add_child_ordered(dev, 0, name, unit));
1896}
1897
1918device_t
1919device_add_child_ordered(device_t dev, u_int order, const char *name, int unit)
1920{
1921 device_t child;
1922 device_t place;
1923
1924 PDEBUG(("%s at %s with order %u as unit %d",
1925 name, DEVICENAME(dev), order, unit));
1926 KASSERT(name != NULL || unit == -1,
1927 ("child device with wildcard name and specific unit number"));
1928
1929 child = make_device(dev, name, unit);
1930 if (child == NULL)
1931 return (child);
1932 child->order = order;
1933
1934 TAILQ_FOREACH(place, &dev->children, link) {
1935 if (place->order > order)
1936 break;
1937 }
1938
1939 if (place) {
1940 /*
1941 * The device 'place' is the first device whose order is
1942 * greater than the new child.
1943 */
1944 TAILQ_INSERT_BEFORE(place, child, link);
1945 } else {
1946 /*
1947 * The new child's order is greater or equal to the order of
1948 * any existing device. Add the child to the tail of the list.
1949 */
1950 TAILQ_INSERT_TAIL(&dev->children, child, link);
1951 }
1952
1953 bus_data_generation_update();
1954 return (child);
1955}
1956
1970int
1971device_delete_child(device_t dev, device_t child)
1972{
1973 int error;
1974 device_t grandchild;
1975
1976 PDEBUG(("%s from %s", DEVICENAME(child), DEVICENAME(dev)));
1977
1978 /* detach parent before deleting children, if any */
1979 if ((error = device_detach(child)) != 0)
1980 return (error);
1981
1982 /* remove children second */
1983 while ((grandchild = TAILQ_FIRST(&child->children)) != NULL) {
1984 error = device_delete_child(child, grandchild);
1985 if (error)
1986 return (error);
1987 }
1988
1989 if (child->devclass)
1990 devclass_delete_device(child->devclass, child);
1991 if (child->parent)
1992 BUS_CHILD_DELETED(dev, child);
1993 TAILQ_REMOVE(&dev->children, child, link);
1994 TAILQ_REMOVE(&bus_data_devices, child, devlink);
1995 kobj_delete((kobj_t) child, M_BUS);
1996
1997 bus_data_generation_update();
1998 return (0);
1999}
2000
2014int
2015device_delete_children(device_t dev)
2016{
2017 device_t child;
2018 int error;
2019
2020 PDEBUG(("Deleting all children of %s", DEVICENAME(dev)));
2021
2022 error = 0;
2023
2024 while ((child = TAILQ_FIRST(&dev->children)) != NULL) {
2025 error = device_delete_child(dev, child);
2026 if (error) {
2027 PDEBUG(("Failed deleting %s", DEVICENAME(child)));
2028 break;
2029 }
2030 }
2031 return (error);
2032}
2033
2048device_t
2049device_find_child(device_t dev, const char *classname, int unit)
2050{
2051 devclass_t dc;
2052 device_t child;
2053
2054 dc = devclass_find(classname);
2055 if (!dc)
2056 return (NULL);
2057
2058 if (unit != -1) {
2059 child = devclass_get_device(dc, unit);
2060 if (child && child->parent == dev)
2061 return (child);
2062 } else {
2063 for (unit = 0; unit < devclass_get_maxunit(dc); unit++) {
2064 child = devclass_get_device(dc, unit);
2065 if (child && child->parent == dev)
2066 return (child);
2067 }
2068 }
2069 return (NULL);
2070}
2071
2075static driverlink_t
2076first_matching_driver(devclass_t dc, device_t dev)
2077{
2078 if (dev->devclass)
2079 return (devclass_find_driver_internal(dc, dev->devclass->name));
2080 return (TAILQ_FIRST(&dc->drivers));
2081}
2082
2086static driverlink_t
2087next_matching_driver(devclass_t dc, device_t dev, driverlink_t last)
2088{
2089 if (dev->devclass) {
2090 driverlink_t dl;
2091 for (dl = TAILQ_NEXT(last, link); dl; dl = TAILQ_NEXT(dl, link))
2092 if (!strcmp(dev->devclass->name, dl->driver->name))
2093 return (dl);
2094 return (NULL);
2095 }
2096 return (TAILQ_NEXT(last, link));
2097}
2098
2102int
2103device_probe_child(device_t dev, device_t child)
2104{
2105 devclass_t dc;
2106 driverlink_t best = NULL;
2107 driverlink_t dl;
2108 int result, pri = 0;
2109 /* We should preserve the devclass (or lack of) set by the bus. */
2110 int hasclass = (child->devclass != NULL);
2111
2112 bus_topo_assert();
2113
2114 dc = dev->devclass;
2115 if (!dc)
2116 panic("device_probe_child: parent device has no devclass");
2117
2118 /*
2119 * If the state is already probed, then return.
2120 */
2121 if (child->state == DS_ALIVE)
2122 return (0);
2123
2124 for (; dc; dc = dc->parent) {
2125 for (dl = first_matching_driver(dc, child);
2126 dl;
2127 dl = next_matching_driver(dc, child, dl)) {
2128 /* If this driver's pass is too high, then ignore it. */
2129 if (dl->pass > bus_current_pass)
2130 continue;
2131
2132 PDEBUG(("Trying %s", DRIVERNAME(dl->driver)));
2133 result = device_set_driver(child, dl->driver);
2134 if (result == ENOMEM)
2135 return (result);
2136 else if (result != 0)
2137 continue;
2138 if (!hasclass) {
2139 if (device_set_devclass(child,
2140 dl->driver->name) != 0) {
2141 char const * devname =
2142 device_get_name(child);
2143 if (devname == NULL)
2144 devname = "(unknown)";
2145 printf("driver bug: Unable to set "
2146 "devclass (class: %s "
2147 "devname: %s)\n",
2148 dl->driver->name,
2149 devname);
2150 (void)device_set_driver(child, NULL);
2151 continue;
2152 }
2153 }
2154
2155 /* Fetch any flags for the device before probing. */
2156 resource_int_value(dl->driver->name, child->unit,
2157 "flags", &child->devflags);
2158
2159 result = DEVICE_PROBE(child);
2160
2161 /*
2162 * If the driver returns SUCCESS, there can be
2163 * no higher match for this device.
2164 */
2165 if (result == 0) {
2166 best = dl;
2167 pri = 0;
2168 break;
2169 }
2170
2171 /* Reset flags and devclass before the next probe. */
2172 child->devflags = 0;
2173 if (!hasclass)
2174 (void)device_set_devclass(child, NULL);
2175
2176 /*
2177 * Reset DF_QUIET in case this driver doesn't
2178 * end up as the best driver.
2179 */
2180 device_verbose(child);
2181
2182 /*
2183 * Probes that return BUS_PROBE_NOWILDCARD or lower
2184 * only match on devices whose driver was explicitly
2185 * specified.
2186 */
2187 if (result <= BUS_PROBE_NOWILDCARD &&
2188 !(child->flags & DF_FIXEDCLASS)) {
2189 result = ENXIO;
2190 }
2191
2192 /*
2193 * The driver returned an error so it
2194 * certainly doesn't match.
2195 */
2196 if (result > 0) {
2197 (void)device_set_driver(child, NULL);
2198 continue;
2199 }
2200
2201 /*
2202 * A priority lower than SUCCESS, remember the
2203 * best matching driver. Initialise the value
2204 * of pri for the first match.
2205 */
2206 if (best == NULL || result > pri) {
2207 best = dl;
2208 pri = result;
2209 continue;
2210 }
2211 }
2212 /*
2213 * If we have an unambiguous match in this devclass,
2214 * don't look in the parent.
2215 */
2216 if (best && pri == 0)
2217 break;
2218 }
2219
2220 if (best == NULL)
2221 return (ENXIO);
2222
2223 /*
2224 * If we found a driver, change state and initialise the devclass.
2225 */
2226 if (pri < 0) {
2227 /* Set the winning driver, devclass, and flags. */
2228 result = device_set_driver(child, best->driver);
2229 if (result != 0)
2230 return (result);
2231 if (!child->devclass) {
2232 result = device_set_devclass(child, best->driver->name);
2233 if (result != 0) {
2234 (void)device_set_driver(child, NULL);
2235 return (result);
2236 }
2237 }
2238 resource_int_value(best->driver->name, child->unit,
2239 "flags", &child->devflags);
2240
2241 /*
2242 * A bit bogus. Call the probe method again to make sure
2243 * that we have the right description.
2244 */
2245 result = DEVICE_PROBE(child);
2246 if (result > 0) {
2247 if (!hasclass)
2248 (void)device_set_devclass(child, NULL);
2249 (void)device_set_driver(child, NULL);
2250 return (result);
2251 }
2252 }
2253
2254 child->state = DS_ALIVE;
2255 bus_data_generation_update();
2256 return (0);
2257}
2258
2262device_t
2263device_get_parent(device_t dev)
2264{
2265 return (dev->parent);
2266}
2267
2284int
2285device_get_children(device_t dev, device_t **devlistp, int *devcountp)
2286{
2287 int count;
2288 device_t child;
2289 device_t *list;
2290
2291 count = 0;
2292 TAILQ_FOREACH(child, &dev->children, link) {
2293 count++;
2294 }
2295 if (count == 0) {
2296 *devlistp = NULL;
2297 *devcountp = 0;
2298 return (0);
2299 }
2300
2301 list = malloc(count * sizeof(device_t), M_TEMP, M_NOWAIT|M_ZERO);
2302 if (!list)
2303 return (ENOMEM);
2304
2305 count = 0;
2306 TAILQ_FOREACH(child, &dev->children, link) {
2307 list[count] = child;
2308 count++;
2309 }
2310
2311 *devlistp = list;
2312 *devcountp = count;
2313
2314 return (0);
2315}
2316
2321driver_t *
2322device_get_driver(device_t dev)
2323{
2324 return (dev->driver);
2325}
2326
2331devclass_t
2332device_get_devclass(device_t dev)
2333{
2334 return (dev->devclass);
2335}
2336
2341const char *
2342device_get_name(device_t dev)
2343{
2344 if (dev != NULL && dev->devclass)
2345 return (devclass_get_name(dev->devclass));
2346 return (NULL);
2347}
2348
2354const char *
2355device_get_nameunit(device_t dev)
2356{
2357 return (dev->nameunit);
2358}
2359
2363int
2364device_get_unit(device_t dev)
2365{
2366 return (dev->unit);
2367}
2368
2372const char *
2373device_get_desc(device_t dev)
2374{
2375 return (dev->desc);
2376}
2377
2381uint32_t
2382device_get_flags(device_t dev)
2383{
2384 return (dev->devflags);
2385}
2386
2387struct sysctl_ctx_list *
2388device_get_sysctl_ctx(device_t dev)
2389{
2390 return (&dev->sysctl_ctx);
2391}
2392
2393struct sysctl_oid *
2394device_get_sysctl_tree(device_t dev)
2395{
2396 return (dev->sysctl_tree);
2397}
2398
2404int
2405device_print_prettyname(device_t dev)
2406{
2407 const char *name = device_get_name(dev);
2408
2409 if (name == NULL)
2410 return (printf("unknown: "));
2411 return (printf("%s%d: ", name, device_get_unit(dev)));
2412}
2413
2421int
2422device_printf(device_t dev, const char * fmt, ...)
2423{
2424 char buf[128];
2425 struct sbuf sb;
2426 const char *name;
2427 va_list ap;
2428 size_t retval;
2429
2430 retval = 0;
2431
2432 sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN);
2433 sbuf_set_drain(&sb, sbuf_printf_drain, &retval);
2434
2435 name = device_get_name(dev);
2436
2437 if (name == NULL)
2438 sbuf_cat(&sb, "unknown: ");
2439 else
2440 sbuf_printf(&sb, "%s%d: ", name, device_get_unit(dev));
2441
2442 va_start(ap, fmt);
2443 sbuf_vprintf(&sb, fmt, ap);
2444 va_end(ap);
2445
2446 sbuf_finish(&sb);
2447 sbuf_delete(&sb);
2448
2449 return (retval);
2450}
2451
2459int
2460device_log(device_t dev, int pri, const char * fmt, ...)
2461{
2462 char buf[128];
2463 struct sbuf sb;
2464 const char *name;
2465 va_list ap;
2466 size_t retval;
2467
2468 retval = 0;
2469
2470 sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN);
2471
2472 name = device_get_name(dev);
2473
2474 if (name == NULL)
2475 sbuf_cat(&sb, "unknown: ");
2476 else
2477 sbuf_printf(&sb, "%s%d: ", name, device_get_unit(dev));
2478
2479 va_start(ap, fmt);
2480 sbuf_vprintf(&sb, fmt, ap);
2481 va_end(ap);
2482
2483 sbuf_finish(&sb);
2484
2485 log(pri, "%.*s", (int) sbuf_len(&sb), sbuf_data(&sb));
2486 retval = sbuf_len(&sb);
2487
2488 sbuf_delete(&sb);
2489
2490 return (retval);
2491}
2492
2496static void
2497device_set_desc_internal(device_t dev, const char* desc, int copy)
2498{
2499 if (dev->desc && (dev->flags & DF_DESCMALLOCED)) {
2500 free(dev->desc, M_BUS);
2501 dev->flags &= ~DF_DESCMALLOCED;
2502 dev->desc = NULL;
2503 }
2504
2505 if (copy && desc) {
2506 dev->desc = malloc(strlen(desc) + 1, M_BUS, M_NOWAIT);
2507 if (dev->desc) {
2508 strcpy(dev->desc, desc);
2509 dev->flags |= DF_DESCMALLOCED;
2510 }
2511 } else {
2512 /* Avoid a -Wcast-qual warning */
2513 dev->desc = (char *)(uintptr_t) desc;
2514 }
2515
2516 bus_data_generation_update();
2517}
2518
2526void
2527device_set_desc(device_t dev, const char* desc)
2528{
2529 device_set_desc_internal(dev, desc, FALSE);
2530}
2531
2538void
2539device_set_desc_copy(device_t dev, const char* desc)
2540{
2541 device_set_desc_internal(dev, desc, TRUE);
2542}
2543
2547void
2548device_set_flags(device_t dev, uint32_t flags)
2549{
2550 dev->devflags = flags;
2551}
2552
2559void *
2560device_get_softc(device_t dev)
2561{
2562 return (dev->softc);
2563}
2564
2571void
2572device_set_softc(device_t dev, void *softc)
2573{
2574 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC))
2575 free(dev->softc, M_BUS_SC);
2576 dev->softc = softc;
2577 if (dev->softc)
2578 dev->flags |= DF_EXTERNALSOFTC;
2579 else
2580 dev->flags &= ~DF_EXTERNALSOFTC;
2581}
2582
2589void
2590device_free_softc(void *softc)
2591{
2592 free(softc, M_BUS_SC);
2593}
2594
2603void
2604device_claim_softc(device_t dev)
2605{
2606 if (dev->softc)
2607 dev->flags |= DF_EXTERNALSOFTC;
2608 else
2609 dev->flags &= ~DF_EXTERNALSOFTC;
2610}
2611
2619void *
2620device_get_ivars(device_t dev)
2621{
2622 KASSERT(dev != NULL, ("device_get_ivars(NULL, ...)"));
2623 return (dev->ivars);
2624}
2625
2629void
2630device_set_ivars(device_t dev, void * ivars)
2631{
2632 KASSERT(dev != NULL, ("device_set_ivars(NULL, ...)"));
2633 dev->ivars = ivars;
2634}
2635
2639device_state_t
2640device_get_state(device_t dev)
2641{
2642 return (dev->state);
2643}
2644
2648void
2649device_enable(device_t dev)
2650{
2651 dev->flags |= DF_ENABLED;
2652}
2653
2657void
2658device_disable(device_t dev)
2659{
2660 dev->flags &= ~DF_ENABLED;
2661}
2662
2666void
2667device_busy(device_t dev)
2668{
2669
2670 /*
2671 * Mark the device as busy, recursively up the tree if this busy count
2672 * goes 0->1.
2673 */
2674 if (refcount_acquire(&dev->busy) == 0 && dev->parent != NULL)
2675 device_busy(dev->parent);
2676}
2677
2681void
2682device_unbusy(device_t dev)
2683{
2684
2685 /*
2686 * Mark the device as unbsy, recursively if this is the last busy count.
2687 */
2688 if (refcount_release(&dev->busy) && dev->parent != NULL)
2689 device_unbusy(dev->parent);
2690}
2691
2695void
2696device_quiet(device_t dev)
2697{
2698 dev->flags |= DF_QUIET;
2699}
2700
2704void
2705device_quiet_children(device_t dev)
2706{
2707 dev->flags |= DF_QUIET_CHILDREN;
2708}
2709
2713void
2714device_verbose(device_t dev)
2715{
2716 dev->flags &= ~DF_QUIET;
2717}
2718
2719ssize_t
2720device_get_property(device_t dev, const char *prop, void *val, size_t sz,
2721 device_property_type_t type)
2722{
2723 device_t bus = device_get_parent(dev);
2724
2725 switch (type) {
2726 case DEVICE_PROP_ANY:
2727 case DEVICE_PROP_BUFFER:
2728 break;
2729 case DEVICE_PROP_UINT32:
2730 if (sz % 4 != 0)
2731 return (-1);
2732 break;
2733 case DEVICE_PROP_UINT64:
2734 if (sz % 8 != 0)
2735 return (-1);
2736 break;
2737 default:
2738 return (-1);
2739 }
2740
2741 return (BUS_GET_PROPERTY(bus, dev, prop, val, sz, type));
2742}
2743
2744bool
2745device_has_property(device_t dev, const char *prop)
2746{
2747 return (device_get_property(dev, prop, NULL, 0, DEVICE_PROP_ANY) >= 0);
2748}
2749
2753int
2754device_has_quiet_children(device_t dev)
2755{
2756 return ((dev->flags & DF_QUIET_CHILDREN) != 0);
2757}
2758
2762int
2763device_is_quiet(device_t dev)
2764{
2765 return ((dev->flags & DF_QUIET) != 0);
2766}
2767
2771int
2772device_is_enabled(device_t dev)
2773{
2774 return ((dev->flags & DF_ENABLED) != 0);
2775}
2776
2780int
2781device_is_alive(device_t dev)
2782{
2783 return (dev->state >= DS_ALIVE);
2784}
2785
2790int
2791device_is_attached(device_t dev)
2792{
2793 return (dev->state >= DS_ATTACHED);
2794}
2795
2799int
2800device_is_suspended(device_t dev)
2801{
2802 return ((dev->flags & DF_SUSPENDED) != 0);
2803}
2804
2809int
2810device_set_devclass(device_t dev, const char *classname)
2811{
2812 devclass_t dc;
2813 int error;
2814
2815 if (!classname) {
2816 if (dev->devclass)
2817 devclass_delete_device(dev->devclass, dev);
2818 return (0);
2819 }
2820
2821 if (dev->devclass) {
2822 printf("device_set_devclass: device class already set\n");
2823 return (EINVAL);
2824 }
2825
2826 dc = devclass_find_internal(classname, NULL, TRUE);
2827 if (!dc)
2828 return (ENOMEM);
2829
2830 error = devclass_add_device(dc, dev);
2831
2832 bus_data_generation_update();
2833 return (error);
2834}
2835
2840int
2841device_set_devclass_fixed(device_t dev, const char *classname)
2842{
2843 int error;
2844
2845 if (classname == NULL)
2846 return (EINVAL);
2847
2848 error = device_set_devclass(dev, classname);
2849 if (error)
2850 return (error);
2851 dev->flags |= DF_FIXEDCLASS;
2852 return (0);
2853}
2854
2859bool
2860device_is_devclass_fixed(device_t dev)
2861{
2862 return ((dev->flags & DF_FIXEDCLASS) != 0);
2863}
2864
2872int
2873device_set_driver(device_t dev, driver_t *driver)
2874{
2875 int domain;
2876 struct domainset *policy;
2877
2878 if (dev->state >= DS_ATTACHED)
2879 return (EBUSY);
2880
2881 if (dev->driver == driver)
2882 return (0);
2883
2884 if (dev->softc && !(dev->flags & DF_EXTERNALSOFTC)) {
2885 free(dev->softc, M_BUS_SC);
2886 dev->softc = NULL;
2887 }
2888 device_set_desc(dev, NULL);
2889 kobj_delete((kobj_t) dev, NULL);
2890 dev->driver = driver;
2891 if (driver) {
2892 kobj_init((kobj_t) dev, (kobj_class_t) driver);
2893 if (!(dev->flags & DF_EXTERNALSOFTC) && driver->size > 0) {
2894 if (bus_get_domain(dev, &domain) == 0)
2895 policy = DOMAINSET_PREF(domain);
2896 else
2897 policy = DOMAINSET_RR();
2898 dev->softc = malloc_domainset(driver->size, M_BUS_SC,
2899 policy, M_NOWAIT | M_ZERO);
2900 if (!dev->softc) {
2901 kobj_delete((kobj_t) dev, NULL);
2902 kobj_init((kobj_t) dev, &null_class);
2903 dev->driver = NULL;
2904 return (ENOMEM);
2905 }
2906 }
2907 } else {
2908 kobj_init((kobj_t) dev, &null_class);
2909 }
2910
2911 bus_data_generation_update();
2912 return (0);
2913}
2914
2942int
2943device_probe(device_t dev)
2944{
2945 int error;
2946
2947 bus_topo_assert();
2948
2949 if (dev->state >= DS_ALIVE)
2950 return (-1);
2951
2952 if (!(dev->flags & DF_ENABLED)) {
2953 if (bootverbose && device_get_name(dev) != NULL) {
2954 device_print_prettyname(dev);
2955 printf("not probed (disabled)\n");
2956 }
2957 return (-1);
2958 }
2959 if ((error = device_probe_child(dev->parent, dev)) != 0) {
2960 if (bus_current_pass == BUS_PASS_DEFAULT &&
2961 !(dev->flags & DF_DONENOMATCH)) {
2962 BUS_PROBE_NOMATCH(dev->parent, dev);
2963 devnomatch(dev);
2964 dev->flags |= DF_DONENOMATCH;
2965 }
2966 return (error);
2967 }
2968 return (0);
2969}
2970
2976int
2977device_probe_and_attach(device_t dev)
2978{
2979 int error;
2980
2981 bus_topo_assert();
2982
2983 error = device_probe(dev);
2984 if (error == -1)
2985 return (0);
2986 else if (error != 0)
2987 return (error);
2988
2989 CURVNET_SET_QUIET(vnet0);
2990 error = device_attach(dev);
2991 CURVNET_RESTORE();
2992 return error;
2993}
2994
3014int
3015device_attach(device_t dev)
3016{
3017 uint64_t attachtime;
3018 uint16_t attachentropy;
3019 int error;
3020
3021 if (resource_disabled(dev->driver->name, dev->unit)) {
3022 device_disable(dev);
3023 if (bootverbose)
3024 device_printf(dev, "disabled via hints entry\n");
3025 return (ENXIO);
3026 }
3027
3028 device_sysctl_init(dev);
3029 if (!device_is_quiet(dev))
3030 device_print_child(dev->parent, dev);
3031 attachtime = get_cyclecount();
3032 dev->state = DS_ATTACHING;
3033 if ((error = DEVICE_ATTACH(dev)) != 0) {
3034 printf("device_attach: %s%d attach returned %d\n",
3035 dev->driver->name, dev->unit, error);
3036 if (!(dev->flags & DF_FIXEDCLASS))
3037 devclass_delete_device(dev->devclass, dev);
3038 (void)device_set_driver(dev, NULL);
3039 device_sysctl_fini(dev);
3040 KASSERT(dev->busy == 0, ("attach failed but busy"));
3041 dev->state = DS_NOTPRESENT;
3042 return (error);
3043 }
3044 dev->flags |= DF_ATTACHED_ONCE;
3045 /* We only need the low bits of this time, but ranges from tens to thousands
3046 * have been seen, so keep 2 bytes' worth.
3047 */
3048 attachentropy = (uint16_t)(get_cyclecount() - attachtime);
3049 random_harvest_direct(&attachentropy, sizeof(attachentropy), RANDOM_ATTACH);
3050 device_sysctl_update(dev);
3051 dev->state = DS_ATTACHED;
3052 dev->flags &= ~DF_DONENOMATCH;
3053 EVENTHANDLER_DIRECT_INVOKE(device_attach, dev);
3054 devadded(dev);
3055 return (0);
3056}
3057
3074int
3075device_detach(device_t dev)
3076{
3077 int error;
3078
3079 bus_topo_assert();
3080
3081 PDEBUG(("%s", DEVICENAME(dev)));
3082 if (dev->busy > 0)
3083 return (EBUSY);
3084 if (dev->state == DS_ATTACHING) {
3085 device_printf(dev, "device in attaching state! Deferring detach.\n");
3086 return (EBUSY);
3087 }
3088 if (dev->state != DS_ATTACHED)
3089 return (0);
3090
3091 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev, EVHDEV_DETACH_BEGIN);
3092 if ((error = DEVICE_DETACH(dev)) != 0) {
3093 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev,
3094 EVHDEV_DETACH_FAILED);
3095 return (error);
3096 } else {
3097 EVENTHANDLER_DIRECT_INVOKE(device_detach, dev,
3098 EVHDEV_DETACH_COMPLETE);
3099 }
3100 devremoved(dev);
3101 if (!device_is_quiet(dev))
3102 device_printf(dev, "detached\n");
3103 if (dev->parent)
3104 BUS_CHILD_DETACHED(dev->parent, dev);
3105
3106 if (!(dev->flags & DF_FIXEDCLASS))
3107 devclass_delete_device(dev->devclass, dev);
3108
3109 device_verbose(dev);
3110 dev->state = DS_NOTPRESENT;
3111 (void)device_set_driver(dev, NULL);
3112 device_sysctl_fini(dev);
3113
3114 return (0);
3115}
3116
3130int
3131device_quiesce(device_t dev)
3132{
3133 PDEBUG(("%s", DEVICENAME(dev)));
3134 if (dev->busy > 0)
3135 return (EBUSY);
3136 if (dev->state != DS_ATTACHED)
3137 return (0);
3138
3139 return (DEVICE_QUIESCE(dev));
3140}
3141
3150int
3151device_shutdown(device_t dev)
3152{
3153 if (dev->state < DS_ATTACHED)
3154 return (0);
3155 return (DEVICE_SHUTDOWN(dev));
3156}
3157
3164int
3165device_set_unit(device_t dev, int unit)
3166{
3167 devclass_t dc;
3168 int err;
3169
3170 if (unit == dev->unit)
3171 return (0);
3172 dc = device_get_devclass(dev);
3173 if (unit < dc->maxunit && dc->devices[unit])
3174 return (EBUSY);
3175 err = devclass_delete_device(dc, dev);
3176 if (err)
3177 return (err);
3178 dev->unit = unit;
3179 err = devclass_add_device(dc, dev);
3180 if (err)
3181 return (err);
3182
3183 bus_data_generation_update();
3184 return (0);
3185}
3186
3187/*======================================*/
3188/*
3189 * Some useful method implementations to make life easier for bus drivers.
3190 */
3191
3192void
3193resource_init_map_request_impl(struct resource_map_request *args, size_t sz)
3194{
3195 bzero(args, sz);
3196 args->size = sz;
3197 args->memattr = VM_MEMATTR_DEVICE;
3198}
3199
3205void
3206resource_list_init(struct resource_list *rl)
3207{
3208 STAILQ_INIT(rl);
3209}
3210
3219void
3220resource_list_free(struct resource_list *rl)
3221{
3222 struct resource_list_entry *rle;
3223
3224 while ((rle = STAILQ_FIRST(rl)) != NULL) {
3225 if (rle->res)
3226 panic("resource_list_free: resource entry is busy");
3227 STAILQ_REMOVE_HEAD(rl, link);
3228 free(rle, M_BUS);
3229 }
3230}
3231
3245int
3246resource_list_add_next(struct resource_list *rl, int type, rman_res_t start,
3247 rman_res_t end, rman_res_t count)
3248{
3249 int rid;
3250
3251 rid = 0;
3252 while (resource_list_find(rl, type, rid) != NULL)
3253 rid++;
3254 resource_list_add(rl, type, rid, start, end, count);
3255 return (rid);
3256}
3257
3273struct resource_list_entry *
3274resource_list_add(struct resource_list *rl, int type, int rid,
3275 rman_res_t start, rman_res_t end, rman_res_t count)
3276{
3277 struct resource_list_entry *rle;
3278
3279 rle = resource_list_find(rl, type, rid);
3280 if (!rle) {
3281 rle = malloc(sizeof(struct resource_list_entry), M_BUS,
3282 M_NOWAIT);
3283 if (!rle)
3284 panic("resource_list_add: can't record entry");
3285 STAILQ_INSERT_TAIL(rl, rle, link);
3286 rle->type = type;
3287 rle->rid = rid;
3288 rle->res = NULL;
3289 rle->flags = 0;
3290 }
3291
3292 if (rle->res)
3293 panic("resource_list_add: resource entry is busy");
3294
3295 rle->start = start;
3296 rle->end = end;
3297 rle->count = count;
3298 return (rle);
3299}
3300
3313int
3314resource_list_busy(struct resource_list *rl, int type, int rid)
3315{
3316 struct resource_list_entry *rle;
3317
3318 rle = resource_list_find(rl, type, rid);
3319 if (rle == NULL || rle->res == NULL)
3320 return (0);
3321 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) == RLE_RESERVED) {
3322 KASSERT(!(rman_get_flags(rle->res) & RF_ACTIVE),
3323 ("reserved resource is active"));
3324 return (0);
3325 }
3326 return (1);
3327}
3328
3342int
3343resource_list_reserved(struct resource_list *rl, int type, int rid)
3344{
3345 struct resource_list_entry *rle;
3346
3347 rle = resource_list_find(rl, type, rid);
3348 if (rle != NULL && rle->flags & RLE_RESERVED)
3349 return (1);
3350 return (0);
3351}
3352
3363struct resource_list_entry *
3364resource_list_find(struct resource_list *rl, int type, int rid)
3365{
3366 struct resource_list_entry *rle;
3367
3368 STAILQ_FOREACH(rle, rl, link) {
3369 if (rle->type == type && rle->rid == rid)
3370 return (rle);
3371 }
3372 return (NULL);
3373}
3374
3382void
3383resource_list_delete(struct resource_list *rl, int type, int rid)
3384{
3385 struct resource_list_entry *rle = resource_list_find(rl, type, rid);
3386
3387 if (rle) {
3388 if (rle->res != NULL)
3389 panic("resource_list_delete: resource has not been released");
3390 STAILQ_REMOVE(rl, rle, resource_list_entry, link);
3391 free(rle, M_BUS);
3392 }
3393}
3394
3431struct resource *
3432resource_list_reserve(struct resource_list *rl, device_t bus, device_t child,
3433 int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
3434{
3435 struct resource_list_entry *rle = NULL;
3436 int passthrough = (device_get_parent(child) != bus);
3437 struct resource *r;
3438
3439 if (passthrough)
3440 panic(
3441 "resource_list_reserve() should only be called for direct children");
3442 if (flags & RF_ACTIVE)
3443 panic(
3444 "resource_list_reserve() should only reserve inactive resources");
3445
3446 r = resource_list_alloc(rl, bus, child, type, rid, start, end, count,
3447 flags);
3448 if (r != NULL) {
3449 rle = resource_list_find(rl, type, *rid);
3450 rle->flags |= RLE_RESERVED;
3451 }
3452 return (r);
3453}
3454
3488struct resource *
3489resource_list_alloc(struct resource_list *rl, device_t bus, device_t child,
3490 int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
3491{
3492 struct resource_list_entry *rle = NULL;
3493 int passthrough = (device_get_parent(child) != bus);
3494 int isdefault = RMAN_IS_DEFAULT_RANGE(start, end);
3495
3496 if (passthrough) {
3497 return (BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
3498 type, rid, start, end, count, flags));
3499 }
3500
3501 rle = resource_list_find(rl, type, *rid);
3502
3503 if (!rle)
3504 return (NULL); /* no resource of that type/rid */
3505
3506 if (rle->res) {
3507 if (rle->flags & RLE_RESERVED) {
3508 if (rle->flags & RLE_ALLOCATED)
3509 return (NULL);
3510 if ((flags & RF_ACTIVE) &&
3511 bus_activate_resource(child, type, *rid,
3512 rle->res) != 0)
3513 return (NULL);
3514 rle->flags |= RLE_ALLOCATED;
3515 return (rle->res);
3516 }
3517 device_printf(bus,
3518 "resource entry %#x type %d for child %s is busy\n", *rid,
3519 type, device_get_nameunit(child));
3520 return (NULL);
3521 }
3522
3523 if (isdefault) {
3524 start = rle->start;
3525 count = ulmax(count, rle->count);
3526 end = ulmax(rle->end, start + count - 1);
3527 }
3528
3529 rle->res = BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
3530 type, rid, start, end, count, flags);
3531
3532 /*
3533 * Record the new range.
3534 */
3535 if (rle->res) {
3536 rle->start = rman_get_start(rle->res);
3537 rle->end = rman_get_end(rle->res);
3538 rle->count = count;
3539 }
3540
3541 return (rle->res);
3542}
3543
3561int
3562resource_list_release(struct resource_list *rl, device_t bus, device_t child,
3563 int type, int rid, struct resource *res)
3564{
3565 struct resource_list_entry *rle = NULL;
3566 int passthrough = (device_get_parent(child) != bus);
3567 int error;
3568
3569 if (passthrough) {
3570 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
3571 type, rid, res));
3572 }
3573
3574 rle = resource_list_find(rl, type, rid);
3575
3576 if (!rle)
3577 panic("resource_list_release: can't find resource");
3578 if (!rle->res)
3579 panic("resource_list_release: resource entry is not busy");
3580 if (rle->flags & RLE_RESERVED) {
3581 if (rle->flags & RLE_ALLOCATED) {
3582 if (rman_get_flags(res) & RF_ACTIVE) {
3583 error = bus_deactivate_resource(child, type,
3584 rid, res);
3585 if (error)
3586 return (error);
3587 }
3588 rle->flags &= ~RLE_ALLOCATED;
3589 return (0);
3590 }
3591 return (EINVAL);
3592 }
3593
3594 error = BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
3595 type, rid, res);
3596 if (error)
3597 return (error);
3598
3599 rle->res = NULL;
3600 return (0);
3601}
3602
3618int
3619resource_list_release_active(struct resource_list *rl, device_t bus,
3620 device_t child, int type)
3621{
3622 struct resource_list_entry *rle;
3623 int error, retval;
3624
3625 retval = 0;
3626 STAILQ_FOREACH(rle, rl, link) {
3627 if (rle->type != type)
3628 continue;
3629 if (rle->res == NULL)
3630 continue;
3631 if ((rle->flags & (RLE_RESERVED | RLE_ALLOCATED)) ==
3632 RLE_RESERVED)
3633 continue;
3634 retval = EBUSY;
3635 error = resource_list_release(rl, bus, child, type,
3636 rman_get_rid(rle->res), rle->res);
3637 if (error != 0)
3638 device_printf(bus,
3639 "Failed to release active resource: %d\n", error);
3640 }
3641 return (retval);
3642}
3643
3660int
3661resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child,
3662 int type, int rid)
3663{
3664 struct resource_list_entry *rle = NULL;
3665 int passthrough = (device_get_parent(child) != bus);
3666
3667 if (passthrough)
3668 panic(
3669 "resource_list_unreserve() should only be called for direct children");
3670
3671 rle = resource_list_find(rl, type, rid);
3672
3673 if (!rle)
3674 panic("resource_list_unreserve: can't find resource");
3675 if (!(rle->flags & RLE_RESERVED))
3676 return (EINVAL);
3677 if (rle->flags & RLE_ALLOCATED)
3678 return (EBUSY);
3679 rle->flags &= ~RLE_RESERVED;
3680 return (resource_list_release(rl, bus, child, type, rid, rle->res));
3681}
3682
3698int
3699resource_list_print_type(struct resource_list *rl, const char *name, int type,
3700 const char *format)
3701{
3702 struct resource_list_entry *rle;
3703 int printed, retval;
3704
3705 printed = 0;
3706 retval = 0;
3707 /* Yes, this is kinda cheating */
3708 STAILQ_FOREACH(rle, rl, link) {
3709 if (rle->type == type) {
3710 if (printed == 0)
3711 retval += printf(" %s ", name);
3712 else
3713 retval += printf(",");
3714 printed++;
3715 retval += printf(format, rle->start);
3716 if (rle->count > 1) {
3717 retval += printf("-");
3718 retval += printf(format, rle->start +
3719 rle->count - 1);
3720 }
3721 }
3722 }
3723 return (retval);
3724}
3725
3733void
3734resource_list_purge(struct resource_list *rl)
3735{
3736 struct resource_list_entry *rle;
3737
3738 while ((rle = STAILQ_FIRST(rl)) != NULL) {
3739 if (rle->res)
3740 bus_release_resource(rman_get_device(rle->res),
3741 rle->type, rle->rid, rle->res);
3742 STAILQ_REMOVE_HEAD(rl, link);
3743 free(rle, M_BUS);
3744 }
3745}
3746
3747device_t
3748bus_generic_add_child(device_t dev, u_int order, const char *name, int unit)
3749{
3750 return (device_add_child_ordered(dev, order, name, unit));
3751}
3752
3761int
3762bus_generic_probe(device_t dev)
3763{
3764 devclass_t dc = dev->devclass;
3765 driverlink_t dl;
3766
3767 TAILQ_FOREACH(dl, &dc->drivers, link) {
3768 /*
3769 * If this driver's pass is too high, then ignore it.
3770 * For most drivers in the default pass, this will
3771 * never be true. For early-pass drivers they will
3772 * only call the identify routines of eligible drivers
3773 * when this routine is called. Drivers for later
3774 * passes should have their identify routines called
3775 * on early-pass buses during BUS_NEW_PASS().
3776 */
3777 if (dl->pass > bus_current_pass)
3778 continue;
3779 DEVICE_IDENTIFY(dl->driver, dev);
3780 }
3781
3782 return (0);
3783}
3784
3792int
3793bus_generic_attach(device_t dev)
3794{
3795 device_t child;
3796
3797 TAILQ_FOREACH(child, &dev->children, link) {
3798 device_probe_and_attach(child);
3799 }
3800
3801 return (0);
3802}
3803
3811int
3812bus_delayed_attach_children(device_t dev)
3813{
3814 /* Probe and attach the bus children when interrupts are available */
3815 config_intrhook_oneshot((ich_func_t)bus_generic_attach, dev);
3816
3817 return (0);
3818}
3819
3827int
3828bus_generic_detach(device_t dev)
3829{
3830 device_t child;
3831 int error;
3832
3833 if (dev->state != DS_ATTACHED)
3834 return (EBUSY);
3835
3836 /*
3837 * Detach children in the reverse order.
3838 * See bus_generic_suspend for details.
3839 */
3840 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3841 if ((error = device_detach(child)) != 0)
3842 return (error);
3843 }
3844
3845 return (0);
3846}
3847
3855int
3856bus_generic_shutdown(device_t dev)
3857{
3858 device_t child;
3859
3860 /*
3861 * Shut down children in the reverse order.
3862 * See bus_generic_suspend for details.
3863 */
3864 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3865 device_shutdown(child);
3866 }
3867
3868 return (0);
3869}
3870
3876int
3877bus_generic_suspend_child(device_t dev, device_t child)
3878{
3879 int error;
3880
3881 error = DEVICE_SUSPEND(child);
3882
3883 if (error == 0)
3884 child->flags |= DF_SUSPENDED;
3885
3886 return (error);
3887}
3888
3894int
3895bus_generic_resume_child(device_t dev, device_t child)
3896{
3897 DEVICE_RESUME(child);
3898 child->flags &= ~DF_SUSPENDED;
3899
3900 return (0);
3901}
3902
3912int
3913bus_generic_suspend(device_t dev)
3914{
3915 int error;
3916 device_t child;
3917
3918 /*
3919 * Suspend children in the reverse order.
3920 * For most buses all children are equal, so the order does not matter.
3921 * Other buses, such as acpi, carefully order their child devices to
3922 * express implicit dependencies between them. For such buses it is
3923 * safer to bring down devices in the reverse order.
3924 */
3925 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
3926 error = BUS_SUSPEND_CHILD(dev, child);
3927 if (error != 0) {
3928 child = TAILQ_NEXT(child, link);
3929 if (child != NULL) {
3930 TAILQ_FOREACH_FROM(child, &dev->children, link)
3931 BUS_RESUME_CHILD(dev, child);
3932 }
3933 return (error);
3934 }
3935 }
3936 return (0);
3937}
3938
3945int
3946bus_generic_resume(device_t dev)
3947{
3948 device_t child;
3949
3950 TAILQ_FOREACH(child, &dev->children, link) {
3951 BUS_RESUME_CHILD(dev, child);
3952 /* if resume fails, there's nothing we can usefully do... */
3953 }
3954 return (0);
3955}
3956
3967int
3968bus_helper_reset_post(device_t dev, int flags)
3969{
3970 device_t child;
3971 int error, error1;
3972
3973 error = 0;
3974 TAILQ_FOREACH(child, &dev->children,link) {
3975 BUS_RESET_POST(dev, child);
3976 error1 = (flags & DEVF_RESET_DETACH) != 0 ?
3977 device_probe_and_attach(child) :
3978 BUS_RESUME_CHILD(dev, child);
3979 if (error == 0 && error1 != 0)
3980 error = error1;
3981 }
3982 return (error);
3983}
3984
3985static void
3986bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags)
3987{
3988 child = TAILQ_NEXT(child, link);
3989 if (child == NULL)
3990 return;
3991 TAILQ_FOREACH_FROM(child, &dev->children,link) {
3992 BUS_RESET_POST(dev, child);
3993 if ((flags & DEVF_RESET_DETACH) != 0)
3994 device_probe_and_attach(child);
3995 else
3996 BUS_RESUME_CHILD(dev, child);
3997 }
3998}
3999
4011int
4012bus_helper_reset_prepare(device_t dev, int flags)
4013{
4014 device_t child;
4015 int error;
4016
4017 if (dev->state != DS_ATTACHED)
4018 return (EBUSY);
4019
4020 TAILQ_FOREACH_REVERSE(child, &dev->children, device_list, link) {
4021 if ((flags & DEVF_RESET_DETACH) != 0) {
4022 error = device_get_state(child) == DS_ATTACHED ?
4023 device_detach(child) : 0;
4024 } else {
4025 error = BUS_SUSPEND_CHILD(dev, child);
4026 }
4027 if (error == 0) {
4028 error = BUS_RESET_PREPARE(dev, child);
4029 if (error != 0) {
4030 if ((flags & DEVF_RESET_DETACH) != 0)
4031 device_probe_and_attach(child);
4032 else
4033 BUS_RESUME_CHILD(dev, child);
4034 }
4035 }
4036 if (error != 0) {
4037 bus_helper_reset_prepare_rollback(dev, child, flags);
4038 return (error);
4039 }
4040 }
4041 return (0);
4042}
4043
4053int
4054bus_print_child_header(device_t dev, device_t child)
4055{
4056 int retval = 0;
4057
4058 if (device_get_desc(child)) {
4059 retval += device_printf(child, "<%s>", device_get_desc(child));
4060 } else {
4061 retval += printf("%s", device_get_nameunit(child));
4062 }
4063
4064 return (retval);
4065}
4066
4076int
4077bus_print_child_footer(device_t dev, device_t child)
4078{
4079 return (printf(" on %s\n", device_get_nameunit(dev)));
4080}
4081
4089int
4090bus_print_child_domain(device_t dev, device_t child)
4091{
4092 int domain;
4093
4094 /* No domain? Don't print anything */
4095 if (BUS_GET_DOMAIN(dev, child, &domain) != 0)
4096 return (0);
4097
4098 return (printf(" numa-domain %d", domain));
4099}
4100
4109int
4110bus_generic_print_child(device_t dev, device_t child)
4111{
4112 int retval = 0;
4113
4114 retval += bus_print_child_header(dev, child);
4115 retval += bus_print_child_domain(dev, child);
4116 retval += bus_print_child_footer(dev, child);
4117
4118 return (retval);
4119}
4120
4126int
4127bus_generic_read_ivar(device_t dev, device_t child, int index,
4128 uintptr_t * result)
4129{
4130 return (ENOENT);
4131}
4132
4138int
4139bus_generic_write_ivar(device_t dev, device_t child, int index,
4140 uintptr_t value)
4141{
4142 return (ENOENT);
4143}
4144
4151ssize_t
4152bus_generic_get_property(device_t dev, device_t child, const char *propname,
4153 void *propvalue, size_t size, device_property_type_t type)
4154{
4155 if (device_get_parent(dev) != NULL)
4156 return (BUS_GET_PROPERTY(device_get_parent(dev), child,
4157 propname, propvalue, size, type));
4158
4159 return (-1);
4160}
4161
4167struct resource_list *
4168bus_generic_get_resource_list(device_t dev, device_t child)
4169{
4170 return (NULL);
4171}
4172
4180void
4181bus_generic_driver_added(device_t dev, driver_t *driver)
4182{
4183 device_t child;
4184
4185 DEVICE_IDENTIFY(driver, dev);
4186 TAILQ_FOREACH(child, &dev->children, link) {
4187 if (child->state == DS_NOTPRESENT)
4188 device_probe_and_attach(child);
4189 }
4190}
4191
4202void
4203bus_generic_new_pass(device_t dev)
4204{
4205 driverlink_t dl;
4206 devclass_t dc;
4207 device_t child;
4208
4209 dc = dev->devclass;
4210 TAILQ_FOREACH(dl, &dc->drivers, link) {
4211 if (dl->pass == bus_current_pass)
4212 DEVICE_IDENTIFY(dl->driver, dev);
4213 }
4214 TAILQ_FOREACH(child, &dev->children, link) {
4215 if (child->state >= DS_ATTACHED)
4216 BUS_NEW_PASS(child);
4217 else if (child->state == DS_NOTPRESENT)
4218 device_probe_and_attach(child);
4219 }
4220}
4221
4228int
4229bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq,
4230 int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,
4231 void **cookiep)
4232{
4233 /* Propagate up the bus hierarchy until someone handles it. */
4234 if (dev->parent)
4235 return (BUS_SETUP_INTR(dev->parent, child, irq, flags,
4236 filter, intr, arg, cookiep));
4237 return (EINVAL);
4238}
4239
4246int
4247bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq,
4248 void *cookie)
4249{
4250 /* Propagate up the bus hierarchy until someone handles it. */
4251 if (dev->parent)
4252 return (BUS_TEARDOWN_INTR(dev->parent, child, irq, cookie));
4253 return (EINVAL);
4254}
4255
4262int
4263bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq)
4264{
4265 /* Propagate up the bus hierarchy until someone handles it. */
4266 if (dev->parent)
4267 return (BUS_SUSPEND_INTR(dev->parent, child, irq));
4268 return (EINVAL);
4269}
4270
4277int
4278bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq)
4279{
4280 /* Propagate up the bus hierarchy until someone handles it. */
4281 if (dev->parent)
4282 return (BUS_RESUME_INTR(dev->parent, child, irq));
4283 return (EINVAL);
4284}
4285
4292int
4293bus_generic_adjust_resource(device_t dev, device_t child, int type,
4294 struct resource *r, rman_res_t start, rman_res_t end)
4295{
4296 /* Propagate up the bus hierarchy until someone handles it. */
4297 if (dev->parent)
4298 return (BUS_ADJUST_RESOURCE(dev->parent, child, type, r, start,
4299 end));
4300 return (EINVAL);
4301}
4302
4303/*
4304 * @brief Helper function for implementing BUS_TRANSLATE_RESOURCE().
4305 *
4306 * This simple implementation of BUS_TRANSLATE_RESOURCE() simply calls the
4307 * BUS_TRANSLATE_RESOURCE() method of the parent of @p dev. If there is no
4308 * parent, no translation happens.
4309 */
4310int
4311bus_generic_translate_resource(device_t dev, int type, rman_res_t start,
4312 rman_res_t *newstart)
4313{
4314 if (dev->parent)
4315 return (BUS_TRANSLATE_RESOURCE(dev->parent, type, start,
4316 newstart));
4317 *newstart = start;
4318 return (0);
4319}
4320
4327struct resource *
4328bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid,
4329 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
4330{
4331 /* Propagate up the bus hierarchy until someone handles it. */
4332 if (dev->parent)
4333 return (BUS_ALLOC_RESOURCE(dev->parent, child, type, rid,
4334 start, end, count, flags));
4335 return (NULL);
4336}
4337
4344int
4345bus_generic_release_resource(device_t dev, device_t child, int type, int rid,
4346 struct resource *r)
4347{
4348 /* Propagate up the bus hierarchy until someone handles it. */
4349 if (dev->parent)
4350 return (BUS_RELEASE_RESOURCE(dev->parent, child, type, rid,
4351 r));
4352 return (EINVAL);
4353}
4354
4361int
4362bus_generic_activate_resource(device_t dev, device_t child, int type, int rid,
4363 struct resource *r)
4364{
4365 /* Propagate up the bus hierarchy until someone handles it. */
4366 if (dev->parent)
4367 return (BUS_ACTIVATE_RESOURCE(dev->parent, child, type, rid,
4368 r));
4369 return (EINVAL);
4370}
4371
4378int
4379bus_generic_deactivate_resource(device_t dev, device_t child, int type,
4380 int rid, struct resource *r)
4381{
4382 /* Propagate up the bus hierarchy until someone handles it. */
4383 if (dev->parent)
4384 return (BUS_DEACTIVATE_RESOURCE(dev->parent, child, type, rid,
4385 r));
4386 return (EINVAL);
4387}
4388
4395int
4396bus_generic_map_resource(device_t dev, device_t child, int type,
4397 struct resource *r, struct resource_map_request *args,
4398 struct resource_map *map)
4399{
4400 /* Propagate up the bus hierarchy until someone handles it. */
4401 if (dev->parent)
4402 return (BUS_MAP_RESOURCE(dev->parent, child, type, r, args,
4403 map));
4404 return (EINVAL);
4405}
4406
4413int
4414bus_generic_unmap_resource(device_t dev, device_t child, int type,
4415 struct resource *r, struct resource_map *map)
4416{
4417 /* Propagate up the bus hierarchy until someone handles it. */
4418 if (dev->parent)
4419 return (BUS_UNMAP_RESOURCE(dev->parent, child, type, r, map));
4420 return (EINVAL);
4421}
4422
4429int
4430bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq,
4431 int cpu)
4432{
4433 /* Propagate up the bus hierarchy until someone handles it. */
4434 if (dev->parent)
4435 return (BUS_BIND_INTR(dev->parent, child, irq, cpu));
4436 return (EINVAL);
4437}
4438
4445int
4446bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig,
4447 enum intr_polarity pol)
4448{
4449 /* Propagate up the bus hierarchy until someone handles it. */
4450 if (dev->parent)
4451 return (BUS_CONFIG_INTR(dev->parent, irq, trig, pol));
4452 return (EINVAL);
4453}
4454
4461int
4462bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq,
4463 void *cookie, const char *descr)
4464{
4465 /* Propagate up the bus hierarchy until someone handles it. */
4466 if (dev->parent)
4467 return (BUS_DESCRIBE_INTR(dev->parent, child, irq, cookie,
4468 descr));
4469 return (EINVAL);
4470}
4471
4478int
4479bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op,
4480 size_t setsize, cpuset_t *cpuset)
4481{
4482 /* Propagate up the bus hierarchy until someone handles it. */
4483 if (dev->parent != NULL)
4484 return (BUS_GET_CPUS(dev->parent, child, op, setsize, cpuset));
4485 return (EINVAL);
4486}
4487
4494bus_dma_tag_t
4495bus_generic_get_dma_tag(device_t dev, device_t child)
4496{
4497 /* Propagate up the bus hierarchy until someone handles it. */
4498 if (dev->parent != NULL)
4499 return (BUS_GET_DMA_TAG(dev->parent, child));
4500 return (NULL);
4501}
4502
4509bus_space_tag_t
4510bus_generic_get_bus_tag(device_t dev, device_t child)
4511{
4512 /* Propagate up the bus hierarchy until someone handles it. */
4513 if (dev->parent != NULL)
4514 return (BUS_GET_BUS_TAG(dev->parent, child));
4515 return ((bus_space_tag_t)0);
4516}
4517
4526int
4527bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid,
4528 rman_res_t *startp, rman_res_t *countp)
4529{
4530 struct resource_list * rl = NULL;
4531 struct resource_list_entry * rle = NULL;
4532
4533 rl = BUS_GET_RESOURCE_LIST(dev, child);
4534 if (!rl)
4535 return (EINVAL);
4536
4537 rle = resource_list_find(rl, type, rid);
4538 if (!rle)
4539 return (ENOENT);
4540
4541 if (startp)
4542 *startp = rle->start;
4543 if (countp)
4544 *countp = rle->count;
4545
4546 return (0);
4547}
4548
4557int
4558bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid,
4559 rman_res_t start, rman_res_t count)
4560{
4561 struct resource_list * rl = NULL;
4562
4563 rl = BUS_GET_RESOURCE_LIST(dev, child);
4564 if (!rl)
4565 return (EINVAL);
4566
4567 resource_list_add(rl, type, rid, start, (start + count - 1), count);
4568
4569 return (0);
4570}
4571
4580void
4581bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid)
4582{
4583 struct resource_list * rl = NULL;
4584
4585 rl = BUS_GET_RESOURCE_LIST(dev, child);
4586 if (!rl)
4587 return;
4588
4589 resource_list_delete(rl, type, rid);
4590
4591 return;
4592}
4593
4601int
4602bus_generic_rl_release_resource(device_t dev, device_t child, int type,
4603 int rid, struct resource *r)
4604{
4605 struct resource_list * rl = NULL;
4606
4607 if (device_get_parent(child) != dev)
4608 return (BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
4609 type, rid, r));
4610
4611 rl = BUS_GET_RESOURCE_LIST(dev, child);
4612 if (!rl)
4613 return (EINVAL);
4614
4615 return (resource_list_release(rl, dev, child, type, rid, r));
4616}
4617
4625struct resource *
4626bus_generic_rl_alloc_resource(device_t dev, device_t child, int type,
4627 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
4628{
4629 struct resource_list * rl = NULL;
4630
4631 if (device_get_parent(child) != dev)
4632 return (BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
4633 type, rid, start, end, count, flags));
4634
4635 rl = BUS_GET_RESOURCE_LIST(dev, child);
4636 if (!rl)
4637 return (NULL);
4638
4639 return (resource_list_alloc(rl, dev, child, type, rid,
4640 start, end, count, flags));
4641}
4642
4649int
4650bus_generic_child_present(device_t dev, device_t child)
4651{
4652 return (BUS_CHILD_PRESENT(device_get_parent(dev), dev));
4653}
4654
4655int
4656bus_generic_get_domain(device_t dev, device_t child, int *domain)
4657{
4658 if (dev->parent)
4659 return (BUS_GET_DOMAIN(dev->parent, dev, domain));
4660
4661 return (ENOENT);
4662}
4663
4675int
4676bus_generic_get_device_path(device_t bus, device_t child, const char *locator,
4677 struct sbuf *sb)
4678{
4679 int rv = 0;
4680 device_t parent;
4681
4682 /*
4683 * We don't recurse on ACPI since either we know the handle for the
4684 * device or we don't. And if we're in the generic routine, we don't
4685 * have a ACPI override. All other locators build up a path by having
4686 * their parents create a path and then adding the path element for this
4687 * node. That's why we recurse with parent, bus rather than the typical
4688 * parent, child: each spot in the tree is independent of what our child
4689 * will do with this path.
4690 */
4691 parent = device_get_parent(bus);
4692 if (parent != NULL && strcmp(locator, BUS_LOCATOR_ACPI) != 0) {
4693 rv = BUS_GET_DEVICE_PATH(parent, bus, locator, sb);
4694 }
4695 if (strcmp(locator, BUS_LOCATOR_FREEBSD) == 0) {
4696 if (rv == 0) {
4697 sbuf_printf(sb, "/%s", device_get_nameunit(child));
4698 }
4699 return (rv);
4700 }
4701 /*
4702 * Don't know what to do. So assume we do nothing. Not sure that's
4703 * the right thing, but keeps us from having a big list here.
4704 */
4705 return (0);
4706}
4707
4708
4715int
4716bus_null_rescan(device_t dev)
4717{
4718 return (ENXIO);
4719}
4720
4721/*
4722 * Some convenience functions to make it easier for drivers to use the
4723 * resource-management functions. All these really do is hide the
4724 * indirection through the parent's method table, making for slightly
4725 * less-wordy code. In the future, it might make sense for this code
4726 * to maintain some sort of a list of resources allocated by each device.
4727 */
4728
4729int
4730bus_alloc_resources(device_t dev, struct resource_spec *rs,
4731 struct resource **res)
4732{
4733 int i;
4734
4735 for (i = 0; rs[i].type != -1; i++)
4736 res[i] = NULL;
4737 for (i = 0; rs[i].type != -1; i++) {
4738 res[i] = bus_alloc_resource_any(dev,
4739 rs[i].type, &rs[i].rid, rs[i].flags);
4740 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) {
4741 bus_release_resources(dev, rs, res);
4742 return (ENXIO);
4743 }
4744 }
4745 return (0);
4746}
4747
4748void
4749bus_release_resources(device_t dev, const struct resource_spec *rs,
4750 struct resource **res)
4751{
4752 int i;
4753
4754 for (i = 0; rs[i].type != -1; i++)
4755 if (res[i] != NULL) {
4756 bus_release_resource(
4757 dev, rs[i].type, rs[i].rid, res[i]);
4758 res[i] = NULL;
4759 }
4760}
4761
4768struct resource *
4769bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start,
4770 rman_res_t end, rman_res_t count, u_int flags)
4771{
4772 struct resource *res;
4773
4774 if (dev->parent == NULL)
4775 return (NULL);
4776 res = BUS_ALLOC_RESOURCE(dev->parent, dev, type, rid, start, end,
4777 count, flags);
4778 return (res);
4779}
4780
4787int
4788bus_adjust_resource(device_t dev, int type, struct resource *r, rman_res_t start,
4789 rman_res_t end)
4790{
4791 if (dev->parent == NULL)
4792 return (EINVAL);
4793 return (BUS_ADJUST_RESOURCE(dev->parent, dev, type, r, start, end));
4794}
4795
4802int
4803bus_translate_resource(device_t dev, int type, rman_res_t start,
4804 rman_res_t *newstart)
4805{
4806 if (dev->parent == NULL)
4807 return (EINVAL);
4808 return (BUS_TRANSLATE_RESOURCE(dev->parent, type, start, newstart));
4809}
4810
4817int
4818bus_activate_resource(device_t dev, int type, int rid, struct resource *r)
4819{
4820 if (dev->parent == NULL)
4821 return (EINVAL);
4822 return (BUS_ACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
4823}
4824
4831int
4832bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r)
4833{
4834 if (dev->parent == NULL)
4835 return (EINVAL);
4836 return (BUS_DEACTIVATE_RESOURCE(dev->parent, dev, type, rid, r));
4837}
4838
4845int
4846bus_map_resource(device_t dev, int type, struct resource *r,
4847 struct resource_map_request *args, struct resource_map *map)
4848{
4849 if (dev->parent == NULL)
4850 return (EINVAL);
4851 return (BUS_MAP_RESOURCE(dev->parent, dev, type, r, args, map));
4852}
4853
4860int
4861bus_unmap_resource(device_t dev, int type, struct resource *r,
4862 struct resource_map *map)
4863{
4864 if (dev->parent == NULL)
4865 return (EINVAL);
4866 return (BUS_UNMAP_RESOURCE(dev->parent, dev, type, r, map));
4867}
4868
4875int
4876bus_release_resource(device_t dev, int type, int rid, struct resource *r)
4877{
4878 int rv;
4879
4880 if (dev->parent == NULL)
4881 return (EINVAL);
4882 rv = BUS_RELEASE_RESOURCE(dev->parent, dev, type, rid, r);
4883 return (rv);
4884}
4885
4892int
4893bus_setup_intr(device_t dev, struct resource *r, int flags,
4894 driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep)
4895{
4896 int error;
4897
4898 if (dev->parent == NULL)
4899 return (EINVAL);
4900 error = BUS_SETUP_INTR(dev->parent, dev, r, flags, filter, handler,
4901 arg, cookiep);
4902 if (error != 0)
4903 return (error);
4904 if (handler != NULL && !(flags & INTR_MPSAFE))
4905 device_printf(dev, "[GIANT-LOCKED]\n");
4906 return (0);
4907}
4908
4915int
4916bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
4917{
4918 if (dev->parent == NULL)
4919 return (EINVAL);
4920 return (BUS_TEARDOWN_INTR(dev->parent, dev, r, cookie));
4921}
4922
4929int
4930bus_suspend_intr(device_t dev, struct resource *r)
4931{
4932 if (dev->parent == NULL)
4933 return (EINVAL);
4934 return (BUS_SUSPEND_INTR(dev->parent, dev, r));
4935}
4936
4943int
4944bus_resume_intr(device_t dev, struct resource *r)
4945{
4946 if (dev->parent == NULL)
4947 return (EINVAL);
4948 return (BUS_RESUME_INTR(dev->parent, dev, r));
4949}
4950
4957int
4958bus_bind_intr(device_t dev, struct resource *r, int cpu)
4959{
4960 if (dev->parent == NULL)
4961 return (EINVAL);
4962 return (BUS_BIND_INTR(dev->parent, dev, r, cpu));
4963}
4964
4972int
4973bus_describe_intr(device_t dev, struct resource *irq, void *cookie,
4974 const char *fmt, ...)
4975{
4976 va_list ap;
4977 char descr[MAXCOMLEN + 1];
4978
4979 if (dev->parent == NULL)
4980 return (EINVAL);
4981 va_start(ap, fmt);
4982 vsnprintf(descr, sizeof(descr), fmt, ap);
4983 va_end(ap);
4984 return (BUS_DESCRIBE_INTR(dev->parent, dev, irq, cookie, descr));
4985}
4986
4993int
4994bus_set_resource(device_t dev, int type, int rid,
4995 rman_res_t start, rman_res_t count)
4996{
4997 return (BUS_SET_RESOURCE(device_get_parent(dev), dev, type, rid,
4998 start, count));
4999}
5000
5007int
5008bus_get_resource(device_t dev, int type, int rid,
5009 rman_res_t *startp, rman_res_t *countp)
5010{
5011 return (BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
5012 startp, countp));
5013}
5014
5021rman_res_t
5022bus_get_resource_start(device_t dev, int type, int rid)
5023{
5024 rman_res_t start;
5025 rman_res_t count;
5026 int error;
5027
5028 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
5029 &start, &count);
5030 if (error)
5031 return (0);
5032 return (start);
5033}
5034
5041rman_res_t
5042bus_get_resource_count(device_t dev, int type, int rid)
5043{
5044 rman_res_t start;
5045 rman_res_t count;
5046 int error;
5047
5048 error = BUS_GET_RESOURCE(device_get_parent(dev), dev, type, rid,
5049 &start, &count);
5050 if (error)
5051 return (0);
5052 return (count);
5053}
5054
5061void
5062bus_delete_resource(device_t dev, int type, int rid)
5063{
5064 BUS_DELETE_RESOURCE(device_get_parent(dev), dev, type, rid);
5065}
5066
5073int
5074bus_child_present(device_t child)
5075{
5076 return (BUS_CHILD_PRESENT(device_get_parent(child), child));
5077}
5078
5085int
5086bus_child_pnpinfo(device_t child, struct sbuf *sb)
5087{
5088 device_t parent;
5089
5090 parent = device_get_parent(child);
5091 if (parent == NULL)
5092 return (0);
5093 return (BUS_CHILD_PNPINFO(parent, child, sb));
5094}
5095
5102int
5103bus_generic_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb)
5104{
5105 return (0);
5106}
5107
5114int
5115bus_child_location(device_t child, struct sbuf *sb)
5116{
5117 device_t parent;
5118
5119 parent = device_get_parent(child);
5120 if (parent == NULL)
5121 return (0);
5122 return (BUS_CHILD_LOCATION(parent, child, sb));
5123}
5124
5131int
5132bus_generic_child_location(device_t dev, device_t child, struct sbuf *sb)
5133{
5134 return (0);
5135}
5136
5143int
5144bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset)
5145{
5146 device_t parent;
5147
5148 parent = device_get_parent(dev);
5149 if (parent == NULL)
5150 return (EINVAL);
5151 return (BUS_GET_CPUS(parent, dev, op, setsize, cpuset));
5152}
5153
5160bus_dma_tag_t
5161bus_get_dma_tag(device_t dev)
5162{
5163 device_t parent;
5164
5165 parent = device_get_parent(dev);
5166 if (parent == NULL)
5167 return (NULL);
5168 return (BUS_GET_DMA_TAG(parent, dev));
5169}
5170
5177bus_space_tag_t
5178bus_get_bus_tag(device_t dev)
5179{
5180 device_t parent;
5181
5182 parent = device_get_parent(dev);
5183 if (parent == NULL)
5184 return ((bus_space_tag_t)0);
5185 return (BUS_GET_BUS_TAG(parent, dev));
5186}
5187
5194int
5195bus_get_domain(device_t dev, int *domain)
5196{
5197 return (BUS_GET_DOMAIN(device_get_parent(dev), dev, domain));
5198}
5199
5200/* Resume all devices and then notify userland that we're up again. */
5201static int
5202root_resume(device_t dev)
5203{
5204 int error;
5205
5206 error = bus_generic_resume(dev);
5207 if (error == 0) {
5208 devctl_notify("kern", "power", "resume", NULL); /* Deprecated gone in 14 */
5209 devctl_notify("kernel", "power", "resume", NULL);
5210 }
5211 return (error);
5212}
5213
5214static int
5215root_print_child(device_t dev, device_t child)
5216{
5217 int retval = 0;
5218
5219 retval += bus_print_child_header(dev, child);
5220 retval += printf("\n");
5221
5222 return (retval);
5223}
5224
5225static int
5226root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags,
5227 driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)
5228{
5229 /*
5230 * If an interrupt mapping gets to here something bad has happened.
5231 */
5232 panic("root_setup_intr");
5233}
5234
5235/*
5236 * If we get here, assume that the device is permanent and really is
5237 * present in the system. Removable bus drivers are expected to intercept
5238 * this call long before it gets here. We return -1 so that drivers that
5239 * really care can check vs -1 or some ERRNO returned higher in the food
5240 * chain.
5241 */
5242static int
5243root_child_present(device_t dev, device_t child)
5244{
5245 return (-1);
5246}
5247
5248static int
5249root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize,
5250 cpuset_t *cpuset)
5251{
5252 switch (op) {
5253 case INTR_CPUS:
5254 /* Default to returning the set of all CPUs. */
5255 if (setsize != sizeof(cpuset_t))
5256 return (EINVAL);
5257 *cpuset = all_cpus;
5258 return (0);
5259 default:
5260 return (EINVAL);
5261 }
5262}
5263
5264static kobj_method_t root_methods[] = {
5265 /* Device interface */
5266 KOBJMETHOD(device_shutdown, bus_generic_shutdown),
5267 KOBJMETHOD(device_suspend, bus_generic_suspend),
5268 KOBJMETHOD(device_resume, root_resume),
5269
5270 /* Bus interface */
5271 KOBJMETHOD(bus_print_child, root_print_child),
5272 KOBJMETHOD(bus_read_ivar, bus_generic_read_ivar),
5273 KOBJMETHOD(bus_write_ivar, bus_generic_write_ivar),
5274 KOBJMETHOD(bus_setup_intr, root_setup_intr),
5275 KOBJMETHOD(bus_child_present, root_child_present),
5276 KOBJMETHOD(bus_get_cpus, root_get_cpus),
5277
5278 KOBJMETHOD_END
5279};
5280
5281static driver_t root_driver = {
5282 "root",
5283 root_methods,
5284 1, /* no softc */
5285};
5286
5287device_t root_bus;
5288devclass_t root_devclass;
5289
5290static int
5291root_bus_module_handler(module_t mod, int what, void* arg)
5292{
5293 switch (what) {
5294 case MOD_LOAD:
5295 TAILQ_INIT(&bus_data_devices);
5296 kobj_class_compile((kobj_class_t) &root_driver);
5297 root_bus = make_device(NULL, "root", 0);
5298 root_bus->desc = "System root bus";
5299 kobj_init((kobj_t) root_bus, (kobj_class_t) &root_driver);
5300 root_bus->driver = &root_driver;
5301 root_bus->state = DS_ATTACHED;
5302 root_devclass = devclass_find_internal("root", NULL, FALSE);
5303 devinit();
5304 return (0);
5305
5306 case MOD_SHUTDOWN:
5307 device_shutdown(root_bus);
5308 return (0);
5309 default:
5310 return (EOPNOTSUPP);
5311 }
5312
5313 return (0);
5314}
5315
5316static moduledata_t root_bus_mod = {
5317 "rootbus",
5318 root_bus_module_handler,
5319 NULL
5320};
5321DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
5322
5329void
5330root_bus_configure(void)
5331{
5332 PDEBUG(("."));
5333
5334 /* Eventually this will be split up, but this is sufficient for now. */
5335 bus_set_pass(BUS_PASS_DEFAULT);
5336}
5337
5346int
5347driver_module_handler(module_t mod, int what, void *arg)
5348{
5349 struct driver_module_data *dmd;
5350 devclass_t bus_devclass;
5351 kobj_class_t driver;
5352 int error, pass;
5353
5354 dmd = (struct driver_module_data *)arg;
5355 bus_devclass = devclass_find_internal(dmd->dmd_busname, NULL, TRUE);
5356 error = 0;
5357
5358 switch (what) {
5359 case MOD_LOAD:
5360 if (dmd->dmd_chainevh)
5361 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
5362
5363 pass = dmd->dmd_pass;
5364 driver = dmd->dmd_driver;
5365 PDEBUG(("Loading module: driver %s on bus %s (pass %d)",
5366 DRIVERNAME(driver), dmd->dmd_busname, pass));
5367 error = devclass_add_driver(bus_devclass, driver, pass,
5368 dmd->dmd_devclass);
5369 break;
5370
5371 case MOD_UNLOAD:
5372 PDEBUG(("Unloading module: driver %s from bus %s",
5373 DRIVERNAME(dmd->dmd_driver),
5374 dmd->dmd_busname));
5375 error = devclass_delete_driver(bus_devclass,
5376 dmd->dmd_driver);
5377
5378 if (!error && dmd->dmd_chainevh)
5379 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
5380 break;
5381 case MOD_QUIESCE:
5382 PDEBUG(("Quiesce module: driver %s from bus %s",
5383 DRIVERNAME(dmd->dmd_driver),
5384 dmd->dmd_busname));
5385 error = devclass_quiesce_driver(bus_devclass,
5386 dmd->dmd_driver);
5387
5388 if (!error && dmd->dmd_chainevh)
5389 error = dmd->dmd_chainevh(mod,what,dmd->dmd_chainarg);
5390 break;
5391 default:
5392 error = EOPNOTSUPP;
5393 break;
5394 }
5395
5396 return (error);
5397}
5398
5409void
5410bus_enumerate_hinted_children(device_t bus)
5411{
5412 int i;
5413 const char *dname, *busname;
5414 int dunit;
5415
5416 /*
5417 * enumerate all devices on the specific bus
5418 */
5419 busname = device_get_nameunit(bus);
5420 i = 0;
5421 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0)
5422 BUS_HINTED_CHILD(bus, dname, dunit);
5423
5424 /*
5425 * and all the generic ones.
5426 */
5427 busname = device_get_name(bus);
5428 i = 0;
5429 while (resource_find_match(&i, &dname, &dunit, "at", busname) == 0)
5430 BUS_HINTED_CHILD(bus, dname, dunit);
5431}
5432
5433#ifdef BUS_DEBUG
5434
5435/* the _short versions avoid iteration by not calling anything that prints
5436 * more than oneliners. I love oneliners.
5437 */
5438
5439static void
5440print_device_short(device_t dev, int indent)
5441{
5442 if (!dev)
5443 return;
5444
5445 indentprintf(("device %d: <%s> %sparent,%schildren,%s%s%s%s%s,%sivars,%ssoftc,busy=%d\n",
5446 dev->unit, dev->desc,
5447 (dev->parent? "":"no "),
5448 (TAILQ_EMPTY(&dev->children)? "no ":""),
5449 (dev->flags&DF_ENABLED? "enabled,":"disabled,"),
5450 (dev->flags&DF_FIXEDCLASS? "fixed,":""),
5451 (dev->flags&DF_WILDCARD? "wildcard,":""),
5452 (dev->flags&DF_DESCMALLOCED? "descmalloced,":""),
5453 (dev->flags&DF_SUSPENDED? "suspended,":""),
5454 (dev->ivars? "":"no "),
5455 (dev->softc? "":"no "),
5456 dev->busy));
5457}
5458
5459static void
5460print_device(device_t dev, int indent)
5461{
5462 if (!dev)
5463 return;
5464
5465 print_device_short(dev, indent);
5466
5467 indentprintf(("Parent:\n"));
5468 print_device_short(dev->parent, indent+1);
5469 indentprintf(("Driver:\n"));
5470 print_driver_short(dev->driver, indent+1);
5471 indentprintf(("Devclass:\n"));
5472 print_devclass_short(dev->devclass, indent+1);
5473}
5474
5475void
5476print_device_tree_short(device_t dev, int indent)
5477/* print the device and all its children (indented) */
5478{
5479 device_t child;
5480
5481 if (!dev)
5482 return;
5483
5484 print_device_short(dev, indent);
5485
5486 TAILQ_FOREACH(child, &dev->children, link) {
5487 print_device_tree_short(child, indent+1);
5488 }
5489}
5490
5491void
5492print_device_tree(device_t dev, int indent)
5493/* print the device and all its children (indented) */
5494{
5495 device_t child;
5496
5497 if (!dev)
5498 return;
5499
5500 print_device(dev, indent);
5501
5502 TAILQ_FOREACH(child, &dev->children, link) {
5503 print_device_tree(child, indent+1);
5504 }
5505}
5506
5507static void
5508print_driver_short(driver_t *driver, int indent)
5509{
5510 if (!driver)
5511 return;
5512
5513 indentprintf(("driver %s: softc size = %zd\n",
5514 driver->name, driver->size));
5515}
5516
5517static void
5518print_driver(driver_t *driver, int indent)
5519{
5520 if (!driver)
5521 return;
5522
5523 print_driver_short(driver, indent);
5524}
5525
5526static void
5527print_driver_list(driver_list_t drivers, int indent)
5528{
5529 driverlink_t driver;
5530
5531 TAILQ_FOREACH(driver, &drivers, link) {
5532 print_driver(driver->driver, indent);
5533 }
5534}
5535
5536static void
5537print_devclass_short(devclass_t dc, int indent)
5538{
5539 if ( !dc )
5540 return;
5541
5542 indentprintf(("devclass %s: max units = %d\n", dc->name, dc->maxunit));
5543}
5544
5545static void
5546print_devclass(devclass_t dc, int indent)
5547{
5548 int i;
5549
5550 if ( !dc )
5551 return;
5552
5553 print_devclass_short(dc, indent);
5554 indentprintf(("Drivers:\n"));
5555 print_driver_list(dc->drivers, indent+1);
5556
5557 indentprintf(("Devices:\n"));
5558 for (i = 0; i < dc->maxunit; i++)
5559 if (dc->devices[i])
5560 print_device(dc->devices[i], indent+1);
5561}
5562
5563void
5564print_devclass_list_short(void)
5565{
5566 devclass_t dc;
5567
5568 printf("Short listing of devclasses, drivers & devices:\n");
5569 TAILQ_FOREACH(dc, &devclasses, link) {
5570 print_devclass_short(dc, 0);
5571 }
5572}
5573
5574void
5575print_devclass_list(void)
5576{
5577 devclass_t dc;
5578
5579 printf("Full listing of devclasses, drivers & devices:\n");
5580 TAILQ_FOREACH(dc, &devclasses, link) {
5581 print_devclass(dc, 0);
5582 }
5583}
5584
5585#endif
5586
5587/*
5588 * User-space access to the device tree.
5589 *
5590 * We implement a small set of nodes:
5591 *
5592 * hw.bus Single integer read method to obtain the
5593 * current generation count.
5594 * hw.bus.devices Reads the entire device tree in flat space.
5595 * hw.bus.rman Resource manager interface
5596 *
5597 * We might like to add the ability to scan devclasses and/or drivers to
5598 * determine what else is currently loaded/available.
5599 */
5600
5601static int
5602sysctl_bus_info(SYSCTL_HANDLER_ARGS)
5603{
5604 struct u_businfo ubus;
5605
5606 ubus.ub_version = BUS_USER_VERSION;
5607 ubus.ub_generation = bus_data_generation;
5608
5609 return (SYSCTL_OUT(req, &ubus, sizeof(ubus)));
5610}
5611SYSCTL_PROC(_hw_bus, OID_AUTO, info, CTLTYPE_STRUCT | CTLFLAG_RD |
5612 CTLFLAG_MPSAFE, NULL, 0, sysctl_bus_info, "S,u_businfo",
5613 "bus-related data");
5614
5615static int
5616sysctl_devices(SYSCTL_HANDLER_ARGS)
5617{
5618 struct sbuf sb;
5619 int *name = (int *)arg1;
5620 u_int namelen = arg2;
5621 int index;
5622 device_t dev;
5623 struct u_device *udev;
5624 int error;
5625
5626 if (namelen != 2)
5627 return (EINVAL);
5628
5629 if (bus_data_generation_check(name[0]))
5630 return (EINVAL);
5631
5632 index = name[1];
5633
5634 /*
5635 * Scan the list of devices, looking for the requested index.
5636 */
5637 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
5638 if (index-- == 0)
5639 break;
5640 }
5641 if (dev == NULL)
5642 return (ENOENT);
5643
5644 /*
5645 * Populate the return item, careful not to overflow the buffer.
5646 */
5647 udev = malloc(sizeof(*udev), M_BUS, M_WAITOK | M_ZERO);
5648 if (udev == NULL)
5649 return (ENOMEM);
5650 udev->dv_handle = (uintptr_t)dev;
5651 udev->dv_parent = (uintptr_t)dev->parent;
5652 udev->dv_devflags = dev->devflags;
5653 udev->dv_flags = dev->flags;
5654 udev->dv_state = dev->state;
5655 sbuf_new(&sb, udev->dv_fields, sizeof(udev->dv_fields), SBUF_FIXEDLEN);
5656 if (dev->nameunit != NULL)
5657 sbuf_cat(&sb, dev->nameunit);
5658 sbuf_putc(&sb, '\0');
5659 if (dev->desc != NULL)
5660 sbuf_cat(&sb, dev->desc);
5661 sbuf_putc(&sb, '\0');
5662 if (dev->driver != NULL)
5663 sbuf_cat(&sb, dev->driver->name);
5664 sbuf_putc(&sb, '\0');
5665 bus_child_pnpinfo(dev, &sb);
5666 sbuf_putc(&sb, '\0');
5667 bus_child_location(dev, &sb);
5668 sbuf_putc(&sb, '\0');
5669 error = sbuf_finish(&sb);
5670 if (error == 0)
5671 error = SYSCTL_OUT(req, udev, sizeof(*udev));
5672 sbuf_delete(&sb);
5673 free(udev, M_BUS);
5674 return (error);
5675}
5676
5677SYSCTL_NODE(_hw_bus, OID_AUTO, devices,
5678 CTLFLAG_RD | CTLFLAG_NEEDGIANT, sysctl_devices,
5679 "system device tree");
5680
5681int
5682bus_data_generation_check(int generation)
5683{
5684 if (generation != bus_data_generation)
5685 return (1);
5686
5687 /* XXX generate optimised lists here? */
5688 return (0);
5689}
5690
5691void
5692bus_data_generation_update(void)
5693{
5694 atomic_add_int(&bus_data_generation, 1);
5695}
5696
5697int
5698bus_free_resource(device_t dev, int type, struct resource *r)
5699{
5700 if (r == NULL)
5701 return (0);
5702 return (bus_release_resource(dev, type, rman_get_rid(r), r));
5703}
5704
5705device_t
5706device_lookup_by_name(const char *name)
5707{
5708 device_t dev;
5709
5710 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
5711 if (dev->nameunit != NULL && strcmp(dev->nameunit, name) == 0)
5712 return (dev);
5713 }
5714 return (NULL);
5715}
5716
5717/*
5718 * /dev/devctl2 implementation. The existing /dev/devctl device has
5719 * implicit semantics on open, so it could not be reused for this.
5720 * Another option would be to call this /dev/bus?
5721 */
5722static int
5723find_device(struct devreq *req, device_t *devp)
5724{
5725 device_t dev;
5726
5727 /*
5728 * First, ensure that the name is nul terminated.
5729 */
5730 if (memchr(req->dr_name, '\0', sizeof(req->dr_name)) == NULL)
5731 return (EINVAL);
5732
5733 /*
5734 * Second, try to find an attached device whose name matches
5735 * 'name'.
5736 */
5737 dev = device_lookup_by_name(req->dr_name);
5738 if (dev != NULL) {
5739 *devp = dev;
5740 return (0);
5741 }
5742
5743 /* Finally, give device enumerators a chance. */
5744 dev = NULL;
5745 EVENTHANDLER_DIRECT_INVOKE(dev_lookup, req->dr_name, &dev);
5746 if (dev == NULL)
5747 return (ENOENT);
5748 *devp = dev;
5749 return (0);
5750}
5751
5752static bool
5753driver_exists(device_t bus, const char *driver)
5754{
5755 devclass_t dc;
5756
5757 for (dc = bus->devclass; dc != NULL; dc = dc->parent) {
5758 if (devclass_find_driver_internal(dc, driver) != NULL)
5759 return (true);
5760 }
5761 return (false);
5762}
5763
5764static void
5765device_gen_nomatch(device_t dev)
5766{
5767 device_t child;
5768
5769 if (dev->flags & DF_NEEDNOMATCH &&
5770 dev->state == DS_NOTPRESENT) {
5771 BUS_PROBE_NOMATCH(dev->parent, dev);
5772 devnomatch(dev);
5773 dev->flags |= DF_DONENOMATCH;
5774 }
5775 dev->flags &= ~DF_NEEDNOMATCH;
5776 TAILQ_FOREACH(child, &dev->children, link) {
5777 device_gen_nomatch(child);
5778 }
5779}
5780
5781static void
5782device_do_deferred_actions(void)
5783{
5784 devclass_t dc;
5785 driverlink_t dl;
5786
5787 /*
5788 * Walk through the devclasses to find all the drivers we've tagged as
5789 * deferred during the freeze and call the driver added routines. They
5790 * have already been added to the lists in the background, so the driver
5791 * added routines that trigger a probe will have all the right bidders
5792 * for the probe auction.
5793 */
5794 TAILQ_FOREACH(dc, &devclasses, link) {
5795 TAILQ_FOREACH(dl, &dc->drivers, link) {
5796 if (dl->flags & DL_DEFERRED_PROBE) {
5797 devclass_driver_added(dc, dl->driver);
5798 dl->flags &= ~DL_DEFERRED_PROBE;
5799 }
5800 }
5801 }
5802
5803 /*
5804 * We also defer no-match events during a freeze. Walk the tree and
5805 * generate all the pent-up events that are still relevant.
5806 */
5807 device_gen_nomatch(root_bus);
5808 bus_data_generation_update();
5809}
5810
5811static char *
5812device_get_path(device_t dev, const char *locator)
5813{
5814 struct sbuf *sb;
5815 ssize_t len;
5816 char *rv = NULL;
5817 int error;
5818
5819 sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND | SBUF_INCLUDENUL);
5820 error = BUS_GET_DEVICE_PATH(device_get_parent(dev), dev, locator, sb);
5821 sbuf_finish(sb); /* Note: errors checked with sbuf_len() below */
5822 if (error != 0)
5823 goto out;
5824 len = sbuf_len(sb);
5825 if (len <= 1)
5826 goto out;
5827 rv = malloc(len, M_BUS, M_NOWAIT);
5828 memcpy(rv, sbuf_data(sb), len);
5829out:
5830 sbuf_delete(sb);
5831 return (rv);
5832}
5833
5834static int
5835devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag,
5836 struct thread *td)
5837{
5838 struct devreq *req;
5839 device_t dev;
5840 int error, old;
5841
5842 /* Locate the device to control. */
5843 bus_topo_lock();
5844 req = (struct devreq *)data;
5845 switch (cmd) {
5846 case DEV_ATTACH:
5847 case DEV_DETACH:
5848 case DEV_ENABLE:
5849 case DEV_DISABLE:
5850 case DEV_SUSPEND:
5851 case DEV_RESUME:
5852 case DEV_SET_DRIVER:
5853 case DEV_CLEAR_DRIVER:
5854 case DEV_RESCAN:
5855 case DEV_DELETE:
5856 case DEV_RESET:
5857 error = priv_check(td, PRIV_DRIVER);
5858 if (error == 0)
5859 error = find_device(req, &dev);
5860 break;
5861 case DEV_FREEZE:
5862 case DEV_THAW:
5863 error = priv_check(td, PRIV_DRIVER);
5864 break;
5865 case DEV_GET_PATH:
5866 error = find_device(req, &dev);
5867 break;
5868 default:
5869 error = ENOTTY;
5870 break;
5871 }
5872 if (error) {
5873 bus_topo_unlock();
5874 return (error);
5875 }
5876
5877 /* Perform the requested operation. */
5878 switch (cmd) {
5879 case DEV_ATTACH:
5880 if (device_is_attached(dev))
5881 error = EBUSY;
5882 else if (!device_is_enabled(dev))
5883 error = ENXIO;
5884 else
5885 error = device_probe_and_attach(dev);
5886 break;
5887 case DEV_DETACH:
5888 if (!device_is_attached(dev)) {
5889 error = ENXIO;
5890 break;
5891 }
5892 if (!(req->dr_flags & DEVF_FORCE_DETACH)) {
5893 error = device_quiesce(dev);
5894 if (error)
5895 break;
5896 }
5897 error = device_detach(dev);
5898 break;
5899 case DEV_ENABLE:
5900 if (device_is_enabled(dev)) {
5901 error = EBUSY;
5902 break;
5903 }
5904
5905 /*
5906 * If the device has been probed but not attached (e.g.
5907 * when it has been disabled by a loader hint), just
5908 * attach the device rather than doing a full probe.
5909 */
5910 device_enable(dev);
5911 if (device_is_alive(dev)) {
5912 /*
5913 * If the device was disabled via a hint, clear
5914 * the hint.
5915 */
5916 if (resource_disabled(dev->driver->name, dev->unit))
5917 resource_unset_value(dev->driver->name,
5918 dev->unit, "disabled");
5919 error = device_attach(dev);
5920 } else
5921 error = device_probe_and_attach(dev);
5922 break;
5923 case DEV_DISABLE:
5924 if (!device_is_enabled(dev)) {
5925 error = ENXIO;
5926 break;
5927 }
5928
5929 if (!(req->dr_flags & DEVF_FORCE_DETACH)) {
5930 error = device_quiesce(dev);
5931 if (error)
5932 break;
5933 }
5934
5935 /*
5936 * Force DF_FIXEDCLASS on around detach to preserve
5937 * the existing name.
5938 */
5939 old = dev->flags;
5940 dev->flags |= DF_FIXEDCLASS;
5941 error = device_detach(dev);
5942 if (!(old & DF_FIXEDCLASS))
5943 dev->flags &= ~DF_FIXEDCLASS;
5944 if (error == 0)
5945 device_disable(dev);
5946 break;
5947 case DEV_SUSPEND:
5948 if (device_is_suspended(dev)) {
5949 error = EBUSY;
5950 break;
5951 }
5952 if (device_get_parent(dev) == NULL) {
5953 error = EINVAL;
5954 break;
5955 }
5956 error = BUS_SUSPEND_CHILD(device_get_parent(dev), dev);
5957 break;
5958 case DEV_RESUME:
5959 if (!device_is_suspended(dev)) {
5960 error = EINVAL;
5961 break;
5962 }
5963 if (device_get_parent(dev) == NULL) {
5964 error = EINVAL;
5965 break;
5966 }
5967 error = BUS_RESUME_CHILD(device_get_parent(dev), dev);
5968 break;
5969 case DEV_SET_DRIVER: {
5970 devclass_t dc;
5971 char driver[128];
5972
5973 error = copyinstr(req->dr_data, driver, sizeof(driver), NULL);
5974 if (error)
5975 break;
5976 if (driver[0] == '\0') {
5977 error = EINVAL;
5978 break;
5979 }
5980 if (dev->devclass != NULL &&
5981 strcmp(driver, dev->devclass->name) == 0)
5982 /* XXX: Could possibly force DF_FIXEDCLASS on? */
5983 break;
5984
5985 /*
5986 * Scan drivers for this device's bus looking for at
5987 * least one matching driver.
5988 */
5989 if (dev->parent == NULL) {
5990 error = EINVAL;
5991 break;
5992 }
5993 if (!driver_exists(dev->parent, driver)) {
5994 error = ENOENT;
5995 break;
5996 }
5997 dc = devclass_create(driver);
5998 if (dc == NULL) {
5999 error = ENOMEM;
6000 break;
6001 }
6002
6003 /* Detach device if necessary. */
6004 if (device_is_attached(dev)) {
6005 if (req->dr_flags & DEVF_SET_DRIVER_DETACH)
6006 error = device_detach(dev);
6007 else
6008 error = EBUSY;
6009 if (error)
6010 break;
6011 }
6012
6013 /* Clear any previously-fixed device class and unit. */
6014 if (dev->flags & DF_FIXEDCLASS)
6015 devclass_delete_device(dev->devclass, dev);
6016 dev->flags |= DF_WILDCARD;
6017 dev->unit = -1;
6018
6019 /* Force the new device class. */
6020 error = devclass_add_device(dc, dev);
6021 if (error)
6022 break;
6023 dev->flags |= DF_FIXEDCLASS;
6024 error = device_probe_and_attach(dev);
6025 break;
6026 }
6027 case DEV_CLEAR_DRIVER:
6028 if (!(dev->flags & DF_FIXEDCLASS)) {
6029 error = 0;
6030 break;
6031 }
6032 if (device_is_attached(dev)) {
6033 if (req->dr_flags & DEVF_CLEAR_DRIVER_DETACH)
6034 error = device_detach(dev);
6035 else
6036 error = EBUSY;
6037 if (error)
6038 break;
6039 }
6040
6041 dev->flags &= ~DF_FIXEDCLASS;
6042 dev->flags |= DF_WILDCARD;
6043 devclass_delete_device(dev->devclass, dev);
6044 error = device_probe_and_attach(dev);
6045 break;
6046 case DEV_RESCAN:
6047 if (!device_is_attached(dev)) {
6048 error = ENXIO;
6049 break;
6050 }
6051 error = BUS_RESCAN(dev);
6052 break;
6053 case DEV_DELETE: {
6054 device_t parent;
6055
6056 parent = device_get_parent(dev);
6057 if (parent == NULL) {
6058 error = EINVAL;
6059 break;
6060 }
6061 if (!(req->dr_flags & DEVF_FORCE_DELETE)) {
6062 if (bus_child_present(dev) != 0) {
6063 error = EBUSY;
6064 break;
6065 }
6066 }
6067
6068 error = device_delete_child(parent, dev);
6069 break;
6070 }
6071 case DEV_FREEZE:
6072 if (device_frozen)
6073 error = EBUSY;
6074 else
6075 device_frozen = true;
6076 break;
6077 case DEV_THAW:
6078 if (!device_frozen)
6079 error = EBUSY;
6080 else {
6081 device_do_deferred_actions();
6082 device_frozen = false;
6083 }
6084 break;
6085 case DEV_RESET:
6086 if ((req->dr_flags & ~(DEVF_RESET_DETACH)) != 0) {
6087 error = EINVAL;
6088 break;
6089 }
6090 error = BUS_RESET_CHILD(device_get_parent(dev), dev,
6091 req->dr_flags);
6092 break;
6093 case DEV_GET_PATH: {
6094 char locator[64];
6095 char *path;
6096 ssize_t len;
6097
6098 error = copyinstr(req->dr_buffer.buffer, locator, sizeof(locator), NULL);
6099 if (error)
6100 break;
6101 path = device_get_path(dev, locator);
6102 if (path == NULL) {
6103 error = ENOMEM;
6104 break;
6105 }
6106 len = strlen(path) + 1;
6107 if (req->dr_buffer.length < len) {
6108 error = ENAMETOOLONG;
6109 } else {
6110 error = copyout(path, req->dr_buffer.buffer, len);
6111 }
6112 req->dr_buffer.length = len;
6113 free(path, M_BUS);
6114 break;
6115 }
6116 }
6117 bus_topo_unlock();
6118 return (error);
6119}
6120
6121static struct cdevsw devctl2_cdevsw = {
6122 .d_version = D_VERSION,
6123 .d_ioctl = devctl2_ioctl,
6124 .d_name = "devctl2",
6125};
6126
6127static void
6128devctl2_init(void)
6129{
6130 make_dev_credf(MAKEDEV_ETERNAL, &devctl2_cdevsw, 0, NULL,
6131 UID_ROOT, GID_WHEEL, 0644, "devctl2");
6132}
6133
6134/*
6135 * For maintaining device 'at' location info to avoid recomputing it
6136 */
6137struct device_location_node {
6138 const char *dln_locator;
6139 const char *dln_path;
6140 TAILQ_ENTRY(device_location_node) dln_link;
6141};
6142typedef TAILQ_HEAD(device_location_list, device_location_node) device_location_list_t;
6143
6144struct device_location_cache {
6145 device_location_list_t dlc_list;
6146};
6147
6148
6149/*
6150 * Location cache for wired devices.
6151 */
6152device_location_cache_t *
6153dev_wired_cache_init(void)
6154{
6155 device_location_cache_t *dcp;
6156
6157 dcp = malloc(sizeof(*dcp), M_BUS, M_WAITOK | M_ZERO);
6158 TAILQ_INIT(&dcp->dlc_list);
6159
6160 return (dcp);
6161}
6162
6163void
6164dev_wired_cache_fini(device_location_cache_t *dcp)
6165{
6166 struct device_location_node *dln, *tdln;
6167
6168 TAILQ_FOREACH_SAFE(dln, &dcp->dlc_list, dln_link, tdln) {
6169 /* Note: one allocation for both node and locator, but not path */
6170 free(__DECONST(void *, dln->dln_path), M_BUS);
6171 free(dln, M_BUS);
6172 }
6173 free(dcp, M_BUS);
6174}
6175
6176static struct device_location_node *
6177dev_wired_cache_lookup(device_location_cache_t *dcp, const char *locator)
6178{
6179 struct device_location_node *dln;
6180
6181 TAILQ_FOREACH(dln, &dcp->dlc_list, dln_link) {
6182 if (strcmp(locator, dln->dln_locator) == 0)
6183 return (dln);
6184 }
6185
6186 return (NULL);
6187}
6188
6189static struct device_location_node *
6190dev_wired_cache_add(device_location_cache_t *dcp, const char *locator, const char *path)
6191{
6192 struct device_location_node *dln;
6193 char *l;
6194
6195 dln = malloc(sizeof(*dln) + strlen(locator) + 1, M_BUS, M_WAITOK | M_ZERO);
6196 dln->dln_locator = l = (char *)(dln + 1);
6197 memcpy(l, locator, strlen(locator) + 1);
6198 dln->dln_path = path;
6199 TAILQ_INSERT_HEAD(&dcp->dlc_list, dln, dln_link);
6200
6201 return (dln);
6202}
6203
6204bool
6205dev_wired_cache_match(device_location_cache_t *dcp, device_t dev, const char *at)
6206{
6207 const char *cp, *path;
6208 char locator[32];
6209 int len;
6210 struct device_location_node *res;
6211
6212 cp = strchr(at, ':');
6213 if (cp == NULL)
6214 return (false);
6215 len = cp - at;
6216 if (len > sizeof(locator) - 1) /* Skip too long locator */
6217 return (false);
6218 memcpy(locator, at, len);
6219 locator[len] = '\0';
6220 cp++;
6221
6222 /* maybe cache this inside device_t and look that up, but not yet */
6223 res = dev_wired_cache_lookup(dcp, locator);
6224 if (res == NULL) {
6225 path = device_get_path(dev, locator);
6226 res = dev_wired_cache_add(dcp, locator, path);
6227 }
6228 if (res == NULL || res->dln_path == NULL)
6229 return (false);
6230
6231 return (strcmp(res->dln_path, cp) == 0);
6232}
6233
6234/*
6235 * APIs to manage deprecation and obsolescence.
6236 */
6237static int obsolete_panic = 0;
6238SYSCTL_INT(_debug, OID_AUTO, obsolete_panic, CTLFLAG_RWTUN, &obsolete_panic, 0,
6239 "Panic when obsolete features are used (0 = never, 1 = if obsolete, "
6240 "2 = if deprecated)");
6241
6242static void
6243gone_panic(int major, int running, const char *msg)
6244{
6245 switch (obsolete_panic)
6246 {
6247 case 0:
6248 return;
6249 case 1:
6250 if (running < major)
6251 return;
6252 /* FALLTHROUGH */
6253 default:
6254 panic("%s", msg);
6255 }
6256}
6257
6258void
6259_gone_in(int major, const char *msg)
6260{
6261 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg);
6262 if (P_OSREL_MAJOR(__FreeBSD_version) >= major)
6263 printf("Obsolete code will be removed soon: %s\n", msg);
6264 else
6265 printf("Deprecated code (to be removed in FreeBSD %d): %s\n",
6266 major, msg);
6267}
6268
6269void
6270_gone_in_dev(device_t dev, int major, const char *msg)
6271{
6272 gone_panic(major, P_OSREL_MAJOR(__FreeBSD_version), msg);
6273 if (P_OSREL_MAJOR(__FreeBSD_version) >= major)
6274 device_printf(dev,
6275 "Obsolete code will be removed soon: %s\n", msg);
6276 else
6277 device_printf(dev,
6278 "Deprecated code (to be removed in FreeBSD %d): %s\n",
6279 major, msg);
6280}
6281
6282#ifdef DDB
6283DB_SHOW_COMMAND(device, db_show_device)
6284{
6285 device_t dev;
6286
6287 if (!have_addr)
6288 return;
6289
6290 dev = (device_t)addr;
6291
6292 db_printf("name: %s\n", device_get_nameunit(dev));
6293 db_printf(" driver: %s\n", DRIVERNAME(dev->driver));
6294 db_printf(" class: %s\n", DEVCLANAME(dev->devclass));
6295 db_printf(" addr: %p\n", dev);
6296 db_printf(" parent: %p\n", dev->parent);
6297 db_printf(" softc: %p\n", dev->softc);
6298 db_printf(" ivars: %p\n", dev->ivars);
6299}
6300
6301DB_SHOW_ALL_COMMAND(devices, db_show_all_devices)
6302{
6303 device_t dev;
6304
6305 TAILQ_FOREACH(dev, &bus_data_devices, devlink) {
6306 db_show_device((db_expr_t)dev, true, count, modif);
6307 }
6308}
6309#endif
count
int * count
Definition: cpufreq_if.m:63
type
device_property_type_t type
Definition: bus_if.m:941
bus
INTERFACE bus
Definition: bus_if.m:39
parent
device_t parent
Definition: device_if.m:187
device
INTERFACE device
Definition: device_if.m:40
name
const char * name
Definition: kern_fail.c:145
bootverbose
int bootverbose
Definition: init_main.c:131
busy
static u_int busy
Definition: kern_clocksource.c:95
cv_init
void cv_init(struct cv *cvp, const char *desc)
Definition: kern_condvar.c:77
make_dev_credf
struct cdev * make_dev_credf(int flags, struct cdevsw *devsw, int unit, struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt,...)
Definition: kern_conf.c:911
fsetown
int fsetown(pid_t pgid, struct sigio **sigiop)
Definition: kern_descrip.c:1190
funsetown
void funsetown(struct sigio **sigiop)
Definition: kern_descrip.c:1101
fgetown
pid_t fgetown(struct sigio **sigiop)
Definition: kern_descrip.c:1274
knlist_remove
void knlist_remove(struct knlist *knl, struct knote *kn, int islocked)
Definition: kern_event.c:2467
knlist_add
void knlist_add(struct knlist *knl, struct knote *kn, int islocked)
Definition: kern_event.c:2420
knote
void knote(struct knlist *list, long hint, int lockflags)
Definition: kern_event.c:2363
knlist_init_mtx
void knlist_init_mtx(struct knlist *knl, struct mtx *lock)
Definition: kern_event.c:2564
malloc
void *() malloc(size_t size, struct malloc_type *mtp, int flags)
Definition: kern_malloc.c:632
malloc_domainset
void * malloc_domainset(size_t size, struct malloc_type *mtp, struct domainset *ds, int flags)
Definition: kern_malloc.c:705
free
void free(void *addr, struct malloc_type *mtp)
Definition: kern_malloc.c:907
Giant
struct mtx __exclusive_cache_line Giant
Definition: kern_mutex.c:181
priv_check
int priv_check(struct thread *td, int priv)
Definition: kern_priv.c:271
panic
void panic(const char *fmt,...)
Definition: kern_shutdown.c:884
pgsigio
void pgsigio(struct sigio **sigiop, int sig, int checkctty)
Definition: kern_sig.c:4041
sysctl_ctx_free
int sysctl_ctx_free(struct sysctl_ctx_list *clist)
Definition: kern_sysctl.c:608
sysctl_rename_oid
void sysctl_rename_oid(struct sysctl_oid *oidp, const char *name)
Definition: kern_sysctl.c:924
sysctl_handle_int
int sysctl_handle_int(SYSCTL_HANDLER_ARGS)
Definition: kern_sysctl.c:1644
sysctl_ctx_init
int sysctl_ctx_init(struct sysctl_ctx_list *c)
Definition: kern_sysctl.c:590
sbuf_new_for_sysctl
struct sbuf * sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length, struct sysctl_req *req)
Definition: kern_sysctl.c:2503
result
linker_file_t * result
Definition: linker_if.m:148
start
void *** start
Definition: linker_if.m:98
value
caddr_t value
Definition: linker_if.m:63
domain
struct iommu_domain ** domain
Definition: msi_if.m:96
child
device_t child
Definition: msi_if.m:58
data
uint32_t * data
Definition: msi_if.m:90
addr
uint64_t * addr
Definition: msi_if.m:89
src
struct intr_irqsrc ** src
Definition: msi_if.m:76
res
struct resource * res
Definition: pic_if.m:98
_device
Implementation of _device.
Definition: subr_bus.c:121
_device::KOBJ_FIELDS
KOBJ_FIELDS
Definition: subr_bus.c:126
dev_event_info
Definition: subr_bus.c:400
dev_softc
Definition: subr_bus.c:407
dev_softc::async
int async
Definition: subr_bus.c:411
dev_softc::nonblock
int nonblock
Definition: subr_bus.c:409
dev_softc::sel
struct selinfo sel
Definition: subr_bus.c:414
dev_softc::queued
int queued
Definition: subr_bus.c:410
dev_softc::sigio
struct sigio * sigio
Definition: subr_bus.c:416
dev_softc::inuse
int inuse
Definition: subr_bus.c:408
dev_softc::mtx
struct mtx mtx
Definition: subr_bus.c:412
dev_softc::cv
struct cv cv
Definition: subr_bus.c:413
dev_softc::zone
uma_zone_t zone
Definition: subr_bus.c:417
dev_softc::devq
struct devq devq
Definition: subr_bus.c:415
device_location_node
Definition: subr_bus.c:6137
device_location_node::dln_path
const char * dln_path
Definition: subr_bus.c:6139
device_location_node::dln_locator
const char * dln_locator
Definition: subr_bus.c:6138
config_intrhook_oneshot
void config_intrhook_oneshot(ich_func_t func, void *arg)
Definition: subr_autoconf.c:221
bus_helper_reset_prepare_rollback
static void bus_helper_reset_prepare_rollback(device_t dev, device_t child, int flags)
Definition: subr_bus.c:3986
next_matching_driver
static driverlink_t next_matching_driver(devclass_t dc, device_t dev, driverlink_t last)
Definition: subr_bus.c:2087
bus_translate_resource
int bus_translate_resource(device_t dev, int type, rman_res_t start, rman_res_t *newstart)
Wrapper function for BUS_TRANSLATE_RESOURCE().
Definition: subr_bus.c:4803
devctl_queue
static void devctl_queue(struct dev_event_info *dei)
Definition: subr_bus.c:664
device_set_ivars
void device_set_ivars(device_t dev, void *ivars)
Set the device's ivars field.
Definition: subr_bus.c:2630
resource_list_add
struct resource_list_entry * resource_list_add(struct resource_list *rl, int type, int rid, rman_res_t start, rman_res_t end, rman_res_t count)
Add or modify a resource entry.
Definition: subr_bus.c:3274
root_bus
device_t root_bus
Definition: subr_bus.c:5287
bus_get_dma_tag
bus_dma_tag_t bus_get_dma_tag(device_t dev)
Wrapper function for BUS_GET_DMA_TAG().
Definition: subr_bus.c:5161
devclasses
static devclass_list_t devclasses
Definition: subr_bus.c:989
bus_generic_get_resource_list
struct resource_list * bus_generic_get_resource_list(device_t dev, device_t child)
Stub function for implementing BUS_GET_RESOURCE_LIST().
Definition: subr_bus.c:4168
print_driver_short
#define print_driver_short(d, i)
Definition: subr_bus.c:204
bus_generic_driver_added
void bus_generic_driver_added(device_t dev, driver_t *driver)
Helper function for implementing BUS_DRIVER_ADDED().
Definition: subr_bus.c:4181
bus_deactivate_resource
int bus_deactivate_resource(device_t dev, int type, int rid, struct resource *r)
Wrapper function for BUS_DEACTIVATE_RESOURCE().
Definition: subr_bus.c:4832
bus_alloc_resources
int bus_alloc_resources(device_t dev, struct resource_spec *rs, struct resource **res)
Definition: subr_bus.c:4730
passes
static driver_list_t passes
Definition: subr_bus.c:902
bus_generic_translate_resource
int bus_generic_translate_resource(device_t dev, int type, rman_res_t start, rman_res_t *newstart)
Definition: subr_bus.c:4311
print_device_tree_short
#define print_device_tree_short(d, i)
Definition: subr_bus.c:202
driver_register_pass
static void driver_register_pass(struct driverlink *new)
Register the pass level of a new driver attachment.
Definition: subr_bus.c:916
devclass_get_devices
int devclass_get_devices(devclass_t dc, device_t **devlistp, int *devcountp)
Get a list of devices in the devclass.
Definition: subr_bus.c:1475
devclass_get_device
device_t devclass_get_device(devclass_t dc, int unit)
Find a device given a unit number.
Definition: subr_bus.c:1429
devclass_get_drivers
int devclass_get_drivers(devclass_t dc, driver_t ***listp, int *countp)
Get a list of drivers in the devclass.
Definition: subr_bus.c:1516
bus_data_generation
static int bus_data_generation
Definition: subr_bus.c:862
device_is_enabled
int device_is_enabled(device_t dev)
Return non-zero if the DF_ENABLED flag is set on the device.
Definition: subr_bus.c:2772
root_resume
static int root_resume(device_t dev)
Definition: subr_bus.c:5202
bus_generic_child_location
int bus_generic_child_location(device_t dev, device_t child, struct sbuf *sb)
Generic implementation that does nothing for bus_child_location.
Definition: subr_bus.c:5132
device_is_suspended
int device_is_suspended(device_t dev)
Return non-zero if the device is currently suspended.
Definition: subr_bus.c:2800
device_get_desc
const char * device_get_desc(device_t dev)
Return the device's description string.
Definition: subr_bus.c:2373
bus_suspend_intr
int bus_suspend_intr(device_t dev, struct resource *r)
Wrapper function for BUS_SUSPEND_INTR().
Definition: subr_bus.c:4930
device_delete_children
int device_delete_children(device_t dev)
Delete all children devices of the given device, if any.
Definition: subr_bus.c:2015
bus_generic_rl_release_resource
int bus_generic_rl_release_resource(device_t dev, device_t child, int type, int rid, struct resource *r)
Helper function for implementing BUS_RELEASE_RESOURCE().
Definition: subr_bus.c:4602
device_sysctl_update
static void device_sysctl_update(device_t dev)
Definition: subr_bus.c:343
devctl_notify
void devctl_notify(const char *system, const char *subsystem, const char *type, const char *data)
Send a 'notification' to userland, using standard ways.
Definition: subr_bus.c:681
device_set_devclass_fixed
int device_set_devclass_fixed(device_t dev, const char *classname)
Set the devclass of a device and mark the devclass fixed.
Definition: subr_bus.c:2841
bus_generic_resume
int bus_generic_resume(device_t dev)
Helper function for implementing DEVICE_RESUME()
Definition: subr_bus.c:3946
dev_wired_cache_init
device_location_cache_t * dev_wired_cache_init(void)
Definition: subr_bus.c:6153
devclass_driver_added
static void devclass_driver_added(devclass_t dc, driver_t *driver)
Register that a device driver has been added to a devclass.
Definition: subr_bus.c:1099
devctl_alloc_dei
static struct dev_event_info * devctl_alloc_dei(void)
Definition: subr_bus.c:614
device_set_driver
int device_set_driver(device_t dev, driver_t *driver)
Set the driver of a device.
Definition: subr_bus.c:2873
device_get_state
device_state_t device_get_state(device_t dev)
Return the device's state.
Definition: subr_bus.c:2640
device_get_path
static char * device_get_path(device_t dev, const char *locator)
Definition: subr_bus.c:5812
device_get_children
int device_get_children(device_t dev, device_t **devlistp, int *devcountp)
Get a list of children of a device.
Definition: subr_bus.c:2285
bus_generic_get_cpus
int bus_generic_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize, cpuset_t *cpuset)
Helper function for implementing BUS_GET_CPUS().
Definition: subr_bus.c:4479
device_probe
int device_probe(device_t dev)
Probe a device, and return this status.
Definition: subr_bus.c:2943
device_quiet_children
void device_quiet_children(device_t dev)
Set the DF_QUIET_CHILDREN flag for the device.
Definition: subr_bus.c:2705
resource_list_find
struct resource_list_entry * resource_list_find(struct resource_list *rl, int type, int rid)
Find a resource entry by type and rid.
Definition: subr_bus.c:3364
SYSCTL_NODE
SYSCTL_NODE(_hw, OID_AUTO, bus, CTLFLAG_RW|CTLFLAG_MPSAFE, NULL, NULL)
root_driver
static driver_t root_driver
Definition: subr_bus.c:5281
device_get_property
ssize_t device_get_property(device_t dev, const char *prop, void *val, size_t sz, device_property_type_t type)
Definition: subr_bus.c:2720
device_frozen
static bool device_frozen
Definition: subr_bus.c:164
device_detach
int device_detach(device_t dev)
Detach a driver from a device.
Definition: subr_bus.c:3075
bus_generic_suspend
int bus_generic_suspend(device_t dev)
Helper function for implementing DEVICE_SUSPEND()
Definition: subr_bus.c:3913
devremoved
static void devremoved(device_t dev)
Definition: subr_bus.c:781
root_get_cpus
static int root_get_cpus(device_t dev, device_t child, enum cpu_sets op, size_t setsize, cpuset_t *cpuset)
Definition: subr_bus.c:5249
bus_data_generation_update
void bus_data_generation_update(void)
Definition: subr_bus.c:5692
device_sysctl_handler
static int device_sysctl_handler(SYSCTL_HANDLER_ARGS)
Definition: subr_bus.c:262
print_devclass_list_short
#define print_devclass_list_short()
Definition: subr_bus.c:209
root_devclass
devclass_t root_devclass
Definition: subr_bus.c:5288
bus_generic_config_intr
int bus_generic_config_intr(device_t dev, int irq, enum intr_trigger trig, enum intr_polarity pol)
Helper function for implementing BUS_CONFIG_INTR().
Definition: subr_bus.c:4446
bus_generic_get_device_path
int bus_generic_get_device_path(device_t bus, device_t child, const char *locator, struct sbuf *sb)
Helper function to implement normal BUS_GET_DEVICE_PATH()
Definition: subr_bus.c:4676
devclass_sysctl_handler
static int devclass_sysctl_handler(SYSCTL_HANDLER_ARGS)
Definition: subr_bus.c:222
DEVCLASS_SYSCTL_PARENT
@ DEVCLASS_SYSCTL_PARENT
Definition: subr_bus.c:218
bus_delete_resource
void bus_delete_resource(device_t dev, int type, int rid)
Wrapper function for BUS_DELETE_RESOURCE().
Definition: subr_bus.c:5062
device_do_deferred_actions
static void device_do_deferred_actions(void)
Definition: subr_bus.c:5782
DEFINE_CLASS
DEFINE_CLASS(null, null_methods, 0)
devclass_get_maxunit
int devclass_get_maxunit(devclass_t dc)
Get the maximum unit number used in a devclass.
Definition: subr_bus.c:1567
devread
static d_read_t devread
Definition: subr_bus.c:383
bus_child_pnpinfo
int bus_child_pnpinfo(device_t child, struct sbuf *sb)
Wrapper function for BUS_CHILD_PNPINFO().
Definition: subr_bus.c:5086
bus_generic_release_resource
int bus_generic_release_resource(device_t dev, device_t child, int type, int rid, struct resource *r)
Helper function for implementing BUS_RELEASE_RESOURCE().
Definition: subr_bus.c:4345
bus_topo_lock
void bus_topo_lock(void)
Definition: subr_bus.c:885
EVENTHANDLER_LIST_DEFINE
EVENTHANDLER_LIST_DEFINE(device_attach)
bus_generic_get_bus_tag
bus_space_tag_t bus_generic_get_bus_tag(device_t dev, device_t child)
Helper function for implementing BUS_GET_BUS_TAG().
Definition: subr_bus.c:4510
bus_child_location
int bus_child_location(device_t child, struct sbuf *sb)
Wrapper function for BUS_CHILD_LOCATION().
Definition: subr_bus.c:5115
resource_init_map_request_impl
void resource_init_map_request_impl(struct resource_map_request *args, size_t sz)
Definition: subr_bus.c:3193
filt_devctl_read
static int filt_devctl_read(struct knote *kn, long hint)
Definition: subr_bus.c:598
devclass_get_count
int devclass_get_count(devclass_t dc)
Get the number of devices in a devclass.
Definition: subr_bus.c:1546
dev_wired_cache_lookup
static struct device_location_node * dev_wired_cache_lookup(device_location_cache_t *dcp, const char *locator)
Definition: subr_bus.c:6177
DL_DEFERRED_PROBE
#define DL_DEFERRED_PROBE
bus_topo_unlock
void bus_topo_unlock(void)
Definition: subr_bus.c:892
devctl2_ioctl
static int devctl2_ioctl(struct cdev *cdev, u_long cmd, caddr_t data, int fflag, struct thread *td)
Definition: subr_bus.c:5835
device_is_attached
int device_is_attached(device_t dev)
Return non-zero if the device currently has a driver attached to it.
Definition: subr_bus.c:2791
bus_set_resource
int bus_set_resource(device_t dev, int type, int rid, rman_res_t start, rman_res_t count)
Wrapper function for BUS_SET_RESOURCE().
Definition: subr_bus.c:4994
devclass_set_parent
void devclass_set_parent(devclass_t dc, devclass_t pdc)
Set the parent of a devclass.
Definition: subr_bus.c:1603
bus_activate_resource
int bus_activate_resource(device_t dev, int type, int rid, struct resource *r)
Wrapper function for BUS_ACTIVATE_RESOURCE().
Definition: subr_bus.c:4818
device_set_softc
void device_set_softc(device_t dev, void *softc)
Set the device's softc field.
Definition: subr_bus.c:2572
device_set_desc_internal
static void device_set_desc_internal(device_t dev, const char *desc, int copy)
Definition: subr_bus.c:2497
STAILQ_HEAD
STAILQ_HEAD(devq, dev_event_info)
device_get_devclass
devclass_t device_get_devclass(device_t dev)
Return the current devclass for the device or NULL if there is none.
Definition: subr_bus.c:2332
resource_list_purge
void resource_list_purge(struct resource_list *rl)
Releases all the resources in a list.
Definition: subr_bus.c:3734
root_bus_configure
void root_bus_configure(void)
Automatically configure devices.
Definition: subr_bus.c:5330
bus_unmap_resource
int bus_unmap_resource(device_t dev, int type, struct resource *r, struct resource_map *map)
Wrapper function for BUS_UNMAP_RESOURCE().
Definition: subr_bus.c:4861
devctl_alloc_dei_sb
static struct dev_event_info * devctl_alloc_dei_sb(struct sbuf *sb)
Definition: subr_bus.c:647
bus_print_child_domain
int bus_print_child_domain(device_t dev, device_t child)
Helper function for implementing BUS_PRINT_CHILD().
Definition: subr_bus.c:4090
driver_module_handler
int driver_module_handler(module_t mod, int what, void *arg)
Module handler for registering device drivers.
Definition: subr_bus.c:5347
device_verbose
void device_verbose(device_t dev)
Clear the DF_QUIET flag for the device.
Definition: subr_bus.c:2714
_gone_in
void _gone_in(int major, const char *msg)
Definition: subr_bus.c:6259
device_quiet
void device_quiet(device_t dev)
Set the DF_QUIET flag for the device.
Definition: subr_bus.c:2696
SYSCTL_INT
SYSCTL_INT(_debug, OID_AUTO, obsolete_panic, CTLFLAG_RWTUN, &obsolete_panic, 0, "Panic when obsolete features are used (0 = never, 1 = if obsolete, " "2 = if deprecated)")
resource_list_release_active
int resource_list_release_active(struct resource_list *rl, device_t bus, device_t child, int type)
Release all active resources of a given type.
Definition: subr_bus.c:3619
device_probe_child
int device_probe_child(device_t dev, device_t child)
Definition: subr_bus.c:2103
device_set_desc_copy
void device_set_desc_copy(device_t dev, const char *desc)
Set the device's description.
Definition: subr_bus.c:2539
root_bus_module_handler
static int root_bus_module_handler(module_t mod, int what, void *arg)
Definition: subr_bus.c:5291
resource_list_init
void resource_list_init(struct resource_list *rl)
Initialise a resource list.
Definition: subr_bus.c:3206
resource_list_busy
int resource_list_busy(struct resource_list *rl, int type, int rid)
Determine if a resource entry is busy.
Definition: subr_bus.c:3314
bus_get_resource
int bus_get_resource(device_t dev, int type, int rid, rman_res_t *startp, rman_res_t *countp)
Wrapper function for BUS_GET_RESOURCE().
Definition: subr_bus.c:5008
bus_helper_reset_post
int bus_helper_reset_post(device_t dev, int flags)
Helper function for implementing BUS_RESET_POST.
Definition: subr_bus.c:3968
device_get_sysctl_tree
struct sysctl_oid * device_get_sysctl_tree(device_t dev)
Definition: subr_bus.c:2394
device_printf
int device_printf(device_t dev, const char *fmt,...)
Print the name of the device followed by a colon, a space and the result of calling vprintf() with th...
Definition: subr_bus.c:2422
devctl_dev
static struct cdev * devctl_dev
Definition: subr_bus.c:429
devctl2_cdevsw
static struct cdevsw devctl2_cdevsw
Definition: subr_bus.c:6121
bus_generic_suspend_child
int bus_generic_suspend_child(device_t dev, device_t child)
Default function for suspending a child device.
Definition: subr_bus.c:3877
device_add_child_ordered
device_t device_add_child_ordered(device_t dev, u_int order, const char *name, int unit)
Create a new device.
Definition: subr_bus.c:1919
bus_generic_get_dma_tag
bus_dma_tag_t bus_generic_get_dma_tag(device_t dev, device_t child)
Helper function for implementing BUS_GET_DMA_TAG().
Definition: subr_bus.c:4495
bus_bind_intr
int bus_bind_intr(device_t dev, struct resource *r, int cpu)
Wrapper function for BUS_BIND_INTR().
Definition: subr_bus.c:4958
device_set_devclass
int device_set_devclass(device_t dev, const char *classname)
Set the devclass of a device.
Definition: subr_bus.c:2810
bus_generic_activate_resource
int bus_generic_activate_resource(device_t dev, device_t child, int type, int rid, struct resource *r)
Helper function for implementing BUS_ACTIVATE_RESOURCE().
Definition: subr_bus.c:4362
device_enable
void device_enable(device_t dev)
Set the DF_ENABLED flag for the device.
Definition: subr_bus.c:2649
bus_get_bus_tag
bus_space_tag_t bus_get_bus_tag(device_t dev)
Wrapper function for BUS_GET_BUS_TAG().
Definition: subr_bus.c:5178
SYSCTL_ROOT_NODE
SYSCTL_ROOT_NODE(OID_AUTO, dev, CTLFLAG_RW|CTLFLAG_MPSAFE, NULL, NULL)
bus_generic_suspend_intr
int bus_generic_suspend_intr(device_t dev, device_t child, struct resource *irq)
Helper function for implementing BUS_SUSPEND_INTR().
Definition: subr_bus.c:4263
bus_adjust_resource
int bus_adjust_resource(device_t dev, int type, struct resource *r, rman_res_t start, rman_res_t end)
Wrapper function for BUS_ADJUST_RESOURCE().
Definition: subr_bus.c:4788
bus_generic_describe_intr
int bus_generic_describe_intr(device_t dev, device_t child, struct resource *irq, void *cookie, const char *descr)
Helper function for implementing BUS_DESCRIBE_INTR().
Definition: subr_bus.c:4462
find_device
static int find_device(struct devreq *req, device_t *devp)
Definition: subr_bus.c:5723
bus_print_child_header
int bus_print_child_header(device_t dev, device_t child)
Helper function for implementing BUS_PRINT_CHILD().
Definition: subr_bus.c:4054
resource_list_reserved
int resource_list_reserved(struct resource_list *rl, int type, int rid)
Determine if a resource entry is reserved.
Definition: subr_bus.c:3343
device_sysctl_init
static void device_sysctl_init(device_t dev)
Definition: subr_bus.c:299
make_device
static device_t make_device(device_t parent, const char *name, int unit)
Make a new device and add it as a child of parent.
Definition: subr_bus.c:1803
device_has_quiet_children
int device_has_quiet_children(device_t dev)
Return non-zero if the DF_QUIET_CHIDLREN flag is set on the device.
Definition: subr_bus.c:2754
bus_resume_intr
int bus_resume_intr(device_t dev, struct resource *r)
Wrapper function for BUS_RESUME_INTR().
Definition: subr_bus.c:4944
devclass_get_parent
devclass_t devclass_get_parent(devclass_t dc)
Get the parent of a devclass.
Definition: subr_bus.c:1614
bus_generic_write_ivar
int bus_generic_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
Stub function for implementing BUS_WRITE_IVAR().
Definition: subr_bus.c:4139
PDEBUG
#define PDEBUG(a)
Definition: subr_bus.c:197
bus_generic_resume_intr
int bus_generic_resume_intr(device_t dev, device_t child, struct resource *irq)
Helper function for implementing BUS_RESUME_INTR().
Definition: subr_bus.c:4278
SYSCTL_PROC
SYSCTL_PROC(_hw_bus, OID_AUTO, devctl_queue, CTLTYPE_INT|CTLFLAG_RWTUN|CTLFLAG_MPSAFE, NULL, 0, sysctl_devctl_queue, "I", "devctl queue length")
bus_child_present
int bus_child_present(device_t child)
Wrapper function for BUS_CHILD_PRESENT().
Definition: subr_bus.c:5074
gone_panic
static void gone_panic(int major, int running, const char *msg)
Definition: subr_bus.c:6243
device_get_parent
device_t device_get_parent(device_t dev)
Return the parent of a device.
Definition: subr_bus.c:2263
devclass_driver_deleted
static int devclass_driver_deleted(devclass_t busclass, devclass_t dc, driver_t *driver)
Register that a device driver has been deleted from a devclass.
Definition: subr_bus.c:1211
devctl2_init
static void devctl2_init(void)
Definition: subr_bus.c:6128
devclass_find_driver_internal
static driverlink_t devclass_find_driver_internal(devclass_t dc, const char *classname)
Definition: subr_bus.c:1395
root_bus_mod
static moduledata_t root_bus_mod
Definition: subr_bus.c:5316
driverlink_t
struct driverlink * driverlink_t
Definition: subr_bus.c:84
print_device
#define print_device(d, i)
Definition: subr_bus.c:201
resource_list_reserve
struct resource * resource_list_reserve(struct resource_list *rl, device_t bus, device_t child, int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
Allocate a reserved resource.
Definition: subr_bus.c:3432
devctl_process_running
bool devctl_process_running(void)
Return whether the userland process is running.
Definition: subr_bus.c:608
bus_generic_new_pass
void bus_generic_new_pass(device_t dev)
Helper function for implementing BUS_NEW_PASS().
Definition: subr_bus.c:4203
bus_generic_add_child
device_t bus_generic_add_child(device_t dev, u_int order, const char *name, int unit)
Definition: subr_bus.c:3748
dev_cdevsw
static struct cdevsw dev_cdevsw
Definition: subr_bus.c:388
bus_generic_attach
int bus_generic_attach(device_t dev)
Helper function for implementing DEVICE_ATTACH()
Definition: subr_bus.c:3793
devnomatch
static void devnomatch(device_t dev)
Definition: subr_bus.c:794
root_setup_intr
static int root_setup_intr(device_t dev, device_t child, struct resource *irq, int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)
Definition: subr_bus.c:5226
bus_map_resource
int bus_map_resource(device_t dev, int type, struct resource *r, struct resource_map_request *args, struct resource_map *map)
Wrapper function for BUS_MAP_RESOURCE().
Definition: subr_bus.c:4846
device_set_desc
void device_set_desc(device_t dev, const char *desc)
Set the device's description.
Definition: subr_bus.c:2527
devioctl
static d_ioctl_t devioctl
Definition: subr_bus.c:384
devclass_sysctl_init
static void devclass_sysctl_init(devclass_t dc)
Definition: subr_bus.c:238
bus_enumerate_hinted_children
void bus_enumerate_hinted_children(device_t bus)
Enumerate all hinted devices for this bus.
Definition: subr_bus.c:5410
dev_wired_cache_match
bool dev_wired_cache_match(device_location_cache_t *dcp, device_t dev, const char *at)
Definition: subr_bus.c:6205
device_get_unit
int device_get_unit(device_t dev)
Return the device's unit number.
Definition: subr_bus.c:2364
bus_generic_deactivate_resource
int bus_generic_deactivate_resource(device_t dev, device_t child, int type, int rid, struct resource *r)
Helper function for implementing BUS_DEACTIVATE_RESOURCE().
Definition: subr_bus.c:4379
sysctl_bus_info
static int sysctl_bus_info(SYSCTL_HANDLER_ARGS)
Definition: subr_bus.c:5602
driver_exists
static bool driver_exists(device_t bus, const char *driver)
Definition: subr_bus.c:5753
root_print_child
static int root_print_child(device_t dev, device_t child)
Definition: subr_bus.c:5215
devclass_get_sysctl_tree
struct sysctl_oid * devclass_get_sysctl_tree(devclass_t dc)
Definition: subr_bus.c:1626
bus_get_resource_start
rman_res_t bus_get_resource_start(device_t dev, int type, int rid)
Wrapper function for BUS_GET_RESOURCE().
Definition: subr_bus.c:5022
bus_null_rescan
int bus_null_rescan(device_t dev)
Helper function for implementing BUS_RESCAN().
Definition: subr_bus.c:4716
bus_teardown_intr
int bus_teardown_intr(device_t dev, struct resource *r, void *cookie)
Wrapper function for BUS_TEARDOWN_INTR().
Definition: subr_bus.c:4916
DEVCTL_BUFFER
#define DEVCTL_BUFFER
Definition: subr_bus.c:399
devinit
static void devinit(void)
Definition: subr_bus.c:432
print_driver_list
#define print_driver_list(d, i)
Definition: subr_bus.c:206
devctl_free_dei
static void devctl_free_dei(struct dev_event_info *dei)
Definition: subr_bus.c:658
__FBSDID
__FBSDID("$FreeBSD$")
bus_generic_rl_delete_resource
void bus_generic_rl_delete_resource(device_t dev, device_t child, int type, int rid)
Helper function for implementing BUS_DELETE_RESOURCE().
Definition: subr_bus.c:4581
print_devclass_short
#define print_devclass_short(d, i)
Definition: subr_bus.c:207
device_find_child
device_t device_find_child(device_t dev, const char *classname, int unit)
Find a device given a unit number.
Definition: subr_bus.c:2049
bus_generic_get_domain
int bus_generic_get_domain(device_t dev, device_t child, int *domain)
Definition: subr_bus.c:4656
device_set_flags
void device_set_flags(device_t dev, uint32_t flags)
Set the device's flags.
Definition: subr_bus.c:2548
bus_generic_get_property
ssize_t bus_generic_get_property(device_t dev, device_t child, const char *propname, void *propvalue, size_t size, device_property_type_t type)
Helper function for implementing BUS_GET_PROPERTY().
Definition: subr_bus.c:4152
device_add_child
device_t device_add_child(device_t dev, const char *name, int unit)
Create a new device.
Definition: subr_bus.c:1893
device_unbusy
void device_unbusy(device_t dev)
Decrement the busy counter for the device.
Definition: subr_bus.c:2682
device_claim_softc
void device_claim_softc(device_t dev)
Claim softc.
Definition: subr_bus.c:2604
bus_get_domain
int bus_get_domain(device_t dev, int *domain)
Wrapper function for BUS_GET_DOMAIN().
Definition: subr_bus.c:5195
print_devclass
#define print_devclass(d, i)
Definition: subr_bus.c:208
devclass_add_driver
int devclass_add_driver(devclass_t dc, driver_t *driver, int pass, devclass_t *dcp)
Add a device driver to a device class.
Definition: subr_bus.c:1140
bus_describe_intr
int bus_describe_intr(device_t dev, struct resource *irq, void *cookie, const char *fmt,...)
Wrapper function for BUS_DESCRIBE_INTR().
Definition: subr_bus.c:4973
resource_list_free
void resource_list_free(struct resource_list *rl)
Reclaim memory used by a resource list.
Definition: subr_bus.c:3220
bus_generic_rl_set_resource
int bus_generic_rl_set_resource(device_t dev, device_t child, int type, int rid, rman_res_t start, rman_res_t count)
Helper function for implementing BUS_SET_RESOURCE().
Definition: subr_bus.c:4558
bus_delayed_attach_children
int bus_delayed_attach_children(device_t dev)
Helper function for delaying attaching children.
Definition: subr_bus.c:3812
devkqfilter
static d_kqfilter_t devkqfilter
Definition: subr_bus.c:386
print_device_short
#define print_device_short(d, i)
Definition: subr_bus.c:200
MALLOC_DEFINE
static MALLOC_DEFINE(M_BUS, "bus", "Bus data structures")
device_busy
void device_busy(device_t dev)
Increment the busy counter for the device.
Definition: subr_bus.c:2667
DEVCTL_DEFAULT_QUEUE_LEN
#define DEVCTL_DEFAULT_QUEUE_LEN
Definition: subr_bus.c:375
device_delete_child
int device_delete_child(device_t dev, device_t child)
Delete a device.
Definition: subr_bus.c:1971
bus_setup_intr
int bus_setup_intr(device_t dev, struct resource *r, int flags, driver_filter_t filter, driver_intr_t handler, void *arg, void **cookiep)
Wrapper function for BUS_SETUP_INTR().
Definition: subr_bus.c:4893
DEVICENAME
#define DEVICENAME(d)
Definition: subr_bus.c:198
devclose
static d_close_t devclose
Definition: subr_bus.c:382
device_is_devclass_fixed
bool device_is_devclass_fixed(device_t dev)
Query the device to determine if it's of a fixed devclass.
Definition: subr_bus.c:2860
devsoftc
static struct dev_softc devsoftc
device_log
int device_log(device_t dev, int pri, const char *fmt,...)
Print the name of the device followed by a colon, a space and the result of calling log() with the va...
Definition: subr_bus.c:2460
bus_generic_teardown_intr
int bus_generic_teardown_intr(device_t dev, device_t child, struct resource *irq, void *cookie)
Helper function for implementing BUS_TEARDOWN_INTR().
Definition: subr_bus.c:4247
bus_release_resources
void bus_release_resources(device_t dev, const struct resource_spec *rs, struct resource **res)
Definition: subr_bus.c:4749
devclass_get_sysctl_ctx
struct sysctl_ctx_list * devclass_get_sysctl_ctx(devclass_t dc)
Definition: subr_bus.c:1620
DEVCLANAME
#define DEVCLANAME(d)
Definition: subr_bus.c:167
devclass_alloc_unit
static int devclass_alloc_unit(devclass_t dc, device_t dev, int *unitp)
Allocate a unit number.
Definition: subr_bus.c:1647
resource_list_release
int resource_list_release(struct resource_list *rl, device_t bus, device_t child, int type, int rid, struct resource *res)
Helper function for implementing BUS_RELEASE_RESOURCE()
Definition: subr_bus.c:3562
device_sysctl_fini
static void device_sysctl_fini(device_t dev)
Definition: subr_bus.c:353
devclass_delete_driver
int devclass_delete_driver(devclass_t busclass, driver_t *driver)
Delete a device driver from a device class.
Definition: subr_bus.c:1285
print_driver
#define print_driver(d, i)
Definition: subr_bus.c:205
devclass_find_free_unit
int devclass_find_free_unit(devclass_t dc, int unit)
Find a free unit number in a devclass.
Definition: subr_bus.c:1584
root_methods
static kobj_method_t root_methods[]
Definition: subr_bus.c:5264
bus_generic_bind_intr
int bus_generic_bind_intr(device_t dev, device_t child, struct resource *irq, int cpu)
Helper function for implementing BUS_BIND_INTR().
Definition: subr_bus.c:4430
DRIVERNAME
#define DRIVERNAME(d)
Definition: subr_bus.c:166
bus_generic_map_resource
int bus_generic_map_resource(device_t dev, device_t child, int type, struct resource *r, struct resource_map_request *args, struct resource_map *map)
Helper function for implementing BUS_MAP_RESOURCE().
Definition: subr_bus.c:4396
resource_list_add_next
int resource_list_add_next(struct resource_list *rl, int type, rman_res_t start, rman_res_t end, rman_res_t count)
Add a resource entry.
Definition: subr_bus.c:3246
devclass_quiesce_driver
static int devclass_quiesce_driver(devclass_t busclass, driver_t *driver)
Quiesces a set of device drivers from a device class.
Definition: subr_bus.c:1340
device_get_sysctl_ctx
struct sysctl_ctx_list * device_get_sysctl_ctx(device_t dev)
Definition: subr_bus.c:2388
bus_get_resource_count
rman_res_t bus_get_resource_count(device_t dev, int type, int rid)
Wrapper function for BUS_GET_RESOURCE().
Definition: subr_bus.c:5042
device_get_driver
driver_t * device_get_driver(device_t dev)
Return the current driver for the device or NULL if there is no driver currently attached.
Definition: subr_bus.c:2322
devclass_find_internal
static devclass_t devclass_find_internal(const char *classname, const char *parentname, int create)
Find or create a device class.
Definition: subr_bus.c:1007
bus_generic_shutdown
int bus_generic_shutdown(device_t dev)
Helper function for implementing DEVICE_SHUTDOWN()
Definition: subr_bus.c:3856
resource_list_print_type
int resource_list_print_type(struct resource_list *rl, const char *name, int type, const char *format)
Print a description of resources in a resource list.
Definition: subr_bus.c:3699
bus_helper_reset_prepare
int bus_helper_reset_prepare(device_t dev, int flags)
Helper function for implementing BUS_RESET_PREPARE.
Definition: subr_bus.c:4012
devctl_queue_length
static int devctl_queue_length
Definition: subr_bus.c:377
devclass_delete_device
static int devclass_delete_device(devclass_t dc, device_t dev)
Delete a device from a devclass.
Definition: subr_bus.c:1771
bus_topo_mtx
struct mtx * bus_topo_mtx(void)
Definition: subr_bus.c:878
device_attach
int device_attach(device_t dev)
Attach a device driver to a device.
Definition: subr_bus.c:3015
DEVICE_SYSCTL_PNPINFO
@ DEVICE_SYSCTL_PNPINFO
Definition: subr_bus.c:257
DEVICE_SYSCTL_LOCATION
@ DEVICE_SYSCTL_LOCATION
Definition: subr_bus.c:256
DEVICE_SYSCTL_DRIVER
@ DEVICE_SYSCTL_DRIVER
Definition: subr_bus.c:255
DEVICE_SYSCTL_DESC
@ DEVICE_SYSCTL_DESC
Definition: subr_bus.c:254
DEVICE_SYSCTL_PARENT
@ DEVICE_SYSCTL_PARENT
Definition: subr_bus.c:258
devclass_add_device
static int devclass_add_device(devclass_t dc, device_t dev)
Add a device to a devclass.
Definition: subr_bus.c:1733
print_devclass_list
#define print_devclass_list()
Definition: subr_bus.c:210
device_probe_and_attach
int device_probe_and_attach(device_t dev)
Probe a device and attach a driver if possible.
Definition: subr_bus.c:2977
resource_list_alloc
struct resource * resource_list_alloc(struct resource_list *rl, device_t bus, device_t child, int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
Helper function for implementing BUS_ALLOC_RESOURCE()
Definition: subr_bus.c:3489
device_print_prettyname
int device_print_prettyname(device_t dev)
Print the name of the device followed by a colon and a space.
Definition: subr_bus.c:2405
devaddq
static void devaddq(const char *type, const char *what, device_t dev)
Definition: subr_bus.c:727
bus_free_resource
int bus_free_resource(device_t dev, int type, struct resource *r)
Definition: subr_bus.c:5698
bus_generic_alloc_resource
struct resource * bus_generic_alloc_resource(device_t dev, device_t child, int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
Helper function for implementing BUS_ALLOC_RESOURCE().
Definition: subr_bus.c:4328
device_is_alive
int device_is_alive(device_t dev)
Return non-zero if the device was successfully probed.
Definition: subr_bus.c:2781
bus_generic_unmap_resource
int bus_generic_unmap_resource(device_t dev, device_t child, int type, struct resource *r, struct resource_map *map)
Helper function for implementing BUS_UNMAP_RESOURCE().
Definition: subr_bus.c:4414
device_quiesce
int device_quiesce(device_t dev)
Tells a driver to quiesce itself.
Definition: subr_bus.c:3131
device_get_ivars
void * device_get_ivars(device_t dev)
Get the device's ivars field.
Definition: subr_bus.c:2620
devclass_create
devclass_t devclass_create(const char *classname)
Create a device class.
Definition: subr_bus.c:1062
bus_generic_rl_get_resource
int bus_generic_rl_get_resource(device_t dev, device_t child, int type, int rid, rman_res_t *startp, rman_res_t *countp)
Helper function for implementing BUS_GET_RESOURCE().
Definition: subr_bus.c:4527
_gone_in_dev
void _gone_in_dev(device_t dev, int major, const char *msg)
Definition: subr_bus.c:6270
bus_data_devices
static struct device_list bus_data_devices
Definition: subr_bus.c:861
bus_generic_probe
int bus_generic_probe(device_t dev)
Helper function for implementing DEVICE_PROBE()
Definition: subr_bus.c:3762
devctl_safe_quote_sb
void devctl_safe_quote_sb(struct sbuf *sb, const char *src)
safely quotes strings that might have double quotes in them.
Definition: subr_bus.c:850
DC_HAS_CHILDREN
#define DC_HAS_CHILDREN
null_methods
static kobj_method_t null_methods[]
Definition: subr_bus.c:864
bus_generic_read_ivar
int bus_generic_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
Stub function for implementing BUS_READ_IVAR().
Definition: subr_bus.c:4127
device_gen_nomatch
static void device_gen_nomatch(device_t dev)
Definition: subr_bus.c:5765
first_matching_driver
static driverlink_t first_matching_driver(devclass_t dc, device_t dev)
Definition: subr_bus.c:2076
devclass_get_softc
void * devclass_get_softc(devclass_t dc, int unit)
Find the softc field of a device given a unit number.
Definition: subr_bus.c:1447
device_is_quiet
int device_is_quiet(device_t dev)
Return non-zero if the DF_QUIET flag is set on the device.
Definition: subr_bus.c:2763
dev_wired_cache_fini
void dev_wired_cache_fini(device_location_cache_t *dcp)
Definition: subr_bus.c:6164
obsolete_panic
static int obsolete_panic
Definition: subr_bus.c:6237
dev_wired_cache_add
static struct device_location_node * dev_wired_cache_add(device_location_cache_t *dcp, const char *locator, const char *path)
Definition: subr_bus.c:6190
device_shutdown
int device_shutdown(device_t dev)
Notify a device of system shutdown.
Definition: subr_bus.c:3151
devadded
static void devadded(device_t dev)
Definition: subr_bus.c:771
sysctl_devices
static int sysctl_devices(SYSCTL_HANDLER_ARGS)
Definition: subr_bus.c:5616
bus_topo_assert
void bus_topo_assert()
Definition: subr_bus.c:871
bus_generic_adjust_resource
int bus_generic_adjust_resource(device_t dev, device_t child, int type, struct resource *r, rman_res_t start, rman_res_t end)
Helper function for implementing BUS_ADJUST_RESOURCE().
Definition: subr_bus.c:4293
device_set_unit
int device_set_unit(device_t dev, int unit)
Set the unit number of a device.
Definition: subr_bus.c:3165
bus_generic_child_pnpinfo
int bus_generic_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb)
Generic implementation that does nothing for bus_child_pnpinfo.
Definition: subr_bus.c:5103
resource_list_delete
void resource_list_delete(struct resource_list *rl, int type, int rid)
Delete a resource entry.
Definition: subr_bus.c:3383
bus_alloc_resource
struct resource * bus_alloc_resource(device_t dev, int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
Wrapper function for BUS_ALLOC_RESOURCE().
Definition: subr_bus.c:4769
bus_data_generation_check
int bus_data_generation_check(int generation)
Definition: subr_bus.c:5682
device_get_name
const char * device_get_name(device_t dev)
Return the name of the device's devclass or NULL if there is none.
Definition: subr_bus.c:2342
device_free_softc
void device_free_softc(void *softc)
Free claimed softc.
Definition: subr_bus.c:2590
device_get_softc
void * device_get_softc(device_t dev)
Return the device's softc field.
Definition: subr_bus.c:2560
bus_generic_child_present
int bus_generic_child_present(device_t dev, device_t child)
Helper function for implementing BUS_CHILD_PRESENT().
Definition: subr_bus.c:4650
bus_get_cpus
int bus_get_cpus(device_t dev, enum cpu_sets op, size_t setsize, cpuset_t *cpuset)
Wrapper function for BUS_GET_CPUS().
Definition: subr_bus.c:5144
device_lookup_by_name
device_t device_lookup_by_name(const char *name)
Definition: subr_bus.c:5706
bus_release_resource
int bus_release_resource(device_t dev, int type, int rid, struct resource *r)
Wrapper function for BUS_RELEASE_RESOURCE().
Definition: subr_bus.c:4876
resource_list_unreserve
int resource_list_unreserve(struct resource_list *rl, device_t bus, device_t child, int type, int rid)
Fully release a reserved resource.
Definition: subr_bus.c:3661
bus_generic_rl_alloc_resource
struct resource * bus_generic_rl_alloc_resource(device_t dev, device_t child, int type, int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
Helper function for implementing BUS_ALLOC_RESOURCE().
Definition: subr_bus.c:4626
bus_generic_detach
int bus_generic_detach(device_t dev)
Helper function for implementing DEVICE_DETACH()
Definition: subr_bus.c:3828
device_has_property
bool device_has_property(device_t dev, const char *prop)
Definition: subr_bus.c:2745
bus_current_pass
int bus_current_pass
Definition: subr_bus.c:903
bus_set_pass
void bus_set_pass(int pass)
Raise the current bus pass.
Definition: subr_bus.c:948
bus_generic_resume_child
int bus_generic_resume_child(device_t dev, device_t child)
Default function for resuming a child device.
Definition: subr_bus.c:3895
devclass_find
devclass_t devclass_find(const char *classname)
Find a device class.
Definition: subr_bus.c:1076
bus_generic_setup_intr
int bus_generic_setup_intr(device_t dev, device_t child, struct resource *irq, int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg, void **cookiep)
Helper function for implementing BUS_SETUP_INTR().
Definition: subr_bus.c:4229
device_print_child
static int device_print_child(device_t dev, device_t child)
Print a description of a device.
Definition: subr_bus.c:1864
devpoll
static d_poll_t devpoll
Definition: subr_bus.c:385
devclass_get_name
const char * devclass_get_name(devclass_t dc)
Return the name of the devclass.
Definition: subr_bus.c:1414
root_child_present
static int root_child_present(device_t dev, device_t child)
Definition: subr_bus.c:5243
device_disable
void device_disable(device_t dev)
Clear the DF_ENABLED flag for the device.
Definition: subr_bus.c:2658
device_get_nameunit
const char * device_get_nameunit(device_t dev)
Return a string containing the device's devclass name followed by an ascii representation of the devi...
Definition: subr_bus.c:2355
device_get_flags
uint32_t device_get_flags(device_t dev)
Return the device's flags.
Definition: subr_bus.c:2382
devctl_rfiltops
struct filterops devctl_rfiltops
Definition: subr_bus.c:423
sysctl_devctl_queue
static int sysctl_devctl_queue(SYSCTL_HANDLER_ARGS)
Definition: subr_bus.c:800
print_device_tree
#define print_device_tree(d, i)
Definition: subr_bus.c:203
bus_generic_print_child
int bus_generic_print_child(device_t dev, device_t child)
Helper function for implementing BUS_PRINT_CHILD().
Definition: subr_bus.c:4110
DECLARE_MODULE
DECLARE_MODULE(rootbus, root_bus_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST)
TAILQ_HEAD
typedef TAILQ_HEAD(devclass_list, devclass)
Definition: subr_bus.c:97
filt_devctl_detach
static void filt_devctl_detach(struct knote *kn)
Definition: subr_bus.c:592
bus_print_child_footer
int bus_print_child_footer(device_t dev, device_t child)
Helper function for implementing BUS_PRINT_CHILD().
Definition: subr_bus.c:4077
devopen
static d_open_t devopen
Definition: subr_bus.c:381
resource_disabled
int resource_disabled(const char *name, int unit)
Definition: subr_hints.c:485
resource_unset_value
int resource_unset_value(const char *name, int unit, const char *resname)
Definition: subr_hints.c:501
resource_find_match
int resource_find_match(int *anchor, const char **name, int *unit, const char *resname, const char *value)
Definition: subr_hints.c:436
resource_string_value
int resource_string_value(const char *name, int unit, const char *resname, const char **result)
Definition: subr_hints.c:388
resource_int_value
int resource_int_value(const char *name, int unit, const char *resname, int *result)
Definition: subr_hints.c:341
kobj_init
void kobj_init(kobj_t obj, kobj_class_t cls)
Definition: subr_kobj.c:310
kobj_class_free
void kobj_class_free(kobj_class_t cls)
Definition: subr_kobj.c:233
kobj_delete
void kobj_delete(kobj_t obj, struct malloc_type *mtype)
Definition: subr_kobj.c:330
kobj_class_compile
void kobj_class_compile(kobj_class_t cls)
Definition: subr_kobj.c:157
vsnprintf
int vsnprintf(char *str, size_t size, const char *format, va_list ap)
Definition: subr_prf.c:565
sbuf_printf_drain
int sbuf_printf_drain(void *arg, const char *data, int len)
Definition: subr_prf.c:1298
printf
int printf(const char *fmt,...)
Definition: subr_prf.c:397
snprintf
int snprintf(char *str, size_t size, const char *format,...)
Definition: subr_prf.c:550
log
void log(int level, const char *fmt,...)
Definition: subr_prf.c:314
rman_get_device
device_t rman_get_device(struct resource *r)
Definition: subr_rman.c:955
rman_get_flags
u_int rman_get_flags(struct resource *r)
Definition: subr_rman.c:850
rman_get_end
rman_res_t rman_get_end(struct resource *r)
Definition: subr_rman.c:836
rman_get_rid
int rman_get_rid(struct resource *r)
Definition: subr_rman.c:941
rman_get_start
rman_res_t rman_get_start(struct resource *r)
Definition: subr_rman.c:822
sbuf_clear_flags
void sbuf_clear_flags(struct sbuf *s, int flags)
Definition: subr_sbuf.c:299
sbuf_finish
int sbuf_finish(struct sbuf *s)
Definition: subr_sbuf.c:833
sbuf_putc
int sbuf_putc(struct sbuf *s, int c)
Definition: subr_sbuf.c:754
sbuf_delete
void sbuf_delete(struct sbuf *s)
Definition: subr_sbuf.c:898
sbuf_printf
int sbuf_printf(struct sbuf *s, const char *fmt,...)
Definition: subr_sbuf.c:739
sbuf_set_drain
void sbuf_set_drain(struct sbuf *s, sbuf_drain_func *func, void *ctx)
Definition: subr_sbuf.c:376
sbuf_vprintf
int sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap)
Definition: subr_sbuf.c:650
sbuf_len
ssize_t sbuf_len(struct sbuf *s)
Definition: subr_sbuf.c:877
sbuf_data
char * sbuf_data(struct sbuf *s)
Definition: subr_sbuf.c:862
sbuf_cpy
int sbuf_cpy(struct sbuf *s, const char *str)
Definition: subr_sbuf.c:622
sbuf_new
struct sbuf * sbuf_new(struct sbuf *s, char *buf, int length, int flags)
Definition: subr_sbuf.c:196
sbuf_cat
int sbuf_cat(struct sbuf *s, const char *str)
Definition: subr_sbuf.c:566
all_cpus
cpuset_t all_cpus
Definition: subr_smp.c:70
flags
uint16_t flags
Definition: subr_stats.c:2
uiomove
int uiomove(void *cp, int n, struct uio *uio)
Definition: subr_uio.c:195
selrecord
void selrecord(struct thread *selector, struct selinfo *sip)
Definition: sys_generic.c:1869
selwakeup
void selwakeup(struct selinfo *sip)
Definition: sys_generic.c:1917
mtx
struct mtx mtx
Definition: uipc_ktls.c:0
path
const char * path
Definition: vfs_extattr.c:715
buf
struct stat * buf
Definition: vfs_syscalls.c:2423