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