sys/kern/kern_conf.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999-2002 Poul-Henning Kamp
   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 <sys/param.h>
  33 #include <sys/kernel.h>
  34 #include <sys/systm.h>
  35 #include <sys/bus.h>
  36 #include <sys/bio.h>
  37 #include <sys/lock.h>
  38 #include <sys/mutex.h>
  39 #include <sys/module.h>
  40 #include <sys/malloc.h>
  41 #include <sys/conf.h>
  42 #include <sys/vnode.h>
  43 #include <sys/queue.h>
  44 #include <sys/poll.h>
  45 #include <sys/sx.h>
  46 #include <sys/ctype.h>
  47 #include <sys/ucred.h>
  48 #include <sys/taskqueue.h>
  49 #include <machine/stdarg.h>
  50
  51 #include <fs/devfs/devfs_int.h>
  52 #include <vm/vm.h>
  53
  54 static MALLOC_DEFINE(M_DEVT, "cdev", "cdev storage");
  55
  56 struct mtx devmtx;
  57 static void destroy_devl(struct cdev *dev);
  58 static int destroy_dev_sched_cbl(struct cdev *dev,
  59     void (*cb)(void *), void *arg);
  60 static void destroy_dev_tq(void *ctx, int pending);
  61 static int make_dev_credv(int flags, struct cdev **dres, struct cdevsw *devsw,
  62     int unit, struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt,
  63     va_list ap);
  64
  65 static struct cdev_priv_list cdevp_free_list =
  66     TAILQ_HEAD_INITIALIZER(cdevp_free_list);
  67 static SLIST_HEAD(free_cdevsw, cdevsw) cdevsw_gt_post_list =
  68     SLIST_HEAD_INITIALIZER(cdevsw_gt_post_list);
  69
  70 void
  71 dev_lock(void)
  72 {
  73
  74         mtx_lock(&devmtx);
  75 }
  76
  77 /*
  78  * Free all the memory collected while the cdev mutex was
  79  * locked. Since devmtx is after the system map mutex, free() cannot
  80  * be called immediately and is postponed until cdev mutex can be
  81  * dropped.
  82  */
  83 static void
  84 dev_unlock_and_free(void)
  85 {
  86         struct cdev_priv_list cdp_free;
  87         struct free_cdevsw csw_free;
  88         struct cdev_priv *cdp;
  89         struct cdevsw *csw;
  90
  91         mtx_assert(&devmtx, MA_OWNED);
  92
  93         /*
  94          * Make the local copy of the list heads while the dev_mtx is
  95          * held. Free it later.
  96          */
  97         TAILQ_INIT(&cdp_free);
  98         TAILQ_CONCAT(&cdp_free, &cdevp_free_list, cdp_list);
  99         csw_free = cdevsw_gt_post_list;
 100         SLIST_INIT(&cdevsw_gt_post_list);
 101
 102         mtx_unlock(&devmtx);
 103
 104         while ((cdp = TAILQ_FIRST(&cdp_free)) != NULL) {
 105                 TAILQ_REMOVE(&cdp_free, cdp, cdp_list);
 106                 devfs_free(&cdp->cdp_c);
 107         }
 108         while ((csw = SLIST_FIRST(&csw_free)) != NULL) {
 109                 SLIST_REMOVE_HEAD(&csw_free, d_postfree_list);
 110                 free(csw, M_DEVT);
 111         }
 112 }
 113
 114 static void
 115 dev_free_devlocked(struct cdev *cdev)
 116 {
 117         struct cdev_priv *cdp;
 118
 119         mtx_assert(&devmtx, MA_OWNED);
 120         cdp = cdev2priv(cdev);
 121         KASSERT((cdp->cdp_flags & CDP_UNREF_DTR) == 0,
 122             ("destroy_dev() was not called after delist_dev(%p)", cdev));
 123         TAILQ_INSERT_HEAD(&cdevp_free_list, cdp, cdp_list);
 124 }
 125
 126 static void
 127 cdevsw_free_devlocked(struct cdevsw *csw)
 128 {
 129
 130         mtx_assert(&devmtx, MA_OWNED);
 131         SLIST_INSERT_HEAD(&cdevsw_gt_post_list, csw, d_postfree_list);
 132 }
 133
 134 void
 135 dev_unlock(void)
 136 {
 137
 138         mtx_unlock(&devmtx);
 139 }
 140
 141 void
 142 dev_ref(struct cdev *dev)
 143 {
 144
 145         mtx_assert(&devmtx, MA_NOTOWNED);
 146         mtx_lock(&devmtx);
 147         dev->si_refcount++;
 148         mtx_unlock(&devmtx);
 149 }
 150
 151 void
 152 dev_refl(struct cdev *dev)
 153 {
 154
 155         mtx_assert(&devmtx, MA_OWNED);
 156         dev->si_refcount++;
 157 }
 158
 159 void
 160 dev_rel(struct cdev *dev)
 161 {
 162         int flag = 0;
 163
 164         mtx_assert(&devmtx, MA_NOTOWNED);
 165         dev_lock();
 166         dev->si_refcount--;
 167         KASSERT(dev->si_refcount >= 0,
 168             ("dev_rel(%s) gave negative count", devtoname(dev)));
 169         if (dev->si_devsw == NULL && dev->si_refcount == 0) {
 170                 LIST_REMOVE(dev, si_list);
 171                 flag = 1;
 172         }
 173         dev_unlock();
 174         if (flag)
 175                 devfs_free(dev);
 176 }
 177
 178 struct cdevsw *
 179 dev_refthread(struct cdev *dev, int *ref)
 180 {
 181         struct cdevsw *csw;
 182         struct cdev_priv *cdp;
 183
 184         mtx_assert(&devmtx, MA_NOTOWNED);
 185         if ((dev->si_flags & SI_ETERNAL) != 0) {
 186                 *ref = 0;
 187                 return (dev->si_devsw);
 188         }
 189         dev_lock();
 190         csw = dev->si_devsw;
 191         if (csw != NULL) {
 192                 cdp = cdev2priv(dev);
 193                 if ((cdp->cdp_flags & CDP_SCHED_DTR) == 0)
 194                         atomic_add_long(&dev->si_threadcount, 1);
 195                 else
 196                         csw = NULL;
 197         }
 198         dev_unlock();
 199         *ref = 1;
 200         return (csw);
 201 }
 202
 203 struct cdevsw *
 204 devvn_refthread(struct vnode *vp, struct cdev **devp, int *ref)
 205 {
 206         struct cdevsw *csw;
 207         struct cdev_priv *cdp;
 208         struct cdev *dev;
 209
 210         mtx_assert(&devmtx, MA_NOTOWNED);
 211         if ((vp->v_vflag & VV_ETERNALDEV) != 0) {
 212                 dev = vp->v_rdev;
 213                 if (dev == NULL)
 214                         return (NULL);
 215                 KASSERT((dev->si_flags & SI_ETERNAL) != 0,
 216                     ("Not eternal cdev"));
 217                 *ref = 0;
 218                 csw = dev->si_devsw;
 219                 KASSERT(csw != NULL, ("Eternal cdev is destroyed"));
 220                 *devp = dev;
 221                 return (csw);
 222         }
 223
 224         csw = NULL;
 225         dev_lock();
 226         dev = vp->v_rdev;
 227         if (dev == NULL) {
 228                 dev_unlock();
 229                 return (NULL);
 230         }
 231         cdp = cdev2priv(dev);
 232         if ((cdp->cdp_flags & CDP_SCHED_DTR) == 0) {
 233                 csw = dev->si_devsw;
 234                 if (csw != NULL)
 235                         atomic_add_long(&dev->si_threadcount, 1);
 236         }
 237         dev_unlock();
 238         if (csw != NULL) {
 239                 *devp = dev;
 240                 *ref = 1;
 241         }
 242         return (csw);
 243 }
 244
 245 void
 246 dev_relthread(struct cdev *dev, int ref)
 247 {
 248
 249         mtx_assert(&devmtx, MA_NOTOWNED);
 250         if (!ref)
 251                 return;
 252         KASSERT(dev->si_threadcount > 0,
 253             ("%s threadcount is wrong", dev->si_name));
 254         atomic_subtract_rel_long(&dev->si_threadcount, 1);
 255 }
 256
 257 int
 258 nullop(void)
 259 {
 260
 261         return (0);
 262 }
 263
 264 int
 265 eopnotsupp(void)
 266 {
 267
 268         return (EOPNOTSUPP);
 269 }
 270
 271 static int
 272 enxio(void)
 273 {
 274         return (ENXIO);
 275 }
 276
 277 static int
 278 enodev(void)
 279 {
 280         return (ENODEV);
 281 }
 282
 283 /* Define a dead_cdevsw for use when devices leave unexpectedly. */
 284
 285 #define dead_open       (d_open_t *)enxio
 286 #define dead_close      (d_close_t *)enxio
 287 #define dead_read       (d_read_t *)enxio
 288 #define dead_write      (d_write_t *)enxio
 289 #define dead_ioctl      (d_ioctl_t *)enxio
 290 #define dead_poll       (d_poll_t *)enodev
 291 #define dead_mmap       (d_mmap_t *)enodev
 292
 293 static void
 294 dead_strategy(struct bio *bp)
 295 {
 296
 297         biofinish(bp, NULL, ENXIO);
 298 }
 299
 300 #define dead_dump       (dumper_t *)enxio
 301 #define dead_kqfilter   (d_kqfilter_t *)enxio
 302 #define dead_mmap_single (d_mmap_single_t *)enodev
 303
 304 static struct cdevsw dead_cdevsw = {
 305         .d_version =    D_VERSION,
 306         .d_open =       dead_open,
 307         .d_close =      dead_close,
 308         .d_read =       dead_read,
 309         .d_write =      dead_write,
 310         .d_ioctl =      dead_ioctl,
 311         .d_poll =       dead_poll,
 312         .d_mmap =       dead_mmap,
 313         .d_strategy =   dead_strategy,
 314         .d_name =       "dead",
 315         .d_dump =       dead_dump,
 316         .d_kqfilter =   dead_kqfilter,
 317         .d_mmap_single = dead_mmap_single
 318 };
 319
 320 /* Default methods if driver does not specify method */
 321
 322 #define null_open       (d_open_t *)nullop
 323 #define null_close      (d_close_t *)nullop
 324 #define no_read         (d_read_t *)enodev
 325 #define no_write        (d_write_t *)enodev
 326 #define no_ioctl        (d_ioctl_t *)enodev
 327 #define no_mmap         (d_mmap_t *)enodev
 328 #define no_kqfilter     (d_kqfilter_t *)enodev
 329 #define no_mmap_single  (d_mmap_single_t *)enodev
 330
 331 static void
 332 no_strategy(struct bio *bp)
 333 {
 334
 335         biofinish(bp, NULL, ENODEV);
 336 }
 337
 338 static int
 339 no_poll(struct cdev *dev __unused, int events, struct thread *td __unused)
 340 {
 341
 342         return (poll_no_poll(events));
 343 }
 344
 345 #define no_dump         (dumper_t *)enodev
 346
 347 static int
 348 giant_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
 349 {
 350         struct cdevsw *dsw;
 351         int ref, retval;
 352
 353         dsw = dev_refthread(dev, &ref);
 354         if (dsw == NULL)
 355                 return (ENXIO);
 356         mtx_lock(&Giant);
 357         retval = dsw->d_gianttrick->d_open(dev, oflags, devtype, td);
 358         mtx_unlock(&Giant);
 359         dev_relthread(dev, ref);
 360         return (retval);
 361 }
 362
 363 static int
 364 giant_fdopen(struct cdev *dev, int oflags, struct thread *td, struct file *fp)
 365 {
 366         struct cdevsw *dsw;
 367         int ref, retval;
 368
 369         dsw = dev_refthread(dev, &ref);
 370         if (dsw == NULL)
 371                 return (ENXIO);
 372         mtx_lock(&Giant);
 373         retval = dsw->d_gianttrick->d_fdopen(dev, oflags, td, fp);
 374         mtx_unlock(&Giant);
 375         dev_relthread(dev, ref);
 376         return (retval);
 377 }
 378
 379 static int
 380 giant_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
 381 {
 382         struct cdevsw *dsw;
 383         int ref, retval;
 384
 385         dsw = dev_refthread(dev, &ref);
 386         if (dsw == NULL)
 387                 return (ENXIO);
 388         mtx_lock(&Giant);
 389         retval = dsw->d_gianttrick->d_close(dev, fflag, devtype, td);
 390         mtx_unlock(&Giant);
 391         dev_relthread(dev, ref);
 392         return (retval);
 393 }
 394
 395 static void
 396 giant_strategy(struct bio *bp)
 397 {
 398         struct cdevsw *dsw;
 399         struct cdev *dev;
 400         int ref;
 401
 402         dev = bp->bio_dev;
 403         dsw = dev_refthread(dev, &ref);
 404         if (dsw == NULL) {
 405                 biofinish(bp, NULL, ENXIO);
 406                 return;
 407         }
 408         mtx_lock(&Giant);
 409         dsw->d_gianttrick->d_strategy(bp);
 410         mtx_unlock(&Giant);
 411         dev_relthread(dev, ref);
 412 }
 413
 414 static int
 415 giant_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
 416 {
 417         struct cdevsw *dsw;
 418         int ref, retval;
 419
 420         dsw = dev_refthread(dev, &ref);
 421         if (dsw == NULL)
 422                 return (ENXIO);
 423         mtx_lock(&Giant);
 424         retval = dsw->d_gianttrick->d_ioctl(dev, cmd, data, fflag, td);
 425         mtx_unlock(&Giant);
 426         dev_relthread(dev, ref);
 427         return (retval);
 428 }
 429
 430 static int
 431 giant_read(struct cdev *dev, struct uio *uio, int ioflag)
 432 {
 433         struct cdevsw *dsw;
 434         int ref, retval;
 435
 436         dsw = dev_refthread(dev, &ref);
 437         if (dsw == NULL)
 438                 return (ENXIO);
 439         mtx_lock(&Giant);
 440         retval = dsw->d_gianttrick->d_read(dev, uio, ioflag);
 441         mtx_unlock(&Giant);
 442         dev_relthread(dev, ref);
 443         return (retval);
 444 }
 445
 446 static int
 447 giant_write(struct cdev *dev, struct uio *uio, int ioflag)
 448 {
 449         struct cdevsw *dsw;
 450         int ref, retval;
 451
 452         dsw = dev_refthread(dev, &ref);
 453         if (dsw == NULL)
 454                 return (ENXIO);
 455         mtx_lock(&Giant);
 456         retval = dsw->d_gianttrick->d_write(dev, uio, ioflag);
 457         mtx_unlock(&Giant);
 458         dev_relthread(dev, ref);
 459         return (retval);
 460 }
 461
 462 static int
 463 giant_poll(struct cdev *dev, int events, struct thread *td)
 464 {
 465         struct cdevsw *dsw;
 466         int ref, retval;
 467
 468         dsw = dev_refthread(dev, &ref);
 469         if (dsw == NULL)
 470                 return (ENXIO);
 471         mtx_lock(&Giant);
 472         retval = dsw->d_gianttrick->d_poll(dev, events, td);
 473         mtx_unlock(&Giant);
 474         dev_relthread(dev, ref);
 475         return (retval);
 476 }
 477
 478 static int
 479 giant_kqfilter(struct cdev *dev, struct knote *kn)
 480 {
 481         struct cdevsw *dsw;
 482         int ref, retval;
 483
 484         dsw = dev_refthread(dev, &ref);
 485         if (dsw == NULL)
 486                 return (ENXIO);
 487         mtx_lock(&Giant);
 488         retval = dsw->d_gianttrick->d_kqfilter(dev, kn);
 489         mtx_unlock(&Giant);
 490         dev_relthread(dev, ref);
 491         return (retval);
 492 }
 493
 494 static int
 495 giant_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr, int nprot,
 496     vm_memattr_t *memattr)
 497 {
 498         struct cdevsw *dsw;
 499         int ref, retval;
 500
 501         dsw = dev_refthread(dev, &ref);
 502         if (dsw == NULL)
 503                 return (ENXIO);
 504         mtx_lock(&Giant);
 505         retval = dsw->d_gianttrick->d_mmap(dev, offset, paddr, nprot,
 506             memattr);
 507         mtx_unlock(&Giant);
 508         dev_relthread(dev, ref);
 509         return (retval);
 510 }
 511
 512 static int
 513 giant_mmap_single(struct cdev *dev, vm_ooffset_t *offset, vm_size_t size,
 514     vm_object_t *object, int nprot)
 515 {
 516         struct cdevsw *dsw;
 517         int ref, retval;
 518
 519         dsw = dev_refthread(dev, &ref);
 520         if (dsw == NULL)
 521                 return (ENXIO);
 522         mtx_lock(&Giant);
 523         retval = dsw->d_gianttrick->d_mmap_single(dev, offset, size, object,
 524             nprot);
 525         mtx_unlock(&Giant);
 526         dev_relthread(dev, ref);
 527         return (retval);
 528 }
 529
 530 static void
 531 notify(struct cdev *dev, const char *ev, int flags)
 532 {
 533         static const char prefix[] = "cdev=";
 534         char *data;
 535         int namelen, mflags;
 536
 537         if (cold)
 538                 return;
 539         mflags = (flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK;
 540         namelen = strlen(dev->si_name);
 541         data = malloc(namelen + sizeof(prefix), M_TEMP, mflags);
 542         if (data == NULL)
 543                 return;
 544         memcpy(data, prefix, sizeof(prefix) - 1);
 545         memcpy(data + sizeof(prefix) - 1, dev->si_name, namelen + 1);
 546         devctl_notify_f("DEVFS", "CDEV", ev, data, mflags);
 547         free(data, M_TEMP);
 548 }
 549
 550 static void
 551 notify_create(struct cdev *dev, int flags)
 552 {
 553
 554         notify(dev, "CREATE", flags);
 555 }
 556
 557 static void
 558 notify_destroy(struct cdev *dev)
 559 {
 560
 561         notify(dev, "DESTROY", MAKEDEV_WAITOK);
 562 }
 563
 564 static struct cdev *
 565 newdev(struct make_dev_args *args, struct cdev *si)
 566 {
 567         struct cdev *si2;
 568         struct cdevsw *csw;
 569
 570         mtx_assert(&devmtx, MA_OWNED);
 571         csw = args->mda_devsw;
 572         si2 = NULL;
 573         if (csw->d_flags & D_NEEDMINOR) {
 574                 /* We may want to return an existing device */
 575                 LIST_FOREACH(si2, &csw->d_devs, si_list) {
 576                         if (dev2unit(si2) == args->mda_unit) {
 577                                 dev_free_devlocked(si);
 578                                 si = si2;
 579                                 break;
 580                         }
 581                 }
 582
 583                 /*
 584                  * If we're returning an existing device, we should make sure
 585                  * it isn't already initialized.  This would have been caught
 586                  * in consumers anyways, but it's good to catch such a case
 587                  * early.  We still need to complete initialization of the
 588                  * device, and we'll use whatever make_dev_args were passed in
 589                  * to do so.
 590                  */
 591                 KASSERT(si2 == NULL || (si2->si_flags & SI_NAMED) == 0,
 592                     ("make_dev() by driver %s on pre-existing device (min=%x, name=%s)",
 593                     args->mda_devsw->d_name, dev2unit(si2), devtoname(si2)));
 594         }
 595         si->si_drv0 = args->mda_unit;
 596         si->si_drv1 = args->mda_si_drv1;
 597         si->si_drv2 = args->mda_si_drv2;
 598         /* Only push to csw->d_devs if it's not a cloned device. */
 599         if (si2 == NULL) {
 600                 si->si_devsw = csw;
 601                 LIST_INSERT_HEAD(&csw->d_devs, si, si_list);
 602         } else {
 603                 KASSERT(si->si_devsw == csw,
 604                     ("%s: inconsistent devsw between clone_create() and make_dev()",
 605                     __func__));
 606         }
 607         return (si);
 608 }
 609
 610 static void
 611 fini_cdevsw(struct cdevsw *devsw)
 612 {
 613         struct cdevsw *gt;
 614
 615         if (devsw->d_gianttrick != NULL) {
 616                 gt = devsw->d_gianttrick;
 617                 memcpy(devsw, gt, sizeof *devsw);
 618                 cdevsw_free_devlocked(gt);
 619                 devsw->d_gianttrick = NULL;
 620         }
 621         devsw->d_flags &= ~D_INIT;
 622 }
 623
 624 static int
 625 prep_cdevsw(struct cdevsw *devsw, int flags)
 626 {
 627         struct cdevsw *dsw2;
 628
 629         mtx_assert(&devmtx, MA_OWNED);
 630         if (devsw->d_flags & D_INIT)
 631                 return (0);
 632         if (devsw->d_flags & D_NEEDGIANT) {
 633                 dev_unlock();
 634                 dsw2 = malloc(sizeof *dsw2, M_DEVT,
 635                      (flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK);
 636                 dev_lock();
 637                 if (dsw2 == NULL && !(devsw->d_flags & D_INIT))
 638                         return (ENOMEM);
 639         } else
 640                 dsw2 = NULL;
 641         if (devsw->d_flags & D_INIT) {
 642                 if (dsw2 != NULL)
 643                         cdevsw_free_devlocked(dsw2);
 644                 return (0);
 645         }
 646
 647         if (devsw->d_version != D_VERSION_03) {
 648                 printf(
 649                     "WARNING: Device driver \"%s\" has wrong version %s\n",
 650                     devsw->d_name == NULL ? "???" : devsw->d_name,
 651                     "and is disabled.  Recompile KLD module.");
 652                 devsw->d_open = dead_open;
 653                 devsw->d_close = dead_close;
 654                 devsw->d_read = dead_read;
 655                 devsw->d_write = dead_write;
 656                 devsw->d_ioctl = dead_ioctl;
 657                 devsw->d_poll = dead_poll;
 658                 devsw->d_mmap = dead_mmap;
 659                 devsw->d_mmap_single = dead_mmap_single;
 660                 devsw->d_strategy = dead_strategy;
 661                 devsw->d_dump = dead_dump;
 662                 devsw->d_kqfilter = dead_kqfilter;
 663         }
 664
 665         if (devsw->d_flags & D_NEEDGIANT) {
 666                 if (devsw->d_gianttrick == NULL) {
 667                         memcpy(dsw2, devsw, sizeof *dsw2);
 668                         devsw->d_gianttrick = dsw2;
 669                         dsw2 = NULL;
 670                 }
 671         }
 672
 673 #define FIXUP(member, noop, giant)                              \
 674         do {                                                    \
 675                 if (devsw->member == NULL) {                    \
 676                         devsw->member = noop;                   \
 677                 } else if (devsw->d_flags & D_NEEDGIANT)        \
 678                         devsw->member = giant;                  \
 679                 }                                               \
 680         while (0)
 681
 682         FIXUP(d_open,           null_open,      giant_open);
 683         FIXUP(d_fdopen,         NULL,           giant_fdopen);
 684         FIXUP(d_close,          null_close,     giant_close);
 685         FIXUP(d_read,           no_read,        giant_read);
 686         FIXUP(d_write,          no_write,       giant_write);
 687         FIXUP(d_ioctl,          no_ioctl,       giant_ioctl);
 688         FIXUP(d_poll,           no_poll,        giant_poll);
 689         FIXUP(d_mmap,           no_mmap,        giant_mmap);
 690         FIXUP(d_strategy,       no_strategy,    giant_strategy);
 691         FIXUP(d_kqfilter,       no_kqfilter,    giant_kqfilter);
 692         FIXUP(d_mmap_single,    no_mmap_single, giant_mmap_single);
 693
 694         if (devsw->d_dump == NULL)      devsw->d_dump = no_dump;
 695
 696         LIST_INIT(&devsw->d_devs);
 697
 698         devsw->d_flags |= D_INIT;
 699
 700         if (dsw2 != NULL)
 701                 cdevsw_free_devlocked(dsw2);
 702         return (0);
 703 }
 704
 705 static int
 706 prep_devname(struct cdev *dev, const char *fmt, va_list ap)
 707 {
 708         int len;
 709         char *from, *q, *s, *to;
 710
 711         mtx_assert(&devmtx, MA_OWNED);
 712
 713         len = vsnrprintf(dev->si_name, sizeof(dev->si_name), 32, fmt, ap);
 714         if (len > sizeof(dev->si_name) - 1)
 715                 return (ENAMETOOLONG);
 716
 717         /* Strip leading slashes. */
 718         for (from = dev->si_name; *from == '/'; from++)
 719                 ;
 720
 721         for (to = dev->si_name; *from != '\0'; from++, to++) {
 722                 /*
 723                  * Spaces and double quotation marks cause
 724                  * problems for the devctl(4) protocol.
 725                  * Reject names containing those characters.
 726                  */
 727                 if (isspace(*from) || *from == '"')
 728                         return (EINVAL);
 729                 /* Treat multiple sequential slashes as single. */
 730                 while (from[0] == '/' && from[1] == '/')
 731                         from++;
 732                 /* Trailing slash is considered invalid. */
 733                 if (from[0] == '/' && from[1] == '\0')
 734                         return (EINVAL);
 735                 *to = *from;
 736         }
 737         *to = '\0';
 738
 739         if (dev->si_name[0] == '\0')
 740                 return (EINVAL);
 741
 742         /* Disallow "." and ".." components. */
 743         for (s = dev->si_name;;) {
 744                 for (q = s; *q != '/' && *q != '\0'; q++)
 745                         ;
 746                 if (q - s == 1 && s[0] == '.')
 747                         return (EINVAL);
 748                 if (q - s == 2 && s[0] == '.' && s[1] == '.')
 749                         return (EINVAL);
 750                 if (*q != '/')
 751                         break;
 752                 s = q + 1;
 753         }
 754
 755         if (devfs_dev_exists(dev->si_name) != 0)
 756                 return (EEXIST);
 757
 758         return (0);
 759 }
 760
 761 void
 762 make_dev_args_init_impl(struct make_dev_args *args, size_t sz)
 763 {
 764
 765         bzero(args, sz);
 766         args->mda_size = sz;
 767 }
 768
 769 static int
 770 make_dev_sv(struct make_dev_args *args1, struct cdev **dres,
 771     const char *fmt, va_list ap)
 772 {
 773         struct cdev *dev, *dev_new;
 774         struct make_dev_args args;
 775         int res;
 776
 777         bzero(&args, sizeof(args));
 778         if (sizeof(args) < args1->mda_size)
 779                 return (EINVAL);
 780         bcopy(args1, &args, args1->mda_size);
 781         KASSERT((args.mda_flags & MAKEDEV_WAITOK) == 0 ||
 782             (args.mda_flags & MAKEDEV_NOWAIT) == 0,
 783             ("make_dev_sv: both WAITOK and NOWAIT specified"));
 784         dev_new = devfs_alloc(args.mda_flags);
 785         if (dev_new == NULL)
 786                 return (ENOMEM);
 787         dev_lock();
 788         res = prep_cdevsw(args.mda_devsw, args.mda_flags);
 789         if (res != 0) {
 790                 dev_unlock();
 791                 devfs_free(dev_new);
 792                 return (res);
 793         }
 794         dev = newdev(&args, dev_new);
 795         if ((dev->si_flags & SI_NAMED) == 0) {
 796                 res = prep_devname(dev, fmt, ap);
 797                 if (res != 0) {
 798                         if ((args.mda_flags & MAKEDEV_CHECKNAME) == 0) {
 799                                 panic(
 800                         "make_dev_sv: bad si_name (error=%d, si_name=%s)",
 801                                     res, dev->si_name);
 802                         }
 803                         if (dev == dev_new) {
 804                                 LIST_REMOVE(dev, si_list);
 805                                 dev_unlock();
 806                                 devfs_free(dev);
 807                         } else
 808                                 dev_unlock();
 809                         return (res);
 810                 }
 811         }
 812         if ((args.mda_flags & MAKEDEV_REF) != 0)
 813                 dev_refl(dev);
 814         if ((args.mda_flags & MAKEDEV_ETERNAL) != 0)
 815                 dev->si_flags |= SI_ETERNAL;
 816         KASSERT(!(dev->si_flags & SI_NAMED),
 817             ("make_dev() by driver %s on pre-existing device (min=%x, name=%s)",
 818             args.mda_devsw->d_name, dev2unit(dev), devtoname(dev)));
 819         dev->si_flags |= SI_NAMED;
 820         if (args.mda_cr != NULL)
 821                 dev->si_cred = crhold(args.mda_cr);
 822         dev->si_uid = args.mda_uid;
 823         dev->si_gid = args.mda_gid;
 824         dev->si_mode = args.mda_mode;
 825
 826         devfs_create(dev);
 827         clean_unrhdrl(devfs_inos);
 828         dev_unlock_and_free();
 829
 830         notify_create(dev, args.mda_flags);
 831
 832         *dres = dev;
 833         return (0);
 834 }
 835
 836 int
 837 make_dev_s(struct make_dev_args *args, struct cdev **dres,
 838     const char *fmt, ...)
 839 {
 840         va_list ap;
 841         int res;
 842
 843         va_start(ap, fmt);
 844         res = make_dev_sv(args, dres, fmt, ap);
 845         va_end(ap);
 846         return (res);
 847 }
 848
 849 static int
 850 make_dev_credv(int flags, struct cdev **dres, struct cdevsw *devsw, int unit,
 851     struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt,
 852     va_list ap)
 853 {
 854         struct make_dev_args args;
 855
 856         make_dev_args_init(&args);
 857         args.mda_flags = flags;
 858         args.mda_devsw = devsw;
 859         args.mda_cr = cr;
 860         args.mda_uid = uid;
 861         args.mda_gid = gid;
 862         args.mda_mode = mode;
 863         args.mda_unit = unit;
 864         return (make_dev_sv(&args, dres, fmt, ap));
 865 }
 866
 867 struct cdev *
 868 make_dev(struct cdevsw *devsw, int unit, uid_t uid, gid_t gid, int mode,
 869     const char *fmt, ...)
 870 {
 871         struct cdev *dev;
 872         va_list ap;
 873         int res __unused;
 874
 875         va_start(ap, fmt);
 876         res = make_dev_credv(0, &dev, devsw, unit, NULL, uid, gid, mode, fmt,
 877                       ap);
 878         va_end(ap);
 879         KASSERT(res == 0 && dev != NULL,
 880             ("make_dev: failed make_dev_credv (error=%d)", res));
 881         return (dev);
 882 }
 883
 884 struct cdev *
 885 make_dev_cred(struct cdevsw *devsw, int unit, struct ucred *cr, uid_t uid,
 886     gid_t gid, int mode, const char *fmt, ...)
 887 {
 888         struct cdev *dev;
 889         va_list ap;
 890         int res __unused;
 891
 892         va_start(ap, fmt);
 893         res = make_dev_credv(0, &dev, devsw, unit, cr, uid, gid, mode, fmt, ap);
 894         va_end(ap);
 895
 896         KASSERT(res == 0 && dev != NULL,
 897             ("make_dev_cred: failed make_dev_credv (error=%d)", res));
 898         return (dev);
 899 }
 900
 901 struct cdev *
 902 make_dev_credf(int flags, struct cdevsw *devsw, int unit, struct ucred *cr,
 903     uid_t uid, gid_t gid, int mode, const char *fmt, ...)
 904 {
 905         struct cdev *dev;
 906         va_list ap;
 907         int res;
 908
 909         va_start(ap, fmt);
 910         res = make_dev_credv(flags, &dev, devsw, unit, cr, uid, gid, mode,
 911             fmt, ap);
 912         va_end(ap);
 913
 914         KASSERT(((flags & MAKEDEV_NOWAIT) != 0 && res == ENOMEM) ||
 915             ((flags & MAKEDEV_CHECKNAME) != 0 && res != ENOMEM) || res == 0,
 916             ("make_dev_credf: failed make_dev_credv (error=%d)", res));
 917         return (res == 0 ? dev : NULL);
 918 }
 919
 920 int
 921 make_dev_p(int flags, struct cdev **cdev, struct cdevsw *devsw,
 922     struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt, ...)
 923 {
 924         va_list ap;
 925         int res;
 926
 927         va_start(ap, fmt);
 928         res = make_dev_credv(flags, cdev, devsw, 0, cr, uid, gid, mode,
 929             fmt, ap);
 930         va_end(ap);
 931
 932         KASSERT(((flags & MAKEDEV_NOWAIT) != 0 && res == ENOMEM) ||
 933             ((flags & MAKEDEV_CHECKNAME) != 0 && res != ENOMEM) || res == 0,
 934             ("make_dev_p: failed make_dev_credv (error=%d)", res));
 935         return (res);
 936 }
 937
 938 static void
 939 dev_dependsl(struct cdev *pdev, struct cdev *cdev)
 940 {
 941
 942         cdev->si_parent = pdev;
 943         cdev->si_flags |= SI_CHILD;
 944         LIST_INSERT_HEAD(&pdev->si_children, cdev, si_siblings);
 945 }
 946
 947
 948 void
 949 dev_depends(struct cdev *pdev, struct cdev *cdev)
 950 {
 951
 952         dev_lock();
 953         dev_dependsl(pdev, cdev);
 954         dev_unlock();
 955 }
 956
 957 static int
 958 make_dev_alias_v(int flags, struct cdev **cdev, struct cdev *pdev,
 959     const char *fmt, va_list ap)
 960 {
 961         struct cdev *dev;
 962         int error;
 963
 964         KASSERT(pdev != NULL, ("make_dev_alias_v: pdev is NULL"));
 965         KASSERT((flags & MAKEDEV_WAITOK) == 0 || (flags & MAKEDEV_NOWAIT) == 0,
 966             ("make_dev_alias_v: both WAITOK and NOWAIT specified"));
 967         KASSERT((flags & ~(MAKEDEV_WAITOK | MAKEDEV_NOWAIT |
 968             MAKEDEV_CHECKNAME)) == 0,
 969             ("make_dev_alias_v: invalid flags specified (flags=%02x)", flags));
 970
 971         dev = devfs_alloc(flags);
 972         if (dev == NULL)
 973                 return (ENOMEM);
 974         dev_lock();
 975         dev->si_flags |= SI_ALIAS;
 976         error = prep_devname(dev, fmt, ap);
 977         if (error != 0) {
 978                 if ((flags & MAKEDEV_CHECKNAME) == 0) {
 979                         panic("make_dev_alias_v: bad si_name "
 980                             "(error=%d, si_name=%s)", error, dev->si_name);
 981                 }
 982                 dev_unlock();
 983                 devfs_free(dev);
 984                 return (error);
 985         }
 986         dev->si_flags |= SI_NAMED;
 987         devfs_create(dev);
 988         dev_dependsl(pdev, dev);
 989         clean_unrhdrl(devfs_inos);
 990         dev_unlock();
 991
 992         notify_create(dev, flags);
 993         *cdev = dev;
 994
 995         return (0);
 996 }
 997
 998 struct cdev *
 999 make_dev_alias(struct cdev *pdev, const char *fmt, ...)
1000 {
1001         struct cdev *dev;
1002         va_list ap;
1003         int res __unused;
1004
1005         va_start(ap, fmt);
1006         res = make_dev_alias_v(MAKEDEV_WAITOK, &dev, pdev, fmt, ap);
1007         va_end(ap);
1008
1009         KASSERT(res == 0 && dev != NULL,
1010             ("make_dev_alias: failed make_dev_alias_v (error=%d)", res));
1011         return (dev);
1012 }
1013
1014 int
1015 make_dev_alias_p(int flags, struct cdev **cdev, struct cdev *pdev,
1016     const char *fmt, ...)
1017 {
1018         va_list ap;
1019         int res;
1020
1021         va_start(ap, fmt);
1022         res = make_dev_alias_v(flags, cdev, pdev, fmt, ap);
1023         va_end(ap);
1024         return (res);
1025 }
1026
1027 int
1028 make_dev_physpath_alias(int flags, struct cdev **cdev, struct cdev *pdev,
1029     struct cdev *old_alias, const char *physpath)
1030 {
1031         char *devfspath;
1032         int physpath_len;
1033         int max_parentpath_len;
1034         int parentpath_len;
1035         int devfspathbuf_len;
1036         int mflags;
1037         int ret;
1038
1039         *cdev = NULL;
1040         devfspath = NULL;
1041         physpath_len = strlen(physpath);
1042         ret = EINVAL;
1043         if (physpath_len == 0)
1044                 goto out;
1045
1046         if (strncmp("id1,", physpath, 4) == 0) {
1047                 physpath += 4;
1048                 physpath_len -= 4;
1049                 if (physpath_len == 0)
1050                         goto out;
1051         }
1052
1053         max_parentpath_len = SPECNAMELEN - physpath_len - /*/*/1;
1054         parentpath_len = strlen(pdev->si_name);
1055         if (max_parentpath_len < parentpath_len) {
1056                 if (bootverbose)
1057                         printf("WARNING: Unable to alias %s "
1058                             "to %s/%s - path too long\n",
1059                             pdev->si_name, physpath, pdev->si_name);
1060                 ret = ENAMETOOLONG;
1061                 goto out;
1062         }
1063
1064         mflags = (flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK;
1065         devfspathbuf_len = physpath_len + /*/*/1 + parentpath_len + /*NUL*/1;
1066         devfspath = malloc(devfspathbuf_len, M_DEVBUF, mflags);
1067         if (devfspath == NULL) {
1068                 ret = ENOMEM;
1069                 goto out;
1070         }
1071
1072         sprintf(devfspath, "%s/%s", physpath, pdev->si_name);
1073         if (old_alias != NULL && strcmp(old_alias->si_name, devfspath) == 0) {
1074                 /* Retain the existing alias. */
1075                 *cdev = old_alias;
1076                 old_alias = NULL;
1077                 ret = 0;
1078         } else {
1079                 ret = make_dev_alias_p(flags, cdev, pdev, "%s", devfspath);
1080         }
1081 out:
1082         if (old_alias != NULL)
1083                 destroy_dev(old_alias);
1084         if (devfspath != NULL)
1085                 free(devfspath, M_DEVBUF);
1086         return (ret);
1087 }
1088
1089 static void
1090 destroy_devl(struct cdev *dev)
1091 {
1092         struct cdevsw *csw;
1093         struct cdev_privdata *p;
1094         struct cdev_priv *cdp;
1095
1096         mtx_assert(&devmtx, MA_OWNED);
1097         KASSERT(dev->si_flags & SI_NAMED,
1098             ("WARNING: Driver mistake: destroy_dev on %d\n", dev2unit(dev)));
1099         KASSERT((dev->si_flags & SI_ETERNAL) == 0,
1100             ("WARNING: Driver mistake: destroy_dev on eternal %d\n",
1101              dev2unit(dev)));
1102
1103         cdp = cdev2priv(dev);
1104         if ((cdp->cdp_flags & CDP_UNREF_DTR) == 0) {
1105                 /*
1106                  * Avoid race with dev_rel(), e.g. from the populate
1107                  * loop.  If CDP_UNREF_DTR flag is set, the reference
1108                  * to be dropped at the end of destroy_devl() was
1109                  * already taken by delist_dev_locked().
1110                  */
1111                 dev_refl(dev);
1112
1113                 devfs_destroy(dev);
1114         }
1115
1116         /* Remove name marking */
1117         dev->si_flags &= ~SI_NAMED;
1118
1119         /* If we are a child, remove us from the parents list */
1120         if (dev->si_flags & SI_CHILD) {
1121                 LIST_REMOVE(dev, si_siblings);
1122                 dev->si_flags &= ~SI_CHILD;
1123         }
1124
1125         /* Kill our children */
1126         while (!LIST_EMPTY(&dev->si_children))
1127                 destroy_devl(LIST_FIRST(&dev->si_children));
1128
1129         /* Remove from clone list */
1130         if (dev->si_flags & SI_CLONELIST) {
1131                 LIST_REMOVE(dev, si_clone);
1132                 dev->si_flags &= ~SI_CLONELIST;
1133         }
1134
1135         csw = dev->si_devsw;
1136         dev->si_devsw = NULL;   /* already NULL for SI_ALIAS */
1137         while (csw != NULL && csw->d_purge != NULL && dev->si_threadcount) {
1138                 csw->d_purge(dev);
1139                 msleep(csw, &devmtx, PRIBIO, "devprg", hz/10);
1140                 if (dev->si_threadcount)
1141                         printf("Still %lu threads in %s\n",
1142                             dev->si_threadcount, devtoname(dev));
1143         }
1144         while (dev->si_threadcount != 0) {
1145                 /* Use unique dummy wait ident */
1146                 msleep(&csw, &devmtx, PRIBIO, "devdrn", hz / 10);
1147         }
1148
1149         dev_unlock();
1150         if ((cdp->cdp_flags & CDP_UNREF_DTR) == 0) {
1151                 /* avoid out of order notify events */
1152                 notify_destroy(dev);
1153         }
1154         mtx_lock(&cdevpriv_mtx);
1155         while ((p = LIST_FIRST(&cdp->cdp_fdpriv)) != NULL) {
1156                 devfs_destroy_cdevpriv(p);
1157                 mtx_lock(&cdevpriv_mtx);
1158         }
1159         mtx_unlock(&cdevpriv_mtx);
1160         dev_lock();
1161
1162         dev->si_drv1 = 0;
1163         dev->si_drv2 = 0;
1164         bzero(&dev->__si_u, sizeof(dev->__si_u));
1165
1166         if (!(dev->si_flags & SI_ALIAS)) {
1167                 /* Remove from cdevsw list */
1168                 LIST_REMOVE(dev, si_list);
1169
1170                 /* If cdevsw has no more struct cdev *'s, clean it */
1171                 if (LIST_EMPTY(&csw->d_devs)) {
1172                         fini_cdevsw(csw);
1173                         wakeup(&csw->d_devs);
1174                 }
1175         }
1176         dev->si_flags &= ~SI_ALIAS;
1177         cdp->cdp_flags &= ~CDP_UNREF_DTR;
1178         dev->si_refcount--;
1179
1180         if (dev->si_refcount > 0)
1181                 LIST_INSERT_HEAD(&dead_cdevsw.d_devs, dev, si_list);
1182         else
1183                 dev_free_devlocked(dev);
1184 }
1185
1186 static void
1187 delist_dev_locked(struct cdev *dev)
1188 {
1189         struct cdev_priv *cdp;
1190         struct cdev *child;
1191
1192         mtx_assert(&devmtx, MA_OWNED);
1193         cdp = cdev2priv(dev);
1194         if ((cdp->cdp_flags & CDP_UNREF_DTR) != 0)
1195                 return;
1196         cdp->cdp_flags |= CDP_UNREF_DTR;
1197         dev_refl(dev);
1198         devfs_destroy(dev);
1199         LIST_FOREACH(child, &dev->si_children, si_siblings)
1200                 delist_dev_locked(child);
1201         dev_unlock();
1202         /* ensure the destroy event is queued in order */
1203         notify_destroy(dev);
1204         dev_lock();
1205 }
1206
1207 /*
1208  * This function will delist a character device and its children from
1209  * the directory listing and create a destroy event without waiting
1210  * for all character device references to go away. At some later point
1211  * destroy_dev() must be called to complete the character device
1212  * destruction. After calling this function the character device name
1213  * can instantly be re-used.
1214  */
1215 void
1216 delist_dev(struct cdev *dev)
1217 {
1218
1219         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "delist_dev");
1220         dev_lock();
1221         delist_dev_locked(dev);
1222         dev_unlock();
1223 }
1224
1225 void
1226 destroy_dev(struct cdev *dev)
1227 {
1228
1229         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "destroy_dev");
1230         dev_lock();
1231         destroy_devl(dev);
1232         dev_unlock_and_free();
1233 }
1234
1235 const char *
1236 devtoname(struct cdev *dev)
1237 {
1238
1239         return (dev->si_name);
1240 }
1241
1242 int
1243 dev_stdclone(char *name, char **namep, const char *stem, int *unit)
1244 {
1245         int u, i;
1246
1247         i = strlen(stem);
1248         if (bcmp(stem, name, i) != 0)
1249                 return (0);
1250         if (!isdigit(name[i]))
1251                 return (0);
1252         u = 0;
1253         if (name[i] == '0' && isdigit(name[i+1]))
1254                 return (0);
1255         while (isdigit(name[i])) {
1256                 u *= 10;
1257                 u += name[i++] - '0';
1258         }
1259         if (u > 0xffffff)
1260                 return (0);
1261         *unit = u;
1262         if (namep)
1263                 *namep = &name[i];
1264         if (name[i])
1265                 return (2);
1266         return (1);
1267 }
1268
1269 /*
1270  * Helper functions for cloning device drivers.
1271  *
1272  * The objective here is to make it unnecessary for the device drivers to
1273  * use rman or similar to manage their unit number space.  Due to the way
1274  * we do "on-demand" devices, using rman or other "private" methods
1275  * will be very tricky to lock down properly once we lock down this file.
1276  *
1277  * Instead we give the drivers these routines which puts the struct cdev *'s
1278  * that are to be managed on their own list, and gives the driver the ability
1279  * to ask for the first free unit number or a given specified unit number.
1280  *
1281  * In addition these routines support paired devices (pty, nmdm and similar)
1282  * by respecting a number of "flag" bits in the minor number.
1283  *
1284  */
1285
1286 struct clonedevs {
1287         LIST_HEAD(,cdev)        head;
1288 };
1289
1290 void
1291 clone_setup(struct clonedevs **cdp)
1292 {
1293
1294         *cdp = malloc(sizeof **cdp, M_DEVBUF, M_WAITOK | M_ZERO);
1295         LIST_INIT(&(*cdp)->head);
1296 }
1297
1298 int
1299 clone_create(struct clonedevs **cdp, struct cdevsw *csw, int *up,
1300     struct cdev **dp, int extra)
1301 {
1302         struct clonedevs *cd;
1303         struct cdev *dev, *ndev, *dl, *de;
1304         struct make_dev_args args;
1305         int unit, low, u;
1306
1307         KASSERT(*cdp != NULL,
1308             ("clone_setup() not called in driver \"%s\"", csw->d_name));
1309         KASSERT(!(extra & CLONE_UNITMASK),
1310             ("Illegal extra bits (0x%x) in clone_create", extra));
1311         KASSERT(*up <= CLONE_UNITMASK,
1312             ("Too high unit (0x%x) in clone_create", *up));
1313         KASSERT(csw->d_flags & D_NEEDMINOR,
1314             ("clone_create() on cdevsw without minor numbers"));
1315
1316
1317         /*
1318          * Search the list for a lot of things in one go:
1319          *   A preexisting match is returned immediately.
1320          *   The lowest free unit number if we are passed -1, and the place
1321          *       in the list where we should insert that new element.
1322          *   The place to insert a specified unit number, if applicable
1323          *       the end of the list.
1324          */
1325         unit = *up;
1326         ndev = devfs_alloc(MAKEDEV_WAITOK);
1327         dev_lock();
1328         prep_cdevsw(csw, MAKEDEV_WAITOK);
1329         low = extra;
1330         de = dl = NULL;
1331         cd = *cdp;
1332         LIST_FOREACH(dev, &cd->head, si_clone) {
1333                 KASSERT(dev->si_flags & SI_CLONELIST,
1334                     ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
1335                 u = dev2unit(dev);
1336                 if (u == (unit | extra)) {
1337                         *dp = dev;
1338                         dev_unlock();
1339                         devfs_free(ndev);
1340                         return (0);
1341                 }
1342                 if (unit == -1 && u == low) {
1343                         low++;
1344                         de = dev;
1345                         continue;
1346                 } else if (u < (unit | extra)) {
1347                         de = dev;
1348                         continue;
1349                 } else if (u > (unit | extra)) {
1350                         dl = dev;
1351                         break;
1352                 }
1353         }
1354         if (unit == -1)
1355                 unit = low & CLONE_UNITMASK;
1356         make_dev_args_init(&args);
1357         args.mda_unit = unit | extra;
1358         args.mda_devsw = csw;
1359         dev = newdev(&args, ndev);
1360         if (dev->si_flags & SI_CLONELIST) {
1361                 printf("dev %p (%s) is on clonelist\n", dev, dev->si_name);
1362                 printf("unit=%d, low=%d, extra=0x%x\n", unit, low, extra);
1363                 LIST_FOREACH(dev, &cd->head, si_clone) {
1364                         printf("\t%p %s\n", dev, dev->si_name);
1365                 }
1366                 panic("foo");
1367         }
1368         KASSERT(!(dev->si_flags & SI_CLONELIST),
1369             ("Dev %p(%s) should not be on clonelist", dev, dev->si_name));
1370         if (dl != NULL)
1371                 LIST_INSERT_BEFORE(dl, dev, si_clone);
1372         else if (de != NULL)
1373                 LIST_INSERT_AFTER(de, dev, si_clone);
1374         else
1375                 LIST_INSERT_HEAD(&cd->head, dev, si_clone);
1376         dev->si_flags |= SI_CLONELIST;
1377         *up = unit;
1378         dev_unlock_and_free();
1379         return (1);
1380 }
1381
1382 /*
1383  * Kill everything still on the list.  The driver should already have
1384  * disposed of any softc hung of the struct cdev *'s at this time.
1385  */
1386 void
1387 clone_cleanup(struct clonedevs **cdp)
1388 {
1389         struct cdev *dev;
1390         struct cdev_priv *cp;
1391         struct clonedevs *cd;
1392
1393         cd = *cdp;
1394         if (cd == NULL)
1395                 return;
1396         dev_lock();
1397         while (!LIST_EMPTY(&cd->head)) {
1398                 dev = LIST_FIRST(&cd->head);
1399                 LIST_REMOVE(dev, si_clone);
1400                 KASSERT(dev->si_flags & SI_CLONELIST,
1401                     ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
1402                 dev->si_flags &= ~SI_CLONELIST;
1403                 cp = cdev2priv(dev);
1404                 if (!(cp->cdp_flags & CDP_SCHED_DTR)) {
1405                         cp->cdp_flags |= CDP_SCHED_DTR;
1406                         KASSERT(dev->si_flags & SI_NAMED,
1407                                 ("Driver has goofed in cloning underways udev %jx unit %x",
1408                                 (uintmax_t)dev2udev(dev), dev2unit(dev)));
1409                         destroy_devl(dev);
1410                 }
1411         }
1412         dev_unlock_and_free();
1413         free(cd, M_DEVBUF);
1414         *cdp = NULL;
1415 }
1416
1417 static TAILQ_HEAD(, cdev_priv) dev_ddtr =
1418         TAILQ_HEAD_INITIALIZER(dev_ddtr);
1419 static struct task dev_dtr_task = TASK_INITIALIZER(0, destroy_dev_tq, NULL);
1420
1421 static void
1422 destroy_dev_tq(void *ctx, int pending)
1423 {
1424         struct cdev_priv *cp;
1425         struct cdev *dev;
1426         void (*cb)(void *);
1427         void *cb_arg;
1428
1429         dev_lock();
1430         while (!TAILQ_EMPTY(&dev_ddtr)) {
1431                 cp = TAILQ_FIRST(&dev_ddtr);
1432                 dev = &cp->cdp_c;
1433                 KASSERT(cp->cdp_flags & CDP_SCHED_DTR,
1434                     ("cdev %p in dev_destroy_tq without CDP_SCHED_DTR", cp));
1435                 TAILQ_REMOVE(&dev_ddtr, cp, cdp_dtr_list);
1436                 cb = cp->cdp_dtr_cb;
1437                 cb_arg = cp->cdp_dtr_cb_arg;
1438                 destroy_devl(dev);
1439                 dev_unlock_and_free();
1440                 dev_rel(dev);
1441                 if (cb != NULL)
1442                         cb(cb_arg);
1443                 dev_lock();
1444         }
1445         dev_unlock();
1446 }
1447
1448 /*
1449  * devmtx shall be locked on entry. devmtx will be unlocked after
1450  * function return.
1451  */
1452 static int
1453 destroy_dev_sched_cbl(struct cdev *dev, void (*cb)(void *), void *arg)
1454 {
1455         struct cdev_priv *cp;
1456
1457         mtx_assert(&devmtx, MA_OWNED);
1458         cp = cdev2priv(dev);
1459         if (cp->cdp_flags & CDP_SCHED_DTR) {
1460                 dev_unlock();
1461                 return (0);
1462         }
1463         dev_refl(dev);
1464         cp->cdp_flags |= CDP_SCHED_DTR;
1465         cp->cdp_dtr_cb = cb;
1466         cp->cdp_dtr_cb_arg = arg;
1467         TAILQ_INSERT_TAIL(&dev_ddtr, cp, cdp_dtr_list);
1468         dev_unlock();
1469         taskqueue_enqueue(taskqueue_swi_giant, &dev_dtr_task);
1470         return (1);
1471 }
1472
1473 int
1474 destroy_dev_sched_cb(struct cdev *dev, void (*cb)(void *), void *arg)
1475 {
1476
1477         dev_lock();
1478         return (destroy_dev_sched_cbl(dev, cb, arg));
1479 }
1480
1481 int
1482 destroy_dev_sched(struct cdev *dev)
1483 {
1484
1485         return (destroy_dev_sched_cb(dev, NULL, NULL));
1486 }
1487
1488 void
1489 destroy_dev_drain(struct cdevsw *csw)
1490 {
1491
1492         dev_lock();
1493         while (!LIST_EMPTY(&csw->d_devs)) {
1494                 msleep(&csw->d_devs, &devmtx, PRIBIO, "devscd", hz/10);
1495         }
1496         dev_unlock();
1497 }
1498
1499 void
1500 drain_dev_clone_events(void)
1501 {
1502
1503         sx_xlock(&clone_drain_lock);
1504         sx_xunlock(&clone_drain_lock);
1505 }
1506
1507 #include "opt_ddb.h"
1508 #ifdef DDB
1509 #include <sys/kernel.h>
1510
1511 #include <ddb/ddb.h>
1512
1513 DB_SHOW_COMMAND(cdev, db_show_cdev)
1514 {
1515         struct cdev_priv *cdp;
1516         struct cdev *dev;
1517         u_int flags;
1518         char buf[512];
1519
1520         if (!have_addr) {
1521                 TAILQ_FOREACH(cdp, &cdevp_list, cdp_list) {
1522                         dev = &cdp->cdp_c;
1523                         db_printf("%s %p\n", dev->si_name, dev);
1524                         if (db_pager_quit)
1525                                 break;
1526                 }
1527                 return;
1528         }
1529
1530         dev = (struct cdev *)addr;
1531         cdp = cdev2priv(dev);
1532         db_printf("dev %s ref %d use %ld thr %ld inuse %u fdpriv %p\n",
1533             dev->si_name, dev->si_refcount, dev->si_usecount,
1534             dev->si_threadcount, cdp->cdp_inuse, cdp->cdp_fdpriv.lh_first);
1535         db_printf("devsw %p si_drv0 %d si_drv1 %p si_drv2 %p\n",
1536             dev->si_devsw, dev->si_drv0, dev->si_drv1, dev->si_drv2);
1537         flags = dev->si_flags;
1538 #define SI_FLAG(flag)   do {                                            \
1539         if (flags & (flag)) {                                           \
1540                 if (buf[0] != '\0')                                     \
1541                         strlcat(buf, ", ", sizeof(buf));                \
1542                 strlcat(buf, (#flag) + 3, sizeof(buf));                 \
1543                 flags &= ~(flag);                                       \
1544         }                                                               \
1545 } while (0)
1546         buf[0] = '\0';
1547         SI_FLAG(SI_ETERNAL);
1548         SI_FLAG(SI_ALIAS);
1549         SI_FLAG(SI_NAMED);
1550         SI_FLAG(SI_CHILD);
1551         SI_FLAG(SI_DUMPDEV);
1552         SI_FLAG(SI_CLONELIST);
1553         db_printf("si_flags %s\n", buf);
1554
1555         flags = cdp->cdp_flags;
1556 #define CDP_FLAG(flag)  do {                                            \
1557         if (flags & (flag)) {                                           \
1558                 if (buf[0] != '\0')                                     \
1559                         strlcat(buf, ", ", sizeof(buf));                \
1560                 strlcat(buf, (#flag) + 4, sizeof(buf));                 \
1561                 flags &= ~(flag);                                       \
1562         }                                                               \
1563 } while (0)
1564         buf[0] = '\0';
1565         CDP_FLAG(CDP_ACTIVE);
1566         CDP_FLAG(CDP_SCHED_DTR);
1567         db_printf("cdp_flags %s\n", buf);
1568 }
1569 #endif