sys/geom/multipath/g_multipath.c

   1 /*-
   2  * Copyright (c) 2011-2013 Alexander Motin <mav@FreeBSD.org>
   3  * Copyright (c) 2006-2007 Matthew Jacob <mjacob@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27 /*
  28  * Based upon work by Pawel Jakub Dawidek <pjd@FreeBSD.org> for all of the
  29  * fine geom examples, and by Poul Henning Kamp <phk@FreeBSD.org> for GEOM
  30  * itself, all of which is most gratefully acknowledged.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/module.h>
  39 #include <sys/limits.h>
  40 #include <sys/lock.h>
  41 #include <sys/mutex.h>
  42 #include <sys/bio.h>
  43 #include <sys/sbuf.h>
  44 #include <sys/sysctl.h>
  45 #include <sys/kthread.h>
  46 #include <sys/malloc.h>
  47 #include <geom/geom.h>
  48 #include <geom/multipath/g_multipath.h>
  49
  50 FEATURE(geom_multipath, "GEOM multipath support");
  51
  52 SYSCTL_DECL(_kern_geom);
  53 static SYSCTL_NODE(_kern_geom, OID_AUTO, multipath, CTLFLAG_RW, 0,
  54     "GEOM_MULTIPATH tunables");
  55 static u_int g_multipath_debug = 0;
  56 SYSCTL_UINT(_kern_geom_multipath, OID_AUTO, debug, CTLFLAG_RW,
  57     &g_multipath_debug, 0, "Debug level");
  58 static u_int g_multipath_exclusive = 1;
  59 SYSCTL_UINT(_kern_geom_multipath, OID_AUTO, exclusive, CTLFLAG_RW,
  60     &g_multipath_exclusive, 0, "Exclusively open providers");
  61
  62 static enum {
  63         GKT_NIL,
  64         GKT_RUN,
  65         GKT_DIE
  66 } g_multipath_kt_state;
  67 static struct bio_queue_head gmtbq;
  68 static struct mtx gmtbq_mtx;
  69
  70 static int g_multipath_read_metadata(struct g_consumer *cp,
  71     struct g_multipath_metadata *md);
  72 static int g_multipath_write_metadata(struct g_consumer *cp,
  73     struct g_multipath_metadata *md);
  74
  75 static void g_multipath_orphan(struct g_consumer *);
  76 static void g_multipath_resize(struct g_consumer *);
  77 static void g_multipath_start(struct bio *);
  78 static void g_multipath_done(struct bio *);
  79 static void g_multipath_done_error(struct bio *);
  80 static void g_multipath_kt(void *);
  81
  82 static int g_multipath_destroy(struct g_geom *);
  83 static int
  84 g_multipath_destroy_geom(struct gctl_req *, struct g_class *, struct g_geom *);
  85
  86 static struct g_geom *g_multipath_find_geom(struct g_class *, const char *);
  87 static int g_multipath_rotate(struct g_geom *);
  88
  89 static g_taste_t g_multipath_taste;
  90 static g_ctl_req_t g_multipath_config;
  91 static g_init_t g_multipath_init;
  92 static g_fini_t g_multipath_fini;
  93 static g_dumpconf_t g_multipath_dumpconf;
  94
  95 struct g_class g_multipath_class = {
  96         .name           = G_MULTIPATH_CLASS_NAME,
  97         .version        = G_VERSION,
  98         .ctlreq         = g_multipath_config,
  99         .taste          = g_multipath_taste,
 100         .destroy_geom   = g_multipath_destroy_geom,
 101         .init           = g_multipath_init,
 102         .fini           = g_multipath_fini
 103 };
 104
 105 #define MP_FAIL         0x00000001
 106 #define MP_LOST         0x00000002
 107 #define MP_NEW          0x00000004
 108 #define MP_POSTED       0x00000008
 109 #define MP_BAD          (MP_FAIL | MP_LOST | MP_NEW)
 110 #define MP_WITHER       0x00000010
 111 #define MP_IDLE         0x00000020
 112 #define MP_IDLE_MASK    0xffffffe0
 113
 114 static int
 115 g_multipath_good(struct g_geom *gp)
 116 {
 117         struct g_consumer *cp;
 118         int n = 0;
 119
 120         LIST_FOREACH(cp, &gp->consumer, consumer) {
 121                 if ((cp->index & MP_BAD) == 0)
 122                         n++;
 123         }
 124         return (n);
 125 }
 126
 127 static void
 128 g_multipath_fault(struct g_consumer *cp, int cause)
 129 {
 130         struct g_multipath_softc *sc;
 131         struct g_consumer *lcp;
 132         struct g_geom *gp;
 133
 134         gp = cp->geom;
 135         sc = gp->softc;
 136         cp->index |= cause;
 137         if (g_multipath_good(gp) == 0 && sc->sc_ndisks > 0) {
 138                 LIST_FOREACH(lcp, &gp->consumer, consumer) {
 139                         if (lcp->provider == NULL ||
 140                             (lcp->index & (MP_LOST | MP_NEW)))
 141                                 continue;
 142                         if (sc->sc_ndisks > 1 && lcp == cp)
 143                                 continue;
 144                         printf("GEOM_MULTIPATH: "
 145                             "all paths in %s were marked FAIL, restore %s\n",
 146                             sc->sc_name, lcp->provider->name);
 147                         lcp->index &= ~MP_FAIL;
 148                 }
 149         }
 150         if (cp != sc->sc_active)
 151                 return;
 152         sc->sc_active = NULL;
 153         LIST_FOREACH(lcp, &gp->consumer, consumer) {
 154                 if ((lcp->index & MP_BAD) == 0) {
 155                         sc->sc_active = lcp;
 156                         break;
 157                 }
 158         }
 159         if (sc->sc_active == NULL) {
 160                 printf("GEOM_MULTIPATH: out of providers for %s\n",
 161                     sc->sc_name);
 162         } else if (sc->sc_active_active != 1) {
 163                 printf("GEOM_MULTIPATH: %s is now active path in %s\n",
 164                     sc->sc_active->provider->name, sc->sc_name);
 165         }
 166 }
 167
 168 static struct g_consumer *
 169 g_multipath_choose(struct g_geom *gp, struct bio *bp)
 170 {
 171         struct g_multipath_softc *sc;
 172         struct g_consumer *best, *cp;
 173
 174         sc = gp->softc;
 175         if (sc->sc_active_active == 0 ||
 176             (sc->sc_active_active == 2 && bp->bio_cmd != BIO_READ))
 177                 return (sc->sc_active);
 178         best = NULL;
 179         LIST_FOREACH(cp, &gp->consumer, consumer) {
 180                 if (cp->index & MP_BAD)
 181                         continue;
 182                 cp->index += MP_IDLE;
 183                 if (best == NULL || cp->private < best->private ||
 184                     (cp->private == best->private && cp->index > best->index))
 185                         best = cp;
 186         }
 187         if (best != NULL)
 188                 best->index &= ~MP_IDLE_MASK;
 189         return (best);
 190 }
 191
 192 static void
 193 g_mpd(void *arg, int flags __unused)
 194 {
 195         struct g_geom *gp;
 196         struct g_multipath_softc *sc;
 197         struct g_consumer *cp;
 198         int w;
 199
 200         g_topology_assert();
 201         cp = arg;
 202         gp = cp->geom;
 203         if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0) {
 204                 w = cp->acw;
 205                 g_access(cp, -cp->acr, -cp->acw, -cp->ace);
 206                 if (w > 0 && cp->provider != NULL &&
 207                     (cp->provider->geom->flags & G_GEOM_WITHER) == 0) {
 208                         cp->index |= MP_WITHER;
 209                         g_post_event(g_mpd, cp, M_WAITOK, NULL);
 210                         return;
 211                 }
 212         }
 213         sc = gp->softc;
 214         mtx_lock(&sc->sc_mtx);
 215         if (cp->provider) {
 216                 printf("GEOM_MULTIPATH: %s removed from %s\n",
 217                     cp->provider->name, gp->name);
 218                 g_detach(cp);
 219         }
 220         g_destroy_consumer(cp);
 221         mtx_unlock(&sc->sc_mtx);
 222         if (LIST_EMPTY(&gp->consumer))
 223                 g_multipath_destroy(gp);
 224 }
 225
 226 static void
 227 g_multipath_orphan(struct g_consumer *cp)
 228 {
 229         struct g_multipath_softc *sc;
 230         uintptr_t *cnt;
 231
 232         g_topology_assert();
 233         printf("GEOM_MULTIPATH: %s in %s was disconnected\n",
 234             cp->provider->name, cp->geom->name);
 235         sc = cp->geom->softc;
 236         cnt = (uintptr_t *)&cp->private;
 237         mtx_lock(&sc->sc_mtx);
 238         sc->sc_ndisks--;
 239         g_multipath_fault(cp, MP_LOST);
 240         if (*cnt == 0 && (cp->index & MP_POSTED) == 0) {
 241                 cp->index |= MP_POSTED;
 242                 mtx_unlock(&sc->sc_mtx);
 243                 g_mpd(cp, 0);
 244         } else
 245                 mtx_unlock(&sc->sc_mtx);
 246 }
 247
 248 static void
 249 g_multipath_resize(struct g_consumer *cp)
 250 {
 251         struct g_multipath_softc *sc;
 252         struct g_geom *gp;
 253         struct g_consumer *cp1;
 254         struct g_provider *pp;
 255         struct g_multipath_metadata md;
 256         off_t size, psize, ssize;
 257         int error;
 258
 259         g_topology_assert();
 260
 261         gp = cp->geom;
 262         pp = cp->provider;
 263         sc = gp->softc;
 264
 265         if (sc->sc_stopping)
 266                 return;
 267
 268         if (pp->mediasize < sc->sc_size) {
 269                 size = pp->mediasize;
 270                 ssize = pp->sectorsize;
 271         } else {
 272                 size = ssize = OFF_MAX;
 273                 mtx_lock(&sc->sc_mtx);
 274                 LIST_FOREACH(cp1, &gp->consumer, consumer) {
 275                         pp = cp1->provider;
 276                         if (pp == NULL)
 277                                 continue;
 278                         if (pp->mediasize < size) {
 279                                 size = pp->mediasize;
 280                                 ssize = pp->sectorsize;
 281                         }
 282                 }
 283                 mtx_unlock(&sc->sc_mtx);
 284                 if (size == OFF_MAX || size == sc->sc_size)
 285                         return;
 286         }
 287         psize = size - ((sc->sc_uuid[0] != 0) ? ssize : 0);
 288         printf("GEOM_MULTIPATH: %s size changed from %jd to %jd\n",
 289             sc->sc_name, sc->sc_pp->mediasize, psize);
 290         if (sc->sc_uuid[0] != 0 && size < sc->sc_size) {
 291                 error = g_multipath_read_metadata(cp, &md);
 292                 if (error ||
 293                     (strcmp(md.md_magic, G_MULTIPATH_MAGIC) != 0) ||
 294                     (memcmp(md.md_uuid, sc->sc_uuid, sizeof(sc->sc_uuid)) != 0) ||
 295                     (strcmp(md.md_name, sc->sc_name) != 0) ||
 296                     (md.md_size != 0 && md.md_size != size) ||
 297                     (md.md_sectorsize != 0 && md.md_sectorsize != ssize)) {
 298                         g_multipath_destroy(gp);
 299                         return;
 300                 }
 301         }
 302         sc->sc_size = size;
 303         g_resize_provider(sc->sc_pp, psize);
 304
 305         if (sc->sc_uuid[0] != 0) {
 306                 pp = cp->provider;
 307                 strlcpy(md.md_magic, G_MULTIPATH_MAGIC, sizeof(md.md_magic));
 308                 memcpy(md.md_uuid, sc->sc_uuid, sizeof (sc->sc_uuid));
 309                 strlcpy(md.md_name, sc->sc_name, sizeof(md.md_name));
 310                 md.md_version = G_MULTIPATH_VERSION;
 311                 md.md_size = size;
 312                 md.md_sectorsize = ssize;
 313                 md.md_active_active = sc->sc_active_active;
 314                 error = g_multipath_write_metadata(cp, &md);
 315                 if (error != 0)
 316                         printf("GEOM_MULTIPATH: Can't update metadata on %s "
 317                             "(%d)\n", pp->name, error);
 318         }
 319 }
 320
 321 static void
 322 g_multipath_start(struct bio *bp)
 323 {
 324         struct g_multipath_softc *sc;
 325         struct g_geom *gp;
 326         struct g_consumer *cp;
 327         struct bio *cbp;
 328         uintptr_t *cnt;
 329
 330         gp = bp->bio_to->geom;
 331         sc = gp->softc;
 332         KASSERT(sc != NULL, ("NULL sc"));
 333         cbp = g_clone_bio(bp);
 334         if (cbp == NULL) {
 335                 g_io_deliver(bp, ENOMEM);
 336                 return;
 337         }
 338         mtx_lock(&sc->sc_mtx);
 339         cp = g_multipath_choose(gp, bp);
 340         if (cp == NULL) {
 341                 mtx_unlock(&sc->sc_mtx);
 342                 g_destroy_bio(cbp);
 343                 g_io_deliver(bp, ENXIO);
 344                 return;
 345         }
 346         if ((uintptr_t)bp->bio_driver1 < sc->sc_ndisks)
 347                 bp->bio_driver1 = (void *)(uintptr_t)sc->sc_ndisks;
 348         cnt = (uintptr_t *)&cp->private;
 349         (*cnt)++;
 350         mtx_unlock(&sc->sc_mtx);
 351         cbp->bio_done = g_multipath_done;
 352         g_io_request(cbp, cp);
 353 }
 354
 355 static void
 356 g_multipath_done(struct bio *bp)
 357 {
 358         struct g_multipath_softc *sc;
 359         struct g_consumer *cp;
 360         uintptr_t *cnt;
 361
 362         if (bp->bio_error == ENXIO || bp->bio_error == EIO) {
 363                 mtx_lock(&gmtbq_mtx);
 364                 bioq_insert_tail(&gmtbq, bp);
 365                 mtx_unlock(&gmtbq_mtx);
 366                 wakeup(&g_multipath_kt_state);
 367         } else {
 368                 cp = bp->bio_from;
 369                 sc = cp->geom->softc;
 370                 cnt = (uintptr_t *)&cp->private;
 371                 mtx_lock(&sc->sc_mtx);
 372                 (*cnt)--;
 373                 if (*cnt == 0 && (cp->index & MP_LOST)) {
 374                         if (g_post_event(g_mpd, cp, M_NOWAIT, NULL) == 0)
 375                                 cp->index |= MP_POSTED;
 376                         mtx_unlock(&sc->sc_mtx);
 377                 } else
 378                         mtx_unlock(&sc->sc_mtx);
 379                 g_std_done(bp);
 380         }
 381 }
 382
 383 static void
 384 g_multipath_done_error(struct bio *bp)
 385 {
 386         struct bio *pbp;
 387         struct g_geom *gp;
 388         struct g_multipath_softc *sc;
 389         struct g_consumer *cp;
 390         struct g_provider *pp;
 391         uintptr_t *cnt;
 392
 393         /*
 394          * If we had a failure, we have to check first to see
 395          * whether the consumer it failed on was the currently
 396          * active consumer (i.e., this is the first in perhaps
 397          * a number of failures). If so, we then switch consumers
 398          * to the next available consumer.
 399          */
 400
 401         pbp = bp->bio_parent;
 402         gp = pbp->bio_to->geom;
 403         sc = gp->softc;
 404         cp = bp->bio_from;
 405         pp = cp->provider;
 406         cnt = (uintptr_t *)&cp->private;
 407
 408         mtx_lock(&sc->sc_mtx);
 409         if ((cp->index & MP_FAIL) == 0) {
 410                 printf("GEOM_MULTIPATH: Error %d, %s in %s marked FAIL\n",
 411                     bp->bio_error, pp->name, sc->sc_name);
 412                 g_multipath_fault(cp, MP_FAIL);
 413         }
 414         (*cnt)--;
 415         if (*cnt == 0 && (cp->index & (MP_LOST | MP_POSTED)) == MP_LOST) {
 416                 cp->index |= MP_POSTED;
 417                 mtx_unlock(&sc->sc_mtx);
 418                 g_post_event(g_mpd, cp, M_WAITOK, NULL);
 419         } else
 420                 mtx_unlock(&sc->sc_mtx);
 421
 422         /*
 423          * If we can fruitfully restart the I/O, do so.
 424          */
 425         if (pbp->bio_children < (uintptr_t)pbp->bio_driver1) {
 426                 pbp->bio_inbed++;
 427                 g_destroy_bio(bp);
 428                 g_multipath_start(pbp);
 429         } else {
 430                 g_std_done(bp);
 431         }
 432 }
 433
 434 static void
 435 g_multipath_kt(void *arg)
 436 {
 437
 438         g_multipath_kt_state = GKT_RUN;
 439         mtx_lock(&gmtbq_mtx);
 440         while (g_multipath_kt_state == GKT_RUN) {
 441                 for (;;) {
 442                         struct bio *bp;
 443
 444                         bp = bioq_takefirst(&gmtbq);
 445                         if (bp == NULL)
 446                                 break;
 447                         mtx_unlock(&gmtbq_mtx);
 448                         g_multipath_done_error(bp);
 449                         mtx_lock(&gmtbq_mtx);
 450                 }
 451                 if (g_multipath_kt_state != GKT_RUN)
 452                         break;
 453                 msleep(&g_multipath_kt_state, &gmtbq_mtx, PRIBIO,
 454                     "gkt:wait", 0);
 455         }
 456         mtx_unlock(&gmtbq_mtx);
 457         wakeup(&g_multipath_kt_state);
 458         kproc_exit(0);
 459 }
 460
 461
 462 static int
 463 g_multipath_access(struct g_provider *pp, int dr, int dw, int de)
 464 {
 465         struct g_geom *gp;
 466         struct g_consumer *cp, *badcp = NULL;
 467         struct g_multipath_softc *sc;
 468         int error;
 469
 470         gp = pp->geom;
 471
 472         /* Error used if we have no valid consumers. */
 473         error = ENXIO;
 474
 475         LIST_FOREACH(cp, &gp->consumer, consumer) {
 476                 if (cp->index & MP_WITHER)
 477                         continue;
 478
 479                 error = g_access(cp, dr, dw, de);
 480                 if (error) {
 481                         badcp = cp;
 482                         goto fail;
 483                 }
 484         }
 485
 486         if (error != 0)
 487                 return (error);
 488
 489         sc = gp->softc;
 490         sc->sc_opened += dr + dw + de;
 491         if (sc->sc_stopping && sc->sc_opened == 0)
 492                 g_multipath_destroy(gp);
 493
 494         return (0);
 495
 496 fail:
 497         LIST_FOREACH(cp, &gp->consumer, consumer) {
 498                 if (cp == badcp)
 499                         break;
 500                 if (cp->index & MP_WITHER)
 501                         continue;
 502
 503                 (void) g_access(cp, -dr, -dw, -de);
 504         }
 505         return (error);
 506 }
 507
 508 static struct g_geom *
 509 g_multipath_create(struct g_class *mp, struct g_multipath_metadata *md)
 510 {
 511         struct g_multipath_softc *sc;
 512         struct g_geom *gp;
 513         struct g_provider *pp;
 514
 515         g_topology_assert();
 516
 517         LIST_FOREACH(gp, &mp->geom, geom) {
 518                 sc = gp->softc;
 519                 if (sc == NULL || sc->sc_stopping)
 520                         continue;
 521                 if (strcmp(gp->name, md->md_name) == 0) {
 522                         printf("GEOM_MULTIPATH: name %s already exists\n",
 523                             md->md_name);
 524                         return (NULL);
 525                 }
 526         }
 527
 528         gp = g_new_geomf(mp, "%s", md->md_name);
 529         sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
 530         mtx_init(&sc->sc_mtx, "multipath", NULL, MTX_DEF);
 531         memcpy(sc->sc_uuid, md->md_uuid, sizeof (sc->sc_uuid));
 532         memcpy(sc->sc_name, md->md_name, sizeof (sc->sc_name));
 533         sc->sc_active_active = md->md_active_active;
 534         sc->sc_size = md->md_size;
 535         gp->softc = sc;
 536         gp->start = g_multipath_start;
 537         gp->orphan = g_multipath_orphan;
 538         gp->resize = g_multipath_resize;
 539         gp->access = g_multipath_access;
 540         gp->dumpconf = g_multipath_dumpconf;
 541
 542         pp = g_new_providerf(gp, "multipath/%s", md->md_name);
 543         pp->flags |= G_PF_DIRECT_SEND | G_PF_DIRECT_RECEIVE;
 544         if (md->md_size != 0) {
 545                 pp->mediasize = md->md_size -
 546                     ((md->md_uuid[0] != 0) ? md->md_sectorsize : 0);
 547                 pp->sectorsize = md->md_sectorsize;
 548         }
 549         sc->sc_pp = pp;
 550         g_error_provider(pp, 0);
 551         printf("GEOM_MULTIPATH: %s created\n", gp->name);
 552         return (gp);
 553 }
 554
 555 static int
 556 g_multipath_add_disk(struct g_geom *gp, struct g_provider *pp)
 557 {
 558         struct g_multipath_softc *sc;
 559         struct g_consumer *cp, *nxtcp;
 560         int error, acr, acw, ace;
 561
 562         g_topology_assert();
 563
 564         sc = gp->softc;
 565         KASSERT(sc, ("no softc"));
 566
 567         /*
 568          * Make sure that the passed provider isn't already attached
 569          */
 570         LIST_FOREACH(cp, &gp->consumer, consumer) {
 571                 if (cp->provider == pp)
 572                         break;
 573         }
 574         if (cp) {
 575                 printf("GEOM_MULTIPATH: provider %s already attached to %s\n",
 576                     pp->name, gp->name);
 577                 return (EEXIST);
 578         }
 579         nxtcp = LIST_FIRST(&gp->consumer);
 580         cp = g_new_consumer(gp);
 581         cp->flags |= G_CF_DIRECT_SEND | G_CF_DIRECT_RECEIVE;
 582         cp->private = NULL;
 583         cp->index = MP_NEW;
 584         error = g_attach(cp, pp);
 585         if (error != 0) {
 586                 printf("GEOM_MULTIPATH: cannot attach %s to %s",
 587                     pp->name, sc->sc_name);
 588                 g_destroy_consumer(cp);
 589                 return (error);
 590         }
 591
 592         /*
 593          * Set access permissions on new consumer to match other consumers
 594          */
 595         if (sc->sc_pp) {
 596                 acr = sc->sc_pp->acr;
 597                 acw = sc->sc_pp->acw;
 598                 ace = sc->sc_pp->ace;
 599         } else
 600                 acr = acw = ace = 0;
 601         if (g_multipath_exclusive) {
 602                 acr++;
 603                 acw++;
 604                 ace++;
 605         }
 606         error = g_access(cp, acr, acw, ace);
 607         if (error) {
 608                 printf("GEOM_MULTIPATH: cannot set access in "
 609                     "attaching %s to %s (%d)\n",
 610                     pp->name, sc->sc_name, error);
 611                 g_detach(cp);
 612                 g_destroy_consumer(cp);
 613                 return (error);
 614         }
 615         if (sc->sc_size == 0) {
 616                 sc->sc_size = pp->mediasize -
 617                     ((sc->sc_uuid[0] != 0) ? pp->sectorsize : 0);
 618                 sc->sc_pp->mediasize = sc->sc_size;
 619                 sc->sc_pp->sectorsize = pp->sectorsize;
 620         }
 621         if (sc->sc_pp->stripesize == 0 && sc->sc_pp->stripeoffset == 0) {
 622                 sc->sc_pp->stripesize = pp->stripesize;
 623                 sc->sc_pp->stripeoffset = pp->stripeoffset;
 624         }
 625         sc->sc_pp->flags |= pp->flags & G_PF_ACCEPT_UNMAPPED;
 626         mtx_lock(&sc->sc_mtx);
 627         cp->index = 0;
 628         sc->sc_ndisks++;
 629         mtx_unlock(&sc->sc_mtx);
 630         printf("GEOM_MULTIPATH: %s added to %s\n",
 631             pp->name, sc->sc_name);
 632         if (sc->sc_active == NULL) {
 633                 sc->sc_active = cp;
 634                 if (sc->sc_active_active != 1)
 635                         printf("GEOM_MULTIPATH: %s is now active path in %s\n",
 636                             pp->name, sc->sc_name);
 637         }
 638         return (0);
 639 }
 640
 641 static int
 642 g_multipath_destroy(struct g_geom *gp)
 643 {
 644         struct g_multipath_softc *sc;
 645         struct g_consumer *cp, *cp1;
 646
 647         g_topology_assert();
 648         if (gp->softc == NULL)
 649                 return (ENXIO);
 650         sc = gp->softc;
 651         if (!sc->sc_stopping) {
 652                 printf("GEOM_MULTIPATH: destroying %s\n", gp->name);
 653                 sc->sc_stopping = 1;
 654         }
 655         if (sc->sc_opened != 0) {
 656                 g_wither_provider(sc->sc_pp, ENXIO);
 657                 sc->sc_pp = NULL;
 658                 return (EINPROGRESS);
 659         }
 660         LIST_FOREACH_SAFE(cp, &gp->consumer, consumer, cp1) {
 661                 mtx_lock(&sc->sc_mtx);
 662                 if ((cp->index & MP_POSTED) == 0) {
 663                         cp->index |= MP_POSTED;
 664                         mtx_unlock(&sc->sc_mtx);
 665                         g_mpd(cp, 0);
 666                         if (cp1 == NULL)
 667                                 return(0);      /* Recursion happened. */
 668                 } else
 669                         mtx_unlock(&sc->sc_mtx);
 670         }
 671         if (!LIST_EMPTY(&gp->consumer))
 672                 return (EINPROGRESS);
 673         mtx_destroy(&sc->sc_mtx);
 674         g_free(gp->softc);
 675         gp->softc = NULL;
 676         printf("GEOM_MULTIPATH: %s destroyed\n", gp->name);
 677         g_wither_geom(gp, ENXIO);
 678         return (0);
 679 }
 680
 681 static int
 682 g_multipath_destroy_geom(struct gctl_req *req, struct g_class *mp,
 683     struct g_geom *gp)
 684 {
 685
 686         return (g_multipath_destroy(gp));
 687 }
 688
 689 static int
 690 g_multipath_rotate(struct g_geom *gp)
 691 {
 692         struct g_consumer *lcp, *first_good_cp = NULL;
 693         struct g_multipath_softc *sc = gp->softc;
 694         int active_cp_seen = 0;
 695
 696         g_topology_assert();
 697         if (sc == NULL)
 698                 return (ENXIO);
 699         LIST_FOREACH(lcp, &gp->consumer, consumer) {
 700                 if ((lcp->index & MP_BAD) == 0) {
 701                         if (first_good_cp == NULL)
 702                                 first_good_cp = lcp;
 703                         if (active_cp_seen)
 704                                 break;
 705                 }
 706                 if (sc->sc_active == lcp)
 707                         active_cp_seen = 1;
 708         }
 709         if (lcp == NULL)
 710                 lcp = first_good_cp;
 711         if (lcp && lcp != sc->sc_active) {
 712                 sc->sc_active = lcp;
 713                 if (sc->sc_active_active != 1)
 714                         printf("GEOM_MULTIPATH: %s is now active path in %s\n",
 715                             lcp->provider->name, sc->sc_name);
 716         }
 717         return (0);
 718 }
 719
 720 static void
 721 g_multipath_init(struct g_class *mp)
 722 {
 723         bioq_init(&gmtbq);
 724         mtx_init(&gmtbq_mtx, "gmtbq", NULL, MTX_DEF);
 725         kproc_create(g_multipath_kt, mp, NULL, 0, 0, "g_mp_kt");
 726 }
 727
 728 static void
 729 g_multipath_fini(struct g_class *mp)
 730 {
 731         if (g_multipath_kt_state == GKT_RUN) {
 732                 mtx_lock(&gmtbq_mtx);
 733                 g_multipath_kt_state = GKT_DIE;
 734                 wakeup(&g_multipath_kt_state);
 735                 msleep(&g_multipath_kt_state, &gmtbq_mtx, PRIBIO,
 736                     "gmp:fini", 0);
 737                 mtx_unlock(&gmtbq_mtx);
 738         }
 739 }
 740
 741 static int
 742 g_multipath_read_metadata(struct g_consumer *cp,
 743     struct g_multipath_metadata *md)
 744 {
 745         struct g_provider *pp;
 746         u_char *buf;
 747         int error;
 748
 749         g_topology_assert();
 750         error = g_access(cp, 1, 0, 0);
 751         if (error != 0)
 752                 return (error);
 753         pp = cp->provider;
 754         g_topology_unlock();
 755         buf = g_read_data(cp, pp->mediasize - pp->sectorsize,
 756             pp->sectorsize, &error);
 757         g_topology_lock();
 758         g_access(cp, -1, 0, 0);
 759         if (buf == NULL)
 760                 return (error);
 761         multipath_metadata_decode(buf, md);
 762         g_free(buf);
 763         return (0);
 764 }
 765
 766 static int
 767 g_multipath_write_metadata(struct g_consumer *cp,
 768     struct g_multipath_metadata *md)
 769 {
 770         struct g_provider *pp;
 771         u_char *buf;
 772         int error;
 773
 774         g_topology_assert();
 775         error = g_access(cp, 1, 1, 1);
 776         if (error != 0)
 777                 return (error);
 778         pp = cp->provider;
 779         g_topology_unlock();
 780         buf = g_malloc(pp->sectorsize, M_WAITOK | M_ZERO);
 781         multipath_metadata_encode(md, buf);
 782         error = g_write_data(cp, pp->mediasize - pp->sectorsize,
 783             buf, pp->sectorsize);
 784         g_topology_lock();
 785         g_access(cp, -1, -1, -1);
 786         g_free(buf);
 787         return (error);
 788 }
 789
 790 static struct g_geom *
 791 g_multipath_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
 792 {
 793         struct g_multipath_metadata md;
 794         struct g_multipath_softc *sc;
 795         struct g_consumer *cp;
 796         struct g_geom *gp, *gp1;
 797         int error, isnew;
 798
 799         g_topology_assert();
 800
 801         gp = g_new_geomf(mp, "multipath:taste");
 802         gp->start = g_multipath_start;
 803         gp->access = g_multipath_access;
 804         gp->orphan = g_multipath_orphan;
 805         cp = g_new_consumer(gp);
 806         g_attach(cp, pp);
 807         error = g_multipath_read_metadata(cp, &md);
 808         g_detach(cp);
 809         g_destroy_consumer(cp);
 810         g_destroy_geom(gp);
 811         if (error != 0)
 812                 return (NULL);
 813         gp = NULL;
 814
 815         if (strcmp(md.md_magic, G_MULTIPATH_MAGIC) != 0) {
 816                 if (g_multipath_debug)
 817                         printf("%s is not MULTIPATH\n", pp->name);
 818                 return (NULL);
 819         }
 820         if (md.md_version != G_MULTIPATH_VERSION) {
 821                 printf("%s has version %d multipath id- this module is version "
 822                     " %d: rejecting\n", pp->name, md.md_version,
 823                     G_MULTIPATH_VERSION);
 824                 return (NULL);
 825         }
 826         if (md.md_size != 0 && md.md_size != pp->mediasize)
 827                 return (NULL);
 828         if (md.md_sectorsize != 0 && md.md_sectorsize != pp->sectorsize)
 829                 return (NULL);
 830         if (g_multipath_debug)
 831                 printf("MULTIPATH: %s/%s\n", md.md_name, md.md_uuid);
 832
 833         /*
 834          * Let's check if such a device already is present. We check against
 835          * uuid alone first because that's the true distinguishor. If that
 836          * passes, then we check for name conflicts. If there are conflicts,
 837          * modify the name.
 838          *
 839          * The whole purpose of this is to solve the problem that people don't
 840          * pick good unique names, but good unique names (like uuids) are a
 841          * pain to use. So, we allow people to build GEOMs with friendly names
 842          * and uuids, and modify the names in case there's a collision.
 843          */
 844         sc = NULL;
 845         LIST_FOREACH(gp, &mp->geom, geom) {
 846                 sc = gp->softc;
 847                 if (sc == NULL || sc->sc_stopping)
 848                         continue;
 849                 if (strncmp(md.md_uuid, sc->sc_uuid, sizeof(md.md_uuid)) == 0)
 850                         break;
 851         }
 852
 853         LIST_FOREACH(gp1, &mp->geom, geom) {
 854                 if (gp1 == gp)
 855                         continue;
 856                 sc = gp1->softc;
 857                 if (sc == NULL || sc->sc_stopping)
 858                         continue;
 859                 if (strncmp(md.md_name, sc->sc_name, sizeof(md.md_name)) == 0)
 860                         break;
 861         }
 862
 863         /*
 864          * If gp is NULL, we had no extant MULTIPATH geom with this uuid.
 865          *
 866          * If gp1 is *not* NULL, that means we have a MULTIPATH geom extant
 867          * with the same name (but a different UUID).
 868          *
 869          * If gp is NULL, then modify the name with a random number and
 870          * complain, but allow the creation of the geom to continue.
 871          *
 872          * If gp is *not* NULL, just use the geom's name as we're attaching
 873          * this disk to the (previously generated) name.
 874          */
 875
 876         if (gp1) {
 877                 sc = gp1->softc;
 878                 if (gp == NULL) {
 879                         char buf[16];
 880                         u_long rand = random();
 881
 882                         snprintf(buf, sizeof (buf), "%s-%lu", md.md_name, rand);
 883                         printf("GEOM_MULTIPATH: geom %s/%s exists already\n",
 884                             sc->sc_name, sc->sc_uuid);
 885                         printf("GEOM_MULTIPATH: %s will be (temporarily) %s\n",
 886                             md.md_uuid, buf);
 887                         strlcpy(md.md_name, buf, sizeof(md.md_name));
 888                 } else {
 889                         strlcpy(md.md_name, sc->sc_name, sizeof(md.md_name));
 890                 }
 891         }
 892
 893         if (gp == NULL) {
 894                 gp = g_multipath_create(mp, &md);
 895                 if (gp == NULL) {
 896                         printf("GEOM_MULTIPATH: cannot create geom %s/%s\n",
 897                             md.md_name, md.md_uuid);
 898                         return (NULL);
 899                 }
 900                 isnew = 1;
 901         } else {
 902                 isnew = 0;
 903         }
 904
 905         sc = gp->softc;
 906         KASSERT(sc != NULL, ("sc is NULL"));
 907         error = g_multipath_add_disk(gp, pp);
 908         if (error != 0) {
 909                 if (isnew)
 910                         g_multipath_destroy(gp);
 911                 return (NULL);
 912         }
 913         return (gp);
 914 }
 915
 916 static void
 917 g_multipath_ctl_add_name(struct gctl_req *req, struct g_class *mp,
 918     const char *name)
 919 {
 920         struct g_multipath_softc *sc;
 921         struct g_geom *gp;
 922         struct g_consumer *cp;
 923         struct g_provider *pp;
 924         const char *mpname;
 925         static const char devpf[6] = "/dev/";
 926
 927         g_topology_assert();
 928
 929         mpname = gctl_get_asciiparam(req, "arg0");
 930         if (mpname == NULL) {
 931                 gctl_error(req, "No 'arg0' argument");
 932                 return;
 933         }
 934         gp = g_multipath_find_geom(mp, mpname);
 935         if (gp == NULL) {
 936                 gctl_error(req, "Device %s is invalid", mpname);
 937                 return;
 938         }
 939         sc = gp->softc;
 940
 941         if (strncmp(name, devpf, 5) == 0)
 942                 name += 5;
 943         pp = g_provider_by_name(name);
 944         if (pp == NULL) {
 945                 gctl_error(req, "Provider %s is invalid", name);
 946                 return;
 947         }
 948
 949         /*
 950          * Check to make sure parameters match.
 951          */
 952         LIST_FOREACH(cp, &gp->consumer, consumer) {
 953                 if (cp->provider == pp) {
 954                         gctl_error(req, "provider %s is already there",
 955                             pp->name);
 956                         return;
 957                 }
 958         }
 959         if (sc->sc_pp->mediasize != 0 &&
 960             sc->sc_pp->mediasize + (sc->sc_uuid[0] != 0 ? pp->sectorsize : 0)
 961              != pp->mediasize) {
 962                 gctl_error(req, "Providers size mismatch %jd != %jd",
 963                     (intmax_t) sc->sc_pp->mediasize +
 964                         (sc->sc_uuid[0] != 0 ? pp->sectorsize : 0),
 965                     (intmax_t) pp->mediasize);
 966                 return;
 967         }
 968         if (sc->sc_pp->sectorsize != 0 &&
 969             sc->sc_pp->sectorsize != pp->sectorsize) {
 970                 gctl_error(req, "Providers sectorsize mismatch %u != %u",
 971                     sc->sc_pp->sectorsize, pp->sectorsize);
 972                 return;
 973         }
 974
 975         /*
 976          * Now add....
 977          */
 978         (void) g_multipath_add_disk(gp, pp);
 979 }
 980
 981 static void
 982 g_multipath_ctl_prefer(struct gctl_req *req, struct g_class *mp)
 983 {
 984         struct g_geom *gp;
 985         struct g_multipath_softc *sc;
 986         struct g_consumer *cp;
 987         const char *name, *mpname;
 988         static const char devpf[6] = "/dev/";
 989         int *nargs;
 990
 991         g_topology_assert();
 992
 993         mpname = gctl_get_asciiparam(req, "arg0");
 994         if (mpname == NULL) {
 995                 gctl_error(req, "No 'arg0' argument");
 996                 return;
 997         }
 998         gp = g_multipath_find_geom(mp, mpname);
 999         if (gp == NULL) {
1000                 gctl_error(req, "Device %s is invalid", mpname);
1001                 return;
1002         }
1003         sc = gp->softc;
1004
1005         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
1006         if (nargs == NULL) {
1007                 gctl_error(req, "No 'nargs' argument");
1008                 return;
1009         }
1010         if (*nargs != 2) {
1011                 gctl_error(req, "missing device");
1012                 return;
1013         }
1014
1015         name = gctl_get_asciiparam(req, "arg1");
1016         if (name == NULL) {
1017                 gctl_error(req, "No 'arg1' argument");
1018                 return;
1019         }
1020         if (strncmp(name, devpf, 5) == 0) {
1021                 name += 5;
1022         }
1023
1024         LIST_FOREACH(cp, &gp->consumer, consumer) {
1025                 if (cp->provider != NULL
1026                       && strcmp(cp->provider->name, name) == 0)
1027                     break;
1028         }
1029
1030         if (cp == NULL) {
1031                 gctl_error(req, "Provider %s not found", name);
1032                 return;
1033         }
1034
1035         mtx_lock(&sc->sc_mtx);
1036
1037         if (cp->index & MP_BAD) {
1038                 gctl_error(req, "Consumer %s is invalid", name);
1039                 mtx_unlock(&sc->sc_mtx);
1040                 return;
1041         }
1042
1043         /* Here when the consumer is present and in good shape */
1044
1045         sc->sc_active = cp;
1046         if (!sc->sc_active_active)
1047             printf("GEOM_MULTIPATH: %s now active path in %s\n",
1048                 sc->sc_active->provider->name, sc->sc_name);
1049
1050         mtx_unlock(&sc->sc_mtx);
1051 }
1052
1053 static void
1054 g_multipath_ctl_add(struct gctl_req *req, struct g_class *mp)
1055 {
1056         struct g_multipath_softc *sc;
1057         struct g_geom *gp;
1058         const char *mpname, *name;
1059
1060         mpname = gctl_get_asciiparam(req, "arg0");
1061         if (mpname == NULL) {
1062                 gctl_error(req, "No 'arg0' argument");
1063                 return;
1064         }
1065         gp = g_multipath_find_geom(mp, mpname);
1066         if (gp == NULL) {
1067                 gctl_error(req, "Device %s not found", mpname);
1068                 return;
1069         }
1070         sc = gp->softc;
1071
1072         name = gctl_get_asciiparam(req, "arg1");
1073         if (name == NULL) {
1074                 gctl_error(req, "No 'arg1' argument");
1075                 return;
1076         }
1077         g_multipath_ctl_add_name(req, mp, name);
1078 }
1079
1080 static void
1081 g_multipath_ctl_create(struct gctl_req *req, struct g_class *mp)
1082 {
1083         struct g_multipath_metadata md;
1084         struct g_multipath_softc *sc;
1085         struct g_geom *gp;
1086         const char *mpname, *name;
1087         char param[16];
1088         int *nargs, i, *val;
1089
1090         g_topology_assert();
1091
1092         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
1093         if (*nargs < 2) {
1094                 gctl_error(req, "wrong number of arguments.");
1095                 return;
1096         }
1097
1098         mpname = gctl_get_asciiparam(req, "arg0");
1099         if (mpname == NULL) {
1100                 gctl_error(req, "No 'arg0' argument");
1101                 return;
1102         }
1103         gp = g_multipath_find_geom(mp, mpname);
1104         if (gp != NULL) {
1105                 gctl_error(req, "Device %s already exist", mpname);
1106                 return;
1107         }
1108
1109         memset(&md, 0, sizeof(md));
1110         strlcpy(md.md_magic, G_MULTIPATH_MAGIC, sizeof(md.md_magic));
1111         md.md_version = G_MULTIPATH_VERSION;
1112         strlcpy(md.md_name, mpname, sizeof(md.md_name));
1113         md.md_size = 0;
1114         md.md_sectorsize = 0;
1115         md.md_uuid[0] = 0;
1116         md.md_active_active = 0;
1117         val = gctl_get_paraml(req, "active_active", sizeof(*val));
1118         if (val != NULL && *val != 0)
1119                 md.md_active_active = 1;
1120         val = gctl_get_paraml(req, "active_read", sizeof(*val));
1121         if (val != NULL && *val != 0)
1122                 md.md_active_active = 2;
1123         gp = g_multipath_create(mp, &md);
1124         if (gp == NULL) {
1125                 gctl_error(req, "GEOM_MULTIPATH: cannot create geom %s/%s\n",
1126                     md.md_name, md.md_uuid);
1127                 return;
1128         }
1129         sc = gp->softc;
1130
1131         for (i = 1; i < *nargs; i++) {
1132                 snprintf(param, sizeof(param), "arg%d", i);
1133                 name = gctl_get_asciiparam(req, param);
1134                 g_multipath_ctl_add_name(req, mp, name);
1135         }
1136
1137         if (sc->sc_ndisks != (*nargs - 1))
1138                 g_multipath_destroy(gp);
1139 }
1140
1141 static void
1142 g_multipath_ctl_configure(struct gctl_req *req, struct g_class *mp)
1143 {
1144         struct g_multipath_softc *sc;
1145         struct g_geom *gp;
1146         struct g_consumer *cp;
1147         struct g_provider *pp;
1148         struct g_multipath_metadata md;
1149         const char *name;
1150         int error, *val;
1151
1152         g_topology_assert();
1153
1154         name = gctl_get_asciiparam(req, "arg0");
1155         if (name == NULL) {
1156                 gctl_error(req, "No 'arg0' argument");
1157                 return;
1158         }
1159         gp = g_multipath_find_geom(mp, name);
1160         if (gp == NULL) {
1161                 gctl_error(req, "Device %s is invalid", name);
1162                 return;
1163         }
1164         sc = gp->softc;
1165         val = gctl_get_paraml(req, "active_active", sizeof(*val));
1166         if (val != NULL && *val != 0)
1167                 sc->sc_active_active = 1;
1168         val = gctl_get_paraml(req, "active_read", sizeof(*val));
1169         if (val != NULL && *val != 0)
1170                 sc->sc_active_active = 2;
1171         val = gctl_get_paraml(req, "active_passive", sizeof(*val));
1172         if (val != NULL && *val != 0)
1173                 sc->sc_active_active = 0;
1174         if (sc->sc_uuid[0] != 0 && sc->sc_active != NULL) {
1175                 cp = sc->sc_active;
1176                 pp = cp->provider;
1177                 strlcpy(md.md_magic, G_MULTIPATH_MAGIC, sizeof(md.md_magic));
1178                 memcpy(md.md_uuid, sc->sc_uuid, sizeof (sc->sc_uuid));
1179                 strlcpy(md.md_name, name, sizeof(md.md_name));
1180                 md.md_version = G_MULTIPATH_VERSION;
1181                 md.md_size = pp->mediasize;
1182                 md.md_sectorsize = pp->sectorsize;
1183                 md.md_active_active = sc->sc_active_active;
1184                 error = g_multipath_write_metadata(cp, &md);
1185                 if (error != 0)
1186                         gctl_error(req, "Can't update metadata on %s (%d)",
1187                             pp->name, error);
1188         }
1189 }
1190
1191 static void
1192 g_multipath_ctl_fail(struct gctl_req *req, struct g_class *mp, int fail)
1193 {
1194         struct g_multipath_softc *sc;
1195         struct g_geom *gp;
1196         struct g_consumer *cp;
1197         const char *mpname, *name;
1198         int found;
1199
1200         mpname = gctl_get_asciiparam(req, "arg0");
1201         if (mpname == NULL) {
1202                 gctl_error(req, "No 'arg0' argument");
1203                 return;
1204         }
1205         gp = g_multipath_find_geom(mp, mpname);
1206         if (gp == NULL) {
1207                 gctl_error(req, "Device %s not found", mpname);
1208                 return;
1209         }
1210         sc = gp->softc;
1211
1212         name = gctl_get_asciiparam(req, "arg1");
1213         if (name == NULL) {
1214                 gctl_error(req, "No 'arg1' argument");
1215                 return;
1216         }
1217
1218         found = 0;
1219         mtx_lock(&sc->sc_mtx);
1220         LIST_FOREACH(cp, &gp->consumer, consumer) {
1221                 if (cp->provider != NULL &&
1222                     strcmp(cp->provider->name, name) == 0 &&
1223                     (cp->index & MP_LOST) == 0) {
1224                         found = 1;
1225                         if (!fail == !(cp->index & MP_FAIL))
1226                                 continue;
1227                         printf("GEOM_MULTIPATH: %s in %s is marked %s.\n",
1228                                 name, sc->sc_name, fail ? "FAIL" : "OK");
1229                         if (fail) {
1230                                 g_multipath_fault(cp, MP_FAIL);
1231                         } else {
1232                                 cp->index &= ~MP_FAIL;
1233                         }
1234                 }
1235         }
1236         mtx_unlock(&sc->sc_mtx);
1237         if (found == 0)
1238                 gctl_error(req, "Provider %s not found", name);
1239 }
1240
1241 static void
1242 g_multipath_ctl_remove(struct gctl_req *req, struct g_class *mp)
1243 {
1244         struct g_multipath_softc *sc;
1245         struct g_geom *gp;
1246         struct g_consumer *cp, *cp1;
1247         const char *mpname, *name;
1248         uintptr_t *cnt;
1249         int found;
1250
1251         mpname = gctl_get_asciiparam(req, "arg0");
1252         if (mpname == NULL) {
1253                 gctl_error(req, "No 'arg0' argument");
1254                 return;
1255         }
1256         gp = g_multipath_find_geom(mp, mpname);
1257         if (gp == NULL) {
1258                 gctl_error(req, "Device %s not found", mpname);
1259                 return;
1260         }
1261         sc = gp->softc;
1262
1263         name = gctl_get_asciiparam(req, "arg1");
1264         if (name == NULL) {
1265                 gctl_error(req, "No 'arg1' argument");
1266                 return;
1267         }
1268
1269         found = 0;
1270         mtx_lock(&sc->sc_mtx);
1271         LIST_FOREACH_SAFE(cp, &gp->consumer, consumer, cp1) {
1272                 if (cp->provider != NULL &&
1273                     strcmp(cp->provider->name, name) == 0 &&
1274                     (cp->index & MP_LOST) == 0) {
1275                         found = 1;
1276                         printf("GEOM_MULTIPATH: removing %s from %s\n",
1277                             cp->provider->name, cp->geom->name);
1278                         sc->sc_ndisks--;
1279                         g_multipath_fault(cp, MP_LOST);
1280                         cnt = (uintptr_t *)&cp->private;
1281                         if (*cnt == 0 && (cp->index & MP_POSTED) == 0) {
1282                                 cp->index |= MP_POSTED;
1283                                 mtx_unlock(&sc->sc_mtx);
1284                                 g_mpd(cp, 0);
1285                                 if (cp1 == NULL)
1286                                         return; /* Recursion happened. */
1287                                 mtx_lock(&sc->sc_mtx);
1288                         }
1289                 }
1290         }
1291         mtx_unlock(&sc->sc_mtx);
1292         if (found == 0)
1293                 gctl_error(req, "Provider %s not found", name);
1294 }
1295
1296 static struct g_geom *
1297 g_multipath_find_geom(struct g_class *mp, const char *name)
1298 {
1299         struct g_geom *gp;
1300         struct g_multipath_softc *sc;
1301
1302         LIST_FOREACH(gp, &mp->geom, geom) {
1303                 sc = gp->softc;
1304                 if (sc == NULL || sc->sc_stopping)
1305                         continue;
1306                 if (strcmp(gp->name, name) == 0)
1307                         return (gp);
1308         }
1309         return (NULL);
1310 }
1311
1312 static void
1313 g_multipath_ctl_stop(struct gctl_req *req, struct g_class *mp)
1314 {
1315         struct g_geom *gp;
1316         const char *name;
1317         int error;
1318
1319         g_topology_assert();
1320
1321         name = gctl_get_asciiparam(req, "arg0");
1322         if (name == NULL) {
1323                 gctl_error(req, "No 'arg0' argument");
1324                 return;
1325         }
1326         gp = g_multipath_find_geom(mp, name);
1327         if (gp == NULL) {
1328                 gctl_error(req, "Device %s is invalid", name);
1329                 return;
1330         }
1331         error = g_multipath_destroy(gp);
1332         if (error != 0 && error != EINPROGRESS)
1333                 gctl_error(req, "failed to stop %s (err=%d)", name, error);
1334 }
1335
1336 static void
1337 g_multipath_ctl_destroy(struct gctl_req *req, struct g_class *mp)
1338 {
1339         struct g_geom *gp;
1340         struct g_multipath_softc *sc;
1341         struct g_consumer *cp;
1342         struct g_provider *pp;
1343         const char *name;
1344         uint8_t *buf;
1345         int error;
1346
1347         g_topology_assert();
1348
1349         name = gctl_get_asciiparam(req, "arg0");
1350         if (name == NULL) {
1351                 gctl_error(req, "No 'arg0' argument");
1352                 return;
1353         }
1354         gp = g_multipath_find_geom(mp, name);
1355         if (gp == NULL) {
1356                 gctl_error(req, "Device %s is invalid", name);
1357                 return;
1358         }
1359         sc = gp->softc;
1360
1361         if (sc->sc_uuid[0] != 0 && sc->sc_active != NULL) {
1362                 cp = sc->sc_active;
1363                 pp = cp->provider;
1364                 error = g_access(cp, 1, 1, 1);
1365                 if (error != 0) {
1366                         gctl_error(req, "Can't open %s (%d)", pp->name, error);
1367                         goto destroy;
1368                 }
1369                 g_topology_unlock();
1370                 buf = g_malloc(pp->sectorsize, M_WAITOK | M_ZERO);
1371                 error = g_write_data(cp, pp->mediasize - pp->sectorsize,
1372                     buf, pp->sectorsize);
1373                 g_topology_lock();
1374                 g_access(cp, -1, -1, -1);
1375                 if (error != 0)
1376                         gctl_error(req, "Can't erase metadata on %s (%d)",
1377                             pp->name, error);
1378         }
1379
1380 destroy:
1381         error = g_multipath_destroy(gp);
1382         if (error != 0 && error != EINPROGRESS)
1383                 gctl_error(req, "failed to destroy %s (err=%d)", name, error);
1384 }
1385
1386 static void
1387 g_multipath_ctl_rotate(struct gctl_req *req, struct g_class *mp)
1388 {
1389         struct g_geom *gp;
1390         const char *name;
1391         int error;
1392
1393         g_topology_assert();
1394
1395         name = gctl_get_asciiparam(req, "arg0");
1396         if (name == NULL) {
1397                 gctl_error(req, "No 'arg0' argument");
1398                 return;
1399         }
1400         gp = g_multipath_find_geom(mp, name);
1401         if (gp == NULL) {
1402                 gctl_error(req, "Device %s is invalid", name);
1403                 return;
1404         }
1405         error = g_multipath_rotate(gp);
1406         if (error != 0) {
1407                 gctl_error(req, "failed to rotate %s (err=%d)", name, error);
1408         }
1409 }
1410
1411 static void
1412 g_multipath_ctl_getactive(struct gctl_req *req, struct g_class *mp)
1413 {
1414         struct sbuf *sb;
1415         struct g_geom *gp;
1416         struct g_multipath_softc *sc;
1417         struct g_consumer *cp;
1418         const char *name;
1419         int empty;
1420
1421         sb = sbuf_new_auto();
1422
1423         g_topology_assert();
1424         name = gctl_get_asciiparam(req, "arg0");
1425         if (name == NULL) {
1426                 gctl_error(req, "No 'arg0' argument");
1427                 return;
1428         }
1429         gp = g_multipath_find_geom(mp, name);
1430         if (gp == NULL) {
1431                 gctl_error(req, "Device %s is invalid", name);
1432                 return;
1433         }
1434         sc = gp->softc;
1435         if (sc->sc_active_active == 1) {
1436                 empty = 1;
1437                 LIST_FOREACH(cp, &gp->consumer, consumer) {
1438                         if (cp->index & MP_BAD)
1439                                 continue;
1440                         if (!empty)
1441                                 sbuf_cat(sb, " ");
1442                         sbuf_cat(sb, cp->provider->name);
1443                         empty = 0;
1444                 }
1445                 if (empty)
1446                         sbuf_cat(sb, "none");
1447                 sbuf_cat(sb, "\n");
1448         } else if (sc->sc_active && sc->sc_active->provider) {
1449                 sbuf_printf(sb, "%s\n", sc->sc_active->provider->name);
1450         } else {
1451                 sbuf_printf(sb, "none\n");
1452         }
1453         sbuf_finish(sb);
1454         gctl_set_param_err(req, "output", sbuf_data(sb), sbuf_len(sb) + 1);
1455         sbuf_delete(sb);
1456 }
1457
1458 static void
1459 g_multipath_config(struct gctl_req *req, struct g_class *mp, const char *verb)
1460 {
1461         uint32_t *version;
1462         g_topology_assert();
1463         version = gctl_get_paraml(req, "version", sizeof(*version));
1464         if (version == NULL) {
1465                 gctl_error(req, "No 'version' argument");
1466         } else if (*version != G_MULTIPATH_VERSION) {
1467                 gctl_error(req, "Userland and kernel parts are out of sync");
1468         } else if (strcmp(verb, "add") == 0) {
1469                 g_multipath_ctl_add(req, mp);
1470         } else if (strcmp(verb, "prefer") == 0) {
1471                 g_multipath_ctl_prefer(req, mp);
1472         } else if (strcmp(verb, "create") == 0) {
1473                 g_multipath_ctl_create(req, mp);
1474         } else if (strcmp(verb, "configure") == 0) {
1475                 g_multipath_ctl_configure(req, mp);
1476         } else if (strcmp(verb, "stop") == 0) {
1477                 g_multipath_ctl_stop(req, mp);
1478         } else if (strcmp(verb, "destroy") == 0) {
1479                 g_multipath_ctl_destroy(req, mp);
1480         } else if (strcmp(verb, "fail") == 0) {
1481                 g_multipath_ctl_fail(req, mp, 1);
1482         } else if (strcmp(verb, "restore") == 0) {
1483                 g_multipath_ctl_fail(req, mp, 0);
1484         } else if (strcmp(verb, "remove") == 0) {
1485                 g_multipath_ctl_remove(req, mp);
1486         } else if (strcmp(verb, "rotate") == 0) {
1487                 g_multipath_ctl_rotate(req, mp);
1488         } else if (strcmp(verb, "getactive") == 0) {
1489                 g_multipath_ctl_getactive(req, mp);
1490         } else {
1491                 gctl_error(req, "Unknown verb %s", verb);
1492         }
1493 }
1494
1495 static void
1496 g_multipath_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
1497     struct g_consumer *cp, struct g_provider *pp)
1498 {
1499         struct g_multipath_softc *sc;
1500         int good;
1501
1502         g_topology_assert();
1503
1504         sc = gp->softc;
1505         if (sc == NULL)
1506                 return;
1507         if (cp != NULL) {
1508                 sbuf_printf(sb, "%s<State>%s</State>\n", indent,
1509                     (cp->index & MP_NEW) ? "NEW" :
1510                     (cp->index & MP_LOST) ? "LOST" :
1511                     (cp->index & MP_FAIL) ? "FAIL" :
1512                     (sc->sc_active_active == 1 || sc->sc_active == cp) ?
1513                      "ACTIVE" :
1514                      sc->sc_active_active == 2 ? "READ" : "PASSIVE");
1515         } else {
1516                 good = g_multipath_good(gp);
1517                 sbuf_printf(sb, "%s<State>%s</State>\n", indent,
1518                     good == 0 ? "BROKEN" :
1519                     (good != sc->sc_ndisks || sc->sc_ndisks == 1) ?
1520                     "DEGRADED" : "OPTIMAL");
1521         }
1522         if (cp == NULL && pp == NULL) {
1523                 sbuf_printf(sb, "%s<UUID>%s</UUID>\n", indent, sc->sc_uuid);
1524                 sbuf_printf(sb, "%s<Mode>Active/%s</Mode>\n", indent,
1525                     sc->sc_active_active == 2 ? "Read" :
1526                     sc->sc_active_active == 1 ? "Active" : "Passive");
1527                 sbuf_printf(sb, "%s<Type>%s</Type>\n", indent,
1528                     sc->sc_uuid[0] == 0 ? "MANUAL" : "AUTOMATIC");
1529         }
1530 }
1531
1532 DECLARE_GEOM_CLASS(g_multipath_class, g_multipath);