The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_conf.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 5f14e8983de329ef691badbfb0df04ee


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.