Deleted Added
sdiff udiff text old ( 174280 ) new ( 177301 )
full compact
kern_conf.c (174280) kern_conf.c (177301)
1/*-
2 * Copyright (c) 1999-2002 Poul-Henning Kamp
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 1999-2002 Poul-Henning Kamp
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sys/kern/kern_conf.c 174280 2007-12-05 01:22:03Z thompsa $");
28__FBSDID("$FreeBSD: head/sys/kern/kern_conf.c 177301 2008-03-17 13:17:10Z kib $");
29
30#include <sys/param.h>
31#include <sys/kernel.h>
32#include <sys/systm.h>
33#include <sys/bio.h>
34#include <sys/lock.h>
35#include <sys/mutex.h>
36#include <sys/module.h>

--- 19 unchanged lines hidden (view full) ---

56 void (*cb)(void *), void *arg);
57static struct cdev *make_dev_credv(int flags,
58 struct cdevsw *devsw, int minornr,
59 struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt,
60 va_list ap);
61
62static struct cdev_priv_list cdevp_free_list =
63 TAILQ_HEAD_INITIALIZER(cdevp_free_list);
29
30#include <sys/param.h>
31#include <sys/kernel.h>
32#include <sys/systm.h>
33#include <sys/bio.h>
34#include <sys/lock.h>
35#include <sys/mutex.h>
36#include <sys/module.h>

--- 19 unchanged lines hidden (view full) ---

56 void (*cb)(void *), void *arg);
57static struct cdev *make_dev_credv(int flags,
58 struct cdevsw *devsw, int minornr,
59 struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt,
60 va_list ap);
61
62static struct cdev_priv_list cdevp_free_list =
63 TAILQ_HEAD_INITIALIZER(cdevp_free_list);
64static SLIST_HEAD(free_cdevsw, cdevsw) cdevsw_gt_post_list =
65 SLIST_HEAD_INITIALIZER();
64
65void
66dev_lock(void)
67{
68
69 mtx_lock(&devmtx);
70}
71
66
67void
68dev_lock(void)
69{
70
71 mtx_lock(&devmtx);
72}
73
74/*
75 * Free all the memory collected while the cdev mutex was
76 * locked. Since devmtx is after the system map mutex, free() cannot
77 * be called immediately and is postponed until cdev mutex can be
78 * dropped.
79 */
72static void
73dev_unlock_and_free(void)
74{
80static void
81dev_unlock_and_free(void)
82{
83 struct cdev_priv_list cdp_free;
84 struct free_cdevsw csw_free;
75 struct cdev_priv *cdp;
85 struct cdev_priv *cdp;
86 struct cdevsw *csw;
76
77 mtx_assert(&devmtx, MA_OWNED);
87
88 mtx_assert(&devmtx, MA_OWNED);
78 while ((cdp = TAILQ_FIRST(&cdevp_free_list)) != NULL) {
79 TAILQ_REMOVE(&cdevp_free_list, cdp, cdp_list);
80 mtx_unlock(&devmtx);
89
90 /*
91 * Make the local copy of the list heads while the dev_mtx is
92 * held. Free it later.
93 */
94 TAILQ_INIT(&cdp_free);
95 TAILQ_CONCAT(&cdp_free, &cdevp_free_list, cdp_list);
96 csw_free = cdevsw_gt_post_list;
97 SLIST_INIT(&cdevsw_gt_post_list);
98
99 mtx_unlock(&devmtx);
100
101 while ((cdp = TAILQ_FIRST(&cdp_free)) != NULL) {
102 TAILQ_REMOVE(&cdp_free, cdp, cdp_list);
81 devfs_free(&cdp->cdp_c);
103 devfs_free(&cdp->cdp_c);
82 mtx_lock(&devmtx);
83 }
104 }
84 mtx_unlock(&devmtx);
105 while ((csw = SLIST_FIRST(&csw_free)) != NULL) {
106 SLIST_REMOVE_HEAD(&csw_free, d_postfree_list);
107 free(csw, M_DEVT);
108 }
85}
86
87static void
88dev_free_devlocked(struct cdev *cdev)
89{
90 struct cdev_priv *cdp;
91
92 mtx_assert(&devmtx, MA_OWNED);
93 cdp = cdev->si_priv;
94 TAILQ_INSERT_HEAD(&cdevp_free_list, cdp, cdp_list);
95}
96
109}
110
111static void
112dev_free_devlocked(struct cdev *cdev)
113{
114 struct cdev_priv *cdp;
115
116 mtx_assert(&devmtx, MA_OWNED);
117 cdp = cdev->si_priv;
118 TAILQ_INSERT_HEAD(&cdevp_free_list, cdp, cdp_list);
119}
120
121static void
122cdevsw_free_devlocked(struct cdevsw *csw)
123{
124
125 mtx_assert(&devmtx, MA_OWNED);
126 SLIST_INSERT_HEAD(&cdevsw_gt_post_list, csw, d_postfree_list);
127}
128
97void
98dev_unlock(void)
99{
100
101 mtx_unlock(&devmtx);
102}
103
104void

