sys/geom/stripe/g_stripe.c

   1 /*-
   2  * Copyright (c) 2004-2005 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/kernel.h>
  33 #include <sys/module.h>
  34 #include <sys/lock.h>
  35 #include <sys/mutex.h>
  36 #include <sys/bio.h>
  37 #include <sys/sysctl.h>
  38 #include <sys/malloc.h>
  39 #include <vm/uma.h>
  40 #include <geom/geom.h>
  41 #include <geom/stripe/g_stripe.h>
  42
  43
  44 #define MAX_IO_SIZE     (DFLTPHYS * 2)
  45 static MALLOC_DEFINE(M_STRIPE, "stripe_data", "GEOM_STRIPE Data");
  46
  47 static uma_zone_t g_stripe_zone;
  48
  49 static int g_stripe_destroy(struct g_stripe_softc *sc, boolean_t force);
  50 static int g_stripe_destroy_geom(struct gctl_req *req, struct g_class *mp,
  51     struct g_geom *gp);
  52
  53 static g_taste_t g_stripe_taste;
  54 static g_ctl_req_t g_stripe_config;
  55 static g_dumpconf_t g_stripe_dumpconf;
  56 static g_init_t g_stripe_init;
  57 static g_fini_t g_stripe_fini;
  58
  59 struct g_class g_stripe_class = {
  60         .name = G_STRIPE_CLASS_NAME,
  61         .version = G_VERSION,
  62         .ctlreq = g_stripe_config,
  63         .taste = g_stripe_taste,
  64         .destroy_geom = g_stripe_destroy_geom,
  65         .init = g_stripe_init,
  66         .fini = g_stripe_fini
  67 };
  68
  69 SYSCTL_DECL(_kern_geom);
  70 SYSCTL_NODE(_kern_geom, OID_AUTO, stripe, CTLFLAG_RW, 0, "GEOM_STRIPE stuff");
  71 static u_int g_stripe_debug = 0;
  72 TUNABLE_INT("kern.geom.stripe.debug", &g_stripe_debug);
  73 SYSCTL_UINT(_kern_geom_stripe, OID_AUTO, debug, CTLFLAG_RW, &g_stripe_debug, 0,
  74     "Debug level");
  75 static int g_stripe_fast = 0;
  76 TUNABLE_INT("kern.geom.stripe.fast", &g_stripe_fast);
  77 static int
  78 g_sysctl_stripe_fast(SYSCTL_HANDLER_ARGS)
  79 {
  80         int error, fast;
  81
  82         fast = g_stripe_fast;
  83         error = sysctl_handle_int(oidp, &fast, 0, req);
  84         if (error == 0 && req->newptr != NULL)
  85                 g_stripe_fast = fast;
  86         return (error);
  87 }
  88 SYSCTL_PROC(_kern_geom_stripe, OID_AUTO, fast, CTLTYPE_INT | CTLFLAG_RW,
  89     NULL, 0, g_sysctl_stripe_fast, "I", "Fast, but memory-consuming, mode");
  90 static u_int g_stripe_maxmem = MAX_IO_SIZE * 100;
  91 TUNABLE_INT("kern.geom.stripe.maxmem", &g_stripe_maxmem);
  92 SYSCTL_UINT(_kern_geom_stripe, OID_AUTO, maxmem, CTLFLAG_RD, &g_stripe_maxmem,
  93     0, "Maximum memory that can be allocated in \"fast\" mode (in bytes)");
  94 static u_int g_stripe_fast_failed = 0;
  95 SYSCTL_UINT(_kern_geom_stripe, OID_AUTO, fast_failed, CTLFLAG_RD,
  96     &g_stripe_fast_failed, 0, "How many times \"fast\" mode failed");
  97
  98 /*
  99  * Greatest Common Divisor.
 100  */
 101 static u_int
 102 gcd(u_int a, u_int b)
 103 {
 104         u_int c;
 105
 106         while (b != 0) {
 107                 c = a;
 108                 a = b;
 109                 b = (c % b);
 110         }
 111         return (a);
 112 }
 113
 114 /*
 115  * Least Common Multiple.
 116  */
 117 static u_int
 118 lcm(u_int a, u_int b)
 119 {
 120
 121         return ((a * b) / gcd(a, b));
 122 }
 123
 124 static void
 125 g_stripe_init(struct g_class *mp __unused)
 126 {
 127
 128         g_stripe_zone = uma_zcreate("g_stripe_zone", MAX_IO_SIZE, NULL, NULL,
 129             NULL, NULL, 0, 0);
 130         g_stripe_maxmem -= g_stripe_maxmem % MAX_IO_SIZE;
 131         uma_zone_set_max(g_stripe_zone, g_stripe_maxmem / MAX_IO_SIZE);
 132 }
 133
 134 static void
 135 g_stripe_fini(struct g_class *mp __unused)
 136 {
 137
 138         uma_zdestroy(g_stripe_zone);
 139 }
 140
 141 /*
 142  * Return the number of valid disks.
 143  */
 144 static u_int
 145 g_stripe_nvalid(struct g_stripe_softc *sc)
 146 {
 147         u_int i, no;
 148
 149         no = 0;
 150         for (i = 0; i < sc->sc_ndisks; i++) {
 151                 if (sc->sc_disks[i] != NULL)
 152                         no++;
 153         }
 154
 155         return (no);
 156 }
 157
 158 static void
 159 g_stripe_remove_disk(struct g_consumer *cp)
 160 {
 161         struct g_stripe_softc *sc;
 162         u_int no;
 163
 164         KASSERT(cp != NULL, ("Non-valid disk in %s.", __func__));
 165         sc = (struct g_stripe_softc *)cp->private;
 166         KASSERT(sc != NULL, ("NULL sc in %s.", __func__));
 167         no = cp->index;
 168
 169         G_STRIPE_DEBUG(0, "Disk %s removed from %s.", cp->provider->name,
 170             sc->sc_name);
 171
 172         sc->sc_disks[no] = NULL;
 173         if (sc->sc_provider != NULL) {
 174                 sc->sc_provider->flags |= G_PF_WITHER;
 175                 g_orphan_provider(sc->sc_provider, ENXIO);
 176                 sc->sc_provider = NULL;
 177                 G_STRIPE_DEBUG(0, "Device %s removed.", sc->sc_name);
 178         }
 179
 180         if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
 181                 g_access(cp, -cp->acr, -cp->acw, -cp->ace);
 182         g_detach(cp);
 183         g_destroy_consumer(cp);
 184 }
 185
 186 static void
 187 g_stripe_orphan(struct g_consumer *cp)
 188 {
 189         struct g_stripe_softc *sc;
 190         struct g_geom *gp;
 191
 192         g_topology_assert();
 193         gp = cp->geom;
 194         sc = gp->softc;
 195         if (sc == NULL)
 196                 return;
 197
 198         g_stripe_remove_disk(cp);
 199         /* If there are no valid disks anymore, remove device. */
 200         if (g_stripe_nvalid(sc) == 0)
 201                 g_stripe_destroy(sc, 1);
 202 }
 203
 204 static int
 205 g_stripe_access(struct g_provider *pp, int dr, int dw, int de)
 206 {
 207         struct g_consumer *cp1, *cp2;
 208         struct g_stripe_softc *sc;
 209         struct g_geom *gp;
 210         int error;
 211
 212         gp = pp->geom;
 213         sc = gp->softc;
 214
 215         if (sc == NULL) {
 216                 /*
 217                  * It looks like geom is being withered.
 218                  * In that case we allow only negative requests.
 219                  */
 220                 KASSERT(dr <= 0 && dw <= 0 && de <= 0,
 221                     ("Positive access request (device=%s).", pp->name));
 222                 if ((pp->acr + dr) == 0 && (pp->acw + dw) == 0 &&
 223                     (pp->ace + de) == 0) {
 224                         G_STRIPE_DEBUG(0, "Device %s definitely destroyed.",
 225                             gp->name);
 226                 }
 227                 return (0);
 228         }
 229
 230         /* On first open, grab an extra "exclusive" bit */
 231         if (pp->acr == 0 && pp->acw == 0 && pp->ace == 0)
 232                 de++;
 233         /* ... and let go of it on last close */
 234         if ((pp->acr + dr) == 0 && (pp->acw + dw) == 0 && (pp->ace + de) == 0)
 235                 de--;
 236
 237         error = ENXIO;
 238         LIST_FOREACH(cp1, &gp->consumer, consumer) {
 239                 error = g_access(cp1, dr, dw, de);
 240                 if (error == 0)
 241                         continue;
 242                 /*
 243                  * If we fail here, backout all previous changes.
 244                  */
 245                 LIST_FOREACH(cp2, &gp->consumer, consumer) {
 246                         if (cp1 == cp2)
 247                                 return (error);
 248                         g_access(cp2, -dr, -dw, -de);
 249                 }
 250                 /* NOTREACHED */
 251         }
 252
 253         return (error);
 254 }
 255
 256 static void
 257 g_stripe_copy(struct g_stripe_softc *sc, char *src, char *dst, off_t offset,
 258     off_t length, int mode)
 259 {
 260         u_int stripesize;
 261         size_t len;
 262
 263         stripesize = sc->sc_stripesize;
 264         len = (size_t)(stripesize - (offset & (stripesize - 1)));
 265         do {
 266                 bcopy(src, dst, len);
 267                 if (mode) {
 268                         dst += len + stripesize * (sc->sc_ndisks - 1);
 269                         src += len;
 270                 } else {
 271                         dst += len;
 272                         src += len + stripesize * (sc->sc_ndisks - 1);
 273                 }
 274                 length -= len;
 275                 KASSERT(length >= 0,
 276                     ("Length < 0 (stripesize=%zu, offset=%jd, length=%jd).",
 277                     (size_t)stripesize, (intmax_t)offset, (intmax_t)length));
 278                 if (length > stripesize)
 279                         len = stripesize;
 280                 else
 281                         len = length;
 282         } while (length > 0);
 283 }
 284
 285 static void
 286 g_stripe_done(struct bio *bp)
 287 {
 288         struct g_stripe_softc *sc;
 289         struct bio *pbp;
 290
 291         pbp = bp->bio_parent;
 292         sc = pbp->bio_to->geom->softc;
 293         if (pbp->bio_error == 0)
 294                 pbp->bio_error = bp->bio_error;
 295         pbp->bio_completed += bp->bio_completed;
 296         if (bp->bio_cmd == BIO_READ && bp->bio_caller1 != NULL) {
 297                 g_stripe_copy(sc, bp->bio_data, bp->bio_caller1, bp->bio_offset,
 298                     bp->bio_length, 1);
 299                 bp->bio_data = bp->bio_caller1;
 300                 bp->bio_caller1 = NULL;
 301         }
 302         g_destroy_bio(bp);
 303         pbp->bio_inbed++;
 304         if (pbp->bio_children == pbp->bio_inbed) {
 305                 if (pbp->bio_driver1 != NULL)
 306                         uma_zfree(g_stripe_zone, pbp->bio_driver1);
 307                 g_io_deliver(pbp, pbp->bio_error);
 308         }
 309 }
 310
 311 static int
 312 g_stripe_start_fast(struct bio *bp, u_int no, off_t offset, off_t length)
 313 {
 314         TAILQ_HEAD(, bio) queue = TAILQ_HEAD_INITIALIZER(queue);
 315         u_int nparts = 0, stripesize;
 316         struct g_stripe_softc *sc;
 317         char *addr, *data = NULL;
 318         struct bio *cbp;
 319         int error;
 320
 321         sc = bp->bio_to->geom->softc;
 322
 323         addr = bp->bio_data;
 324         stripesize = sc->sc_stripesize;
 325
 326         cbp = g_clone_bio(bp);
 327         if (cbp == NULL) {
 328                 error = ENOMEM;
 329                 goto failure;
 330         }
 331         TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 332         nparts++;
 333         /*
 334          * Fill in the component buf structure.
 335          */
 336         cbp->bio_done = g_stripe_done;
 337         cbp->bio_offset = offset;
 338         cbp->bio_data = addr;
 339         cbp->bio_caller1 = NULL;
 340         cbp->bio_length = length;
 341         cbp->bio_caller2 = sc->sc_disks[no];
 342
 343         /* offset -= offset % stripesize; */
 344         offset -= offset & (stripesize - 1);
 345         addr += length;
 346         length = bp->bio_length - length;
 347         for (no++; length > 0; no++, length -= stripesize, addr += stripesize) {
 348                 if (no > sc->sc_ndisks - 1) {
 349                         no = 0;
 350                         offset += stripesize;
 351                 }
 352                 if (nparts >= sc->sc_ndisks) {
 353                         cbp = TAILQ_NEXT(cbp, bio_queue);
 354                         if (cbp == NULL)
 355                                 cbp = TAILQ_FIRST(&queue);
 356                         nparts++;
 357                         /*
 358                          * Update bio structure.
 359                          */
 360                         /*
 361                          * MIN() is in case when
 362                          * (bp->bio_length % sc->sc_stripesize) != 0.
 363                          */
 364                         cbp->bio_length += MIN(stripesize, length);
 365                         if (cbp->bio_caller1 == NULL) {
 366                                 cbp->bio_caller1 = cbp->bio_data;
 367                                 cbp->bio_data = NULL;
 368                                 if (data == NULL) {
 369                                         data = uma_zalloc(g_stripe_zone,
 370                                             M_NOWAIT);
 371                                         if (data == NULL) {
 372                                                 error = ENOMEM;
 373                                                 goto failure;
 374                                         }
 375                                 }
 376                         }
 377                 } else {
 378                         cbp = g_clone_bio(bp);
 379                         if (cbp == NULL) {
 380                                 error = ENOMEM;
 381                                 goto failure;
 382                         }
 383                         TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 384                         nparts++;
 385                         /*
 386                          * Fill in the component buf structure.
 387                          */
 388                         cbp->bio_done = g_stripe_done;
 389                         cbp->bio_offset = offset;
 390                         cbp->bio_data = addr;
 391                         cbp->bio_caller1 = NULL;
 392                         /*
 393                          * MIN() is in case when
 394                          * (bp->bio_length % sc->sc_stripesize) != 0.
 395                          */
 396                         cbp->bio_length = MIN(stripesize, length);
 397                         cbp->bio_caller2 = sc->sc_disks[no];
 398                 }
 399         }
 400         if (data != NULL)
 401                 bp->bio_driver1 = data;
 402         /*
 403          * Fire off all allocated requests!
 404          */
 405         while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
 406                 struct g_consumer *cp;
 407
 408                 TAILQ_REMOVE(&queue, cbp, bio_queue);
 409                 cp = cbp->bio_caller2;
 410                 cbp->bio_caller2 = NULL;
 411                 cbp->bio_to = cp->provider;
 412                 if (cbp->bio_caller1 != NULL) {
 413                         cbp->bio_data = data;
 414                         if (bp->bio_cmd == BIO_WRITE) {
 415                                 g_stripe_copy(sc, cbp->bio_caller1, data,
 416                                     cbp->bio_offset, cbp->bio_length, 0);
 417                         }
 418                         data += cbp->bio_length;
 419                 }
 420                 G_STRIPE_LOGREQ(cbp, "Sending request.");
 421                 g_io_request(cbp, cp);
 422         }
 423         return (0);
 424 failure:
 425         if (data != NULL)
 426                 uma_zfree(g_stripe_zone, data);
 427         while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
 428                 TAILQ_REMOVE(&queue, cbp, bio_queue);
 429                 if (cbp->bio_caller1 != NULL) {
 430                         cbp->bio_data = cbp->bio_caller1;
 431                         cbp->bio_caller1 = NULL;
 432                 }
 433                 bp->bio_children--;
 434                 g_destroy_bio(cbp);
 435         }
 436         return (error);
 437 }
 438
 439 static int
 440 g_stripe_start_economic(struct bio *bp, u_int no, off_t offset, off_t length)
 441 {
 442         TAILQ_HEAD(, bio) queue = TAILQ_HEAD_INITIALIZER(queue);
 443         struct g_stripe_softc *sc;
 444         uint32_t stripesize;
 445         struct bio *cbp;
 446         char *addr;
 447         int error;
 448
 449         sc = bp->bio_to->geom->softc;
 450
 451         addr = bp->bio_data;
 452         stripesize = sc->sc_stripesize;
 453
 454         cbp = g_clone_bio(bp);
 455         if (cbp == NULL) {
 456                 error = ENOMEM;
 457                 goto failure;
 458         }
 459         TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 460         /*
 461          * Fill in the component buf structure.
 462          */
 463         cbp->bio_done = g_std_done;
 464         cbp->bio_offset = offset;
 465         cbp->bio_data = addr;
 466         cbp->bio_length = length;
 467         cbp->bio_caller2 = sc->sc_disks[no];
 468
 469         /* offset -= offset % stripesize; */
 470         offset -= offset & (stripesize - 1);
 471         addr += length;
 472         length = bp->bio_length - length;
 473         for (no++; length > 0; no++, length -= stripesize, addr += stripesize) {
 474                 if (no > sc->sc_ndisks - 1) {
 475                         no = 0;
 476                         offset += stripesize;
 477                 }
 478                 cbp = g_clone_bio(bp);
 479                 if (cbp == NULL) {
 480                         error = ENOMEM;
 481                         goto failure;
 482                 }
 483                 TAILQ_INSERT_TAIL(&queue, cbp, bio_queue);
 484
 485                 /*
 486                  * Fill in the component buf structure.
 487                  */
 488                 cbp->bio_done = g_std_done;
 489                 cbp->bio_offset = offset;
 490                 cbp->bio_data = addr;
 491                 /*
 492                  * MIN() is in case when
 493                  * (bp->bio_length % sc->sc_stripesize) != 0.
 494                  */
 495                 cbp->bio_length = MIN(stripesize, length);
 496
 497                 cbp->bio_caller2 = sc->sc_disks[no];
 498         }
 499         /*
 500          * Fire off all allocated requests!
 501          */
 502         while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
 503                 struct g_consumer *cp;
 504
 505                 TAILQ_REMOVE(&queue, cbp, bio_queue);
 506                 cp = cbp->bio_caller2;
 507                 cbp->bio_caller2 = NULL;
 508                 cbp->bio_to = cp->provider;
 509                 G_STRIPE_LOGREQ(cbp, "Sending request.");
 510                 g_io_request(cbp, cp);
 511         }
 512         return (0);
 513 failure:
 514         while ((cbp = TAILQ_FIRST(&queue)) != NULL) {
 515                 TAILQ_REMOVE(&queue, cbp, bio_queue);
 516                 bp->bio_children--;
 517                 g_destroy_bio(cbp);
 518         }
 519         return (error);
 520 }
 521
 522 static void
 523 g_stripe_flush(struct g_stripe_softc *sc, struct bio *bp)
 524 {
 525         struct bio_queue_head queue;
 526         struct g_consumer *cp;
 527         struct bio *cbp;
 528         u_int no;
 529
 530         bioq_init(&queue);
 531         for (no = 0; no < sc->sc_ndisks; no++) {
 532                 cbp = g_clone_bio(bp);
 533                 if (cbp == NULL) {
 534                         for (cbp = bioq_first(&queue); cbp != NULL;
 535                             cbp = bioq_first(&queue)) {
 536                                 bioq_remove(&queue, cbp);
 537                                 g_destroy_bio(cbp);
 538                         }
 539                         if (bp->bio_error == 0)
 540                                 bp->bio_error = ENOMEM;
 541                         g_io_deliver(bp, bp->bio_error);
 542                         return;
 543                 }
 544                 bioq_insert_tail(&queue, cbp);
 545                 cbp->bio_done = g_std_done;
 546                 cbp->bio_caller1 = sc->sc_disks[no];
 547                 cbp->bio_to = sc->sc_disks[no]->provider;
 548         }
 549         for (cbp = bioq_first(&queue); cbp != NULL; cbp = bioq_first(&queue)) {
 550                 bioq_remove(&queue, cbp);
 551                 G_STRIPE_LOGREQ(cbp, "Sending request.");
 552                 cp = cbp->bio_caller1;
 553                 cbp->bio_caller1 = NULL;
 554                 g_io_request(cbp, cp);
 555         }
 556 }
 557
 558 static void
 559 g_stripe_start(struct bio *bp)
 560 {
 561         off_t offset, start, length, nstripe;
 562         struct g_stripe_softc *sc;
 563         u_int no, stripesize;
 564         int error, fast = 0;
 565
 566         sc = bp->bio_to->geom->softc;
 567         /*
 568          * If sc == NULL, provider's error should be set and g_stripe_start()
 569          * should not be called at all.
 570          */
 571         KASSERT(sc != NULL,
 572             ("Provider's error should be set (error=%d)(device=%s).",
 573             bp->bio_to->error, bp->bio_to->name));
 574
 575         G_STRIPE_LOGREQ(bp, "Request received.");
 576
 577         switch (bp->bio_cmd) {
 578         case BIO_READ:
 579         case BIO_WRITE:
 580         case BIO_DELETE:
 581                 break;
 582         case BIO_FLUSH:
 583                 g_stripe_flush(sc, bp);
 584                 return;
 585         case BIO_GETATTR:
 586                 /* To which provider it should be delivered? */
 587         default:
 588                 g_io_deliver(bp, EOPNOTSUPP);
 589                 return;
 590         }
 591
 592         stripesize = sc->sc_stripesize;
 593
 594         /*
 595          * Calculations are quite messy, but fast I hope.
 596          */
 597
 598         /* Stripe number. */
 599         /* nstripe = bp->bio_offset / stripesize; */
 600         nstripe = bp->bio_offset >> (off_t)sc->sc_stripebits;
 601         /* Disk number. */
 602         no = nstripe % sc->sc_ndisks;
 603         /* Start position in stripe. */
 604         /* start = bp->bio_offset % stripesize; */
 605         start = bp->bio_offset & (stripesize - 1);
 606         /* Start position in disk. */
 607         /* offset = (nstripe / sc->sc_ndisks) * stripesize + start; */
 608         offset = ((nstripe / sc->sc_ndisks) << sc->sc_stripebits) + start;
 609         /* Length of data to operate. */
 610         length = MIN(bp->bio_length, stripesize - start);
 611
 612         /*
 613          * Do use "fast" mode when:
 614          * 1. "Fast" mode is ON.
 615          * and
 616          * 2. Request size is less than or equal to MAX_IO_SIZE (128kB),
 617          *    which should always be true.
 618          * and
 619          * 3. Request size is bigger than stripesize * ndisks. If it isn't,
 620          *    there will be no need to send more than one I/O request to
 621          *    a provider, so there is nothing to optmize.
 622          */
 623         if (g_stripe_fast && bp->bio_length <= MAX_IO_SIZE &&
 624             bp->bio_length >= stripesize * sc->sc_ndisks) {
 625                 fast = 1;
 626         }
 627         error = 0;
 628         if (fast) {
 629                 error = g_stripe_start_fast(bp, no, offset, length);
 630                 if (error != 0)
 631                         g_stripe_fast_failed++;
 632         }
 633         /*
 634          * Do use "economic" when:
 635          * 1. "Economic" mode is ON.
 636          * or
 637          * 2. "Fast" mode failed. It can only failed if there is no memory.
 638          */
 639         if (!fast || error != 0)
 640                 error = g_stripe_start_economic(bp, no, offset, length);
 641         if (error != 0) {
 642                 if (bp->bio_error == 0)
 643                         bp->bio_error = error;
 644                 g_io_deliver(bp, bp->bio_error);
 645         }
 646 }
 647
 648 static void
 649 g_stripe_check_and_run(struct g_stripe_softc *sc)
 650 {
 651         off_t mediasize, ms;
 652         u_int no, sectorsize = 0;
 653
 654         if (g_stripe_nvalid(sc) != sc->sc_ndisks)
 655                 return;
 656
 657         sc->sc_provider = g_new_providerf(sc->sc_geom, "stripe/%s",
 658             sc->sc_name);
 659         /*
 660          * Find the smallest disk.
 661          */
 662         mediasize = sc->sc_disks[0]->provider->mediasize;
 663         if (sc->sc_type == G_STRIPE_TYPE_AUTOMATIC)
 664                 mediasize -= sc->sc_disks[0]->provider->sectorsize;
 665         mediasize -= mediasize % sc->sc_stripesize;
 666         sectorsize = sc->sc_disks[0]->provider->sectorsize;
 667         for (no = 1; no < sc->sc_ndisks; no++) {
 668                 ms = sc->sc_disks[no]->provider->mediasize;
 669                 if (sc->sc_type == G_STRIPE_TYPE_AUTOMATIC)
 670                         ms -= sc->sc_disks[no]->provider->sectorsize;
 671                 ms -= ms % sc->sc_stripesize;
 672                 if (ms < mediasize)
 673                         mediasize = ms;
 674                 sectorsize = lcm(sectorsize,
 675                     sc->sc_disks[no]->provider->sectorsize);
 676         }
 677         sc->sc_provider->sectorsize = sectorsize;
 678         sc->sc_provider->mediasize = mediasize * sc->sc_ndisks;
 679         g_error_provider(sc->sc_provider, 0);
 680
 681         G_STRIPE_DEBUG(0, "Device %s activated.", sc->sc_name);
 682 }
 683
 684 static int
 685 g_stripe_read_metadata(struct g_consumer *cp, struct g_stripe_metadata *md)
 686 {
 687         struct g_provider *pp;
 688         u_char *buf;
 689         int error;
 690
 691         g_topology_assert();
 692
 693         error = g_access(cp, 1, 0, 0);
 694         if (error != 0)
 695                 return (error);
 696         pp = cp->provider;
 697         g_topology_unlock();
 698         buf = g_read_data(cp, pp->mediasize - pp->sectorsize, pp->sectorsize,
 699             &error);
 700         g_topology_lock();
 701         g_access(cp, -1, 0, 0);
 702         if (buf == NULL)
 703                 return (error);
 704
 705         /* Decode metadata. */
 706         stripe_metadata_decode(buf, md);
 707         g_free(buf);
 708
 709         return (0);
 710 }
 711
 712 /*
 713  * Add disk to given device.
 714  */
 715 static int
 716 g_stripe_add_disk(struct g_stripe_softc *sc, struct g_provider *pp, u_int no)
 717 {
 718         struct g_consumer *cp, *fcp;
 719         struct g_geom *gp;
 720         int error;
 721
 722         /* Metadata corrupted? */
 723         if (no >= sc->sc_ndisks)
 724                 return (EINVAL);
 725
 726         /* Check if disk is not already attached. */
 727         if (sc->sc_disks[no] != NULL)
 728                 return (EEXIST);
 729
 730         gp = sc->sc_geom;
 731         fcp = LIST_FIRST(&gp->consumer);
 732
 733         cp = g_new_consumer(gp);
 734         error = g_attach(cp, pp);
 735         if (error != 0) {
 736                 g_destroy_consumer(cp);
 737                 return (error);
 738         }
 739
 740         if (fcp != NULL && (fcp->acr > 0 || fcp->acw > 0 || fcp->ace > 0)) {
 741                 error = g_access(cp, fcp->acr, fcp->acw, fcp->ace);
 742                 if (error != 0) {
 743                         g_detach(cp);
 744                         g_destroy_consumer(cp);
 745                         return (error);
 746                 }
 747         }
 748         if (sc->sc_type == G_STRIPE_TYPE_AUTOMATIC) {
 749                 struct g_stripe_metadata md;
 750
 751                 /* Reread metadata. */
 752                 error = g_stripe_read_metadata(cp, &md);
 753                 if (error != 0)
 754                         goto fail;
 755
 756                 if (strcmp(md.md_magic, G_STRIPE_MAGIC) != 0 ||
 757                     strcmp(md.md_name, sc->sc_name) != 0 ||
 758                     md.md_id != sc->sc_id) {
 759                         G_STRIPE_DEBUG(0, "Metadata on %s changed.", pp->name);
 760                         goto fail;
 761                 }
 762         }
 763
 764         cp->private = sc;
 765         cp->index = no;
 766         sc->sc_disks[no] = cp;
 767
 768         G_STRIPE_DEBUG(0, "Disk %s attached to %s.", pp->name, sc->sc_name);
 769
 770         g_stripe_check_and_run(sc);
 771
 772         return (0);
 773 fail:
 774         if (fcp != NULL && (fcp->acr > 0 || fcp->acw > 0 || fcp->ace > 0))
 775                 g_access(cp, -fcp->acr, -fcp->acw, -fcp->ace);
 776         g_detach(cp);
 777         g_destroy_consumer(cp);
 778         return (error);
 779 }
 780
 781 static struct g_geom *
 782 g_stripe_create(struct g_class *mp, const struct g_stripe_metadata *md,
 783     u_int type)
 784 {
 785         struct g_stripe_softc *sc;
 786         struct g_geom *gp;
 787         u_int no;
 788
 789         G_STRIPE_DEBUG(1, "Creating device %s (id=%u).", md->md_name,
 790             md->md_id);
 791
 792         /* Two disks is minimum. */
 793         if (md->md_all < 2) {
 794                 G_STRIPE_DEBUG(0, "Too few disks defined for %s.", md->md_name);
 795                 return (NULL);
 796         }
 797 #if 0
 798         /* Stripe size have to be grater than or equal to sector size. */
 799         if (md->md_stripesize < sectorsize) {
 800                 G_STRIPE_DEBUG(0, "Invalid stripe size for %s.", md->md_name);
 801                 return (NULL);
 802         }
 803 #endif
 804         /* Stripe size have to be power of 2. */
 805         if (!powerof2(md->md_stripesize)) {
 806                 G_STRIPE_DEBUG(0, "Invalid stripe size for %s.", md->md_name);
 807                 return (NULL);
 808         }
 809
 810         /* Check for duplicate unit */
 811         LIST_FOREACH(gp, &mp->geom, geom) {
 812                 sc = gp->softc;
 813                 if (sc != NULL && strcmp(sc->sc_name, md->md_name) == 0) {
 814                         G_STRIPE_DEBUG(0, "Device %s already configured.",
 815                             sc->sc_name);
 816                         return (NULL);
 817                 }
 818         }
 819         gp = g_new_geomf(mp, "%s", md->md_name);
 820         gp->softc = NULL;       /* for a moment */
 821
 822         sc = malloc(sizeof(*sc), M_STRIPE, M_WAITOK | M_ZERO);
 823         gp->start = g_stripe_start;
 824         gp->spoiled = g_stripe_orphan;
 825         gp->orphan = g_stripe_orphan;
 826         gp->access = g_stripe_access;
 827         gp->dumpconf = g_stripe_dumpconf;
 828
 829         sc->sc_id = md->md_id;
 830         sc->sc_stripesize = md->md_stripesize;
 831         sc->sc_stripebits = bitcount32(sc->sc_stripesize - 1);
 832         sc->sc_ndisks = md->md_all;
 833         sc->sc_disks = malloc(sizeof(struct g_consumer *) * sc->sc_ndisks,
 834             M_STRIPE, M_WAITOK | M_ZERO);
 835         for (no = 0; no < sc->sc_ndisks; no++)
 836                 sc->sc_disks[no] = NULL;
 837         sc->sc_type = type;
 838
 839         gp->softc = sc;
 840         sc->sc_geom = gp;
 841         sc->sc_provider = NULL;
 842
 843         G_STRIPE_DEBUG(0, "Device %s created (id=%u).", sc->sc_name, sc->sc_id);
 844
 845         return (gp);
 846 }
 847
 848 static int
 849 g_stripe_destroy(struct g_stripe_softc *sc, boolean_t force)
 850 {
 851         struct g_provider *pp;
 852         struct g_geom *gp;
 853         u_int no;
 854
 855         g_topology_assert();
 856
 857         if (sc == NULL)
 858                 return (ENXIO);
 859
 860         pp = sc->sc_provider;
 861         if (pp != NULL && (pp->acr != 0 || pp->acw != 0 || pp->ace != 0)) {
 862                 if (force) {
 863                         G_STRIPE_DEBUG(0, "Device %s is still open, so it "
 864                             "can't be definitely removed.", pp->name);
 865                 } else {
 866                         G_STRIPE_DEBUG(1,
 867                             "Device %s is still open (r%dw%de%d).", pp->name,
 868                             pp->acr, pp->acw, pp->ace);
 869                         return (EBUSY);
 870                 }
 871         }
 872
 873         for (no = 0; no < sc->sc_ndisks; no++) {
 874                 if (sc->sc_disks[no] != NULL)
 875                         g_stripe_remove_disk(sc->sc_disks[no]);
 876         }
 877
 878         gp = sc->sc_geom;
 879         gp->softc = NULL;
 880         KASSERT(sc->sc_provider == NULL, ("Provider still exists? (device=%s)",
 881             gp->name));
 882         free(sc->sc_disks, M_STRIPE);
 883         free(sc, M_STRIPE);
 884
 885         pp = LIST_FIRST(&gp->provider);
 886         if (pp == NULL || (pp->acr == 0 && pp->acw == 0 && pp->ace == 0))
 887                 G_STRIPE_DEBUG(0, "Device %s destroyed.", gp->name);
 888
 889         g_wither_geom(gp, ENXIO);
 890
 891         return (0);
 892 }
 893
 894 static int
 895 g_stripe_destroy_geom(struct gctl_req *req __unused,
 896     struct g_class *mp __unused, struct g_geom *gp)
 897 {
 898         struct g_stripe_softc *sc;
 899
 900         sc = gp->softc;
 901         return (g_stripe_destroy(sc, 0));
 902 }
 903
 904 static struct g_geom *
 905 g_stripe_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
 906 {
 907         struct g_stripe_metadata md;
 908         struct g_stripe_softc *sc;
 909         struct g_consumer *cp;
 910         struct g_geom *gp;
 911         int error;
 912
 913         g_trace(G_T_TOPOLOGY, "%s(%s, %s)", __func__, mp->name, pp->name);
 914         g_topology_assert();
 915
 916         G_STRIPE_DEBUG(3, "Tasting %s.", pp->name);
 917
 918         gp = g_new_geomf(mp, "stripe:taste");
 919         gp->start = g_stripe_start;
 920         gp->access = g_stripe_access;
 921         gp->orphan = g_stripe_orphan;
 922         cp = g_new_consumer(gp);
 923         g_attach(cp, pp);
 924         error = g_stripe_read_metadata(cp, &md);
 925         g_detach(cp);
 926         g_destroy_consumer(cp);
 927         g_destroy_geom(gp);
 928         if (error != 0)
 929                 return (NULL);
 930         gp = NULL;
 931
 932         if (strcmp(md.md_magic, G_STRIPE_MAGIC) != 0)
 933                 return (NULL);
 934         if (md.md_version > G_STRIPE_VERSION) {
 935                 printf("geom_stripe.ko module is too old to handle %s.\n",
 936                     pp->name);
 937                 return (NULL);
 938         }
 939         /*
 940          * Backward compatibility:
 941          */
 942         /* There was no md_provider field in earlier versions of metadata. */
 943         if (md.md_version < 2)
 944                 bzero(md.md_provider, sizeof(md.md_provider));
 945         /* There was no md_provsize field in earlier versions of metadata. */
 946         if (md.md_version < 3)
 947                 md.md_provsize = pp->mediasize;
 948
 949         if (md.md_provider[0] != '\0' && strcmp(md.md_provider, pp->name) != 0)
 950                 return (NULL);
 951         if (md.md_provsize != pp->mediasize)
 952                 return (NULL);
 953
 954         /*
 955          * Let's check if device already exists.
 956          */
 957         sc = NULL;
 958         LIST_FOREACH(gp, &mp->geom, geom) {
 959                 sc = gp->softc;
 960                 if (sc == NULL)
 961                         continue;
 962                 if (sc->sc_type != G_STRIPE_TYPE_AUTOMATIC)
 963                         continue;
 964                 if (strcmp(md.md_name, sc->sc_name) != 0)
 965                         continue;
 966                 if (md.md_id != sc->sc_id)
 967                         continue;
 968                 break;
 969         }
 970         if (gp != NULL) {
 971                 G_STRIPE_DEBUG(1, "Adding disk %s to %s.", pp->name, gp->name);
 972                 error = g_stripe_add_disk(sc, pp, md.md_no);
 973                 if (error != 0) {
 974                         G_STRIPE_DEBUG(0,
 975                             "Cannot add disk %s to %s (error=%d).", pp->name,
 976                             gp->name, error);
 977                         return (NULL);
 978                 }
 979         } else {
 980                 gp = g_stripe_create(mp, &md, G_STRIPE_TYPE_AUTOMATIC);
 981                 if (gp == NULL) {
 982                         G_STRIPE_DEBUG(0, "Cannot create device %s.",
 983                             md.md_name);
 984                         return (NULL);
 985                 }
 986                 sc = gp->softc;
 987                 G_STRIPE_DEBUG(1, "Adding disk %s to %s.", pp->name, gp->name);
 988                 error = g_stripe_add_disk(sc, pp, md.md_no);
 989                 if (error != 0) {
 990                         G_STRIPE_DEBUG(0,
 991                             "Cannot add disk %s to %s (error=%d).", pp->name,
 992                             gp->name, error);
 993                         g_stripe_destroy(sc, 1);
 994                         return (NULL);
 995                 }
 996         }
 997
 998         return (gp);
 999 }
