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/8.1/sys/kern/kern_conf.c 208344 2010-05-20 09:38:15Z 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 struct cdev *make_dev_credv(int flags,
   59     struct cdevsw *devsw, int unit,
   60     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)
  182 {
  183         struct cdevsw *csw;
  184         struct cdev_priv *cdp;
  185 
  186         mtx_assert(&devmtx, MA_NOTOWNED);
  187         dev_lock();
  188         csw = dev->si_devsw;
  189         if (csw != NULL) {
  190                 cdp = cdev2priv(dev);
  191                 if ((cdp->cdp_flags & CDP_SCHED_DTR) == 0)
  192                         dev->si_threadcount++;
  193                 else
  194                         csw = NULL;
  195         }
  196         dev_unlock();
  197         return (csw);
  198 }
  199 
  200 struct cdevsw *
  201 devvn_refthread(struct vnode *vp, struct cdev **devp)
  202 {
  203         struct cdevsw *csw;
  204         struct cdev_priv *cdp;
  205 
  206         mtx_assert(&devmtx, MA_NOTOWNED);
  207         csw = NULL;
  208         dev_lock();
  209         *devp = vp->v_rdev;
  210         if (*devp != NULL) {
  211                 cdp = cdev2priv(*devp);
  212                 if ((cdp->cdp_flags & CDP_SCHED_DTR) == 0) {
  213                         csw = (*devp)->si_devsw;
  214                         if (csw != NULL)
  215                                 (*devp)->si_threadcount++;
  216                 }
  217         }
  218         dev_unlock();
  219         return (csw);
  220 }
  221 
  222 void    
  223 dev_relthread(struct cdev *dev)
  224 {
  225 
  226         mtx_assert(&devmtx, MA_NOTOWNED);
  227         dev_lock();
  228         KASSERT(dev->si_threadcount > 0,
  229             ("%s threadcount is wrong", dev->si_name));
  230         dev->si_threadcount--;
  231         dev_unlock();
  232 }
  233 
  234 int
  235 nullop(void)
  236 {
  237 
  238         return (0);
  239 }
  240 
  241 int
  242 eopnotsupp(void)
  243 {
  244 
  245         return (EOPNOTSUPP);
  246 }
  247 
  248 static int
  249 enxio(void)
  250 {
  251         return (ENXIO);
  252 }
  253 
  254 static int
  255 enodev(void)
  256 {
  257         return (ENODEV);
  258 }
  259 
  260 /* Define a dead_cdevsw for use when devices leave unexpectedly. */
  261 
  262 #define dead_open       (d_open_t *)enxio
  263 #define dead_close      (d_close_t *)enxio
  264 #define dead_read       (d_read_t *)enxio
  265 #define dead_write      (d_write_t *)enxio
  266 #define dead_ioctl      (d_ioctl_t *)enxio
  267 #define dead_poll       (d_poll_t *)enodev
  268 #define dead_mmap       (d_mmap_t *)enodev
  269 
  270 static void
  271 dead_strategy(struct bio *bp)
  272 {
  273 
  274         biofinish(bp, NULL, ENXIO);
  275 }
  276 
  277 #define dead_dump       (dumper_t *)enxio
  278 #define dead_kqfilter   (d_kqfilter_t *)enxio
  279 #define dead_mmap_single (d_mmap_single_t *)enodev
  280 
  281 static struct cdevsw dead_cdevsw = {
  282         .d_version =    D_VERSION,
  283         .d_flags =      D_NEEDGIANT, /* XXX: does dead_strategy need this ? */
  284         .d_open =       dead_open,
  285         .d_close =      dead_close,
  286         .d_read =       dead_read,
  287         .d_write =      dead_write,
  288         .d_ioctl =      dead_ioctl,
  289         .d_poll =       dead_poll,
  290         .d_mmap =       dead_mmap,
  291         .d_strategy =   dead_strategy,
  292         .d_name =       "dead",
  293         .d_dump =       dead_dump,
  294         .d_kqfilter =   dead_kqfilter,
  295         .d_mmap_single = dead_mmap_single
  296 };
  297 
  298 /* Default methods if driver does not specify method */
  299 
  300 #define null_open       (d_open_t *)nullop
  301 #define null_close      (d_close_t *)nullop
  302 #define no_read         (d_read_t *)enodev
  303 #define no_write        (d_write_t *)enodev
  304 #define no_ioctl        (d_ioctl_t *)enodev
  305 #define no_mmap         (d_mmap2_t *)enodev
  306 #define no_kqfilter     (d_kqfilter_t *)enodev
  307 #define no_mmap_single  (d_mmap_single_t *)enodev
  308 
  309 static void
  310 no_strategy(struct bio *bp)
  311 {
  312 
  313         biofinish(bp, NULL, ENODEV);
  314 }
  315 
  316 static int
  317 no_poll(struct cdev *dev __unused, int events, struct thread *td __unused)
  318 {
  319 
  320         return (poll_no_poll(events));
  321 }
  322 
  323 #define no_dump         (dumper_t *)enodev
  324 
  325 static int
  326 giant_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
  327 {
  328         struct cdevsw *dsw;
  329         int retval;
  330 
  331         dsw = dev_refthread(dev);
  332         if (dsw == NULL)
  333                 return (ENXIO);
  334         mtx_lock(&Giant);
  335         retval = dsw->d_gianttrick->d_open(dev, oflags, devtype, td);
  336         mtx_unlock(&Giant);
  337         dev_relthread(dev);
  338         return (retval);
  339 }
  340 
  341 static int
  342 giant_fdopen(struct cdev *dev, int oflags, struct thread *td, struct file *fp)
  343 {
  344         struct cdevsw *dsw;
  345         int retval;
  346 
  347         dsw = dev_refthread(dev);
  348         if (dsw == NULL)
  349                 return (ENXIO);
  350         mtx_lock(&Giant);
  351         retval = dsw->d_gianttrick->d_fdopen(dev, oflags, td, fp);
  352         mtx_unlock(&Giant);
  353         dev_relthread(dev);
  354         return (retval);
  355 }
  356 
  357 static int
  358 giant_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
  359 {
  360         struct cdevsw *dsw;
  361         int retval;
  362 
  363         dsw = dev_refthread(dev);
  364         if (dsw == NULL)
  365                 return (ENXIO);
  366         mtx_lock(&Giant);
  367         retval = dsw->d_gianttrick->d_close(dev, fflag, devtype, td);
  368         mtx_unlock(&Giant);
  369         dev_relthread(dev);
  370         return (retval);
  371 }
  372 
  373 static void
  374 giant_strategy(struct bio *bp)
  375 {
  376         struct cdevsw *dsw;
  377         struct cdev *dev;
  378 
  379         dev = bp->bio_dev;
  380         dsw = dev_refthread(dev);
  381         if (dsw == NULL) {
  382                 biofinish(bp, NULL, ENXIO);
  383                 return;
  384         }
  385         mtx_lock(&Giant);
  386         dsw->d_gianttrick->d_strategy(bp);
  387         mtx_unlock(&Giant);
  388         dev_relthread(dev);
  389 }
  390 
  391 static int
  392 giant_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
  393 {
  394         struct cdevsw *dsw;
  395         int retval;
  396 
  397         dsw = dev_refthread(dev);
  398         if (dsw == NULL)
  399                 return (ENXIO);
  400         mtx_lock(&Giant);
  401         retval = dsw->d_gianttrick->d_ioctl(dev, cmd, data, fflag, td);
  402         mtx_unlock(&Giant);
  403         dev_relthread(dev);
  404         return (retval);
  405 }
  406   
  407 static int
  408 giant_read(struct cdev *dev, struct uio *uio, int ioflag)
  409 {
  410         struct cdevsw *dsw;
  411         int retval;
  412 
  413         dsw = dev_refthread(dev);
  414         if (dsw == NULL)
  415                 return (ENXIO);
  416         mtx_lock(&Giant);
  417         retval = dsw->d_gianttrick->d_read(dev, uio, ioflag);
  418         mtx_unlock(&Giant);
  419         dev_relthread(dev);
  420         return (retval);
  421 }
  422 
  423 static int
  424 giant_write(struct cdev *dev, struct uio *uio, int ioflag)
  425 {
  426         struct cdevsw *dsw;
  427         int retval;
  428 
  429         dsw = dev_refthread(dev);
  430         if (dsw == NULL)
  431                 return (ENXIO);
  432         mtx_lock(&Giant);
  433         retval = dsw->d_gianttrick->d_write(dev, uio, ioflag);
  434         mtx_unlock(&Giant);
  435         dev_relthread(dev);
  436         return (retval);
  437 }
  438 
  439 static int
  440 giant_poll(struct cdev *dev, int events, struct thread *td)
  441 {
  442         struct cdevsw *dsw;
  443         int retval;
  444 
  445         dsw = dev_refthread(dev);
  446         if (dsw == NULL)
  447                 return (ENXIO);
  448         mtx_lock(&Giant);
  449         retval = dsw->d_gianttrick->d_poll(dev, events, td);
  450         mtx_unlock(&Giant);
  451         dev_relthread(dev);
  452         return (retval);
  453 }
  454 
  455 static int
  456 giant_kqfilter(struct cdev *dev, struct knote *kn)
  457 {
  458         struct cdevsw *dsw;
  459         int retval;
  460 
  461         dsw = dev_refthread(dev);
  462         if (dsw == NULL)
  463                 return (ENXIO);
  464         mtx_lock(&Giant);
  465         retval = dsw->d_gianttrick->d_kqfilter(dev, kn);
  466         mtx_unlock(&Giant);
  467         dev_relthread(dev);
  468         return (retval);
  469 }
  470 
  471 static int
  472 giant_mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot,
  473     vm_memattr_t *memattr)
  474 {
  475         struct cdevsw *dsw;
  476         int retval;
  477 
  478         dsw = dev_refthread(dev);
  479         if (dsw == NULL)
  480                 return (ENXIO);
  481         mtx_lock(&Giant);
  482         if (dsw->d_gianttrick->d_flags & D_MMAP2)
  483                 retval = dsw->d_gianttrick->d_mmap2(dev, offset, paddr, nprot,
  484                     memattr);
  485         else
  486                 retval = dsw->d_gianttrick->d_mmap(dev, offset, paddr, nprot);
  487         mtx_unlock(&Giant);
  488         dev_relthread(dev);
  489         return (retval);
  490 }
  491 
  492 static int
  493 giant_mmap_single(struct cdev *dev, vm_ooffset_t *offset, vm_size_t size,
  494     vm_object_t *object, int nprot)
  495 {
  496         struct cdevsw *dsw;
  497         int retval;
  498 
  499         dsw = dev_refthread(dev);
  500         if (dsw == NULL)
  501                 return (ENXIO);
  502         mtx_lock(&Giant);
  503         retval = dsw->d_gianttrick->d_mmap_single(dev, offset, size, object,
  504             nprot);
  505         mtx_unlock(&Giant);
  506         dev_relthread(dev);
  507         return (retval);
  508 }
  509 
  510 static void
  511 notify(struct cdev *dev, const char *ev, int flags)
  512 {
  513         static const char prefix[] = "cdev=";
  514         char *data;
  515         int namelen;
  516 
  517         if (cold)
  518                 return;
  519         namelen = strlen(dev->si_name);
  520         data = malloc(namelen + sizeof(prefix), M_TEMP,
  521              (flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK);
  522         if (data == NULL)
  523                 return;
  524         memcpy(data, prefix, sizeof(prefix) - 1);
  525         memcpy(data + sizeof(prefix) - 1, dev->si_name, namelen + 1);
  526         devctl_notify("DEVFS", "CDEV", ev, data);
  527         free(data, M_TEMP);
  528 }
  529 
  530 static void
  531 notify_create(struct cdev *dev, int flags)
  532 {
  533 
  534         notify(dev, "CREATE", flags);
  535 }
  536 
  537 static void
  538 notify_destroy(struct cdev *dev)
  539 {
  540 
  541         notify(dev, "DESTROY", MAKEDEV_WAITOK);
  542 }
  543 
  544 static struct cdev *
  545 newdev(struct cdevsw *csw, int unit, struct cdev *si)
  546 {
  547         struct cdev *si2;
  548 
  549         mtx_assert(&devmtx, MA_OWNED);
  550         if (csw->d_flags & D_NEEDMINOR) {
  551                 /* We may want to return an existing device */
  552                 LIST_FOREACH(si2, &csw->d_devs, si_list) {
  553                         if (dev2unit(si2) == unit) {
  554                                 dev_free_devlocked(si);
  555                                 return (si2);
  556                         }
  557                 }
  558         }
  559         si->si_drv0 = unit;
  560         si->si_devsw = csw;
  561         LIST_INSERT_HEAD(&csw->d_devs, si, si_list);
  562         return (si);
  563 }
  564 
  565 static void
  566 fini_cdevsw(struct cdevsw *devsw)
  567 {
  568         struct cdevsw *gt;
  569 
  570         if (devsw->d_gianttrick != NULL) {
  571                 gt = devsw->d_gianttrick;
  572                 memcpy(devsw, gt, sizeof *devsw);
  573                 cdevsw_free_devlocked(gt);
  574                 devsw->d_gianttrick = NULL;
  575         }
  576         devsw->d_flags &= ~D_INIT;
  577 }
  578 
  579 static int
  580 prep_cdevsw(struct cdevsw *devsw, int flags)
  581 {
  582         struct cdevsw *dsw2;
  583 
  584         mtx_assert(&devmtx, MA_OWNED);
  585         if (devsw->d_flags & D_INIT)
  586                 return (1);
  587         if (devsw->d_flags & D_NEEDGIANT) {
  588                 dev_unlock();
  589                 dsw2 = malloc(sizeof *dsw2, M_DEVT,
  590                      (flags & MAKEDEV_NOWAIT) ? M_NOWAIT : M_WAITOK);
  591                 dev_lock();
  592                 if (dsw2 == NULL && !(devsw->d_flags & D_INIT))
  593                         return (0);
  594         } else
  595                 dsw2 = NULL;
  596         if (devsw->d_flags & D_INIT) {
  597                 if (dsw2 != NULL)
  598                         cdevsw_free_devlocked(dsw2);
  599                 return (1);
  600         }
  601 
  602         if (devsw->d_version != D_VERSION_01 &&
  603             devsw->d_version != D_VERSION_02) {
  604                 printf(
  605                     "WARNING: Device driver \"%s\" has wrong version %s\n",
  606                     devsw->d_name == NULL ? "???" : devsw->d_name,
  607                     "and is disabled.  Recompile KLD module.");
  608                 devsw->d_open = dead_open;
  609                 devsw->d_close = dead_close;
  610                 devsw->d_read = dead_read;
  611                 devsw->d_write = dead_write;
  612                 devsw->d_ioctl = dead_ioctl;
  613                 devsw->d_poll = dead_poll;
  614                 devsw->d_mmap = dead_mmap;
  615                 devsw->d_strategy = dead_strategy;
  616                 devsw->d_dump = dead_dump;
  617                 devsw->d_kqfilter = dead_kqfilter;
  618         }
  619         if (devsw->d_version == D_VERSION_01)
  620                 devsw->d_mmap_single = NULL;
  621         
  622         if (devsw->d_flags & D_NEEDGIANT) {
  623                 if (devsw->d_gianttrick == NULL) {
  624                         memcpy(dsw2, devsw, sizeof *dsw2);
  625                         devsw->d_gianttrick = dsw2;
  626                         devsw->d_flags |= D_MMAP2;
  627                         dsw2 = NULL;
  628                 }
  629         }
  630 
  631 #define FIXUP(member, noop, giant)                              \
  632         do {                                                    \
  633                 if (devsw->member == NULL) {                    \
  634                         devsw->member = noop;                   \
  635                 } else if (devsw->d_flags & D_NEEDGIANT)        \
  636                         devsw->member = giant;                  \
  637                 }                                               \
  638         while (0)
  639 
  640         FIXUP(d_open,           null_open,      giant_open);
  641         FIXUP(d_fdopen,         NULL,           giant_fdopen);
  642         FIXUP(d_close,          null_close,     giant_close);
  643         FIXUP(d_read,           no_read,        giant_read);
  644         FIXUP(d_write,          no_write,       giant_write);
  645         FIXUP(d_ioctl,          no_ioctl,       giant_ioctl);
  646         FIXUP(d_poll,           no_poll,        giant_poll);
  647         FIXUP(d_mmap2,          no_mmap,        giant_mmap);
  648         FIXUP(d_strategy,       no_strategy,    giant_strategy);
  649         FIXUP(d_kqfilter,       no_kqfilter,    giant_kqfilter);
  650         FIXUP(d_mmap_single,    no_mmap_single, giant_mmap_single);
  651 
  652         if (devsw->d_dump == NULL)      devsw->d_dump = no_dump;
  653 
  654         LIST_INIT(&devsw->d_devs);
  655 
  656         devsw->d_flags |= D_INIT;
  657 
  658         if (dsw2 != NULL)
  659                 cdevsw_free_devlocked(dsw2);
  660         return (1);
  661 }
  662 
  663 static struct cdev *
  664 make_dev_credv(int flags, struct cdevsw *devsw, int unit,
  665     struct ucred *cr, uid_t uid,
  666     gid_t gid, int mode, const char *fmt, va_list ap)
  667 {
  668         struct cdev *dev;
  669         int i;
  670 
  671         dev = devfs_alloc(flags);
  672         if (dev == NULL)
  673                 return (NULL);
  674         dev_lock();
  675         if (!prep_cdevsw(devsw, flags)) {
  676                 dev_unlock();
  677                 devfs_free(dev);
  678                 return (NULL);
  679         }
  680         dev = newdev(devsw, unit, dev);
  681         if (flags & MAKEDEV_REF)
  682                 dev_refl(dev);
  683         if (dev->si_flags & SI_CHEAPCLONE &&
  684             dev->si_flags & SI_NAMED) {
  685                 /*
  686                  * This is allowed as it removes races and generally
  687                  * simplifies cloning devices.
  688                  * XXX: still ??
  689                  */
  690                 dev_unlock_and_free();
  691                 return (dev);
  692         }
  693         KASSERT(!(dev->si_flags & SI_NAMED),
  694             ("make_dev() by driver %s on pre-existing device (min=%x, name=%s)",
  695             devsw->d_name, dev2unit(dev), devtoname(dev)));
  696 
  697         i = vsnrprintf(dev->__si_namebuf, sizeof dev->__si_namebuf, 32, fmt, ap);
  698         if (i > (sizeof dev->__si_namebuf - 1)) {
  699                 printf("WARNING: Device name truncated! (%s)\n", 
  700                     dev->__si_namebuf);
  701         }
  702                 
  703         dev->si_flags |= SI_NAMED;
  704         if (cr != NULL)
  705                 dev->si_cred = crhold(cr);
  706         dev->si_uid = uid;
  707         dev->si_gid = gid;
  708         dev->si_mode = mode;
  709 
  710         devfs_create(dev);
  711         clean_unrhdrl(devfs_inos);
  712         dev_unlock_and_free();
  713 
  714         notify_create(dev, flags);
  715 
  716         return (dev);
  717 }
  718 
  719 struct cdev *
  720 make_dev(struct cdevsw *devsw, int unit, uid_t uid, gid_t gid, int mode,
  721     const char *fmt, ...)
  722 {
  723         struct cdev *dev;
  724         va_list ap;
  725 
  726         va_start(ap, fmt);
  727         dev = make_dev_credv(0, devsw, unit, NULL, uid, gid, mode, fmt, ap);
  728         va_end(ap);
  729         return (dev);
  730 }
  731 
  732 struct cdev *
  733 make_dev_cred(struct cdevsw *devsw, int unit, struct ucred *cr, uid_t uid,
  734     gid_t gid, int mode, const char *fmt, ...)
  735 {
  736         struct cdev *dev;
  737         va_list ap;
  738 
  739         va_start(ap, fmt);
  740         dev = make_dev_credv(0, devsw, unit, cr, uid, gid, mode, fmt, ap);
  741         va_end(ap);
  742 
  743         return (dev);
  744 }
  745 
  746 struct cdev *
  747 make_dev_credf(int flags, struct cdevsw *devsw, int unit,
  748     struct ucred *cr, uid_t uid,
  749     gid_t gid, int mode, const char *fmt, ...)
  750 {
  751         struct cdev *dev;
  752         va_list ap;
  753 
  754         va_start(ap, fmt);
  755         dev = make_dev_credv(flags, devsw, unit, cr, uid, gid, mode,
  756             fmt, ap);
  757         va_end(ap);
  758 
  759         return (dev);
  760 }
  761 
  762 static void
  763 dev_dependsl(struct cdev *pdev, struct cdev *cdev)
  764 {
  765 
  766         cdev->si_parent = pdev;
  767         cdev->si_flags |= SI_CHILD;
  768         LIST_INSERT_HEAD(&pdev->si_children, cdev, si_siblings);
  769 }
  770 
  771 
  772 void
  773 dev_depends(struct cdev *pdev, struct cdev *cdev)
  774 {
  775 
  776         dev_lock();
  777         dev_dependsl(pdev, cdev);
  778         dev_unlock();
  779 }
  780 
  781 struct cdev *
  782 make_dev_alias(struct cdev *pdev, const char *fmt, ...)
  783 {
  784         struct cdev *dev;
  785         va_list ap;
  786         int i;
  787 
  788         KASSERT(pdev != NULL, ("NULL pdev"));
  789         dev = devfs_alloc(MAKEDEV_WAITOK);
  790         dev_lock();
  791         dev->si_flags |= SI_ALIAS;
  792         dev->si_flags |= SI_NAMED;
  793         va_start(ap, fmt);
  794         i = vsnrprintf(dev->__si_namebuf, sizeof dev->__si_namebuf, 32, fmt, ap);
  795         if (i > (sizeof dev->__si_namebuf - 1)) {
  796                 printf("WARNING: Device name truncated! (%s)\n", 
  797                     dev->__si_namebuf);
  798         }
  799         va_end(ap);
  800 
  801         devfs_create(dev);
  802         dev_dependsl(pdev, dev);
  803         clean_unrhdrl(devfs_inos);
  804         dev_unlock();
  805 
  806         notify_create(dev, MAKEDEV_WAITOK);
  807 
  808         return (dev);
  809 }
  810 
  811 static void
  812 destroy_devl(struct cdev *dev)
  813 {
  814         struct cdevsw *csw;
  815         struct cdev_privdata *p, *p1;
  816 
  817         mtx_assert(&devmtx, MA_OWNED);
  818         KASSERT(dev->si_flags & SI_NAMED,
  819             ("WARNING: Driver mistake: destroy_dev on %d\n", dev2unit(dev)));
  820 
  821         devfs_destroy(dev);
  822 
  823         /* Remove name marking */
  824         dev->si_flags &= ~SI_NAMED;
  825 
  826         /* If we are a child, remove us from the parents list */
  827         if (dev->si_flags & SI_CHILD) {
  828                 LIST_REMOVE(dev, si_siblings);
  829                 dev->si_flags &= ~SI_CHILD;
  830         }
  831 
  832         /* Kill our children */
  833         while (!LIST_EMPTY(&dev->si_children))
  834                 destroy_devl(LIST_FIRST(&dev->si_children));
  835 
  836         /* Remove from clone list */
  837         if (dev->si_flags & SI_CLONELIST) {
  838                 LIST_REMOVE(dev, si_clone);
  839                 dev->si_flags &= ~SI_CLONELIST;
  840         }
  841 
  842         dev->si_refcount++;     /* Avoid race with dev_rel() */
  843         csw = dev->si_devsw;
  844         dev->si_devsw = NULL;   /* already NULL for SI_ALIAS */
  845         while (csw != NULL && csw->d_purge != NULL && dev->si_threadcount) {
  846                 csw->d_purge(dev);
  847                 msleep(csw, &devmtx, PRIBIO, "devprg", hz/10);
  848                 if (dev->si_threadcount)
  849                         printf("Still %lu threads in %s\n",
  850                             dev->si_threadcount, devtoname(dev));
  851         }
  852         while (dev->si_threadcount != 0) {
  853                 /* Use unique dummy wait ident */
  854                 msleep(&csw, &devmtx, PRIBIO, "devdrn", hz / 10);
  855         }
  856 
  857         dev_unlock();
  858         notify_destroy(dev);
  859         mtx_lock(&cdevpriv_mtx);
  860         LIST_FOREACH_SAFE(p, &cdev2priv(dev)->cdp_fdpriv, cdpd_list, p1) {
  861                 devfs_destroy_cdevpriv(p);
  862                 mtx_lock(&cdevpriv_mtx);
  863         }
  864         mtx_unlock(&cdevpriv_mtx);
  865         dev_lock();
  866 
  867         dev->si_drv1 = 0;
  868         dev->si_drv2 = 0;
  869         bzero(&dev->__si_u, sizeof(dev->__si_u));
  870 
  871         if (!(dev->si_flags & SI_ALIAS)) {
  872                 /* Remove from cdevsw list */
  873                 LIST_REMOVE(dev, si_list);
  874 
  875                 /* If cdevsw has no more struct cdev *'s, clean it */
  876                 if (LIST_EMPTY(&csw->d_devs)) {
  877                         fini_cdevsw(csw);
  878                         wakeup(&csw->d_devs);
  879                 }
  880         }
  881         dev->si_flags &= ~SI_ALIAS;
  882         dev->si_refcount--;     /* Avoid race with dev_rel() */
  883 
  884         if (dev->si_refcount > 0) {
  885                 LIST_INSERT_HEAD(&dead_cdevsw.d_devs, dev, si_list);
  886         } else {
  887                 dev_free_devlocked(dev);
  888         }
  889 }
  890 
  891 void
  892 destroy_dev(struct cdev *dev)
  893 {
  894 
  895         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "destroy_dev");
  896         dev_lock();
  897         destroy_devl(dev);
  898         dev_unlock_and_free();
  899 }
  900 
  901 const char *
  902 devtoname(struct cdev *dev)
  903 {
  904 
  905         return (dev->si_name);
  906 }
  907 
  908 int
  909 dev_stdclone(char *name, char **namep, const char *stem, int *unit)
  910 {
  911         int u, i;
  912 
  913         i = strlen(stem);
  914         if (bcmp(stem, name, i) != 0)
  915                 return (0);
  916         if (!isdigit(name[i]))
  917                 return (0);
  918         u = 0;
  919         if (name[i] == '' && isdigit(name[i+1]))
  920                 return (0);
  921         while (isdigit(name[i])) {
  922                 u *= 10;
  923                 u += name[i++] - '';
  924         }
  925         if (u > 0xffffff)
  926                 return (0);
  927         *unit = u;
  928         if (namep)
  929                 *namep = &name[i];
  930         if (name[i]) 
  931                 return (2);
  932         return (1);
  933 }
  934 
  935 /*
  936  * Helper functions for cloning device drivers.
  937  *
  938  * The objective here is to make it unnecessary for the device drivers to
  939  * use rman or similar to manage their unit number space.  Due to the way
  940  * we do "on-demand" devices, using rman or other "private" methods 
  941  * will be very tricky to lock down properly once we lock down this file.
  942  *
  943  * Instead we give the drivers these routines which puts the struct cdev *'s
  944  * that are to be managed on their own list, and gives the driver the ability
  945  * to ask for the first free unit number or a given specified unit number.
  946  *
  947  * In addition these routines support paired devices (pty, nmdm and similar)
  948  * by respecting a number of "flag" bits in the minor number.
  949  *
  950  */
  951 
  952 struct clonedevs {
  953         LIST_HEAD(,cdev)        head;
  954 };
  955 
  956 void
  957 clone_setup(struct clonedevs **cdp)
  958 {
  959 
  960         *cdp = malloc(sizeof **cdp, M_DEVBUF, M_WAITOK | M_ZERO);
  961         LIST_INIT(&(*cdp)->head);
  962 }
  963 
  964 int
  965 clone_create(struct clonedevs **cdp, struct cdevsw *csw, int *up,
  966     struct cdev **dp, int extra)
  967 {
  968         struct clonedevs *cd;
  969         struct cdev *dev, *ndev, *dl, *de;
  970         int unit, low, u;
  971 
  972         KASSERT(*cdp != NULL,
  973             ("clone_setup() not called in driver \"%s\"", csw->d_name));
  974         KASSERT(!(extra & CLONE_UNITMASK),
  975             ("Illegal extra bits (0x%x) in clone_create", extra));
  976         KASSERT(*up <= CLONE_UNITMASK,
  977             ("Too high unit (0x%x) in clone_create", *up));
  978         KASSERT(csw->d_flags & D_NEEDMINOR,
  979             ("clone_create() on cdevsw without minor numbers"));
  980 
  981 
  982         /*
  983          * Search the list for a lot of things in one go:
  984          *   A preexisting match is returned immediately.
  985          *   The lowest free unit number if we are passed -1, and the place
  986          *       in the list where we should insert that new element.
  987          *   The place to insert a specified unit number, if applicable
  988          *       the end of the list.
  989          */
  990         unit = *up;
  991         ndev = devfs_alloc(MAKEDEV_WAITOK);
  992         dev_lock();
  993         prep_cdevsw(csw, MAKEDEV_WAITOK);
  994         low = extra;
  995         de = dl = NULL;
  996         cd = *cdp;
  997         LIST_FOREACH(dev, &cd->head, si_clone) {
  998                 KASSERT(dev->si_flags & SI_CLONELIST,
  999                     ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
 1000                 u = dev2unit(dev);
 1001                 if (u == (unit | extra)) {
 1002                         *dp = dev;
 1003                         dev_unlock();
 1004                         devfs_free(ndev);
 1005                         return (0);
 1006                 }
 1007                 if (unit == -1 && u == low) {
 1008                         low++;
 1009                         de = dev;
 1010                         continue;
 1011                 } else if (u < (unit | extra)) {
 1012                         de = dev;
 1013                         continue;
 1014                 } else if (u > (unit | extra)) {
 1015                         dl = dev;
 1016                         break;
 1017                 }
 1018         }
 1019         if (unit == -1)
 1020                 unit = low & CLONE_UNITMASK;
 1021         dev = newdev(csw, unit | extra, ndev);
 1022         if (dev->si_flags & SI_CLONELIST) {
 1023                 printf("dev %p (%s) is on clonelist\n", dev, dev->si_name);
 1024                 printf("unit=%d, low=%d, extra=0x%x\n", unit, low, extra);
 1025                 LIST_FOREACH(dev, &cd->head, si_clone) {
 1026                         printf("\t%p %s\n", dev, dev->si_name);
 1027                 }
 1028                 panic("foo");
 1029         }
 1030         KASSERT(!(dev->si_flags & SI_CLONELIST),
 1031             ("Dev %p(%s) should not be on clonelist", dev, dev->si_name));
 1032         if (dl != NULL)
 1033                 LIST_INSERT_BEFORE(dl, dev, si_clone);
 1034         else if (de != NULL)
 1035                 LIST_INSERT_AFTER(de, dev, si_clone);
 1036         else
 1037                 LIST_INSERT_HEAD(&cd->head, dev, si_clone);
 1038         dev->si_flags |= SI_CLONELIST;
 1039         *up = unit;
 1040         dev_unlock_and_free();
 1041         return (1);
 1042 }
 1043 
 1044 /*
 1045  * Kill everything still on the list.  The driver should already have
 1046  * disposed of any softc hung of the struct cdev *'s at this time.
 1047  */
 1048 void
 1049 clone_cleanup(struct clonedevs **cdp)
 1050 {
 1051         struct cdev *dev;
 1052         struct cdev_priv *cp;
 1053         struct clonedevs *cd;
 1054         
 1055         cd = *cdp;
 1056         if (cd == NULL)
 1057                 return;
 1058         dev_lock();
 1059         while (!LIST_EMPTY(&cd->head)) {
 1060                 dev = LIST_FIRST(&cd->head);
 1061                 LIST_REMOVE(dev, si_clone);
 1062                 KASSERT(dev->si_flags & SI_CLONELIST,
 1063                     ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
 1064                 dev->si_flags &= ~SI_CLONELIST;
 1065                 cp = cdev2priv(dev);
 1066                 if (!(cp->cdp_flags & CDP_SCHED_DTR)) {
 1067                         cp->cdp_flags |= CDP_SCHED_DTR;
 1068                         KASSERT(dev->si_flags & SI_NAMED,
 1069                                 ("Driver has goofed in cloning underways udev %x unit %x", dev2udev(dev), dev2unit(dev)));
 1070                         destroy_devl(dev);
 1071                 }
 1072         }
 1073         dev_unlock_and_free();
 1074         free(cd, M_DEVBUF);
 1075         *cdp = NULL;
 1076 }
 1077 
 1078 static TAILQ_HEAD(, cdev_priv) dev_ddtr =
 1079         TAILQ_HEAD_INITIALIZER(dev_ddtr);
 1080 static struct task dev_dtr_task;
 1081 
 1082 static void
 1083 destroy_dev_tq(void *ctx, int pending)
 1084 {
 1085         struct cdev_priv *cp;
 1086         struct cdev *dev;
 1087         void (*cb)(void *);
 1088         void *cb_arg;
 1089 
 1090         dev_lock();
 1091         while (!TAILQ_EMPTY(&dev_ddtr)) {
 1092                 cp = TAILQ_FIRST(&dev_ddtr);
 1093                 dev = &cp->cdp_c;
 1094                 KASSERT(cp->cdp_flags & CDP_SCHED_DTR,
 1095                     ("cdev %p in dev_destroy_tq without CDP_SCHED_DTR", cp));
 1096                 TAILQ_REMOVE(&dev_ddtr, cp, cdp_dtr_list);
 1097                 cb = cp->cdp_dtr_cb;
 1098                 cb_arg = cp->cdp_dtr_cb_arg;
 1099                 destroy_devl(dev);
 1100                 dev_unlock_and_free();
 1101                 dev_rel(dev);
 1102                 if (cb != NULL)
 1103                         cb(cb_arg);
 1104                 dev_lock();
 1105         }
 1106         dev_unlock();
 1107 }
 1108 
 1109 /*
 1110  * devmtx shall be locked on entry. devmtx will be unlocked after
 1111  * function return.
 1112  */
 1113 static int
 1114 destroy_dev_sched_cbl(struct cdev *dev, void (*cb)(void *), void *arg)
 1115 {
 1116         struct cdev_priv *cp;
 1117 
 1118         mtx_assert(&devmtx, MA_OWNED);
 1119         cp = cdev2priv(dev);
 1120         if (cp->cdp_flags & CDP_SCHED_DTR) {
 1121                 dev_unlock();
 1122                 return (0);
 1123         }
 1124         dev_refl(dev);
 1125         cp->cdp_flags |= CDP_SCHED_DTR;
 1126         cp->cdp_dtr_cb = cb;
 1127         cp->cdp_dtr_cb_arg = arg;
 1128         TAILQ_INSERT_TAIL(&dev_ddtr, cp, cdp_dtr_list);
 1129         dev_unlock();
 1130         taskqueue_enqueue(taskqueue_swi_giant, &dev_dtr_task);
 1131         return (1);
 1132 }
 1133 
 1134 int
 1135 destroy_dev_sched_cb(struct cdev *dev, void (*cb)(void *), void *arg)
 1136 {
 1137 
 1138         dev_lock();
 1139         return (destroy_dev_sched_cbl(dev, cb, arg));
 1140 }
 1141 
 1142 int
 1143 destroy_dev_sched(struct cdev *dev)
 1144 {
 1145 
 1146         return (destroy_dev_sched_cb(dev, NULL, NULL));
 1147 }
 1148 
 1149 void
 1150 destroy_dev_drain(struct cdevsw *csw)
 1151 {
 1152 
 1153         dev_lock();
 1154         while (!LIST_EMPTY(&csw->d_devs)) {
 1155                 msleep(&csw->d_devs, &devmtx, PRIBIO, "devscd", hz/10);
 1156         }
 1157         dev_unlock();
 1158 }
 1159 
 1160 void
 1161 drain_dev_clone_events(void)
 1162 {
 1163 
 1164         sx_xlock(&clone_drain_lock);
 1165         sx_xunlock(&clone_drain_lock);
 1166 }
 1167 
 1168 static void
 1169 devdtr_init(void *dummy __unused)
 1170 {
 1171 
 1172         TASK_INIT(&dev_dtr_task, 0, destroy_dev_tq, NULL);
 1173 }
 1174 
 1175 SYSINIT(devdtr, SI_SUB_DEVFS, SI_ORDER_SECOND, devdtr_init, NULL);

Cache object: 0554206b94e05e5f0b8f19fcb0a8827c


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