--- 187 unchanged lines hidden (view full) ---

292 return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
293}
294
295#define no_dump (dumper_t *)enodev
296
297static int
298giant_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
299{
129void
130dev_unlock(void)
131{
132
133 mtx_unlock(&devmtx);
134}
135
136void

--- 187 unchanged lines hidden (view full) ---

324 return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
325}
326
327#define no_dump (dumper_t *)enodev
328
329static int
330giant_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
331{
332 struct cdevsw *dsw;
300 int retval;
301
333 int retval;
334
335 dsw = dev_refthread(dev);
336 if (dsw == NULL)
337 return (ENXIO);
302 mtx_lock(&Giant);
338 mtx_lock(&Giant);
303 retval = dev->si_devsw->d_gianttrick->
304 d_open(dev, oflags, devtype, td);
339 retval = dsw->d_gianttrick->d_open(dev, oflags, devtype, td);
305 mtx_unlock(&Giant);
340 mtx_unlock(&Giant);
341 dev_relthread(dev);
306 return (retval);
307}
308
309static int
310giant_fdopen(struct cdev *dev, int oflags, struct thread *td, struct file *fp)
311{
342 return (retval);
343}
344
345static int
346giant_fdopen(struct cdev *dev, int oflags, struct thread *td, struct file *fp)
347{
348 struct cdevsw *dsw;
312 int retval;
313
349 int retval;
350
351 dsw = dev_refthread(dev);
352 if (dsw == NULL)
353 return (ENXIO);
314 mtx_lock(&Giant);
354 mtx_lock(&Giant);
315 retval = dev->si_devsw->d_gianttrick->
316 d_fdopen(dev, oflags, td, fp);
355 retval = dsw->d_gianttrick->d_fdopen(dev, oflags, td, fp);
317 mtx_unlock(&Giant);
356 mtx_unlock(&Giant);
357 dev_relthread(dev);
318 return (retval);
319}
320
321static int
322giant_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
323{
358 return (retval);
359}
360
361static int
362giant_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
363{
364 struct cdevsw *dsw;
324 int retval;
325
365 int retval;
366
367 dsw = dev_refthread(dev);
368 if (dsw == NULL)
369 return (ENXIO);
326 mtx_lock(&Giant);
370 mtx_lock(&Giant);
327 retval = dev->si_devsw->d_gianttrick->
328 d_close(dev, fflag, devtype, td);
371 retval = dsw->d_gianttrick->d_close(dev, fflag, devtype, td);
329 mtx_unlock(&Giant);
372 mtx_unlock(&Giant);
373 dev_relthread(dev);
330 return (retval);
331}
332
333static void
334giant_strategy(struct bio *bp)
335{
374 return (retval);
375}
376
377static void
378giant_strategy(struct bio *bp)
379{
380 struct cdevsw *dsw;
381 struct cdev *dev;
336
382
383 dev = bp->bio_dev;
384 dsw = dev_refthread(dev);
385 if (dsw == NULL) {
386 biofinish(bp, NULL, ENXIO);
387 return;
388 }
337 mtx_lock(&Giant);
389 mtx_lock(&Giant);
338 bp->bio_dev->si_devsw->d_gianttrick->
339 d_strategy(bp);
390 dsw->d_gianttrick->d_strategy(bp);
340 mtx_unlock(&Giant);
391 mtx_unlock(&Giant);
392 dev_relthread(dev);
341}
342
343static int
344giant_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
345{
393}
394
395static int
396giant_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
397{
398 struct cdevsw *dsw;
346 int retval;
347
399 int retval;
400
401 dsw = dev_refthread(dev);
402 if (dsw == NULL)
403 return (ENXIO);
348 mtx_lock(&Giant);
349 retval = dev->si_devsw->d_gianttrick->
350 d_ioctl(dev, cmd, data, fflag, td);
351 mtx_unlock(&Giant);
404 mtx_lock(&Giant);
405 retval = dev->si_devsw->d_gianttrick->
406 d_ioctl(dev, cmd, data, fflag, td);
407 mtx_unlock(&Giant);
408 dev_relthread(dev);
352 return (retval);
353}
354
355static int
356giant_read(struct cdev *dev, struct uio *uio, int ioflag)
357{
409 return (retval);
410}
411
412static int
413giant_read(struct cdev *dev, struct uio *uio, int ioflag)
414{
415 struct cdevsw *dsw;
358 int retval;
359
416 int retval;
417
418 dsw = dev_refthread(dev);
419 if (dsw == NULL)
420 return (ENXIO);
360 mtx_lock(&Giant);
361 retval = dev->si_devsw->d_gianttrick->
362 d_read(dev, uio, ioflag);
363 mtx_unlock(&Giant);
421 mtx_lock(&Giant);
422 retval = dev->si_devsw->d_gianttrick->
423 d_read(dev, uio, ioflag);
424 mtx_unlock(&Giant);
425 dev_relthread(dev);
364 return (retval);
365}
366
367static int
368giant_write(struct cdev *dev, struct uio *uio, int ioflag)
369{
426 return (retval);
427}
428
429static int
430giant_write(struct cdev *dev, struct uio *uio, int ioflag)
431{
432 struct cdevsw *dsw;
370 int retval;
371
433 int retval;
434
435 dsw = dev_refthread(dev);
436 if (dsw == NULL)
437 return (ENXIO);
372 mtx_lock(&Giant);
438 mtx_lock(&Giant);
373 retval = dev->si_devsw->d_gianttrick->
374 d_write(dev, uio, ioflag);
439 retval = dsw->d_gianttrick->d_write(dev, uio, ioflag);
375 mtx_unlock(&Giant);
440 mtx_unlock(&Giant);
441 dev_relthread(dev);
376 return (retval);
377}
378
379static int
380giant_poll(struct cdev *dev, int events, struct thread *td)
381{
442 return (retval);
443}
444
445static int
446giant_poll(struct cdev *dev, int events, struct thread *td)
447{
448 struct cdevsw *dsw;
382 int retval;
383
449 int retval;
450
451 dsw = dev_refthread(dev);
452 if (dsw == NULL)
453 return (ENXIO);
384 mtx_lock(&Giant);
454 mtx_lock(&Giant);
385 retval = dev->si_devsw->d_gianttrick->
386 d_poll(dev, events, td);
455 retval = dsw->d_gianttrick->d_poll(dev, events, td);
387 mtx_unlock(&Giant);
456 mtx_unlock(&Giant);
457 dev_relthread(dev);
388 return (retval);
389}
390
391static int
392giant_kqfilter(struct cdev *dev, struct knote *kn)
393{
458 return (retval);
459}
460
461static int
462giant_kqfilter(struct cdev *dev, struct knote *kn)
463{
464 struct cdevsw *dsw;
394 int retval;
395
465 int retval;
466
467 dsw = dev_refthread(dev);
468 if (dsw == NULL)
469 return (ENXIO);
396 mtx_lock(&Giant);
470 mtx_lock(&Giant);
397 retval = dev->si_devsw->d_gianttrick->
398 d_kqfilter(dev, kn);
471 retval = dsw->d_gianttrick->d_kqfilter(dev, kn);
399 mtx_unlock(&Giant);
472 mtx_unlock(&Giant);
473 dev_relthread(dev);
400 return (retval);
401}
402
403static int
404giant_mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
405{
474 return (retval);
475}
476
477static int
478giant_mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
479{
480 struct cdevsw *dsw;
406 int retval;
407
481 int retval;
482
483 dsw = dev_refthread(dev);
484 if (dsw == NULL)
485 return (ENXIO);
408 mtx_lock(&Giant);
486 mtx_lock(&Giant);
409 retval = dev->si_devsw->d_gianttrick->
410 d_mmap(dev, offset, paddr, nprot);
487 retval = dsw->d_gianttrick->d_mmap(dev, offset, paddr, nprot);
411 mtx_unlock(&Giant);
488 mtx_unlock(&Giant);
489 dev_relthread(dev);
412 return (retval);
413}
414
415
416/*
417 * struct cdev * and u_dev_t primitives
418 */
419

