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_disk.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$");
   38 
   39 #include "opt_geom.h"
   40 
   41 #include <sys/param.h>
   42 #include <sys/systm.h>
   43 #include <sys/kernel.h>
   44 #include <sys/sysctl.h>
   45 #include <sys/bio.h>
   46 #include <sys/ctype.h>
   47 #include <sys/fcntl.h>
   48 #include <sys/malloc.h>
   49 #include <sys/devicestat.h>
   50 #include <machine/md_var.h>
   51 
   52 #include <sys/lock.h>
   53 #include <sys/mutex.h>
   54 #include <geom/geom.h>
   55 #include <geom/geom_disk.h>
   56 #include <geom/geom_int.h>
   57 
   58 #include <dev/led/led.h>
   59 
   60 struct g_disk_softc {
   61         struct disk             *dp;
   62         struct sysctl_ctx_list  sysctl_ctx;
   63         struct sysctl_oid       *sysctl_tree;
   64         char                    led[64];
   65         uint32_t                state;
   66 };
   67 
   68 static struct mtx g_disk_done_mtx;
   69 
   70 static g_access_t g_disk_access;
   71 static g_init_t g_disk_init;
   72 static g_fini_t g_disk_fini;
   73 static g_start_t g_disk_start;
   74 static g_ioctl_t g_disk_ioctl;
   75 static g_dumpconf_t g_disk_dumpconf;
   76 
   77 static struct g_class g_disk_class = {
   78         .name = "DISK",
   79         .version = G_VERSION,
   80         .init = g_disk_init,
   81         .fini = g_disk_fini,
   82         .start = g_disk_start,
   83         .access = g_disk_access,
   84         .ioctl = g_disk_ioctl,
   85         .dumpconf = g_disk_dumpconf,
   86 };
   87 
   88 SYSCTL_DECL(_kern_geom);
   89 SYSCTL_NODE(_kern_geom, OID_AUTO, disk, CTLFLAG_RW, 0, "GEOM_DISK stuff");
   90 
   91 static void
   92 g_disk_init(struct g_class *mp __unused)
   93 {
   94 
   95         mtx_init(&g_disk_done_mtx, "g_disk_done", NULL, MTX_DEF);
   96 }
   97 
   98 static void
   99 g_disk_fini(struct g_class *mp __unused)
  100 {
  101 
  102         mtx_destroy(&g_disk_done_mtx);
  103 }
  104 
  105 DECLARE_GEOM_CLASS(g_disk_class, g_disk);
  106 
  107 static void __inline
  108 g_disk_lock_giant(struct disk *dp)
  109 {
  110         if (dp->d_flags & DISKFLAG_NEEDSGIANT)
  111                 mtx_lock(&Giant);
  112 }
  113 
  114 static void __inline
  115 g_disk_unlock_giant(struct disk *dp)
  116 {
  117         if (dp->d_flags & DISKFLAG_NEEDSGIANT)
  118                 mtx_unlock(&Giant);
  119 }
  120 
  121 static int
  122 g_disk_access(struct g_provider *pp, int r, int w, int e)
  123 {
  124         struct disk *dp;
  125         struct g_disk_softc *sc;
  126         int error;
  127 
  128         g_trace(G_T_ACCESS, "g_disk_access(%s, %d, %d, %d)",
  129             pp->name, r, w, e);
  130         g_topology_assert();
  131         sc = pp->geom->softc;
  132         if (sc == NULL || (dp = sc->dp) == NULL || dp->d_destroyed) {
  133                 /*
  134                  * Allow decreasing access count even if disk is not
  135                  * avaliable anymore.
  136                  */
  137                 if (r <= 0 && w <= 0 && e <= 0)
  138                         return (0);
  139                 return (ENXIO);
  140         }
  141         r += pp->acr;
  142         w += pp->acw;
  143         e += pp->ace;
  144         error = 0;
  145         if ((pp->acr + pp->acw + pp->ace) == 0 && (r + w + e) > 0) {
  146                 if (dp->d_open != NULL) {
  147                         g_disk_lock_giant(dp);
  148                         error = dp->d_open(dp);
  149                         if (bootverbose && error != 0)
  150                                 printf("Opened disk %s -> %d\n",
  151                                     pp->name, error);
  152                         g_disk_unlock_giant(dp);
  153                         if (error != 0)
  154                                 return (error);
  155                 }
  156                 pp->mediasize = dp->d_mediasize;
  157                 pp->sectorsize = dp->d_sectorsize;
  158                 if (dp->d_flags & DISKFLAG_CANDELETE)
  159                         pp->flags |= G_PF_CANDELETE;
  160                 else
  161                         pp->flags &= ~G_PF_CANDELETE;
  162                 pp->stripeoffset = dp->d_stripeoffset;
  163                 pp->stripesize = dp->d_stripesize;
  164                 dp->d_flags |= DISKFLAG_OPEN;
  165                 if (dp->d_maxsize == 0) {
  166                         printf("WARNING: Disk drive %s%d has no d_maxsize\n",
  167                             dp->d_name, dp->d_unit);
  168                         dp->d_maxsize = DFLTPHYS;
  169                 }
  170         } else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) {
  171                 if (dp->d_close != NULL) {
  172                         g_disk_lock_giant(dp);
  173                         error = dp->d_close(dp);
  174                         if (error != 0)
  175                                 printf("Closed disk %s -> %d\n",
  176                                     pp->name, error);
  177                         g_disk_unlock_giant(dp);
  178                 }
  179                 sc->state = G_STATE_ACTIVE;
  180                 if (sc->led[0] != 0)
  181                         led_set(sc->led, "");
  182                 dp->d_flags &= ~DISKFLAG_OPEN;
  183         }
  184         return (error);
  185 }
  186 
  187 static void
  188 g_disk_kerneldump(struct bio *bp, struct disk *dp)
  189 {
  190         struct g_kerneldump *gkd;
  191         struct g_geom *gp;
  192 
  193         gkd = (struct g_kerneldump*)bp->bio_data;
  194         gp = bp->bio_to->geom;
  195         g_trace(G_T_TOPOLOGY, "g_disk_kerneldump(%s, %jd, %jd)",
  196                 gp->name, (intmax_t)gkd->offset, (intmax_t)gkd->length);
  197         if (dp->d_dump == NULL) {
  198                 g_io_deliver(bp, ENODEV);
  199                 return;
  200         }
  201         gkd->di.dumper = dp->d_dump;
  202         gkd->di.priv = dp;
  203         gkd->di.blocksize = dp->d_sectorsize;
  204         gkd->di.maxiosize = dp->d_maxsize;
  205         gkd->di.mediaoffset = gkd->offset;
  206         if ((gkd->offset + gkd->length) > dp->d_mediasize)
  207                 gkd->length = dp->d_mediasize - gkd->offset;
  208         gkd->di.mediasize = gkd->length;
  209         g_io_deliver(bp, 0);
  210 }
  211 
  212 static void
  213 g_disk_setstate(struct bio *bp, struct g_disk_softc *sc)
  214 {
  215         const char *cmd;
  216 
  217         memcpy(&sc->state, bp->bio_data, sizeof(sc->state));
  218         if (sc->led[0] != 0) {
  219                 switch (sc->state) {
  220                 case G_STATE_FAILED:
  221                         cmd = "1";
  222                         break;
  223                 case G_STATE_REBUILD:
  224                         cmd = "f5";
  225                         break;
  226                 case G_STATE_RESYNC:
  227                         cmd = "f1";
  228                         break;
  229                 default:
  230                         cmd = "";
  231                         break;
  232                 }
  233                 led_set(sc->led, cmd);
  234         }
  235         g_io_deliver(bp, 0);
  236 }
  237 
  238 static void
  239 g_disk_done(struct bio *bp)
  240 {
  241         struct bio *bp2;
  242         struct disk *dp;
  243         struct g_disk_softc *sc;
  244 
  245         /* See "notes" for why we need a mutex here */
  246         /* XXX: will witness accept a mix of Giant/unGiant drivers here ? */
  247         mtx_lock(&g_disk_done_mtx);
  248         bp->bio_completed = bp->bio_length - bp->bio_resid;
  249 
  250         bp2 = bp->bio_parent;
  251         if (bp2->bio_error == 0)
  252                 bp2->bio_error = bp->bio_error;
  253         bp2->bio_completed += bp->bio_completed;
  254         if ((bp->bio_cmd & (BIO_READ|BIO_WRITE|BIO_DELETE)) &&
  255             (sc = bp2->bio_to->geom->softc) &&
  256             (dp = sc->dp)) {
  257                 devstat_end_transaction_bio(dp->d_devstat, bp);
  258         }
  259         g_destroy_bio(bp);
  260         bp2->bio_inbed++;
  261         if (bp2->bio_children == bp2->bio_inbed) {
  262                 bp2->bio_resid = bp2->bio_bcount - bp2->bio_completed;
  263                 g_io_deliver(bp2, bp2->bio_error);
  264         }
  265         mtx_unlock(&g_disk_done_mtx);
  266 }
  267 
  268 static int
  269 g_disk_ioctl(struct g_provider *pp, u_long cmd, void * data, int fflag, struct thread *td)
  270 {
  271         struct g_geom *gp;
  272         struct disk *dp;
  273         struct g_disk_softc *sc;
  274         int error;
  275 
  276         gp = pp->geom;
  277         sc = gp->softc;
  278         dp = sc->dp;
  279 
  280         if (dp->d_ioctl == NULL)
  281                 return (ENOIOCTL);
  282         g_disk_lock_giant(dp);
  283         error = dp->d_ioctl(dp, cmd, data, fflag, td);
  284         g_disk_unlock_giant(dp);
  285         return(error);
  286 }
  287 
  288 static void
  289 g_disk_start(struct bio *bp)
  290 {
  291         struct bio *bp2, *bp3;
  292         struct disk *dp;
  293         struct g_disk_softc *sc;
  294         int error;
  295         off_t off;
  296 
  297         sc = bp->bio_to->geom->softc;
  298         if (sc == NULL || (dp = sc->dp) == NULL || dp->d_destroyed) {
  299                 g_io_deliver(bp, ENXIO);
  300                 return;
  301         }
  302         error = EJUSTRETURN;
  303         switch(bp->bio_cmd) {
  304         case BIO_DELETE:
  305                 if (!(dp->d_flags & DISKFLAG_CANDELETE)) {
  306                         error = EOPNOTSUPP;
  307                         break;
  308                 }
  309                 /* fall-through */
  310         case BIO_READ:
  311         case BIO_WRITE:
  312                 off = 0;
  313                 bp3 = NULL;
  314                 bp2 = g_clone_bio(bp);
  315                 if (bp2 == NULL) {
  316                         error = ENOMEM;
  317                         break;
  318                 }
  319                 do {
  320                         bp2->bio_offset += off;
  321                         bp2->bio_length -= off;
  322                         bp2->bio_data += off;
  323                         if (bp2->bio_length > dp->d_maxsize) {
  324                                 /*
  325                                  * XXX: If we have a stripesize we should really
  326                                  * use it here.
  327                                  */
  328                                 bp2->bio_length = dp->d_maxsize;
  329                                 off += dp->d_maxsize;
  330                                 /*
  331                                  * To avoid a race, we need to grab the next bio
  332                                  * before we schedule this one.  See "notes".
  333                                  */
  334                                 bp3 = g_clone_bio(bp);
  335                                 if (bp3 == NULL)
  336                                         bp->bio_error = ENOMEM;
  337                         }
  338                         bp2->bio_done = g_disk_done;
  339                         bp2->bio_pblkno = bp2->bio_offset / dp->d_sectorsize;
  340                         bp2->bio_bcount = bp2->bio_length;
  341                         bp2->bio_disk = dp;
  342                         devstat_start_transaction_bio(dp->d_devstat, bp2);
  343                         g_disk_lock_giant(dp);
  344                         dp->d_strategy(bp2);
  345                         g_disk_unlock_giant(dp);
  346                         bp2 = bp3;
  347                         bp3 = NULL;
  348                 } while (bp2 != NULL);
  349                 break;
  350         case BIO_GETATTR:
  351                 if (g_handleattr_int(bp, "GEOM::candelete",
  352                     (dp->d_flags & DISKFLAG_CANDELETE) != 0))
  353                         break;
  354                 else if (g_handleattr_int(bp, "GEOM::fwsectors",
  355                     dp->d_fwsectors))
  356                         break;
  357                 else if (g_handleattr_int(bp, "GEOM::fwheads", dp->d_fwheads))
  358                         break;
  359                 else if (g_handleattr_off_t(bp, "GEOM::frontstuff", 0))
  360                         break;
  361                 else if (g_handleattr_str(bp, "GEOM::ident", dp->d_ident))
  362                         break;
  363                 else if (!strcmp(bp->bio_attribute, "GEOM::kerneldump"))
  364                         g_disk_kerneldump(bp, dp);
  365                 else if (!strcmp(bp->bio_attribute, "GEOM::setstate"))
  366                         g_disk_setstate(bp, sc);
  367                 else 
  368                         error = ENOIOCTL;
  369                 break;
  370         case BIO_FLUSH:
  371                 g_trace(G_T_BIO, "g_disk_flushcache(%s)",
  372                     bp->bio_to->name);
  373                 if (!(dp->d_flags & DISKFLAG_CANFLUSHCACHE)) {
  374                         error = EOPNOTSUPP;
  375                         break;
  376                 }
  377                 bp2 = g_clone_bio(bp);
  378                 if (bp2 == NULL) {
  379                         g_io_deliver(bp, ENOMEM);
  380                         return;
  381                 }
  382                 bp2->bio_done = g_disk_done;
  383                 bp2->bio_disk = dp;
  384                 g_disk_lock_giant(dp);
  385                 dp->d_strategy(bp2);
  386                 g_disk_unlock_giant(dp);
  387                 break;
  388         default:
  389                 error = EOPNOTSUPP;
  390                 break;
  391         }
  392         if (error != EJUSTRETURN)
  393                 g_io_deliver(bp, error);
  394         return;
  395 }
  396 
  397 static void
  398 g_disk_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp)
  399 {
  400         struct disk *dp;
  401         struct g_disk_softc *sc;
  402 
  403         sc = gp->softc;
  404         if (sc == NULL || (dp = sc->dp) == NULL)
  405                 return;
  406         if (indent == NULL) {
  407                 sbuf_printf(sb, " hd %u", dp->d_fwheads);
  408                 sbuf_printf(sb, " sc %u", dp->d_fwsectors);
  409                 return;
  410         }
  411         if (pp != NULL) {
  412                 sbuf_printf(sb, "%s<fwheads>%u</fwheads>\n",
  413                     indent, dp->d_fwheads);
  414                 sbuf_printf(sb, "%s<fwsectors>%u</fwsectors>\n",
  415                     indent, dp->d_fwsectors);
  416         }
  417 }
  418 
  419 static void
  420 g_disk_create(void *arg, int flag)
  421 {
  422         struct g_geom *gp;
  423         struct g_provider *pp;
  424         struct disk *dp;
  425         struct g_disk_softc *sc;
  426         char tmpstr[80];
  427 
  428         if (flag == EV_CANCEL)
  429                 return;
  430         g_topology_assert();
  431         dp = arg;
  432         sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
  433         sc->dp = dp;
  434         gp = g_new_geomf(&g_disk_class, "%s%d", dp->d_name, dp->d_unit);
  435         gp->softc = sc;
  436         pp = g_new_providerf(gp, "%s", gp->name);
  437         pp->mediasize = dp->d_mediasize;
  438         pp->sectorsize = dp->d_sectorsize;
  439         if (dp->d_flags & DISKFLAG_CANDELETE)
  440                 pp->flags |= G_PF_CANDELETE;
  441         pp->stripeoffset = dp->d_stripeoffset;
  442         pp->stripesize = dp->d_stripesize;
  443         if (bootverbose)
  444                 printf("GEOM: new disk %s\n", gp->name);
  445         sysctl_ctx_init(&sc->sysctl_ctx);
  446         snprintf(tmpstr, sizeof(tmpstr), "GEOM disk %s", gp->name);
  447         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
  448                 SYSCTL_STATIC_CHILDREN(_kern_geom_disk), OID_AUTO, gp->name,
  449                 CTLFLAG_RD, 0, tmpstr);
  450         if (sc->sysctl_tree != NULL) {
  451                 snprintf(tmpstr, sizeof(tmpstr),
  452                     "kern.geom.disk.%s.led", gp->name);
  453                 TUNABLE_STR_FETCH(tmpstr, sc->led, sizeof(sc->led));
  454                 SYSCTL_ADD_STRING(&sc->sysctl_ctx,
  455                     SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "led",
  456                     CTLFLAG_RW | CTLFLAG_TUN, sc->led, sizeof(sc->led),
  457                     "LED name");
  458         }
  459         pp->private = sc;
  460         dp->d_geom = gp;
  461         g_error_provider(pp, 0);
  462 }
  463 
  464 static void
  465 g_disk_destroy(void *ptr, int flag)
  466 {
  467         struct disk *dp;
  468         struct g_geom *gp;
  469         struct g_disk_softc *sc;
  470 
  471         g_topology_assert();
  472         dp = ptr;
  473         gp = dp->d_geom;
  474         if (gp != NULL) {
  475                 sc = gp->softc;
  476                 if (sc->sysctl_tree != NULL) {
  477                         sysctl_ctx_free(&sc->sysctl_ctx);
  478                         sc->sysctl_tree = NULL;
  479                 }
  480                 if (sc->led[0] != 0) {
  481                         led_set(sc->led, "");
  482                         sc->led[0] = 0;
  483                 }
  484                 g_free(sc);
  485                 gp->softc = NULL;
  486                 g_wither_geom(gp, ENXIO);
  487         }
  488         g_free(dp);
  489 }
  490 
  491 /*
  492  * We only allow printable characters in disk ident,
  493  * the rest is converted to 'x<HH>'.
  494  */
  495 static void
  496 g_disk_ident_adjust(char *ident, size_t size)
  497 {
  498         char *p, tmp[4], newid[DISK_IDENT_SIZE];
  499 
  500         newid[0] = '\0';
  501         for (p = ident; *p != '\0'; p++) {
  502                 if (isprint(*p)) {
  503                         tmp[0] = *p;
  504                         tmp[1] = '\0';
  505                 } else {
  506                         snprintf(tmp, sizeof(tmp), "x%02hhx",
  507                             *(unsigned char *)p);
  508                 }
  509                 if (strlcat(newid, tmp, sizeof(newid)) >= sizeof(newid))
  510                         break;
  511         }
  512         bzero(ident, size);
  513         strlcpy(ident, newid, size);
  514 }
  515 
  516 struct disk *
  517 disk_alloc()
  518 {
  519         struct disk *dp;
  520 
  521         dp = g_malloc(sizeof *dp, M_WAITOK | M_ZERO);
  522         return (dp);
  523 }
  524 
  525 void
  526 disk_create(struct disk *dp, int version)
  527 {
  528         if (version != DISK_VERSION_00 && version != DISK_VERSION_01) {
  529                 printf("WARNING: Attempt to add disk %s%d %s",
  530                     dp->d_name, dp->d_unit,
  531                     " using incompatible ABI version of disk(9)\n");
  532                 printf("WARNING: Ignoring disk %s%d\n",
  533                     dp->d_name, dp->d_unit);
  534                 return;
  535         }
  536         KASSERT(dp->d_strategy != NULL, ("disk_create need d_strategy"));
  537         KASSERT(dp->d_name != NULL, ("disk_create need d_name"));
  538         KASSERT(*dp->d_name != 0, ("disk_create need d_name"));
  539         KASSERT(strlen(dp->d_name) < SPECNAMELEN - 4, ("disk name too long"));
  540         if (dp->d_devstat == NULL)
  541                 dp->d_devstat = devstat_new_entry(dp->d_name, dp->d_unit,
  542                     dp->d_sectorsize, DEVSTAT_ALL_SUPPORTED,
  543                     DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
  544         dp->d_geom = NULL;
  545         g_disk_ident_adjust(dp->d_ident, sizeof(dp->d_ident));
  546         g_post_event(g_disk_create, dp, M_WAITOK, dp, NULL);
  547 }
  548 
  549 void
  550 disk_destroy(struct disk *dp)
  551 {
  552 
  553         g_cancel_event(dp);
  554         dp->d_destroyed = 1;
  555         if (dp->d_devstat != NULL)
  556                 devstat_remove_entry(dp->d_devstat);
  557         g_post_event(g_disk_destroy, dp, M_WAITOK, NULL);
  558 }
  559 
  560 void
  561 disk_gone(struct disk *dp)
  562 {
  563         struct g_geom *gp;
  564         struct g_provider *pp;
  565 
  566         gp = dp->d_geom;
  567         if (gp != NULL)
  568                 LIST_FOREACH(pp, &gp->provider, provider)
  569                         g_wither_provider(pp, ENXIO);
  570 }
  571 
  572 static void
  573 g_kern_disks(void *p, int flag __unused)
  574 {
  575         struct sbuf *sb;
  576         struct g_geom *gp;
  577         char *sp;
  578 
  579         sb = p;
  580         sp = "";
  581         g_topology_assert();
  582         LIST_FOREACH(gp, &g_disk_class.geom, geom) {
  583                 sbuf_printf(sb, "%s%s", sp, gp->name);
  584                 sp = " ";
  585         }
  586         sbuf_finish(sb);
  587 }
  588 
  589 static int
  590 sysctl_disks(SYSCTL_HANDLER_ARGS)
  591 {
  592         int error;
  593         struct sbuf *sb;
  594 
  595         sb = sbuf_new_auto();
  596         g_waitfor_event(g_kern_disks, sb, M_WAITOK, NULL);
  597         error = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1);
  598         sbuf_delete(sb);
  599         return error;
  600 }
  601  
  602 SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NOLOCK, 0, 0, 
  603     sysctl_disks, "A", "names of available disks");
  604 

Cache object: 07e78aab1f523d75995edee4b35f97fe


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