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-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
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.0/sys/geom/geom_dev.c 254389 2013-08-15 22:52:39Z ken $");
   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         error = g_attach(cp, pp);
  226         KASSERT(error == 0,
  227             ("g_dev_taste(%s) failed to g_attach, err=%d", pp->name, error));
  228         error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &dev,
  229             &g_dev_cdevsw, NULL, UID_ROOT, GID_OPERATOR, 0640, "%s", gp->name);
  230         if (error != 0) {
  231                 printf("%s: make_dev_p() failed (gp->name=%s, error=%d)\n",
  232                     __func__, gp->name, error);
  233                 g_detach(cp);
  234                 g_destroy_consumer(cp);
  235                 g_destroy_geom(gp);
  236                 mtx_destroy(&sc->sc_mtx);
  237                 g_free(sc);
  238                 return (NULL);
  239         }
  240         dev->si_flags |= SI_UNMAPPED;
  241         sc->sc_dev = dev;
  242 
  243         /* Search for device alias name and create it if found. */
  244         adev = NULL;
  245         for (len = MIN(strlen(gp->name), sizeof(buf) - 15); len > 0; len--) {
  246                 snprintf(buf, sizeof(buf), "kern.devalias.%s", gp->name);
  247                 buf[14 + len] = 0;
  248                 val = getenv(buf);
  249                 if (val != NULL) {
  250                         snprintf(buf, sizeof(buf), "%s%s",
  251                             val, gp->name + len);
  252                         freeenv(val);
  253                         make_dev_alias_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK,
  254                             &adev, dev, "%s", buf);
  255                         adev->si_flags |= SI_UNMAPPED;
  256                         break;
  257                 }
  258         }
  259 
  260         dev->si_iosize_max = MAXPHYS;
  261         dev->si_drv2 = cp;
  262         if (adev != NULL) {
  263                 adev->si_iosize_max = MAXPHYS;
  264                 adev->si_drv2 = cp;
  265         }
  266 
  267         g_dev_attrchanged(cp, "GEOM::physpath");
  268 
  269         return (gp);
  270 }
  271 
  272 static int
  273 g_dev_open(struct cdev *dev, int flags, int fmt, struct thread *td)
  274 {
  275         struct g_consumer *cp;
  276         struct g_dev_softc *sc;
  277         int error, r, w, e;
  278 
  279         cp = dev->si_drv2;
  280         if (cp == NULL)
  281                 return(ENXIO);          /* g_dev_taste() not done yet */
  282         g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
  283             cp->geom->name, flags, fmt, td);
  284 
  285         r = flags & FREAD ? 1 : 0;
  286         w = flags & FWRITE ? 1 : 0;
  287 #ifdef notyet
  288         e = flags & O_EXCL ? 1 : 0;
  289 #else
  290         e = 0;
  291 #endif
  292         if (w) {
  293                 /*
  294                  * When running in very secure mode, do not allow
  295                  * opens for writing of any disks.
  296                  */
  297                 error = securelevel_ge(td->td_ucred, 2);
  298                 if (error)
  299                         return (error);
  300         }
  301         g_topology_lock();
  302         error = g_access(cp, r, w, e);
  303         g_topology_unlock();
  304         if (error == 0) {
  305                 sc = cp->private;
  306                 mtx_lock(&sc->sc_mtx);
  307                 if (sc->sc_open == 0 && sc->sc_active != 0)
  308                         wakeup(&sc->sc_active);
  309                 sc->sc_open += r + w + e;
  310                 mtx_unlock(&sc->sc_mtx);
  311         }
  312         return(error);
  313 }
  314 
  315 static int
  316 g_dev_close(struct cdev *dev, int flags, int fmt, struct thread *td)
  317 {
  318         struct g_consumer *cp;
  319         struct g_dev_softc *sc;
  320         int error, r, w, e;
  321 
  322         cp = dev->si_drv2;
  323         if (cp == NULL)
  324                 return(ENXIO);
  325         g_trace(G_T_ACCESS, "g_dev_close(%s, %d, %d, %p)",
  326             cp->geom->name, flags, fmt, td);
  327         
  328         r = flags & FREAD ? -1 : 0;
  329         w = flags & FWRITE ? -1 : 0;
  330 #ifdef notyet
  331         e = flags & O_EXCL ? -1 : 0;
  332 #else
  333         e = 0;
  334 #endif
  335         sc = cp->private;
  336         mtx_lock(&sc->sc_mtx);
  337         sc->sc_open += r + w + e;
  338         while (sc->sc_open == 0 && sc->sc_active != 0)
  339                 msleep(&sc->sc_active, &sc->sc_mtx, 0, "PRIBIO", 0);
  340         mtx_unlock(&sc->sc_mtx);
  341         g_topology_lock();
  342         error = g_access(cp, r, w, e);
  343         g_topology_unlock();
  344         return (error);
  345 }
  346 
  347 /*
  348  * XXX: Until we have unmessed the ioctl situation, there is a race against
  349  * XXX: a concurrent orphanization.  We cannot close it by holding topology
  350  * XXX: since that would prevent us from doing our job, and stalling events
  351  * XXX: will break (actually: stall) the BSD disklabel hacks.
  352  */
  353 static int
  354 g_dev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
  355 {
  356         struct g_consumer *cp;
  357         struct g_provider *pp;
  358         struct g_kerneldump kd;
  359         off_t offset, length, chunk;
  360         int i, error;
  361         u_int u;
  362 
  363         cp = dev->si_drv2;
  364         pp = cp->provider;
  365 
  366         error = 0;
  367         KASSERT(cp->acr || cp->acw,
  368             ("Consumer with zero access count in g_dev_ioctl"));
  369 
  370         i = IOCPARM_LEN(cmd);
  371         switch (cmd) {
  372         case DIOCGSECTORSIZE:
  373                 *(u_int *)data = cp->provider->sectorsize;
  374                 if (*(u_int *)data == 0)
  375                         error = ENOENT;
  376                 break;
  377         case DIOCGMEDIASIZE:
  378                 *(off_t *)data = cp->provider->mediasize;
  379                 if (*(off_t *)data == 0)
  380                         error = ENOENT;
  381                 break;
  382         case DIOCGFWSECTORS:
  383                 error = g_io_getattr("GEOM::fwsectors", cp, &i, data);
  384                 if (error == 0 && *(u_int *)data == 0)
  385                         error = ENOENT;
  386                 break;
  387         case DIOCGFWHEADS:
  388                 error = g_io_getattr("GEOM::fwheads", cp, &i, data);
  389                 if (error == 0 && *(u_int *)data == 0)
  390                         error = ENOENT;
  391                 break;
  392         case DIOCGFRONTSTUFF:
  393                 error = g_io_getattr("GEOM::frontstuff", cp, &i, data);
  394                 break;
  395         case DIOCSKERNELDUMP:
  396                 u = *((u_int *)data);
  397                 if (!u) {
  398                         set_dumper(NULL, NULL);
  399                         error = 0;
  400                         break;
  401                 }
  402                 kd.offset = 0;
  403                 kd.length = OFF_MAX;
  404                 i = sizeof kd;
  405                 error = g_io_getattr("GEOM::kerneldump", cp, &i, &kd);
  406                 if (!error) {
  407                         error = set_dumper(&kd.di, devtoname(dev));
  408                         if (!error)
  409                                 dev->si_flags |= SI_DUMPDEV;
  410                 }
  411                 break;
  412         case DIOCGFLUSH:
  413                 error = g_io_flush(cp);
  414                 break;
  415         case DIOCGDELETE:
  416                 offset = ((off_t *)data)[0];
  417                 length = ((off_t *)data)[1];
  418                 if ((offset % cp->provider->sectorsize) != 0 ||
  419                     (length % cp->provider->sectorsize) != 0 || length <= 0) {
  420                         printf("%s: offset=%jd length=%jd\n", __func__, offset,
  421                             length);
  422                         error = EINVAL;
  423                         break;
  424                 }
  425                 while (length > 0) { 
  426                         chunk = length;
  427                         if (g_dev_del_max_sectors != 0 && chunk >
  428                             g_dev_del_max_sectors * cp->provider->sectorsize) {
  429                                 chunk = g_dev_del_max_sectors *
  430                                     cp->provider->sectorsize;
  431                         }
  432                         error = g_delete_data(cp, offset, chunk);
  433                         length -= chunk;
  434                         offset += chunk;
  435                         if (error)
  436                                 break;
  437                         /*
  438                          * Since the request size can be large, the service
  439                          * time can be is likewise.  We make this ioctl
  440                          * interruptible by checking for signals for each bio.
  441                          */
  442                         if (SIGPENDING(td))
  443                                 break;
  444                 }
  445                 break;
  446         case DIOCGIDENT:
  447                 error = g_io_getattr("GEOM::ident", cp, &i, data);
  448                 break;
  449         case DIOCGPROVIDERNAME:
  450                 if (pp == NULL)
  451                         return (ENOENT);
  452                 strlcpy(data, pp->name, i);
  453                 break;
  454         case DIOCGSTRIPESIZE:
  455                 *(off_t *)data = cp->provider->stripesize;
  456                 break;
  457         case DIOCGSTRIPEOFFSET:
  458                 *(off_t *)data = cp->provider->stripeoffset;
  459                 break;
  460         case DIOCGPHYSPATH:
  461                 error = g_io_getattr("GEOM::physpath", cp, &i, data);
  462                 if (error == 0 && *(char *)data == '\0')
  463                         error = ENOENT;
  464                 break;
  465         default:
  466                 if (cp->provider->geom->ioctl != NULL) {
  467                         error = cp->provider->geom->ioctl(cp->provider, cmd, data, fflag, td);
  468                 } else {
  469                         error = ENOIOCTL;
  470                 }
  471         }
  472 
  473         return (error);
  474 }
  475 
  476 static void
  477 g_dev_done(struct bio *bp2)
  478 {
  479         struct g_consumer *cp;
  480         struct g_dev_softc *sc;
  481         struct bio *bp;
  482         int destroy;
  483 
  484         cp = bp2->bio_from;
  485         sc = cp->private;
  486         bp = bp2->bio_parent;
  487         bp->bio_error = bp2->bio_error;
  488         if (bp->bio_error != 0) {
  489                 g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
  490                     bp2, bp->bio_error);
  491                 bp->bio_flags |= BIO_ERROR;
  492         } else {
  493                 g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %jd",
  494                     bp2, bp, bp->bio_resid, (intmax_t)bp2->bio_completed);
  495         }
  496         bp->bio_resid = bp->bio_length - bp2->bio_completed;
  497         bp->bio_completed = bp2->bio_completed;
  498         g_destroy_bio(bp2);
  499         destroy = 0;
  500         mtx_lock(&sc->sc_mtx);
  501         if ((--sc->sc_active) == 0) {
  502                 if (sc->sc_open == 0)
  503                         wakeup(&sc->sc_active);
  504                 if (sc->sc_dev == NULL)
  505                         destroy = 1;
  506         }
  507         mtx_unlock(&sc->sc_mtx);
  508         if (destroy)
  509                 g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
  510         biodone(bp);
  511 }
  512 
  513 static void
  514 g_dev_strategy(struct bio *bp)
  515 {
  516         struct g_consumer *cp;
  517         struct bio *bp2;
  518         struct cdev *dev;
  519         struct g_dev_softc *sc;
  520 
  521         KASSERT(bp->bio_cmd == BIO_READ ||
  522                 bp->bio_cmd == BIO_WRITE ||
  523                 bp->bio_cmd == BIO_DELETE ||
  524                 bp->bio_cmd == BIO_FLUSH,
  525                 ("Wrong bio_cmd bio=%p cmd=%d", bp, bp->bio_cmd));
  526         dev = bp->bio_dev;
  527         cp = dev->si_drv2;
  528         sc = cp->private;
  529         KASSERT(cp->acr || cp->acw,
  530             ("Consumer with zero access count in g_dev_strategy"));
  531 #ifdef INVARIANTS
  532         if ((bp->bio_offset % cp->provider->sectorsize) != 0 ||
  533             (bp->bio_bcount % cp->provider->sectorsize) != 0) {
  534                 bp->bio_resid = bp->bio_bcount;
  535                 biofinish(bp, NULL, EINVAL);
  536                 return;
  537         }
  538 #endif
  539         mtx_lock(&sc->sc_mtx);
  540         KASSERT(sc->sc_open > 0, ("Closed device in g_dev_strategy"));
  541         sc->sc_active++;
  542         mtx_unlock(&sc->sc_mtx);
  543 
  544         for (;;) {
  545                 /*
  546                  * XXX: This is not an ideal solution, but I belive it to
  547                  * XXX: deadlock safe, all things considered.
  548                  */
  549                 bp2 = g_clone_bio(bp);
  550                 if (bp2 != NULL)
  551                         break;
  552                 pause("gdstrat", hz / 10);
  553         }
  554         KASSERT(bp2 != NULL, ("XXX: ENOMEM in a bad place"));
  555         bp2->bio_done = g_dev_done;
  556         g_trace(G_T_BIO,
  557             "g_dev_strategy(%p/%p) offset %jd length %jd data %p cmd %d",
  558             bp, bp2, (intmax_t)bp->bio_offset, (intmax_t)bp2->bio_length,
  559             bp2->bio_data, bp2->bio_cmd);
  560         g_io_request(bp2, cp);
  561         KASSERT(cp->acr || cp->acw,
  562             ("g_dev_strategy raced with g_dev_close and lost"));
  563 
  564 }
  565 
  566 /*
  567  * g_dev_callback()
  568  *
  569  * Called by devfs when asynchronous device destruction is completed.
  570  * - Mark that we have no attached device any more.
  571  * - If there are no outstanding requests, schedule geom destruction.
  572  *   Otherwise destruction will be scheduled later by g_dev_done().
  573  */
  574 
  575 static void
  576 g_dev_callback(void *arg)
  577 {
  578         struct g_consumer *cp;
  579         struct g_dev_softc *sc;
  580         int destroy;
  581 
  582         cp = arg;
  583         sc = cp->private;
  584         g_trace(G_T_TOPOLOGY, "g_dev_callback(%p(%s))", cp, cp->geom->name);
  585 
  586         mtx_lock(&sc->sc_mtx);
  587         sc->sc_dev = NULL;
  588         sc->sc_alias = NULL;
  589         destroy = (sc->sc_active == 0);
  590         mtx_unlock(&sc->sc_mtx);
  591         if (destroy)
  592                 g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
  593 }
  594 
  595 /*
  596  * g_dev_orphan()
  597  *
  598  * Called from below when the provider orphaned us.
  599  * - Clear any dump settings.
  600  * - Request asynchronous device destruction to prevent any more requests
  601  *   from coming in.  The provider is already marked with an error, so
  602  *   anything which comes in in the interrim will be returned immediately.
  603  */
  604 
  605 static void
  606 g_dev_orphan(struct g_consumer *cp)
  607 {
  608         struct cdev *dev;
  609         struct g_dev_softc *sc;
  610 
  611         g_topology_assert();
  612         sc = cp->private;
  613         dev = sc->sc_dev;
  614         g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, cp->geom->name);
  615 
  616         /* Reset any dump-area set on this device */
  617         if (dev->si_flags & SI_DUMPDEV)
  618                 set_dumper(NULL, NULL);
  619 
  620         /* Destroy the struct cdev *so we get no more requests */
  621         destroy_dev_sched_cb(dev, g_dev_callback, cp);
  622 }
  623 
  624 DECLARE_GEOM_CLASS(g_dev_class, g_dev);

Cache object: 424342fc1cfcb6b14cfcbb7decb479c0


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