--- 65 unchanged lines hidden (view full) ---

485static void
486fini_cdevsw(struct cdevsw *devsw)
487{
488 struct cdevsw *gt;
489
490 if (devsw->d_gianttrick != NULL) {
491 gt = devsw->d_gianttrick;
492 memcpy(devsw, gt, sizeof *devsw);
490 return (retval);
491}
492
493
494/*
495 * struct cdev * and u_dev_t primitives
496 */
497

--- 65 unchanged lines hidden (view full) ---

563static void
564fini_cdevsw(struct cdevsw *devsw)
565{
566 struct cdevsw *gt;
567
568 if (devsw->d_gianttrick != NULL) {
569 gt = devsw->d_gianttrick;
570 memcpy(devsw, gt, sizeof *devsw);
493 free(gt, M_DEVT);
571 cdevsw_free_devlocked(gt);
494 devsw->d_gianttrick = NULL;
495 }
496 devsw->d_flags &= ~D_INIT;
497}
498
499static void
500prep_cdevsw(struct cdevsw *devsw)
501{
502 struct cdevsw *dsw2;
503
572 devsw->d_gianttrick = NULL;
573 }
574 devsw->d_flags &= ~D_INIT;
575}
576
577static void
578prep_cdevsw(struct cdevsw *devsw)
579{
580 struct cdevsw *dsw2;
581
504 if (devsw->d_flags & D_NEEDGIANT)
582 mtx_assert(&devmtx, MA_OWNED);
583 if (devsw->d_flags & D_INIT)
584 return;
585 if (devsw->d_flags & D_NEEDGIANT) {
586 dev_unlock();
505 dsw2 = malloc(sizeof *dsw2, M_DEVT, M_WAITOK);
587 dsw2 = malloc(sizeof *dsw2, M_DEVT, M_WAITOK);
506 else
588 dev_lock();
589 } else
507 dsw2 = NULL;
590 dsw2 = NULL;
508 dev_lock();
591 if (devsw->d_flags & D_INIT) {
592 if (dsw2 != NULL)
593 cdevsw_free_devlocked(dsw2);
594 return;
595 }
509
510 if (devsw->d_version != D_VERSION_01) {
511 printf(
512 "WARNING: Device driver \"%s\" has wrong version %s\n",
513 devsw->d_name == NULL ? "???" : devsw->d_name,
514 "and is disabled. Recompile KLD module.");
515 devsw->d_open = dead_open;
516 devsw->d_close = dead_close;

--- 14 unchanged lines hidden (view full) ---

531 if (devsw->d_kqfilter == NULL) devsw->d_kqfilter = ttykqfilter;
532 if (devsw->d_poll == NULL) devsw->d_poll = ttypoll;
533 }
534
535 if (devsw->d_flags & D_NEEDGIANT) {
536 if (devsw->d_gianttrick == NULL) {
537 memcpy(dsw2, devsw, sizeof *dsw2);
538 devsw->d_gianttrick = dsw2;
596
597 if (devsw->d_version != D_VERSION_01) {
598 printf(
599 "WARNING: Device driver \"%s\" has wrong version %s\n",
600 devsw->d_name == NULL ? "???" : devsw->d_name,
601 "and is disabled. Recompile KLD module.");
602 devsw->d_open = dead_open;
603 devsw->d_close = dead_close;

--- 14 unchanged lines hidden (view full) ---

618 if (devsw->d_kqfilter == NULL) devsw->d_kqfilter = ttykqfilter;
619 if (devsw->d_poll == NULL) devsw->d_poll = ttypoll;
620 }
621
622 if (devsw->d_flags & D_NEEDGIANT) {
623 if (devsw->d_gianttrick == NULL) {
624 memcpy(dsw2, devsw, sizeof *dsw2);
625 devsw->d_gianttrick = dsw2;
539 } else
540 free(dsw2, M_DEVT);
626 dsw2 = NULL;
627 }
541 }
542
543#define FIXUP(member, noop, giant) \
544 do { \
545 if (devsw->member == NULL) { \
546 devsw->member = noop; \
547 } else if (devsw->d_flags & D_NEEDGIANT) \
548 devsw->member = giant; \

--- 12 unchanged lines hidden (view full) ---

561 FIXUP(d_kqfilter, no_kqfilter, giant_kqfilter);
562
563 if (devsw->d_dump == NULL) devsw->d_dump = no_dump;
564
565 LIST_INIT(&devsw->d_devs);
566
567 devsw->d_flags |= D_INIT;
568
628 }
629
630#define FIXUP(member, noop, giant) \
631 do { \
632 if (devsw->member == NULL) { \
633 devsw->member = noop; \
634 } else if (devsw->d_flags & D_NEEDGIANT) \
635 devsw->member = giant; \

--- 12 unchanged lines hidden (view full) ---

648 FIXUP(d_kqfilter, no_kqfilter, giant_kqfilter);
649
650 if (devsw->d_dump == NULL) devsw->d_dump = no_dump;
651
652 LIST_INIT(&devsw->d_devs);
653
654 devsw->d_flags |= D_INIT;
655
569 dev_unlock();
656 if (dsw2 != NULL)
657 cdevsw_free_devlocked(dsw2);
570}
571
572struct cdev *
573make_dev_credv(int flags, struct cdevsw *devsw, int minornr,
574 struct ucred *cr, uid_t uid,
575 gid_t gid, int mode, const char *fmt, va_list ap)
576{
577 struct cdev *dev;
578 int i;
579
580 KASSERT((minornr & ~MAXMINOR) == 0,
581 ("Invalid minor (0x%x) in make_dev", minornr));
582
658}
659
660struct cdev *
661make_dev_credv(int flags, struct cdevsw *devsw, int minornr,
662 struct ucred *cr, uid_t uid,
663 gid_t gid, int mode, const char *fmt, va_list ap)
664{
665 struct cdev *dev;
666 int i;
667
668 KASSERT((minornr & ~MAXMINOR) == 0,
669 ("Invalid minor (0x%x) in make_dev", minornr));
670
583 if (!(devsw->d_flags & D_INIT))
584 prep_cdevsw(devsw);
585 dev = devfs_alloc();
586 dev_lock();
671 dev = devfs_alloc();
672 dev_lock();
673 prep_cdevsw(devsw);
587 dev = newdev(devsw, minornr, dev);
588 if (flags & MAKEDEV_REF)
589 dev_refl(dev);
590 if (dev->si_flags & SI_CHEAPCLONE &&
591 dev->si_flags & SI_NAMED) {
592 /*
593 * This is allowed as it removes races and generally
594 * simplifies cloning devices.

--- 20 unchanged lines hidden (view full) ---

615#endif
616 dev->si_cred = NULL;
617 dev->si_uid = uid;
618 dev->si_gid = gid;
619 dev->si_mode = mode;
620
621 devfs_create(dev);
622 clean_unrhdrl(devfs_inos);
674 dev = newdev(devsw, minornr, dev);
675 if (flags & MAKEDEV_REF)
676 dev_refl(dev);
677 if (dev->si_flags & SI_CHEAPCLONE &&
678 dev->si_flags & SI_NAMED) {
679 /*
680 * This is allowed as it removes races and generally
681 * simplifies cloning devices.

--- 20 unchanged lines hidden (view full) ---

702#endif
703 dev->si_cred = NULL;
704 dev->si_uid = uid;
705 dev->si_gid = gid;
706 dev->si_mode = mode;
707
708 devfs_create(dev);
709 clean_unrhdrl(devfs_inos);
623 dev_unlock();
710 dev_unlock_and_free();
624 return (dev);
625}
626
627struct cdev *
628make_dev(struct cdevsw *devsw, int minornr, uid_t uid, gid_t gid, int mode,
629 const char *fmt, ...)
630{
631 struct cdev *dev;

--- 247 unchanged lines hidden (view full) ---

879
880 KASSERT(*cdp != NULL,
881 ("clone_setup() not called in driver \"%s\"", csw->d_name));
882 KASSERT(!(extra & CLONE_UNITMASK),
883 ("Illegal extra bits (0x%x) in clone_create", extra));
884 KASSERT(*up <= CLONE_UNITMASK,
885 ("Too high unit (0x%x) in clone_create", *up));
886
711 return (dev);
712}
713
714struct cdev *
715make_dev(struct cdevsw *devsw, int minornr, uid_t uid, gid_t gid, int mode,
716 const char *fmt, ...)
717{
718 struct cdev *dev;

--- 247 unchanged lines hidden (view full) ---

966
967 KASSERT(*cdp != NULL,
968 ("clone_setup() not called in driver \"%s\"", csw->d_name));
969 KASSERT(!(extra & CLONE_UNITMASK),
970 ("Illegal extra bits (0x%x) in clone_create", extra));
971 KASSERT(*up <= CLONE_UNITMASK,
972 ("Too high unit (0x%x) in clone_create", *up));
973
887 if (!(csw->d_flags & D_INIT))
888 prep_cdevsw(csw);
889
890 /*
891 * Search the list for a lot of things in one go:
892 * A preexisting match is returned immediately.
893 * The lowest free unit number if we are passed -1, and the place
894 * in the list where we should insert that new element.
895 * The place to insert a specified unit number, if applicable
896 * the end of the list.
897 */
898 unit = *up;
899 ndev = devfs_alloc();
900 dev_lock();
974
975 /*
976 * Search the list for a lot of things in one go:
977 * A preexisting match is returned immediately.
978 * The lowest free unit number if we are passed -1, and the place
979 * in the list where we should insert that new element.
980 * The place to insert a specified unit number, if applicable
981 * the end of the list.
982 */
983 unit = *up;
984 ndev = devfs_alloc();
985 dev_lock();
986 prep_cdevsw(csw);
901 low = extra;
902 de = dl = NULL;
903 cd = *cdp;
904 LIST_FOREACH(dev, &cd->head, si_clone) {
905 KASSERT(dev->si_flags & SI_CLONELIST,
906 ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
907 u = dev2unit(dev);
908 if (u == (unit | extra)) {

--- 63 unchanged lines hidden (view full) ---

972 cp = dev->si_priv;
973 if (!(cp->cdp_flags & CDP_SCHED_DTR)) {
974 cp->cdp_flags |= CDP_SCHED_DTR;
975 KASSERT(dev->si_flags & SI_NAMED,
976 ("Driver has goofed in cloning underways udev %x", dev->si_drv0));
977 destroy_devl(dev);
978 }
979 }
987 low = extra;
988 de = dl = NULL;
989 cd = *cdp;
990 LIST_FOREACH(dev, &cd->head, si_clone) {
991 KASSERT(dev->si_flags & SI_CLONELIST,
992 ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
993 u = dev2unit(dev);
994 if (u == (unit | extra)) {

--- 63 unchanged lines hidden (view full) ---

1058 cp = dev->si_priv;
1059 if (!(cp->cdp_flags & CDP_SCHED_DTR)) {
1060 cp->cdp_flags |= CDP_SCHED_DTR;
1061 KASSERT(dev->si_flags & SI_NAMED,
1062 ("Driver has goofed in cloning underways udev %x", dev->si_drv0));
1063 destroy_devl(dev);
1064 }
1065 }
980 dev_unlock();
1066 dev_unlock_and_free();
981 free(cd, M_DEVBUF);
982 *cdp = NULL;
983}
984
985static TAILQ_HEAD(, cdev_priv) dev_ddtr =
986 TAILQ_HEAD_INITIALIZER(dev_ddtr);
987static struct task dev_dtr_task;
988

--- 10 unchanged lines hidden (view full) ---

999 cp = TAILQ_FIRST(&dev_ddtr);
1000 dev = &cp->cdp_c;
1001 KASSERT(cp->cdp_flags & CDP_SCHED_DTR,
1002 ("cdev %p in dev_destroy_tq without CDP_SCHED_DTR", cp));
1003 TAILQ_REMOVE(&dev_ddtr, cp, cdp_dtr_list);
1004 cb = cp->cdp_dtr_cb;
1005 cb_arg = cp->cdp_dtr_cb_arg;
1006 destroy_devl(dev);
1067 free(cd, M_DEVBUF);
1068 *cdp = NULL;
1069}
1070
1071static TAILQ_HEAD(, cdev_priv) dev_ddtr =
1072 TAILQ_HEAD_INITIALIZER(dev_ddtr);
1073static struct task dev_dtr_task;
1074

--- 10 unchanged lines hidden (view full) ---

1085 cp = TAILQ_FIRST(&dev_ddtr);
1086 dev = &cp->cdp_c;
1087 KASSERT(cp->cdp_flags & CDP_SCHED_DTR,
1088 ("cdev %p in dev_destroy_tq without CDP_SCHED_DTR", cp));
1089 TAILQ_REMOVE(&dev_ddtr, cp, cdp_dtr_list);
1090 cb = cp->cdp_dtr_cb;
1091 cb_arg = cp->cdp_dtr_cb_arg;
1092 destroy_devl(dev);
1007 dev_unlock();
1093 dev_unlock_and_free();
1008 dev_rel(dev);
1009 if (cb != NULL)
1010 cb(cb_arg);
1011 dev_lock();
1012 }
1013 dev_unlock();
1014}
1015

--- 65 unchanged lines hidden --- 		1094 dev_rel(dev);
1095 if (cb != NULL)
1096 cb(cb_arg);
1097 dev_lock();
1098 }
1099 dev_unlock();
1100}
1101

--- 65 unchanged lines hidden ---