g_multipath.c revision 294709
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: stable/10/sys/geom/multipath/g_multipath.c 294709 2016-01-25 09:29:29Z smh $"); 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 50FEATURE(geom_multipath, "GEOM multipath support"); 51 52SYSCTL_DECL(_kern_geom); 53static SYSCTL_NODE(_kern_geom, OID_AUTO, multipath, CTLFLAG_RW, 0, 54 "GEOM_MULTIPATH tunables"); 55static u_int g_multipath_debug = 0; 56SYSCTL_UINT(_kern_geom_multipath, OID_AUTO, debug, CTLFLAG_RW, 57 &g_multipath_debug, 0, "Debug level"); 58static u_int g_multipath_exclusive = 1; 59SYSCTL_UINT(_kern_geom_multipath, OID_AUTO, exclusive, CTLFLAG_RW, 60 &g_multipath_exclusive, 0, "Exclusively open providers"); 61 62static enum { 63 GKT_NIL, 64 GKT_RUN, 65 GKT_DIE 66} g_multipath_kt_state; 67static struct bio_queue_head gmtbq; 68static struct mtx gmtbq_mtx; 69 70static int g_multipath_read_metadata(struct g_consumer *cp, 71 struct g_multipath_metadata *md); 72static int g_multipath_write_metadata(struct g_consumer *cp, 73 struct g_multipath_metadata *md); 74 75static void g_multipath_orphan(struct g_consumer *); 76static void g_multipath_resize(struct g_consumer *); 77static void g_multipath_start(struct bio *); 78static void g_multipath_done(struct bio *); 79static void g_multipath_done_error(struct bio *); 80static void g_multipath_kt(void *); 81 82static int g_multipath_destroy(struct g_geom *); 83static int 84g_multipath_destroy_geom(struct gctl_req *, struct g_class *, struct g_geom *); 85 86static struct g_geom *g_multipath_find_geom(struct g_class *, const char *); 87static int g_multipath_rotate(struct g_geom *); 88 89static g_taste_t g_multipath_taste; 90static g_ctl_req_t g_multipath_config; 91static g_init_t g_multipath_init; 92static g_fini_t g_multipath_fini; 93static g_dumpconf_t g_multipath_dumpconf; 94 95struct 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 114static int 115g_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 127static void 128g_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 168static struct g_consumer * 169g_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 192static void 193g_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 226static void 227g_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 248static void 249g_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 321static void 322g_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 355static void 356g_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 383static void 384g_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 434static void 435g_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 462static int 463g_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 496fail: 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 508static struct g_geom * 509g_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 555static int 556g_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 641static int 642g_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 681static int 682g_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 689static int 690g_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 720static void 721g_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 728static void 729g_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 741static int 742g_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 766static int 767g_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 790static struct g_geom * 791g_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 916static void 917g_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 981static void 982g_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 1053static void 1054g_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 1080static void 1081g_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 1141static void 1142g_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 1191static void 1192g_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 1241static void 1242g_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 1296static struct g_geom * 1297g_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 1312static void 1313g_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 1336static void 1337g_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 1380destroy: 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 1386static void 1387g_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 1411static void 1412g_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 1458static void 1459g_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 1495static void 1496g_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 1532DECLARE_GEOM_CLASS(g_multipath_class, g_multipath); 1533