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/geom/geom_dev.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) 2002 Poul-Henning Kamp
    3  * Copyright (c) 2002 Networks Associates Technology, Inc.
    4  * All rights reserved.
    5  *
    6  * This software was developed for the FreeBSD Project by Poul-Henning Kamp
    7  * and NAI Labs, the Security Research Division of Network Associates, Inc.
    8  * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
    9  * DARPA CHATS research program.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. The names of the authors may not be used to endorse or promote
   20  *    products derived from this software without specific prior written
   21  *    permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  */
   35 
   36 #include <sys/cdefs.h>
   37 __FBSDID("$FreeBSD: releng/10.1/sys/geom/geom_dev.c 260385 2014-01-07 01:32:23Z scottl $");
   38 
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/malloc.h>
   42 #include <sys/kernel.h>
   43 #include <sys/conf.h>
   44 #include <sys/ctype.h>
   45 #include <sys/bio.h>
   46 #include <sys/bus.h>
   47 #include <sys/lock.h>
   48 #include <sys/mutex.h>
   49 #include <sys/proc.h>
   50 #include <sys/errno.h>
   51 #include <sys/time.h>
   52 #include <sys/disk.h>
   53 #include <sys/fcntl.h>
   54 #include <sys/limits.h>
   55 #include <sys/sysctl.h>
   56 #include <geom/geom.h>
   57 #include <geom/geom_int.h>
   58 #include <machine/stdarg.h>
   59 
   60 struct g_dev_softc {
   61         struct mtx       sc_mtx;
   62         struct cdev     *sc_dev;
   63         struct cdev     *sc_alias;
   64         int              sc_open;
   65         int              sc_active;
   66 };
   67 
   68 static d_open_t         g_dev_open;
   69 static d_close_t        g_dev_close;
   70 static d_strategy_t     g_dev_strategy;
   71 static d_ioctl_t        g_dev_ioctl;
   72 
   73 static struct cdevsw g_dev_cdevsw = {
   74         .d_version =    D_VERSION,
   75         .d_open =       g_dev_open,
   76         .d_close =      g_dev_close,
   77         .d_read =       physread,
   78         .d_write =      physwrite,
   79         .d_ioctl =      g_dev_ioctl,
   80         .d_strategy =   g_dev_strategy,
   81         .d_name =       "g_dev",
   82         .d_flags =      D_DISK | D_TRACKCLOSE,
   83 };
   84 
   85 static g_taste_t g_dev_taste;
   86 static g_orphan_t g_dev_orphan;
   87 static g_attrchanged_t g_dev_attrchanged;
   88 
   89 static struct g_class g_dev_class       = {
   90         .name = "DEV",
   91         .version = G_VERSION,
   92         .taste = g_dev_taste,
   93         .orphan = g_dev_orphan,
   94         .attrchanged = g_dev_attrchanged
   95 };
   96 
   97 /*
   98  * We target 262144 (8 x 32768) sectors by default as this significantly
   99  * increases the throughput on commonly used SSD's with a marginal
  100  * increase in non-interruptible request latency.
  101  */
  102 static uint64_t g_dev_del_max_sectors = 262144;
  103 SYSCTL_DECL(_kern_geom);
  104 SYSCTL_NODE(_kern_geom, OID_AUTO, dev, CTLFLAG_RW, 0, "GEOM_DEV stuff");
  105 SYSCTL_QUAD(_kern_geom_dev, OID_AUTO, delete_max_sectors, CTLFLAG_RW,
  106     &g_dev_del_max_sectors, 0, "Maximum number of sectors in a single "
  107     "delete request sent to the provider. Larger requests are chunked "
  108     "so they can be interrupted. (0 = disable chunking)");
  109 
  110 static void
  111 g_dev_destroy(void *arg, int flags __unused)
  112 {
  113         struct g_consumer *cp;
  114         struct g_geom *gp;
  115         struct g_dev_softc *sc;
  116 
  117         g_topology_assert();
  118         cp = arg;
  119         gp = cp->geom;
  120         sc = cp->private;
  121         g_trace(G_T_TOPOLOGY, "g_dev_destroy(%p(%s))", cp, gp->name);
  122         if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
  123                 g_access(cp, -cp->acr, -cp->acw, -cp->ace);
  124         g_detach(cp);
  125         g_destroy_consumer(cp);
  126         g_destroy_geom(gp);
  127         mtx_destroy(&sc->sc_mtx);
  128         g_free(sc);
  129 }
  130 
  131 void
  132 g_dev_print(void)
  133 {
  134         struct g_geom *gp;
  135         char const *p = "";
  136 
  137         LIST_FOREACH(gp, &g_dev_class.geom, geom) {
  138                 printf("%s%s", p, gp->name);
  139                 p = " ";
  140         }
  141         printf("\n");
  142 }
  143 
  144 static void
  145 g_dev_attrchanged(struct g_consumer *cp, const char *attr)
  146 {
  147         struct g_dev_softc *sc;
  148         struct cdev *dev;
  149         char buf[SPECNAMELEN + 6];
  150 
  151         sc = cp->private;
  152         if (strcmp(attr, "GEOM::media") == 0) {
  153                 dev = sc->sc_dev;
  154                 snprintf(buf, sizeof(buf), "cdev=%s", dev->si_name);
  155                 devctl_notify_f("DEVFS", "CDEV", "MEDIACHANGE", buf, M_WAITOK);
  156                 dev = sc->sc_alias;
  157                 if (dev != NULL) {
  158                         snprintf(buf, sizeof(buf), "cdev=%s", dev->si_name);
  159                         devctl_notify_f("DEVFS", "CDEV", "MEDIACHANGE", buf,
  160                             M_WAITOK);
  161                 }
  162                 return;
  163         }
  164 
  165         if (strcmp(attr, "GEOM::physpath") != 0)
  166                 return;
  167 
  168         if (g_access(cp, 1, 0, 0) == 0) {
  169                 char *physpath;
  170                 int error, physpath_len;
  171 
  172                 physpath_len = MAXPATHLEN;
  173                 physpath = g_malloc(physpath_len, M_WAITOK|M_ZERO);
  174                 error =
  175                     g_io_getattr("GEOM::physpath", cp, &physpath_len, physpath);
  176                 g_access(cp, -1, 0, 0);
  177                 if (error == 0 && strlen(physpath) != 0) {
  178                         struct cdev *old_alias_dev;
  179                         struct cdev **alias_devp;
  180 
  181                         dev = sc->sc_dev;
  182                         old_alias_dev = sc->sc_alias;
  183                         alias_devp = (struct cdev **)&sc->sc_alias;
  184                         make_dev_physpath_alias(MAKEDEV_WAITOK, alias_devp,
  185                             dev, old_alias_dev, physpath);
  186                 } else if (sc->sc_alias) {
  187                         destroy_dev((struct cdev *)sc->sc_alias);
  188                         sc->sc_alias = NULL;
  189                 }
  190                 g_free(physpath);
  191         }
  192 }
  193 
  194 struct g_provider *
  195 g_dev_getprovider(struct cdev *dev)
  196 {
  197         struct g_consumer *cp;
  198 
  199         g_topology_assert();
  200         if (dev == NULL)
  201                 return (NULL);
  202         if (dev->si_devsw != &g_dev_cdevsw)
  203                 return (NULL);
  204         cp = dev->si_drv2;
  205         return (cp->provider);
  206 }
  207 
  208 static struct g_geom *
  209 g_dev_taste(struct g_class *mp, struct g_provider *pp, int insist __unused)
  210 {
  211         struct g_geom *gp;
  212         struct g_consumer *cp;
  213         struct g_dev_softc *sc;
  214         int error, len;
  215         struct cdev *dev, *adev;
  216         char buf[64], *val;
  217 
  218         g_trace(G_T_TOPOLOGY, "dev_taste(%s,%s)", mp->name, pp->name);
  219         g_topology_assert();
  220         gp = g_new_geomf(mp, "%s", pp->name);
  221         sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
  222         mtx_init(&sc->sc_mtx, "g_dev", NULL, MTX_DEF);
  223         cp = g_new_consumer(gp);
  224         cp->private = sc;
  225         cp->flags |= G_CF_DIRECT_SEND | G_CF_DIRECT_RECEIVE;
  226         error = g_attach(cp, pp);
  227         KASSERT(error == 0,
  228             ("g_dev_taste(%s) failed to g_attach, err=%d", pp->name, error));
  229         error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &dev,
  230             &g_dev_cdevsw, NULL, UID_ROOT, GID_OPERATOR, 0640, "%s", gp->name);
  231         if (error != 0) {
  232                 printf("%s: make_dev_p() failed (gp->name=%s, error=%d)\n",
  233                     __func__, gp->name, error);
  234                 g_detach(cp);
  235                 g_destroy_consumer(cp);
  236                 g_destroy_geom(gp);
  237                 mtx_destroy(&sc->sc_mtx);
  238                 g_free(sc);
  239                 return (NULL);
  240         }
  241         dev->si_flags |= SI_UNMAPPED;
  242         sc->sc_dev = dev;
  243 
  244         /* Search for device alias name and create it if found. */
  245         adev = NULL;
  246         for (len = MIN(strlen(gp->name), sizeof(buf) - 15); len > 0; len--) {
  247                 snprintf(buf, sizeof(buf), "kern.devalias.%s", gp->name);
  248                 buf[14 + len] = 0;
  249                 val = getenv(buf);
  250                 if (val != NULL) {
  251                         snprintf(buf, sizeof(buf), "%s%s",
  252                             val, gp->name + len);
  253                         freeenv(val);
  254                         make_dev_alias_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK,
  255                             &adev, dev, "%s", buf);
  256                         adev->si_flags |= SI_UNMAPPED;
  257                         break;
  258                 }
  259         }
  260 
  261         dev->si_iosize_max = MAXPHYS;
  262         dev->si_drv2 = cp;
  263         if (adev != NULL) {
  264                 adev->si_iosize_max = MAXPHYS;
  265                 adev->si_drv2 = cp;
  266         }
  267 
  268         g_dev_attrchanged(cp, "GEOM::physpath");
  269 
  270         return (gp);
  271 }
  272 
  273 static int
  274 g_dev_open(struct cdev *dev, int flags, int fmt, struct thread *td)
  275 {
  276         struct g_consumer *cp;
  277         struct g_dev_softc *sc;
  278         int error, r, w, e;
  279 
  280         cp = dev->si_drv2;
  281         if (cp == NULL)
  282                 return(ENXIO);          /* g_dev_taste() not done yet */
  283         g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
  284             cp->geom->name, flags, fmt, td);
  285 
  286         r = flags & FREAD ? 1 : 0;
  287         w = flags & FWRITE ? 1 : 0;
  288 #ifdef notyet
  289         e = flags & O_EXCL ? 1 : 0;
  290 #else
  291         e = 0;
  292 #endif
  293         if (w) {
  294                 /*
  295                  * When running in very secure mode, do not allow
  296                  * opens for writing of any disks.
  297                  */
  298                 error = securelevel_ge(td->td_ucred, 2);
  299                 if (error)
  300                         return (error);
  301         }
  302         g_topology_lock();
  303         error = g_access(cp, r, w, e);
  304         g_topology_unlock();
  305         if (error == 0) {
  306                 sc = cp->private;
  307                 mtx_lock(&sc->sc_mtx);
  308                 if (sc->sc_open == 0 && sc->sc_active != 0)
  309                         wakeup(&sc->sc_active);
  310                 sc->sc_open += r + w + e;
  311                 mtx_unlock(&sc->sc_mtx);
  312         }
  313         return(error);
  314 }
  315 
  316 static int
  317 g_dev_close(struct cdev *dev, int flags, int fmt, struct thread *td)
  318 {
  319         struct g_consumer *cp;
  320         struct g_dev_softc *sc;
  321         int error, r, w, e;
  322 
  323         cp = dev->si_drv2;
  324         if (cp == NULL)
  325                 return(ENXIO);
  326         g_trace(G_T_ACCESS, "g_dev_close(%s, %d, %d, %p)",
  327             cp->geom->name, flags, fmt, td);
  328         
  329         r = flags & FREAD ? -1 : 0;
  330         w = flags & FWRITE ? -1 : 0;
  331 #ifdef notyet
  332         e = flags & O_EXCL ? -1 : 0;
  333 #else
  334         e = 0;
  335 #endif
  336         sc = cp->private;
  337         mtx_lock(&sc->sc_mtx);
  338         sc->sc_open += r + w + e;
  339         while (sc->sc_open == 0 && sc->sc_active != 0)
  340                 msleep(&sc->sc_active, &sc->sc_mtx, 0, "PRIBIO", 0);
  341         mtx_unlock(&sc->sc_mtx);
  342         g_topology_lock();
  343         error = g_access(cp, r, w, e);
  344         g_topology_unlock();
  345         return (error);
  346 }
  347 
  348 /*
  349  * XXX: Until we have unmessed the ioctl situation, there is a race against
  350  * XXX: a concurrent orphanization.  We cannot close it by holding topology
  351  * XXX: since that would prevent us from doing our job, and stalling events
  352  * XXX: will break (actually: stall) the BSD disklabel hacks.
  353  */
  354 static int
  355 g_dev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
  356 {
  357         struct g_consumer *cp;
  358         struct g_provider *pp;
  359         struct g_kerneldump kd;
  360         off_t offset, length, chunk;
  361         int i, error;
  362         u_int u;
  363 
  364         cp = dev->si_drv2;
  365         pp = cp->provider;
  366 
  367         error = 0;
  368         KASSERT(cp->acr || cp->acw,
  369             ("Consumer with zero access count in g_dev_ioctl"));
  370 
  371         i = IOCPARM_LEN(cmd);
  372         switch (cmd) {
  373         case DIOCGSECTORSIZE:
  374                 *(u_int *)data = cp->provider->sectorsize;
  375                 if (*(u_int *)data == 0)
  376                         error = ENOENT;
  377                 break;
  378         case DIOCGMEDIASIZE:
  379                 *(off_t *)data = cp->provider->mediasize;
  380                 if (*(off_t *)data == 0)
  381                         error = ENOENT;
  382                 break;
  383         case DIOCGFWSECTORS:
  384                 error = g_io_getattr("GEOM::fwsectors", cp, &i, data);
  385                 if (error == 0 && *(u_int *)data == 0)
  386                         error = ENOENT;
  387                 break;
  388         case DIOCGFWHEADS:
  389                 error = g_io_getattr("GEOM::fwheads", cp, &i, data);
  390                 if (error == 0 && *(u_int *)data == 0)
  391                         error = ENOENT;
  392                 break;
  393         case DIOCGFRONTSTUFF:
  394                 error = g_io_getattr("GEOM::frontstuff", cp, &i, data);
  395                 break;
  396         case DIOCSKERNELDUMP:
  397                 u = *((u_int *)data);
  398                 if (!u) {
  399                         set_dumper(NULL, NULL);
  400                         error = 0;
  401                         break;
  402                 }
  403                 kd.offset = 0;
  404                 kd.length = OFF_MAX;
  405                 i = sizeof kd;
  406                 error = g_io_getattr("GEOM::kerneldump", cp, &i, &kd);
  407                 if (!error) {
  408                         error = set_dumper(&kd.di, devtoname(dev));
  409                         if (!error)
  410                                 dev->si_flags |= SI_DUMPDEV;
  411                 }
  412                 break;
  413         case DIOCGFLUSH:
  414                 error = g_io_flush(cp);
  415                 break;
  416         case DIOCGDELETE:
  417                 offset = ((off_t *)data)[0];
  418                 length = ((off_t *)data)[1];
  419                 if ((offset % cp->provider->sectorsize) != 0 ||
  420                     (length % cp->provider->sectorsize) != 0 || length <= 0) {
  421                         printf("%s: offset=%jd length=%jd\n", __func__, offset,
  422                             length);
  423                         error = EINVAL;
  424                         break;
  425                 }
  426                 while (length > 0) { 
  427                         chunk = length;
  428                         if (g_dev_del_max_sectors != 0 && chunk >
  429                             g_dev_del_max_sectors * cp->provider->sectorsize) {
  430                                 chunk = g_dev_del_max_sectors *
  431                                     cp->provider->sectorsize;
  432                         }
  433                         error = g_delete_data(cp, offset, chunk);
  434                         length -= chunk;
  435                         offset += chunk;
  436                         if (error)
  437                                 break;
  438                         /*
  439                          * Since the request size can be large, the service
  440                          * time can be is likewise.  We make this ioctl
  441                          * interruptible by checking for signals for each bio.
  442                          */
  443                         if (SIGPENDING(td))
  444                                 break;
  445                 }
  446                 break;
  447         case DIOCGIDENT:
  448                 error = g_io_getattr("GEOM::ident", cp, &i, data);
  449                 break;
  450         case DIOCGPROVIDERNAME:
  451                 if (pp == NULL)
  452                         return (ENOENT);
  453                 strlcpy(data, pp->name, i);
  454                 break;
  455         case DIOCGSTRIPESIZE:
  456                 *(off_t *)data = cp->provider->stripesize;
  457                 break;
  458         case DIOCGSTRIPEOFFSET:
  459                 *(off_t *)data = cp->provider->stripeoffset;
  460                 break;
  461         case DIOCGPHYSPATH:
  462                 error = g_io_getattr("GEOM::physpath", cp, &i, data);
  463                 if (error == 0 && *(char *)data == '\0')
  464                         error = ENOENT;
  465                 break;
  466         default:
  467                 if (cp->provider->geom->ioctl != NULL) {
  468                         error = cp->provider->geom->ioctl(cp->provider, cmd, data, fflag, td);
  469                 } else {
  470                         error = ENOIOCTL;
  471                 }
  472         }
  473 
  474         return (error);
  475 }
  476 
  477 static void
  478 g_dev_done(struct bio *bp2)
  479 {
  480         struct g_consumer *cp;
  481         struct g_dev_softc *sc;
  482         struct bio *bp;
  483         int destroy;
  484 
  485         cp = bp2->bio_from;
  486         sc = cp->private;
  487         bp = bp2->bio_parent;
  488         bp->bio_error = bp2->bio_error;
  489         bp->bio_completed = bp2->bio_completed;
  490         bp->bio_resid = bp->bio_length - bp2->bio_completed;
  491         if (bp2->bio_error != 0) {
  492                 g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
  493                     bp2, bp2->bio_error);
  494                 bp->bio_flags |= BIO_ERROR;
  495         } else {
  496                 g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %jd",
  497                     bp2, bp, bp2->bio_resid, (intmax_t)bp2->bio_completed);
  498         }
  499         g_destroy_bio(bp2);
  500         destroy = 0;
  501         mtx_lock(&sc->sc_mtx);
  502         if ((--sc->sc_active) == 0) {
  503                 if (sc->sc_open == 0)
  504                         wakeup(&sc->sc_active);
  505                 if (sc->sc_dev == NULL)
  506                         destroy = 1;
  507         }
  508         mtx_unlock(&sc->sc_mtx);
  509         if (destroy)
  510                 g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
  511         biodone(bp);
  512 }
  513 
  514 static void
  515 g_dev_strategy(struct bio *bp)
  516 {
  517         struct g_consumer *cp;
  518         struct bio *bp2;
  519         struct cdev *dev;
  520         struct g_dev_softc *sc;
  521 
  522         KASSERT(bp->bio_cmd == BIO_READ ||
  523                 bp->bio_cmd == BIO_WRITE ||
  524                 bp->bio_cmd == BIO_DELETE ||
  525                 bp->bio_cmd == BIO_FLUSH,
  526                 ("Wrong bio_cmd bio=%p cmd=%d", bp, bp->bio_cmd));
  527         dev = bp->bio_dev;
  528         cp = dev->si_drv2;
  529         sc = cp->private;
  530         KASSERT(cp->acr || cp->acw,
  531             ("Consumer with zero access count in g_dev_strategy"));
  532 #ifdef INVARIANTS
  533         if ((bp->bio_offset % cp->provider->sectorsize) != 0 ||
  534             (bp->bio_bcount % cp->provider->sectorsize) != 0) {
  535                 bp->bio_resid = bp->bio_bcount;
  536                 biofinish(bp, NULL, EINVAL);
  537                 return;
  538         }
  539 #endif
  540         mtx_lock(&sc->sc_mtx);
  541         KASSERT(sc->sc_open > 0, ("Closed device in g_dev_strategy"));
  542         sc->sc_active++;
  543         mtx_unlock(&sc->sc_mtx);
  544 
  545         for (;;) {
  546                 /*
  547                  * XXX: This is not an ideal solution, but I belive it to
  548                  * XXX: deadlock safe, all things considered.
  549                  */
  550                 bp2 = g_clone_bio(bp);
  551                 if (bp2 != NULL)
  552                         break;
  553                 pause("gdstrat", hz / 10);
  554         }
  555         KASSERT(bp2 != NULL, ("XXX: ENOMEM in a bad place"));
  556         bp2->bio_done = g_dev_done;
  557         g_trace(G_T_BIO,
  558             "g_dev_strategy(%p/%p) offset %jd length %jd data %p cmd %d",
  559             bp, bp2, (intmax_t)bp->bio_offset, (intmax_t)bp2->bio_length,
  560             bp2->bio_data, bp2->bio_cmd);
  561         g_io_request(bp2, cp);
  562         KASSERT(cp->acr || cp->acw,
  563             ("g_dev_strategy raced with g_dev_close and lost"));
  564 
  565 }
  566 
  567 /*
  568  * g_dev_callback()
  569  *
  570  * Called by devfs when asynchronous device destruction is completed.
  571  * - Mark that we have no attached device any more.
  572  * - If there are no outstanding requests, schedule geom destruction.
  573  *   Otherwise destruction will be scheduled later by g_dev_done().
  574  */
  575 
  576 static void
  577 g_dev_callback(void *arg)
  578 {
  579         struct g_consumer *cp;
  580         struct g_dev_softc *sc;
  581         int destroy;
  582 
  583         cp = arg;
  584         sc = cp->private;
  585         g_trace(G_T_TOPOLOGY, "g_dev_callback(%p(%s))", cp, cp->geom->name);
  586 
  587         mtx_lock(&sc->sc_mtx);
  588         sc->sc_dev = NULL;
  589         sc->sc_alias = NULL;
  590         destroy = (sc->sc_active == 0);
  591         mtx_unlock(&sc->sc_mtx);
  592         if (destroy)
  593                 g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
  594 }
  595 
  596 /*
  597  * g_dev_orphan()
  598  *
  599  * Called from below when the provider orphaned us.
  600  * - Clear any dump settings.
  601  * - Request asynchronous device destruction to prevent any more requests
  602  *   from coming in.  The provider is already marked with an error, so
  603  *   anything which comes in in the interrim will be returned immediately.
  604  */
  605 
  606 static void
  607 g_dev_orphan(struct g_consumer *cp)
  608 {
  609         struct cdev *dev;
  610         struct g_dev_softc *sc;
  611 
  612         g_topology_assert();
  613         sc = cp->private;
  614         dev = sc->sc_dev;
  615         g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, cp->geom->name);
  616 
  617         /* Reset any dump-area set on this device */
  618         if (dev->si_flags & SI_DUMPDEV)
  619                 set_dumper(NULL, NULL);
  620 
  621         /* Destroy the struct cdev *so we get no more requests */
  622         destroy_dev_sched_cb(dev, g_dev_callback, cp);
  623 }
  624 
  625 DECLARE_GEOM_CLASS(g_dev_class, g_dev);

Cache object: 07603dc99467c84f9093e11254934018


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