sys/kern/kern_conf.c

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