1000
1001 static void
1002 g_stripe_ctl_create(struct gctl_req *req, struct g_class *mp)
1003 {
1004         u_int attached, no;
1005         struct g_stripe_metadata md;
1006         struct g_provider *pp;
1007         struct g_stripe_softc *sc;
1008         struct g_geom *gp;
1009         struct sbuf *sb;
1010         intmax_t *stripesize;
1011         const char *name;
1012         char param[16];
1013         int *nargs;
1014
1015         g_topology_assert();
1016         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
1017         if (nargs == NULL) {
1018                 gctl_error(req, "No '%s' argument.", "nargs");
1019                 return;
1020         }
1021         if (*nargs <= 2) {
1022                 gctl_error(req, "Too few arguments.");
1023                 return;
1024         }
1025
1026         strlcpy(md.md_magic, G_STRIPE_MAGIC, sizeof(md.md_magic));
1027         md.md_version = G_STRIPE_VERSION;
1028         name = gctl_get_asciiparam(req, "arg0");
1029         if (name == NULL) {
1030                 gctl_error(req, "No 'arg%u' argument.", 0);
1031                 return;
1032         }
1033         strlcpy(md.md_name, name, sizeof(md.md_name));
1034         md.md_id = arc4random();
1035         md.md_no = 0;
1036         md.md_all = *nargs - 1;
1037         stripesize = gctl_get_paraml(req, "stripesize", sizeof(*stripesize));
1038         if (stripesize == NULL) {
1039                 gctl_error(req, "No '%s' argument.", "stripesize");
1040                 return;
1041         }
1042         md.md_stripesize = *stripesize;
1043         bzero(md.md_provider, sizeof(md.md_provider));
1044         /* This field is not important here. */
1045         md.md_provsize = 0;
1046
1047         /* Check all providers are valid */
1048         for (no = 1; no < *nargs; no++) {
1049                 snprintf(param, sizeof(param), "arg%u", no);
1050                 name = gctl_get_asciiparam(req, param);
1051                 if (name == NULL) {
1052                         gctl_error(req, "No 'arg%u' argument.", no);
1053                         return;
1054                 }
1055                 if (strncmp(name, "/dev/", strlen("/dev/")) == 0)
1056                         name += strlen("/dev/");
1057                 pp = g_provider_by_name(name);
1058                 if (pp == NULL) {
1059                         G_STRIPE_DEBUG(1, "Disk %s is invalid.", name);
1060                         gctl_error(req, "Disk %s is invalid.", name);
1061                         return;
1062                 }
1063         }
1064
1065         gp = g_stripe_create(mp, &md, G_STRIPE_TYPE_MANUAL);
1066         if (gp == NULL) {
1067                 gctl_error(req, "Can't configure %s.", md.md_name);
1068                 return;
1069         }
1070
1071         sc = gp->softc;
1072         sb = sbuf_new_auto();
1073         sbuf_printf(sb, "Can't attach disk(s) to %s:", gp->name);
1074         for (attached = 0, no = 1; no < *nargs; no++) {
1075                 snprintf(param, sizeof(param), "arg%u", no);
1076                 name = gctl_get_asciiparam(req, param);
1077                 if (name == NULL) {
1078                         gctl_error(req, "No 'arg%u' argument.", no);
1079                         continue;
1080                 }
1081                 if (strncmp(name, "/dev/", strlen("/dev/")) == 0)
1082                         name += strlen("/dev/");
1083                 pp = g_provider_by_name(name);
1084                 KASSERT(pp != NULL, ("Provider %s disappear?!", name));
1085                 if (g_stripe_add_disk(sc, pp, no - 1) != 0) {
1086                         G_STRIPE_DEBUG(1, "Disk %u (%s) not attached to %s.",
1087                             no, pp->name, gp->name);
1088                         sbuf_printf(sb, " %s", pp->name);
1089                         continue;
1090                 }
1091                 attached++;
1092         }
1093         sbuf_finish(sb);
1094         if (md.md_all != attached) {
1095                 g_stripe_destroy(gp->softc, 1);
1096                 gctl_error(req, "%s", sbuf_data(sb));
1097         }
1098         sbuf_delete(sb);
1099 }
1100
1101 static struct g_stripe_softc *
1102 g_stripe_find_device(struct g_class *mp, const char *name)
1103 {
1104         struct g_stripe_softc *sc;
1105         struct g_geom *gp;
1106
1107         LIST_FOREACH(gp, &mp->geom, geom) {
1108                 sc = gp->softc;
1109                 if (sc == NULL)
1110                         continue;
1111                 if (strcmp(sc->sc_name, name) == 0)
1112                         return (sc);
1113         }
1114         return (NULL);
1115 }
1116
1117 static void
1118 g_stripe_ctl_destroy(struct gctl_req *req, struct g_class *mp)
1119 {
1120         struct g_stripe_softc *sc;
1121         int *force, *nargs, error;
1122         const char *name;
1123         char param[16];
1124         u_int i;
1125
1126         g_topology_assert();
1127
1128         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
1129         if (nargs == NULL) {
1130                 gctl_error(req, "No '%s' argument.", "nargs");
1131                 return;
1132         }
1133         if (*nargs <= 0) {
1134                 gctl_error(req, "Missing device(s).");
1135                 return;
1136         }
1137         force = gctl_get_paraml(req, "force", sizeof(*force));
1138         if (force == NULL) {
1139                 gctl_error(req, "No '%s' argument.", "force");
1140                 return;
1141         }
1142
1143         for (i = 0; i < (u_int)*nargs; i++) {
1144                 snprintf(param, sizeof(param), "arg%u", i);
1145                 name = gctl_get_asciiparam(req, param);
1146                 if (name == NULL) {
1147                         gctl_error(req, "No 'arg%u' argument.", i);
1148                         return;
1149                 }
1150                 sc = g_stripe_find_device(mp, name);
1151                 if (sc == NULL) {
1152                         gctl_error(req, "No such device: %s.", name);
1153                         return;
1154                 }
1155                 error = g_stripe_destroy(sc, *force);
1156                 if (error != 0) {
1157                         gctl_error(req, "Cannot destroy device %s (error=%d).",
1158                             sc->sc_name, error);
1159                         return;
1160                 }
1161         }
1162 }
1163
1164 static void
1165 g_stripe_config(struct gctl_req *req, struct g_class *mp, const char *verb)
1166 {
1167         uint32_t *version;
1168
1169         g_topology_assert();
1170
1171         version = gctl_get_paraml(req, "version", sizeof(*version));
1172         if (version == NULL) {
1173                 gctl_error(req, "No '%s' argument.", "version");
1174                 return;
1175         }
1176         if (*version != G_STRIPE_VERSION) {
1177                 gctl_error(req, "Userland and kernel parts are out of sync.");
1178                 return;
1179         }
1180
1181         if (strcmp(verb, "create") == 0) {
1182                 g_stripe_ctl_create(req, mp);
1183                 return;
1184         } else if (strcmp(verb, "destroy") == 0 ||
1185             strcmp(verb, "stop") == 0) {
1186                 g_stripe_ctl_destroy(req, mp);
1187                 return;
1188         }
1189
1190         gctl_error(req, "Unknown verb.");
1191 }
1192
1193 static void
1194 g_stripe_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
1195     struct g_consumer *cp, struct g_provider *pp)
1196 {
1197         struct g_stripe_softc *sc;
1198
1199         sc = gp->softc;
1200         if (sc == NULL)
1201                 return;
1202         if (pp != NULL) {
1203                 /* Nothing here. */
1204         } else if (cp != NULL) {
1205                 sbuf_printf(sb, "%s<Number>%u</Number>\n", indent,
1206                     (u_int)cp->index);
1207         } else {
1208                 sbuf_printf(sb, "%s<ID>%u</ID>\n", indent, (u_int)sc->sc_id);
1209                 sbuf_printf(sb, "%s<Stripesize>%u</Stripesize>\n", indent,
1210                     (u_int)sc->sc_stripesize);
1211                 sbuf_printf(sb, "%s<Type>", indent);
1212                 switch (sc->sc_type) {
1213                 case G_STRIPE_TYPE_AUTOMATIC:
1214                         sbuf_printf(sb, "AUTOMATIC");
1215                         break;
1216                 case G_STRIPE_TYPE_MANUAL:
1217                         sbuf_printf(sb, "MANUAL");
1218                         break;
1219                 default:
1220                         sbuf_printf(sb, "UNKNOWN");
1221                         break;
1222                 }
1223                 sbuf_printf(sb, "</Type>\n");
1224                 sbuf_printf(sb, "%s<Status>Total=%u, Online=%u</Status>\n",
1225                     indent, sc->sc_ndisks, g_stripe_nvalid(sc));
1226                 sbuf_printf(sb, "%s<State>", indent);
1227                 if (sc->sc_provider != NULL && sc->sc_provider->error == 0)
1228                         sbuf_printf(sb, "UP");
1229                 else
1230                         sbuf_printf(sb, "DOWN");
1231                 sbuf_printf(sb, "</State>\n");
1232         }
1233 }
1234
1235 DECLARE_GEOM_CLASS(g_stripe_class, g_stripe);