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

Cache object: c046109e6af1d473f60dcf9e61d6b109


[ 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.