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_ccd.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  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  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2003 Poul-Henning Kamp.
    3  * Copyright (c) 1995 Jason R. Thorpe.
    4  * Copyright (c) 1990, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  * All rights reserved.
    7  * Copyright (c) 1988 University of Utah.
    8  *
    9  * This code is derived from software contributed to Berkeley by
   10  * the Systems Programming Group of the University of Utah Computer
   11  * Science Department.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. All advertising materials mentioning features or use of this software
   22  *    must display the following acknowledgement:
   23  *      This product includes software developed for the NetBSD Project
   24  *      by Jason R. Thorpe.
   25  * 4. The names of the authors may not be used to endorse or promote products
   26  *    derived from this software without specific prior written permission.
   27  *
   28  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   29  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   30  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   31  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   32  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   33  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   34  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
   35  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   36  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   38  * SUCH DAMAGE.
   39  *
   40  * Dynamic configuration and disklabel support by:
   41  *      Jason R. Thorpe <thorpej@nas.nasa.gov>
   42  *      Numerical Aerodynamic Simulation Facility
   43  *      Mail Stop 258-6
   44  *      NASA Ames Research Center
   45  *      Moffett Field, CA 94035
   46  *
   47  * from: Utah $Hdr: cd.c 1.6 90/11/28$
   48  *      @(#)cd.c        8.2 (Berkeley) 11/16/93
   49  *      $NetBSD: ccd.c,v 1.22 1995/12/08 19:13:26 thorpej Exp $ 
   50  */
   51 
   52 #include <sys/cdefs.h>
   53 __FBSDID("$FreeBSD: src/sys/geom/geom_ccd.c,v 1.152.2.1 2005/01/31 23:26:00 imp Exp $");
   54 
   55 #include <sys/param.h>
   56 #include <sys/systm.h>
   57 #include <sys/kernel.h>
   58 #include <sys/module.h>
   59 #include <sys/bio.h>
   60 #include <sys/malloc.h>
   61 #include <geom/geom.h>
   62 
   63 /*
   64  * Number of blocks to untouched in front of a component partition.
   65  * This is to avoid violating its disklabel area when it starts at the
   66  * beginning of the slice.
   67  */
   68 #if !defined(CCD_OFFSET)
   69 #define CCD_OFFSET 16
   70 #endif
   71 
   72 /* sc_flags */
   73 #define CCDF_UNIFORM    0x02    /* use LCCD of sizes for uniform interleave */
   74 #define CCDF_MIRROR     0x04    /* use mirroring */
   75 
   76 /* Mask of user-settable ccd flags. */
   77 #define CCDF_USERMASK   (CCDF_UNIFORM|CCDF_MIRROR)
   78 
   79 /*
   80  * Interleave description table.
   81  * Computed at boot time to speed irregular-interleave lookups.
   82  * The idea is that we interleave in "groups".  First we interleave
   83  * evenly over all component disks up to the size of the smallest
   84  * component (the first group), then we interleave evenly over all
   85  * remaining disks up to the size of the next-smallest (second group),
   86  * and so on.
   87  *
   88  * Each table entry describes the interleave characteristics of one
   89  * of these groups.  For example if a concatenated disk consisted of
   90  * three components of 5, 3, and 7 DEV_BSIZE blocks interleaved at
   91  * DEV_BSIZE (1), the table would have three entries:
   92  *
   93  *      ndisk   startblk        startoff        dev
   94  *      3       0               0               0, 1, 2
   95  *      2       9               3               0, 2
   96  *      1       13              5               2
   97  *      0       -               -               -
   98  *
   99  * which says that the first nine blocks (0-8) are interleaved over
  100  * 3 disks (0, 1, 2) starting at block offset 0 on any component disk,
  101  * the next 4 blocks (9-12) are interleaved over 2 disks (0, 2) starting
  102  * at component block 3, and the remaining blocks (13-14) are on disk
  103  * 2 starting at offset 5.
  104  */
  105 struct ccdiinfo {
  106         int     ii_ndisk;       /* # of disks range is interleaved over */
  107         daddr_t ii_startblk;    /* starting scaled block # for range */
  108         daddr_t ii_startoff;    /* starting component offset (block #) */
  109         int     *ii_index;      /* ordered list of components in range */
  110 };
  111 
  112 /*
  113  * Component info table.
  114  * Describes a single component of a concatenated disk.
  115  */
  116 struct ccdcinfo {
  117         daddr_t         ci_size;                /* size */
  118         struct g_provider *ci_provider;         /* provider */
  119         struct g_consumer *ci_consumer;         /* consumer */
  120 };
  121 
  122 /*
  123  * A concatenated disk is described by this structure.
  124  */
  125 
  126 struct ccd_s {
  127         LIST_ENTRY(ccd_s) list;
  128 
  129         int              sc_unit;               /* logical unit number */
  130         int              sc_flags;              /* flags */
  131         daddr_t          sc_size;               /* size of ccd */
  132         int              sc_ileave;             /* interleave */
  133         u_int            sc_ndisks;             /* number of components */
  134         struct ccdcinfo  *sc_cinfo;             /* component info */
  135         struct ccdiinfo  *sc_itable;            /* interleave table */
  136         u_int32_t        sc_secsize;            /* # bytes per sector */
  137         int              sc_pick;               /* side of mirror picked */
  138         daddr_t          sc_blk[2];             /* mirror localization */
  139 };
  140 
  141 static g_start_t g_ccd_start;
  142 static void ccdiodone(struct bio *bp);
  143 static void ccdinterleave(struct ccd_s *);
  144 static int ccdinit(struct gctl_req *req, struct ccd_s *);
  145 static int ccdbuffer(struct bio **ret, struct ccd_s *,
  146                       struct bio *, daddr_t, caddr_t, long);
  147 
  148 static void
  149 g_ccd_orphan(struct g_consumer *cp)
  150 {
  151         /*
  152          * XXX: We don't do anything here.  It is not obvious
  153          * XXX: what DTRT would be, so we do what the previous
  154          * XXX: code did: ignore it and let the user cope.
  155          */
  156 }
  157 
  158 static int
  159 g_ccd_access(struct g_provider *pp, int dr, int dw, int de)
  160 {
  161         struct g_geom *gp;
  162         struct g_consumer *cp1, *cp2;
  163         int error;
  164 
  165         de += dr;
  166         de += dw;
  167 
  168         gp = pp->geom;
  169         error = ENXIO;
  170         LIST_FOREACH(cp1, &gp->consumer, consumer) {
  171                 error = g_access(cp1, dr, dw, de);
  172                 if (error) {
  173                         LIST_FOREACH(cp2, &gp->consumer, consumer) {
  174                                 if (cp1 == cp2)
  175                                         break;
  176                                 g_access(cp2, -dr, -dw, -de);
  177                         }
  178                         break;
  179                 }
  180         }
  181         return (error);
  182 }
  183 
  184 /*
  185  * Free the softc and its substructures.
  186  */
  187 static void
  188 g_ccd_freesc(struct ccd_s *sc)
  189 {
  190         struct ccdiinfo *ii;
  191 
  192         g_free(sc->sc_cinfo);
  193         if (sc->sc_itable != NULL) {
  194                 for (ii = sc->sc_itable; ii->ii_ndisk > 0; ii++)
  195                         if (ii->ii_index != NULL)
  196                                 g_free(ii->ii_index);
  197                 g_free(sc->sc_itable);
  198         }
  199         g_free(sc);
  200 }
  201 
  202 
  203 static int
  204 ccdinit(struct gctl_req *req, struct ccd_s *cs)
  205 {
  206         struct ccdcinfo *ci;
  207         daddr_t size;
  208         int ix;
  209         daddr_t minsize;
  210         int maxsecsize;
  211         off_t mediasize;
  212         u_int sectorsize;
  213 
  214         cs->sc_size = 0;
  215 
  216         maxsecsize = 0;
  217         minsize = 0;
  218         for (ix = 0; ix < cs->sc_ndisks; ix++) {
  219                 ci = &cs->sc_cinfo[ix];
  220 
  221                 mediasize = ci->ci_provider->mediasize;
  222                 sectorsize = ci->ci_provider->sectorsize;
  223                 if (sectorsize > maxsecsize)
  224                         maxsecsize = sectorsize;
  225                 size = mediasize / DEV_BSIZE - CCD_OFFSET;
  226 
  227                 /* Truncate to interleave boundary */
  228 
  229                 if (cs->sc_ileave > 1)
  230                         size -= size % cs->sc_ileave;
  231 
  232                 if (size == 0) {
  233                         gctl_error(req, "Component %s has effective size zero",
  234                             ci->ci_provider->name);
  235                         return(ENODEV);
  236                 }
  237 
  238                 if (minsize == 0 || size < minsize)
  239                         minsize = size;
  240                 ci->ci_size = size;
  241                 cs->sc_size += size;
  242         }
  243 
  244         /*
  245          * Don't allow the interleave to be smaller than
  246          * the biggest component sector.
  247          */
  248         if ((cs->sc_ileave > 0) &&
  249             (cs->sc_ileave < (maxsecsize / DEV_BSIZE))) {
  250                 gctl_error(req, "Interleave to small for sector size");
  251                 return(EINVAL);
  252         }
  253 
  254         /*
  255          * If uniform interleave is desired set all sizes to that of
  256          * the smallest component.  This will guarentee that a single
  257          * interleave table is generated.
  258          *
  259          * Lost space must be taken into account when calculating the
  260          * overall size.  Half the space is lost when CCDF_MIRROR is
  261          * specified.
  262          */
  263         if (cs->sc_flags & CCDF_UNIFORM) {
  264                 for (ix = 0; ix < cs->sc_ndisks; ix++) {
  265                         ci = &cs->sc_cinfo[ix];
  266                         ci->ci_size = minsize;
  267                 }
  268                 cs->sc_size = cs->sc_ndisks * minsize;
  269         }
  270 
  271         if (cs->sc_flags & CCDF_MIRROR) {
  272                 /*
  273                  * Check to see if an even number of components
  274                  * have been specified.  The interleave must also
  275                  * be non-zero in order for us to be able to 
  276                  * guarentee the topology.
  277                  */
  278                 if (cs->sc_ndisks % 2) {
  279                         gctl_error(req,
  280                               "Mirroring requires an even number of disks");
  281                         return(EINVAL);
  282                 }
  283                 if (cs->sc_ileave == 0) {
  284                         gctl_error(req,
  285                              "An interleave must be specified when mirroring");
  286                         return(EINVAL);
  287                 }
  288                 cs->sc_size = (cs->sc_ndisks/2) * minsize;
  289         } 
  290 
  291         /*
  292          * Construct the interleave table.
  293          */
  294         ccdinterleave(cs);
  295 
  296         /*
  297          * Create pseudo-geometry based on 1MB cylinders.  It's
  298          * pretty close.
  299          */
  300         cs->sc_secsize = maxsecsize;
  301 
  302         return (0);
  303 }
  304 
  305 static void
  306 ccdinterleave(struct ccd_s *cs)
  307 {
  308         struct ccdcinfo *ci, *smallci;
  309         struct ccdiinfo *ii;
  310         daddr_t bn, lbn;
  311         int ix;
  312         daddr_t size;
  313 
  314 
  315         /*
  316          * Allocate an interleave table.  The worst case occurs when each
  317          * of N disks is of a different size, resulting in N interleave
  318          * tables.
  319          *
  320          * Chances are this is too big, but we don't care.
  321          */
  322         size = (cs->sc_ndisks + 1) * sizeof(struct ccdiinfo);
  323         cs->sc_itable = g_malloc(size, M_WAITOK | M_ZERO);
  324 
  325         /*
  326          * Trivial case: no interleave (actually interleave of disk size).
  327          * Each table entry represents a single component in its entirety.
  328          *
  329          * An interleave of 0 may not be used with a mirror setup.
  330          */
  331         if (cs->sc_ileave == 0) {
  332                 bn = 0;
  333                 ii = cs->sc_itable;
  334 
  335                 for (ix = 0; ix < cs->sc_ndisks; ix++) {
  336                         /* Allocate space for ii_index. */
  337                         ii->ii_index = g_malloc(sizeof(int), M_WAITOK);
  338                         ii->ii_ndisk = 1;
  339                         ii->ii_startblk = bn;
  340                         ii->ii_startoff = 0;
  341                         ii->ii_index[0] = ix;
  342                         bn += cs->sc_cinfo[ix].ci_size;
  343                         ii++;
  344                 }
  345                 ii->ii_ndisk = 0;
  346                 return;
  347         }
  348 
  349         /*
  350          * The following isn't fast or pretty; it doesn't have to be.
  351          */
  352         size = 0;
  353         bn = lbn = 0;
  354         for (ii = cs->sc_itable; ; ii++) {
  355                 /*
  356                  * Allocate space for ii_index.  We might allocate more then
  357                  * we use.
  358                  */
  359                 ii->ii_index = g_malloc((sizeof(int) * cs->sc_ndisks),
  360                     M_WAITOK);
  361 
  362                 /*
  363                  * Locate the smallest of the remaining components
  364                  */
  365                 smallci = NULL;
  366                 for (ci = cs->sc_cinfo; ci < &cs->sc_cinfo[cs->sc_ndisks]; 
  367                     ci++) {
  368                         if (ci->ci_size > size &&
  369                             (smallci == NULL ||
  370                              ci->ci_size < smallci->ci_size)) {
  371                                 smallci = ci;
  372                         }
  373                 }
  374 
  375                 /*
  376                  * Nobody left, all done
  377                  */
  378                 if (smallci == NULL) {
  379                         ii->ii_ndisk = 0;
  380                         g_free(ii->ii_index);
  381                         ii->ii_index = NULL;
  382                         break;
  383                 }
  384 
  385                 /*
  386                  * Record starting logical block using an sc_ileave blocksize.
  387                  */
  388                 ii->ii_startblk = bn / cs->sc_ileave;
  389 
  390                 /*
  391                  * Record starting component block using an sc_ileave 
  392                  * blocksize.  This value is relative to the beginning of
  393                  * a component disk.
  394                  */
  395                 ii->ii_startoff = lbn;
  396 
  397                 /*
  398                  * Determine how many disks take part in this interleave
  399                  * and record their indices.
  400                  */
  401                 ix = 0;
  402                 for (ci = cs->sc_cinfo; 
  403                     ci < &cs->sc_cinfo[cs->sc_ndisks]; ci++) {
  404                         if (ci->ci_size >= smallci->ci_size) {
  405                                 ii->ii_index[ix++] = ci - cs->sc_cinfo;
  406                         }
  407                 }
  408                 ii->ii_ndisk = ix;
  409                 bn += ix * (smallci->ci_size - size);
  410                 lbn = smallci->ci_size / cs->sc_ileave;
  411                 size = smallci->ci_size;
  412         }
  413 }
  414 
  415 static void
  416 g_ccd_start(struct bio *bp)
  417 {
  418         long bcount, rcount;
  419         struct bio *cbp[2];
  420         caddr_t addr;
  421         daddr_t bn;
  422         int err;
  423         struct ccd_s *cs;
  424 
  425         cs = bp->bio_to->geom->softc;
  426 
  427         /*
  428          * Block all GETATTR requests, we wouldn't know which of our
  429          * subdevices we should ship it off to.
  430          * XXX: this may not be the right policy.
  431          */
  432         if(bp->bio_cmd == BIO_GETATTR) {
  433                 g_io_deliver(bp, EINVAL);
  434                 return;
  435         }
  436 
  437         /*
  438          * Translate the partition-relative block number to an absolute.
  439          */
  440         bn = bp->bio_offset / cs->sc_secsize;
  441 
  442         /*
  443          * Allocate component buffers and fire off the requests
  444          */
  445         addr = bp->bio_data;
  446         for (bcount = bp->bio_length; bcount > 0; bcount -= rcount) {
  447                 err = ccdbuffer(cbp, cs, bp, bn, addr, bcount);
  448                 if (err) {
  449                         bp->bio_completed += bcount;
  450                         if (bp->bio_error == 0)
  451                                 bp->bio_error = err;
  452                         if (bp->bio_completed == bp->bio_length)
  453                                 g_io_deliver(bp, bp->bio_error);
  454                         return;
  455                 }
  456                 rcount = cbp[0]->bio_length;
  457 
  458                 if (cs->sc_flags & CCDF_MIRROR) {
  459                         /*
  460                          * Mirroring.  Writes go to both disks, reads are
  461                          * taken from whichever disk seems most appropriate.
  462                          *
  463                          * We attempt to localize reads to the disk whos arm
  464                          * is nearest the read request.  We ignore seeks due
  465                          * to writes when making this determination and we
  466                          * also try to avoid hogging.
  467                          */
  468                         if (cbp[0]->bio_cmd != BIO_READ) {
  469                                 g_io_request(cbp[0], cbp[0]->bio_from);
  470                                 g_io_request(cbp[1], cbp[1]->bio_from);
  471                         } else {
  472                                 int pick = cs->sc_pick;
  473                                 daddr_t range = cs->sc_size / 16;
  474 
  475                                 if (bn < cs->sc_blk[pick] - range ||
  476                                     bn > cs->sc_blk[pick] + range
  477                                 ) {
  478                                         cs->sc_pick = pick = 1 - pick;
  479                                 }
  480                                 cs->sc_blk[pick] = bn + btodb(rcount);
  481                                 g_io_request(cbp[pick], cbp[pick]->bio_from);
  482                         }
  483                 } else {
  484                         /*
  485                          * Not mirroring
  486                          */
  487                         g_io_request(cbp[0], cbp[0]->bio_from);
  488                 }
  489                 bn += btodb(rcount);
  490                 addr += rcount;
  491         }
  492 }
  493 
  494 /*
  495  * Build a component buffer header.
  496  */
  497 static int
  498 ccdbuffer(struct bio **cb, struct ccd_s *cs, struct bio *bp, daddr_t bn, caddr_t addr, long bcount)
  499 {
  500         struct ccdcinfo *ci, *ci2 = NULL;
  501         struct bio *cbp;
  502         daddr_t cbn, cboff;
  503         off_t cbc;
  504 
  505         /*
  506          * Determine which component bn falls in.
  507          */
  508         cbn = bn;
  509         cboff = 0;
  510 
  511         if (cs->sc_ileave == 0) {
  512                 /*
  513                  * Serially concatenated and neither a mirror nor a parity
  514                  * config.  This is a special case.
  515                  */
  516                 daddr_t sblk;
  517 
  518                 sblk = 0;
  519                 for (ci = cs->sc_cinfo; cbn >= sblk + ci->ci_size; ci++)
  520                         sblk += ci->ci_size;
  521                 cbn -= sblk;
  522         } else {
  523                 struct ccdiinfo *ii;
  524                 int ccdisk, off;
  525 
  526                 /*
  527                  * Calculate cbn, the logical superblock (sc_ileave chunks),
  528                  * and cboff, a normal block offset (DEV_BSIZE chunks) relative
  529                  * to cbn.
  530                  */
  531                 cboff = cbn % cs->sc_ileave;    /* DEV_BSIZE gran */
  532                 cbn = cbn / cs->sc_ileave;      /* DEV_BSIZE * ileave gran */
  533 
  534                 /*
  535                  * Figure out which interleave table to use.
  536                  */
  537                 for (ii = cs->sc_itable; ii->ii_ndisk; ii++) {
  538                         if (ii->ii_startblk > cbn)
  539                                 break;
  540                 }
  541                 ii--;
  542 
  543                 /*
  544                  * off is the logical superblock relative to the beginning 
  545                  * of this interleave block.  
  546                  */
  547                 off = cbn - ii->ii_startblk;
  548 
  549                 /*
  550                  * We must calculate which disk component to use (ccdisk),
  551                  * and recalculate cbn to be the superblock relative to
  552                  * the beginning of the component.  This is typically done by
  553                  * adding 'off' and ii->ii_startoff together.  However, 'off'
  554                  * must typically be divided by the number of components in
  555                  * this interleave array to be properly convert it from a
  556                  * CCD-relative logical superblock number to a 
  557                  * component-relative superblock number.
  558                  */
  559                 if (ii->ii_ndisk == 1) {
  560                         /*
  561                          * When we have just one disk, it can't be a mirror
  562                          * or a parity config.
  563                          */
  564                         ccdisk = ii->ii_index[0];
  565                         cbn = ii->ii_startoff + off;
  566                 } else {
  567                         if (cs->sc_flags & CCDF_MIRROR) {
  568                                 /*
  569                                  * We have forced a uniform mapping, resulting
  570                                  * in a single interleave array.  We double
  571                                  * up on the first half of the available
  572                                  * components and our mirror is in the second
  573                                  * half.  This only works with a single 
  574                                  * interleave array because doubling up
  575                                  * doubles the number of sectors, so there
  576                                  * cannot be another interleave array because
  577                                  * the next interleave array's calculations
  578                                  * would be off.
  579                                  */
  580                                 int ndisk2 = ii->ii_ndisk / 2;
  581                                 ccdisk = ii->ii_index[off % ndisk2];
  582                                 cbn = ii->ii_startoff + off / ndisk2;
  583                                 ci2 = &cs->sc_cinfo[ccdisk + ndisk2];
  584                         } else {
  585                                 ccdisk = ii->ii_index[off % ii->ii_ndisk];
  586                                 cbn = ii->ii_startoff + off / ii->ii_ndisk;
  587                         }
  588                 }
  589 
  590                 ci = &cs->sc_cinfo[ccdisk];
  591 
  592                 /*
  593                  * Convert cbn from a superblock to a normal block so it
  594                  * can be used to calculate (along with cboff) the normal
  595                  * block index into this particular disk.
  596                  */
  597                 cbn *= cs->sc_ileave;
  598         }
  599 
  600         /*
  601          * Fill in the component buf structure.
  602          */
  603         cbp = g_clone_bio(bp);
  604         if (cbp == NULL)
  605                 return (ENOMEM);
  606         cbp->bio_done = g_std_done;
  607         cbp->bio_offset = dbtob(cbn + cboff + CCD_OFFSET);
  608         cbp->bio_data = addr;
  609         if (cs->sc_ileave == 0)
  610               cbc = dbtob((off_t)(ci->ci_size - cbn));
  611         else
  612               cbc = dbtob((off_t)(cs->sc_ileave - cboff));
  613         cbp->bio_length = (cbc < bcount) ? cbc : bcount;
  614 
  615         cbp->bio_from = ci->ci_consumer;
  616         cb[0] = cbp;
  617 
  618         if (cs->sc_flags & CCDF_MIRROR) {
  619                 cbp = g_clone_bio(bp);
  620                 if (cbp == NULL)
  621                         return (ENOMEM);
  622                 cbp->bio_done = cb[0]->bio_done = ccdiodone;
  623                 cbp->bio_offset = cb[0]->bio_offset;
  624                 cbp->bio_data = cb[0]->bio_data;
  625                 cbp->bio_length = cb[0]->bio_length;
  626                 cbp->bio_from = ci2->ci_consumer;
  627                 cbp->bio_caller1 = cb[0];
  628                 cb[0]->bio_caller1 = cbp;
  629                 cb[1] = cbp;
  630         }
  631         return (0);
  632 }
  633 
  634 /*
  635  * Called only for mirrored operations.
  636  */
  637 static void
  638 ccdiodone(struct bio *cbp)
  639 {
  640         struct bio *mbp, *pbp;
  641 
  642         mbp = cbp->bio_caller1;
  643         pbp = cbp->bio_parent;
  644 
  645         if (pbp->bio_cmd == BIO_READ) {
  646                 if (cbp->bio_error == 0) {
  647                         /* We will not be needing the partner bio */
  648                         if (mbp != NULL) {
  649                                 pbp->bio_inbed++;
  650                                 g_destroy_bio(mbp);
  651                         }
  652                         g_std_done(cbp);
  653                         return;
  654                 }
  655                 if (mbp != NULL) {
  656                         /* Try partner the bio instead */
  657                         mbp->bio_caller1 = NULL;
  658                         pbp->bio_inbed++;
  659                         g_destroy_bio(cbp);
  660                         g_io_request(mbp, mbp->bio_from);
  661                         /*
  662                          * XXX: If this comes back OK, we should actually
  663                          * try to write the good data on the failed mirror
  664                          */
  665                         return;
  666                 }
  667                 g_std_done(cbp);
  668                 return;
  669         }
  670         if (mbp != NULL) {
  671                 mbp->bio_caller1 = NULL;
  672                 pbp->bio_inbed++;
  673                 if (cbp->bio_error != 0 && pbp->bio_error == 0)
  674                         pbp->bio_error = cbp->bio_error;
  675                 g_destroy_bio(cbp);
  676                 return;
  677         }
  678         g_std_done(cbp);
  679 }
  680 
  681 static void
  682 g_ccd_create(struct gctl_req *req, struct g_class *mp)
  683 {
  684         int *unit, *ileave, *nprovider;
  685         struct g_geom *gp;
  686         struct g_consumer *cp;
  687         struct g_provider *pp;
  688         struct ccd_s *sc;
  689         struct sbuf *sb;
  690         char buf[20];
  691         int i, error;
  692 
  693         g_topology_assert();
  694         unit = gctl_get_paraml(req, "unit", sizeof (*unit));
  695         ileave = gctl_get_paraml(req, "ileave", sizeof (*ileave));
  696         nprovider = gctl_get_paraml(req, "nprovider", sizeof (*nprovider));
  697 
  698         /* Check for duplicate unit */
  699         LIST_FOREACH(gp, &mp->geom, geom) {
  700                 sc = gp->softc;
  701                 if (sc != NULL && sc->sc_unit == *unit) {
  702                         gctl_error(req, "Unit %d already configured", *unit);
  703                         return;
  704                 }
  705         }
  706 
  707         if (*nprovider <= 0) {
  708                 gctl_error(req, "Bogus nprovider argument (= %d)", *nprovider);
  709                 return;
  710         }
  711 
  712         /* Check all providers are valid */
  713         for (i = 0; i < *nprovider; i++) {
  714                 sprintf(buf, "provider%d", i);
  715                 pp = gctl_get_provider(req, buf);
  716                 if (pp == NULL)
  717                         return;
  718         }
  719 
  720         gp = g_new_geomf(mp, "ccd%d", *unit);
  721         sc = g_malloc(sizeof *sc, M_WAITOK | M_ZERO);
  722         gp->softc = sc;
  723         sc->sc_ndisks = *nprovider;
  724 
  725         /* Allocate space for the component info. */
  726         sc->sc_cinfo = g_malloc(sc->sc_ndisks * sizeof(struct ccdcinfo),
  727             M_WAITOK | M_ZERO);
  728 
  729         /* Create consumers and attach to all providers */
  730         for (i = 0; i < *nprovider; i++) {
  731                 sprintf(buf, "provider%d", i);
  732                 pp = gctl_get_provider(req, buf);
  733                 cp = g_new_consumer(gp);
  734                 error = g_attach(cp, pp);
  735                 KASSERT(error == 0, ("attach to %s failed", pp->name));
  736                 sc->sc_cinfo[i].ci_consumer = cp;
  737                 sc->sc_cinfo[i].ci_provider = pp;
  738         }
  739 
  740         sc->sc_unit = *unit;
  741         sc->sc_ileave = *ileave;
  742 
  743         if (gctl_get_param(req, "uniform", NULL))
  744                 sc->sc_flags |= CCDF_UNIFORM;
  745         if (gctl_get_param(req, "mirror", NULL))
  746                 sc->sc_flags |= CCDF_MIRROR;
  747 
  748         if (sc->sc_ileave == 0 && (sc->sc_flags & CCDF_MIRROR)) {
  749                 printf("%s: disabling mirror, interleave is 0\n", gp->name);
  750                 sc->sc_flags &= ~(CCDF_MIRROR);
  751         }
  752 
  753         if ((sc->sc_flags & CCDF_MIRROR) && !(sc->sc_flags & CCDF_UNIFORM)) {
  754                 printf("%s: mirror/parity forces uniform flag\n", gp->name);
  755                 sc->sc_flags |= CCDF_UNIFORM;
  756         }
  757 
  758         error = ccdinit(req, sc);
  759         if (error != 0) {
  760                 g_ccd_freesc(sc);
  761                 gp->softc = NULL;
  762                 g_wither_geom(gp, ENXIO);
  763                 return;
  764         }
  765 
  766         pp = g_new_providerf(gp, "%s", gp->name);
  767         pp->mediasize = sc->sc_size * (off_t)sc->sc_secsize;
  768         pp->sectorsize = sc->sc_secsize;
  769         g_error_provider(pp, 0);
  770 
  771         sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
  772         sbuf_printf(sb, "ccd%d: %d components ", sc->sc_unit, *nprovider);
  773         for (i = 0; i < *nprovider; i++) {
  774                 sbuf_printf(sb, "%s%s",
  775                     i == 0 ? "(" : ", ", 
  776                     sc->sc_cinfo[i].ci_provider->name);
  777         }
  778         sbuf_printf(sb, "), %jd blocks ", (off_t)pp->mediasize / DEV_BSIZE);
  779         if (sc->sc_ileave != 0)
  780                 sbuf_printf(sb, "interleaved at %d blocks\n",
  781                         sc->sc_ileave);
  782         else
  783                 sbuf_printf(sb, "concatenated\n");
  784         sbuf_finish(sb);
  785         gctl_set_param(req, "output", sbuf_data(sb), sbuf_len(sb) + 1);
  786         sbuf_delete(sb);
  787 }
  788 
  789 static int
  790 g_ccd_destroy_geom(struct gctl_req *req, struct g_class *mp, struct g_geom *gp)
  791 {
  792         struct g_provider *pp;
  793         struct ccd_s *sc;
  794 
  795         g_topology_assert();
  796         sc = gp->softc;
  797         pp = LIST_FIRST(&gp->provider);
  798         if (sc == NULL || pp == NULL)
  799                 return (EBUSY);
  800         if (pp->acr != 0 || pp->acw != 0 || pp->ace != 0) {
  801                 gctl_error(req, "%s is open(r%dw%de%d)", gp->name,
  802                     pp->acr, pp->acw, pp->ace);
  803                 return (EBUSY);
  804         }
  805         g_ccd_freesc(sc);
  806         gp->softc = NULL;
  807         g_wither_geom(gp, ENXIO);
  808         return (0);
  809 }
  810 
  811 static void
  812 g_ccd_list(struct gctl_req *req, struct g_class *mp)
  813 {
  814         struct sbuf *sb;
  815         struct ccd_s *cs;
  816         struct g_geom *gp;
  817         int i, unit, *up;
  818 
  819         up = gctl_get_paraml(req, "unit", sizeof (int));
  820         unit = *up;
  821         sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
  822         LIST_FOREACH(gp, &mp->geom, geom) {
  823                 cs = gp->softc;
  824                 if (cs == NULL || (unit >= 0 && unit != cs->sc_unit))
  825                         continue;
  826                 sbuf_printf(sb, "ccd%d\t\t%d\t%d\t",
  827                     cs->sc_unit, cs->sc_ileave, cs->sc_flags & CCDF_USERMASK);
  828                         
  829                 for (i = 0; i < cs->sc_ndisks; ++i) {
  830                         sbuf_printf(sb, "%s/dev/%s", i == 0 ? "" : " ",
  831                             cs->sc_cinfo[i].ci_provider->name);
  832                 }
  833                 sbuf_printf(sb, "\n");
  834         }
  835         sbuf_finish(sb);
  836         gctl_set_param(req, "output", sbuf_data(sb), sbuf_len(sb) + 1);
  837         sbuf_delete(sb);
  838 }
  839 
  840 static void
  841 g_ccd_config(struct gctl_req *req, struct g_class *mp, char const *verb)
  842 {
  843         struct g_geom *gp;
  844 
  845         g_topology_assert();
  846         if (!strcmp(verb, "create geom")) {
  847                 g_ccd_create(req, mp);
  848         } else if (!strcmp(verb, "destroy geom")) {
  849                 gp = gctl_get_geom(req, mp, "geom");
  850                 if (gp != NULL)
  851                 g_ccd_destroy_geom(req, mp, gp);
  852         } else if (!strcmp(verb, "list")) {
  853                 g_ccd_list(req, mp);
  854         } else {
  855                 gctl_error(req, "unknown verb");
  856         }
  857 }
  858 
  859 static struct g_class g_ccd_class = {
  860         .name = "CCD",
  861         .version = G_VERSION,
  862         .ctlreq = g_ccd_config,
  863         .destroy_geom = g_ccd_destroy_geom,
  864         .start = g_ccd_start,
  865         .orphan = g_ccd_orphan,
  866         .access = g_ccd_access,
  867 };
  868 
  869 DECLARE_GEOM_CLASS(g_ccd_class, g_ccd);

Cache object: a4dda5a57c19c06d918f143db4792994


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