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

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