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: releng/5.4/sys/geom/geom_disk.c 145335 2005-04-20 19:11:07Z cvs2svn $");
   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/conf.h>
   47 #include <sys/fcntl.h>
   48 #include <sys/malloc.h>
   49 #include <sys/sysctl.h>
   50 #include <sys/devicestat.h>
   51 #include <machine/md_var.h>
   52 
   53 #include <sys/lock.h>
   54 #include <sys/mutex.h>
   55 #include <geom/geom.h>
   56 #include <geom/geom_disk.h>
   57 #include <geom/geom_int.h>
   58 
   59 static struct mtx g_disk_done_mtx;
   60 
   61 static g_access_t g_disk_access;
   62 static g_init_t g_disk_init;
   63 static g_fini_t g_disk_fini;
   64 static g_start_t g_disk_start;
   65 static g_ioctl_t g_disk_ioctl;
   66 static g_dumpconf_t g_disk_dumpconf;
   67 
   68 static struct g_class g_disk_class = {
   69         .name = "DISK",
   70         .version = G_VERSION,
   71         .init = g_disk_init,
   72         .fini = g_disk_fini,
   73         .start = g_disk_start,
   74         .access = g_disk_access,
   75         .ioctl = g_disk_ioctl,
   76         .dumpconf = g_disk_dumpconf,
   77 };
   78 
   79 static void
   80 g_disk_init(struct g_class *mp __unused)
   81 {
   82 
   83         mtx_init(&g_disk_done_mtx, "g_disk_done", NULL, MTX_DEF);
   84 }
   85 
   86 static void
   87 g_disk_fini(struct g_class *mp __unused)
   88 {
   89 
   90         mtx_destroy(&g_disk_done_mtx);
   91 }
   92 
   93 DECLARE_GEOM_CLASS(g_disk_class, g_disk);
   94 
   95 static void __inline
   96 g_disk_lock_giant(struct disk *dp)
   97 {
   98         if (dp->d_flags & DISKFLAG_NEEDSGIANT)
   99                 mtx_lock(&Giant);
  100 }
  101 
  102 static void __inline
  103 g_disk_unlock_giant(struct disk *dp)
  104 {
  105         if (dp->d_flags & DISKFLAG_NEEDSGIANT)
  106                 mtx_unlock(&Giant);
  107 }
  108 
  109 static int
  110 g_disk_access(struct g_provider *pp, int r, int w, int e)
  111 {
  112         struct disk *dp;
  113         int error;
  114 
  115         g_trace(G_T_ACCESS, "g_disk_access(%s, %d, %d, %d)",
  116             pp->name, r, w, e);
  117         g_topology_assert();
  118         dp = pp->geom->softc;
  119         if (dp == NULL || dp->d_destroyed) {
  120                 /*
  121                  * Allow decreasing access count even if disk is not
  122                  * avaliable anymore.
  123                  */
  124                 if (r <= 0 && w <= 0 && e <= 0)
  125                         return (0);
  126                 return (ENXIO);
  127         }
  128         r += pp->acr;
  129         w += pp->acw;
  130         e += pp->ace;
  131         error = 0;
  132         if ((pp->acr + pp->acw + pp->ace) == 0 && (r + w + e) > 0) {
  133                 if (dp->d_open != NULL) {
  134                         g_disk_lock_giant(dp);
  135                         error = dp->d_open(dp);
  136                         if (error != 0)
  137                                 printf("Opened disk %s -> %d\n",
  138                                     pp->name, error);
  139                         g_disk_unlock_giant(dp);
  140                 }
  141                 pp->mediasize = dp->d_mediasize;
  142                 pp->sectorsize = dp->d_sectorsize;
  143                 dp->d_flags |= DISKFLAG_OPEN;
  144                 if (dp->d_maxsize == 0) {
  145                         printf("WARNING: Disk drive %s%d has no d_maxsize\n",
  146                             dp->d_name, dp->d_unit);
  147                         dp->d_maxsize = DFLTPHYS;
  148                 }
  149         } else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) {
  150                 if (dp->d_close != NULL) {
  151                         g_disk_lock_giant(dp);
  152                         error = dp->d_close(dp);
  153                         if (error != 0)
  154                                 printf("Closed disk %s -> %d\n",
  155                                     pp->name, error);
  156                         g_disk_unlock_giant(dp);
  157                 }
  158                 dp->d_flags &= ~DISKFLAG_OPEN;
  159         }
  160         return (error);
  161 }
  162 
  163 static void
  164 g_disk_kerneldump(struct bio *bp, struct disk *dp)
  165 { 
  166         int error;
  167         struct g_kerneldump *gkd;
  168         struct dumperinfo di;
  169         struct g_geom *gp;
  170 
  171         gkd = (struct g_kerneldump*)bp->bio_data;
  172         gp = bp->bio_to->geom;
  173         g_trace(G_T_TOPOLOGY, "g_disk_kernedump(%s, %jd, %jd)",
  174                 gp->name, (intmax_t)gkd->offset, (intmax_t)gkd->length);
  175         if (dp->d_dump == NULL) {
  176                 g_io_deliver(bp, ENODEV);
  177                 return;
  178         }
  179         di.dumper = dp->d_dump;
  180         di.priv = dp;
  181         di.blocksize = dp->d_sectorsize;
  182         di.mediaoffset = gkd->offset;
  183         if ((gkd->offset + gkd->length) > dp->d_mediasize)
  184                 gkd->length = dp->d_mediasize - gkd->offset;
  185         di.mediasize = gkd->length;
  186         error = set_dumper(&di);
  187         g_io_deliver(bp, error);
  188 }
  189 
  190 static void
  191 g_disk_done(struct bio *bp)
  192 {
  193         struct bio *bp2;
  194         struct disk *dp;
  195 
  196         /* See "notes" for why we need a mutex here */
  197         /* XXX: will witness accept a mix of Giant/unGiant drivers here ? */
  198         mtx_lock(&g_disk_done_mtx);
  199         bp->bio_completed = bp->bio_length - bp->bio_resid;
  200 
  201         bp2 = bp->bio_parent;
  202         if (bp2->bio_error == 0)
  203                 bp2->bio_error = bp->bio_error;
  204         bp2->bio_completed += bp->bio_completed;
  205         g_destroy_bio(bp);
  206         bp2->bio_inbed++;
  207         if (bp2->bio_children == bp2->bio_inbed) {
  208                 bp2->bio_resid = bp2->bio_bcount - bp2->bio_completed;
  209                 if ((dp = bp2->bio_to->geom->softc))
  210                         devstat_end_transaction_bio(dp->d_devstat, bp2);
  211                 g_io_deliver(bp2, bp2->bio_error);
  212         }
  213         mtx_unlock(&g_disk_done_mtx);
  214 }
  215 
  216 static int
  217 g_disk_ioctl(struct g_provider *pp, u_long cmd, void * data, int fflag, struct thread *td)
  218 {
  219         struct g_geom *gp;
  220         struct disk *dp;
  221         int error;
  222 
  223         gp = pp->geom;
  224         dp = gp->softc;
  225 
  226         if (dp->d_ioctl == NULL)
  227                 return (ENOIOCTL);
  228         g_disk_lock_giant(dp);
  229         error = dp->d_ioctl(dp, cmd, data, fflag, td);
  230         g_disk_unlock_giant(dp);
  231         return(error);
  232 }
  233 
  234 static void
  235 g_disk_start(struct bio *bp)
  236 {
  237         struct bio *bp2, *bp3;
  238         struct disk *dp;
  239         int error;
  240         off_t off;
  241 
  242         dp = bp->bio_to->geom->softc;
  243         if (dp == NULL || dp->d_destroyed)
  244                 g_io_deliver(bp, ENXIO);
  245         error = EJUSTRETURN;
  246         switch(bp->bio_cmd) {
  247         case BIO_DELETE:
  248                 if (!(dp->d_flags & DISKFLAG_CANDELETE)) {
  249                         error = 0;
  250                         break;
  251                 }
  252                 /* fall-through */
  253         case BIO_READ:
  254         case BIO_WRITE:
  255                 off = 0;
  256                 bp3 = NULL;
  257                 bp2 = g_clone_bio(bp);
  258                 if (bp2 == NULL) {
  259                         error = ENOMEM;
  260                         break;
  261                 }
  262                 devstat_start_transaction_bio(dp->d_devstat, bp);
  263                 do {
  264                         bp2->bio_offset += off;
  265                         bp2->bio_length -= off;
  266                         bp2->bio_data += off;
  267                         if (bp2->bio_length > dp->d_maxsize) {
  268                                 /*
  269                                  * XXX: If we have a stripesize we should really
  270                                  * use it here.
  271                                  */
  272                                 bp2->bio_length = dp->d_maxsize;
  273                                 off += dp->d_maxsize;
  274                                 /*
  275                                  * To avoid a race, we need to grab the next bio
  276                                  * before we schedule this one.  See "notes".
  277                                  */
  278                                 bp3 = g_clone_bio(bp);
  279                                 if (bp3 == NULL)
  280                                         bp->bio_error = ENOMEM;
  281                         }
  282                         bp2->bio_done = g_disk_done;
  283                         bp2->bio_pblkno = bp2->bio_offset / dp->d_sectorsize;
  284                         bp2->bio_bcount = bp2->bio_length;
  285                         bp2->bio_disk = dp;
  286                         g_disk_lock_giant(dp);
  287                         dp->d_strategy(bp2);
  288                         g_disk_unlock_giant(dp);
  289                         bp2 = bp3;
  290                         bp3 = NULL;
  291                 } while (bp2 != NULL);
  292                 break;
  293         case BIO_GETATTR:
  294                 if (g_handleattr_int(bp, "GEOM::fwsectors", dp->d_fwsectors))
  295                         break;
  296                 else if (g_handleattr_int(bp, "GEOM::fwheads", dp->d_fwheads))
  297                         break;
  298                 else if (g_handleattr_off_t(bp, "GEOM::frontstuff", 0))
  299                         break;
  300                 else if (!strcmp(bp->bio_attribute, "GEOM::kerneldump"))
  301                         g_disk_kerneldump(bp, dp);
  302                 else 
  303                         error = ENOIOCTL;
  304                 break;
  305         default:
  306                 error = EOPNOTSUPP;
  307                 break;
  308         }
  309         if (error != EJUSTRETURN)
  310                 g_io_deliver(bp, error);
  311         return;
  312 }
  313 
  314 static void
  315 g_disk_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp)
  316 {
  317         struct disk *dp;
  318 
  319         dp = gp->softc;
  320         if (dp == NULL)
  321                 return;
  322         if (indent == NULL) {
  323                 sbuf_printf(sb, " hd %u", dp->d_fwheads);
  324                 sbuf_printf(sb, " sc %u", dp->d_fwsectors);
  325                 return;
  326         }
  327         if (pp != NULL) {
  328                 sbuf_printf(sb, "%s<fwheads>%u</fwheads>\n",
  329                     indent, dp->d_fwheads);
  330                 sbuf_printf(sb, "%s<fwsectors>%u</fwsectors>\n",
  331                     indent, dp->d_fwsectors);
  332         }
  333 }
  334 
  335 static void
  336 g_disk_create(void *arg, int flag)
  337 {
  338         struct g_geom *gp;
  339         struct g_provider *pp;
  340         struct disk *dp;
  341 
  342         if (flag == EV_CANCEL)
  343                 return;
  344         g_topology_assert();
  345         dp = arg;
  346         gp = g_new_geomf(&g_disk_class, "%s%d", dp->d_name, dp->d_unit);
  347         gp->softc = dp;
  348         pp = g_new_providerf(gp, "%s", gp->name);
  349         pp->mediasize = dp->d_mediasize;
  350         pp->sectorsize = dp->d_sectorsize;
  351         if (dp->d_flags & DISKFLAG_CANDELETE)
  352                 pp->flags |= G_PF_CANDELETE;
  353         pp->stripeoffset = dp->d_stripeoffset;
  354         pp->stripesize = dp->d_stripesize;
  355         if (bootverbose)
  356                 printf("GEOM: new disk %s\n", gp->name);
  357         dp->d_geom = gp;
  358         g_error_provider(pp, 0);
  359 }
  360 
  361 static void
  362 g_disk_destroy(void *ptr, int flag)
  363 {
  364         struct disk *dp;
  365         struct g_geom *gp;
  366 
  367         g_topology_assert();
  368         dp = ptr;
  369         gp = dp->d_geom;
  370         if (gp != NULL) {
  371                 gp->softc = NULL;
  372                 g_wither_geom(gp, ENXIO);
  373         }
  374         g_free(dp);
  375 }
  376 
  377 struct disk *
  378 disk_alloc()
  379 {
  380         struct disk *dp;
  381 
  382         dp = g_malloc(sizeof *dp, M_WAITOK | M_ZERO);
  383         return (dp);
  384 }
  385 
  386 void
  387 disk_create(struct disk *dp, int version)
  388 {
  389         if (version != DISK_VERSION_00) {
  390                 printf("WARNING: Attempt to add disk %s%d %s",
  391                     dp->d_name, dp->d_unit,
  392                     " using incompatible ABI version of disk(9)\n");
  393                 printf("WARNING: Ignoring disk %s%d\n",
  394                     dp->d_name, dp->d_unit);
  395                 return;
  396         }
  397         KASSERT(dp->d_strategy != NULL, ("disk_create need d_strategy"));
  398         KASSERT(dp->d_name != NULL, ("disk_create need d_name"));
  399         KASSERT(*dp->d_name != 0, ("disk_create need d_name"));
  400         KASSERT(strlen(dp->d_name) < SPECNAMELEN - 4, ("disk name too long"));
  401         if (dp->d_devstat == NULL)
  402                 dp->d_devstat = devstat_new_entry(dp->d_name, dp->d_unit,
  403                     dp->d_sectorsize, DEVSTAT_ALL_SUPPORTED,
  404                     DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
  405         dp->d_geom = NULL;
  406         g_post_event(g_disk_create, dp, M_WAITOK, dp, NULL);
  407 }
  408 
  409 void
  410 disk_destroy(struct disk *dp)
  411 {
  412 
  413         g_cancel_event(dp);
  414         dp->d_destroyed = 1;
  415         if (dp->d_devstat != NULL)
  416                 devstat_remove_entry(dp->d_devstat);
  417         g_post_event(g_disk_destroy, dp, M_WAITOK, NULL);
  418 }
  419 
  420 static void
  421 g_kern_disks(void *p, int flag __unused)
  422 {
  423         struct sbuf *sb;
  424         struct g_geom *gp;
  425         char *sp;
  426 
  427         sb = p;
  428         sp = "";
  429         g_topology_assert();
  430         LIST_FOREACH(gp, &g_disk_class.geom, geom) {
  431                 sbuf_printf(sb, "%s%s", sp, gp->name);
  432                 sp = " ";
  433         }
  434         sbuf_finish(sb);
  435 }
  436 
  437 static int
  438 sysctl_disks(SYSCTL_HANDLER_ARGS)
  439 {
  440         int error;
  441         struct sbuf *sb;
  442 
  443         sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
  444         g_waitfor_event(g_kern_disks, sb, M_WAITOK, NULL);
  445         error = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1);
  446         sbuf_delete(sb);
  447         return error;
  448 }
  449  
  450 SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_NOLOCK, 0, 0, 
  451     sysctl_disks, "A", "names of available disks");
  452
Cache object: 95d661b05b5f2b424776331abaa2014c
[ 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/geom/geom_disk.c

FreeBSD/Linux Kernel Cross Reference
sys/geom/geom_disk.c
