1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2008 Andrew Thompson <thompsa@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/ctype.h> 33 #include <sys/param.h> 34 #include <sys/bio.h> 35 #include <sys/kernel.h> 36 #include <sys/limits.h> 37 #include <sys/malloc.h> 38 #include <sys/queue.h> 39 #include <sys/sysctl.h> 40 #include <sys/systm.h> 41 42 #include <geom/geom.h> 43 #include <geom/geom_dbg.h> 44 #include <sys/endian.h> 45 46 #include <geom/linux_lvm/g_linux_lvm.h> 47 48 FEATURE(geom_linux_lvm, "GEOM Linux LVM partitioning support"); 49 50 /* Declare malloc(9) label */ 51 static MALLOC_DEFINE(M_GLLVM, "gllvm", "GEOM_LINUX_LVM Data"); 52 53 /* GEOM class methods */ 54 static g_access_t g_llvm_access; 55 static g_init_t g_llvm_init; 56 static g_orphan_t g_llvm_orphan; 57 static g_orphan_t g_llvm_taste_orphan; 58 static g_start_t g_llvm_start; 59 static g_taste_t g_llvm_taste; 60 static g_ctl_destroy_geom_t g_llvm_destroy_geom; 61 62 static void g_llvm_done(struct bio *); 63 static void g_llvm_remove_disk(struct g_llvm_vg *, struct g_consumer *); 64 static int g_llvm_activate_lv(struct g_llvm_vg *, struct g_llvm_lv *); 65 static int g_llvm_add_disk(struct g_llvm_vg *, struct g_provider *, char *); 66 static void g_llvm_free_vg(struct g_llvm_vg *); 67 static int g_llvm_destroy(struct g_llvm_vg *, int); 68 static int g_llvm_read_label(struct g_consumer *, struct g_llvm_label *); 69 static int g_llvm_read_md(struct g_consumer *, struct g_llvm_metadata *, 70 struct g_llvm_label *); 71 72 static int llvm_label_decode(const u_char *, struct g_llvm_label *, int); 73 static int llvm_md_decode(const u_char *, struct g_llvm_metadata *, 74 struct g_llvm_label *); 75 static int llvm_textconf_decode(u_char *, int, 76 struct g_llvm_metadata *); 77 static int llvm_textconf_decode_pv(char **, char *, struct g_llvm_vg *); 78 static int llvm_textconf_decode_lv(char **, char *, struct g_llvm_vg *); 79 static int llvm_textconf_decode_sg(char **, char *, struct g_llvm_lv *); 80 81 SYSCTL_DECL(_kern_geom); 82 SYSCTL_NODE(_kern_geom, OID_AUTO, linux_lvm, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 83 "GEOM_LINUX_LVM stuff"); 84 static u_int g_llvm_debug = 0; 85 SYSCTL_UINT(_kern_geom_linux_lvm, OID_AUTO, debug, CTLFLAG_RWTUN, &g_llvm_debug, 0, 86 "Debug level"); 87 88 LIST_HEAD(, g_llvm_vg) vg_list; 89 90 /* 91 * Called to notify geom when it's been opened, and for what intent 92 */ 93 static int 94 g_llvm_access(struct g_provider *pp, int dr, int dw, int de) 95 { 96 struct g_consumer *c; 97 struct g_llvm_vg *vg; 98 struct g_geom *gp; 99 int error; 100 101 KASSERT(pp != NULL, ("%s: NULL provider", __func__)); 102 gp = pp->geom; 103 KASSERT(gp != NULL, ("%s: NULL geom", __func__)); 104 vg = gp->softc; 105 106 if (vg == NULL) { 107 /* It seems that .access can be called with negative dr,dw,dx 108 * in this case but I want to check for myself */ 109 G_LLVM_DEBUG(0, "access(%d, %d, %d) for %s", 110 dr, dw, de, pp->name); 111 112 /* This should only happen when geom is withered so 113 * allow only negative requests */ 114 KASSERT(dr <= 0 && dw <= 0 && de <= 0, 115 ("%s: Positive access for %s", __func__, pp->name)); 116 if (pp->acr + dr == 0 && pp->acw + dw == 0 && pp->ace + de == 0) 117 G_LLVM_DEBUG(0, 118 "Device %s definitely destroyed", pp->name); 119 return (0); 120 } 121 122 /* Grab an exclusive bit to propagate on our consumers on first open */ 123 if (pp->acr == 0 && pp->acw == 0 && pp->ace == 0) 124 de++; 125 /* ... drop it on close */ 126 if (pp->acr + dr == 0 && pp->acw + dw == 0 && pp->ace + de == 0) 127 de--; 128 129 error = ENXIO; 130 LIST_FOREACH(c, &gp->consumer, consumer) { 131 KASSERT(c != NULL, ("%s: consumer is NULL", __func__)); 132 error = g_access(c, dr, dw, de); 133 if (error != 0) { 134 struct g_consumer *c2; 135 136 /* Backout earlier changes */ 137 LIST_FOREACH(c2, &gp->consumer, consumer) { 138 if (c2 == c) /* all eariler components fixed */ 139 return (error); 140 g_access(c2, -dr, -dw, -de); 141 } 142 } 143 } 144 145 return (error); 146 } 147 148 /* 149 * Dismantle bio_queue and destroy its components 150 */ 151 static void 152 bioq_dismantle(struct bio_queue_head *bq) 153 { 154 struct bio *b; 155 156 for (b = bioq_first(bq); b != NULL; b = bioq_first(bq)) { 157 bioq_remove(bq, b); 158 g_destroy_bio(b); 159 } 160 } 161 162 /* 163 * GEOM .done handler 164 * Can't use standard handler because one requested IO may 165 * fork into additional data IOs 166 */ 167 static void 168 g_llvm_done(struct bio *b) 169 { 170 struct bio *parent_b; 171 172 parent_b = b->bio_parent; 173 174 if (b->bio_error != 0) { 175 G_LLVM_DEBUG(0, "Error %d for offset=%ju, length=%ju on %s", 176 b->bio_error, b->bio_offset, b->bio_length, 177 b->bio_to->name); 178 if (parent_b->bio_error == 0) 179 parent_b->bio_error = b->bio_error; 180 } 181 182 parent_b->bio_inbed++; 183 parent_b->bio_completed += b->bio_completed; 184 185 if (parent_b->bio_children == parent_b->bio_inbed) { 186 parent_b->bio_completed = parent_b->bio_length; 187 g_io_deliver(parent_b, parent_b->bio_error); 188 } 189 g_destroy_bio(b); 190 } 191 192 static void 193 g_llvm_start(struct bio *bp) 194 { 195 struct g_provider *pp; 196 struct g_llvm_vg *vg; 197 struct g_llvm_pv *pv; 198 struct g_llvm_lv *lv; 199 struct g_llvm_segment *sg; 200 struct bio *cb; 201 struct bio_queue_head bq; 202 size_t chunk_size; 203 off_t offset, length; 204 char *addr; 205 u_int count; 206 207 pp = bp->bio_to; 208 lv = pp->private; 209 vg = pp->geom->softc; 210 211 switch (bp->bio_cmd) { 212 case BIO_READ: 213 case BIO_WRITE: 214 case BIO_DELETE: 215 /* XXX BIO_GETATTR allowed? */ 216 break; 217 default: 218 /* 219 * BIO_SPEEDUP and BIO_FLUSH should pass through to all sg 220 * elements, but aren't. 221 */ 222 g_io_deliver(bp, EOPNOTSUPP); 223 return; 224 } 225 226 bioq_init(&bq); 227 228 chunk_size = vg->vg_extentsize; 229 addr = bp->bio_data; 230 offset = bp->bio_offset; /* virtual offset and length */ 231 length = bp->bio_length; 232 233 while (length > 0) { 234 size_t chunk_index, in_chunk_offset, in_chunk_length; 235 236 pv = NULL; 237 cb = g_clone_bio(bp); 238 if (cb == NULL) { 239 bioq_dismantle(&bq); 240 if (bp->bio_error == 0) 241 bp->bio_error = ENOMEM; 242 g_io_deliver(bp, bp->bio_error); 243 return; 244 } 245 246 /* get the segment and the pv */ 247 if (lv->lv_sgcount == 1) { 248 /* skip much of the calculations for a single sg */ 249 chunk_index = 0; 250 in_chunk_offset = 0; 251 in_chunk_length = length; 252 sg = lv->lv_firstsg; 253 pv = sg->sg_pv; 254 cb->bio_offset = offset + sg->sg_pvoffset; 255 } else { 256 chunk_index = offset / chunk_size; /* round downwards */ 257 in_chunk_offset = offset % chunk_size; 258 in_chunk_length = 259 min(length, chunk_size - in_chunk_offset); 260 261 /* XXX could be faster */ 262 LIST_FOREACH(sg, &lv->lv_segs, sg_next) { 263 if (chunk_index >= sg->sg_start && 264 chunk_index <= sg->sg_end) { 265 /* adjust chunk index for sg start */ 266 chunk_index -= sg->sg_start; 267 pv = sg->sg_pv; 268 break; 269 } 270 } 271 cb->bio_offset = 272 (off_t)chunk_index * (off_t)chunk_size 273 + in_chunk_offset + sg->sg_pvoffset; 274 } 275 276 KASSERT(pv != NULL, ("Can't find PV for chunk %zu", 277 chunk_index)); 278 279 cb->bio_to = pv->pv_gprov; 280 cb->bio_done = g_llvm_done; 281 cb->bio_length = in_chunk_length; 282 cb->bio_data = addr; 283 cb->bio_caller1 = pv; 284 bioq_disksort(&bq, cb); 285 286 G_LLVM_DEBUG(5, 287 "Mapped %s(%ju, %ju) on %s to %zu(%zu,%zu) @ %s:%ju", 288 bp->bio_cmd == BIO_READ ? "R" : "W", 289 offset, length, lv->lv_name, 290 chunk_index, in_chunk_offset, in_chunk_length, 291 pv->pv_name, cb->bio_offset); 292 293 addr += in_chunk_length; 294 length -= in_chunk_length; 295 offset += in_chunk_length; 296 } 297 298 /* Fire off bio's here */ 299 count = 0; 300 for (cb = bioq_first(&bq); cb != NULL; cb = bioq_first(&bq)) { 301 bioq_remove(&bq, cb); 302 pv = cb->bio_caller1; 303 cb->bio_caller1 = NULL; 304 G_LLVM_DEBUG(6, "firing bio to %s, offset=%ju, length=%ju", 305 cb->bio_to->name, cb->bio_offset, cb->bio_length); 306 g_io_request(cb, pv->pv_gcons); 307 count++; 308 } 309 if (count == 0) { /* We handled everything locally */ 310 bp->bio_completed = bp->bio_length; 311 g_io_deliver(bp, 0); 312 } 313 } 314 315 static void 316 g_llvm_remove_disk(struct g_llvm_vg *vg, struct g_consumer *cp) 317 { 318 struct g_llvm_pv *pv; 319 struct g_llvm_lv *lv; 320 struct g_llvm_segment *sg; 321 int found; 322 323 KASSERT(cp != NULL, ("Non-valid disk in %s.", __func__)); 324 pv = (struct g_llvm_pv *)cp->private; 325 326 G_LLVM_DEBUG(0, "Disk %s removed from %s.", cp->provider->name, 327 pv->pv_name); 328 329 LIST_FOREACH(lv, &vg->vg_lvs, lv_next) { 330 /* Find segments that map to this disk */ 331 found = 0; 332 LIST_FOREACH(sg, &lv->lv_segs, sg_next) { 333 if (sg->sg_pv == pv) { 334 sg->sg_pv = NULL; 335 lv->lv_sgactive--; 336 found = 1; 337 break; 338 } 339 } 340 if (found) { 341 G_LLVM_DEBUG(0, "Device %s removed.", 342 lv->lv_gprov->name); 343 g_wither_provider(lv->lv_gprov, ENXIO); 344 lv->lv_gprov = NULL; 345 } 346 } 347 348 if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0) 349 g_access(cp, -cp->acr, -cp->acw, -cp->ace); 350 g_detach(cp); 351 g_destroy_consumer(cp); 352 } 353 354 static void 355 g_llvm_orphan(struct g_consumer *cp) 356 { 357 struct g_llvm_vg *vg; 358 struct g_geom *gp; 359 360 g_topology_assert(); 361 gp = cp->geom; 362 vg = gp->softc; 363 if (vg == NULL) 364 return; 365 366 g_llvm_remove_disk(vg, cp); 367 g_llvm_destroy(vg, 1); 368 } 369 370 static int 371 g_llvm_activate_lv(struct g_llvm_vg *vg, struct g_llvm_lv *lv) 372 { 373 struct g_geom *gp; 374 struct g_provider *pp; 375 376 g_topology_assert(); 377 378 KASSERT(lv->lv_sgactive == lv->lv_sgcount, ("segment missing")); 379 380 gp = vg->vg_geom; 381 pp = g_new_providerf(gp, "linux_lvm/%s-%s", vg->vg_name, lv->lv_name); 382 pp->mediasize = vg->vg_extentsize * (off_t)lv->lv_extentcount; 383 pp->sectorsize = vg->vg_sectorsize; 384 g_error_provider(pp, 0); 385 lv->lv_gprov = pp; 386 pp->private = lv; 387 388 G_LLVM_DEBUG(1, "Created %s, %juM", pp->name, 389 pp->mediasize / (1024*1024)); 390 391 return (0); 392 } 393 394 static int 395 g_llvm_add_disk(struct g_llvm_vg *vg, struct g_provider *pp, char *uuid) 396 { 397 struct g_geom *gp; 398 struct g_consumer *cp, *fcp; 399 struct g_llvm_pv *pv; 400 struct g_llvm_lv *lv; 401 struct g_llvm_segment *sg; 402 int error; 403 404 g_topology_assert(); 405 406 LIST_FOREACH(pv, &vg->vg_pvs, pv_next) { 407 if (strcmp(pv->pv_uuid, uuid) == 0) 408 break; /* found it */ 409 } 410 if (pv == NULL) { 411 G_LLVM_DEBUG(3, "uuid %s not found in pv list", uuid); 412 return (ENOENT); 413 } 414 if (pv->pv_gprov != NULL) { 415 G_LLVM_DEBUG(0, "disk %s already initialised in %s", 416 pv->pv_name, vg->vg_name); 417 return (EEXIST); 418 } 419 420 pv->pv_start *= vg->vg_sectorsize; 421 gp = vg->vg_geom; 422 fcp = LIST_FIRST(&gp->consumer); 423 424 cp = g_new_consumer(gp); 425 error = g_attach(cp, pp); 426 G_LLVM_DEBUG(1, "Attached %s to %s at offset %ju", 427 pp->name, pv->pv_name, pv->pv_start); 428 429 if (error != 0) { 430 G_LLVM_DEBUG(0, "cannot attach %s to %s", 431 pp->name, vg->vg_name); 432 g_destroy_consumer(cp); 433 return (error); 434 } 435 436 if (fcp != NULL) { 437 if (fcp->provider->sectorsize != pp->sectorsize) { 438 G_LLVM_DEBUG(0, "Provider %s of %s has invalid " 439 "sector size (%d)", pp->name, vg->vg_name, 440 pp->sectorsize); 441 return (EINVAL); 442 } 443 if (fcp->acr > 0 || fcp->acw || fcp->ace > 0) { 444 /* Replicate access permissions from first "live" 445 * consumer to the new one */ 446 error = g_access(cp, fcp->acr, fcp->acw, fcp->ace); 447 if (error != 0) { 448 g_detach(cp); 449 g_destroy_consumer(cp); 450 return (error); 451 } 452 } 453 } 454 455 cp->private = pv; 456 pv->pv_gcons = cp; 457 pv->pv_gprov = pp; 458 459 LIST_FOREACH(lv, &vg->vg_lvs, lv_next) { 460 /* Find segments that map to this disk */ 461 LIST_FOREACH(sg, &lv->lv_segs, sg_next) { 462 if (strcmp(sg->sg_pvname, pv->pv_name) == 0) { 463 /* avtivate the segment */ 464 KASSERT(sg->sg_pv == NULL, 465 ("segment already mapped")); 466 sg->sg_pvoffset = 467 (off_t)sg->sg_pvstart * vg->vg_extentsize 468 + pv->pv_start; 469 sg->sg_pv = pv; 470 lv->lv_sgactive++; 471 472 G_LLVM_DEBUG(2, "%s: %d to %d @ %s:%d" 473 " offset %ju sector %ju", 474 lv->lv_name, sg->sg_start, sg->sg_end, 475 sg->sg_pvname, sg->sg_pvstart, 476 sg->sg_pvoffset, 477 sg->sg_pvoffset / vg->vg_sectorsize); 478 } 479 } 480 /* Activate any lvs waiting on this disk */ 481 if (lv->lv_gprov == NULL && lv->lv_sgactive == lv->lv_sgcount) { 482 error = g_llvm_activate_lv(vg, lv); 483 if (error) 484 break; 485 } 486 } 487 return (error); 488 } 489 490 static void 491 g_llvm_init(struct g_class *mp) 492 { 493 LIST_INIT(&vg_list); 494 } 495 496 static void 497 g_llvm_free_vg(struct g_llvm_vg *vg) 498 { 499 struct g_llvm_pv *pv; 500 struct g_llvm_lv *lv; 501 struct g_llvm_segment *sg; 502 503 /* Free all the structures */ 504 while ((pv = LIST_FIRST(&vg->vg_pvs)) != NULL) { 505 LIST_REMOVE(pv, pv_next); 506 free(pv, M_GLLVM); 507 } 508 while ((lv = LIST_FIRST(&vg->vg_lvs)) != NULL) { 509 while ((sg = LIST_FIRST(&lv->lv_segs)) != NULL) { 510 LIST_REMOVE(sg, sg_next); 511 free(sg, M_GLLVM); 512 } 513 LIST_REMOVE(lv, lv_next); 514 free(lv, M_GLLVM); 515 } 516 LIST_REMOVE(vg, vg_next); 517 free(vg, M_GLLVM); 518 } 519 520 static void 521 g_llvm_taste_orphan(struct g_consumer *cp) 522 { 523 524 KASSERT(1 == 0, ("%s called while tasting %s.", __func__, 525 cp->provider->name)); 526 } 527 528 static struct g_geom * 529 g_llvm_taste(struct g_class *mp, struct g_provider *pp, int flags __unused) 530 { 531 struct g_consumer *cp; 532 struct g_geom *gp; 533 struct g_llvm_label ll; 534 struct g_llvm_metadata md; 535 struct g_llvm_vg *vg; 536 int error; 537 538 bzero(&md, sizeof(md)); 539 540 g_topology_assert(); 541 g_trace(G_T_TOPOLOGY, "%s(%s, %s)", __func__, mp->name, pp->name); 542 gp = g_new_geomf(mp, "linux_lvm:taste"); 543 /* This orphan function should be never called. */ 544 gp->orphan = g_llvm_taste_orphan; 545 cp = g_new_consumer(gp); 546 cp->flags |= G_CF_DIRECT_SEND | G_CF_DIRECT_RECEIVE; 547 error = g_attach(cp, pp); 548 if (error == 0) { 549 error = g_llvm_read_label(cp, &ll); 550 if (error == 0) 551 error = g_llvm_read_md(cp, &md, &ll); 552 g_detach(cp); 553 } 554 g_destroy_consumer(cp); 555 g_destroy_geom(gp); 556 if (error != 0) 557 return (NULL); 558 559 vg = md.md_vg; 560 if (vg->vg_geom == NULL) { 561 /* new volume group */ 562 gp = g_new_geomf(mp, "%s", vg->vg_name); 563 gp->start = g_llvm_start; 564 gp->spoiled = g_llvm_orphan; 565 gp->orphan = g_llvm_orphan; 566 gp->access = g_llvm_access; 567 vg->vg_sectorsize = pp->sectorsize; 568 vg->vg_extentsize *= vg->vg_sectorsize; 569 vg->vg_geom = gp; 570 gp->softc = vg; 571 G_LLVM_DEBUG(1, "Created volume %s, extent size %zuK", 572 vg->vg_name, vg->vg_extentsize / 1024); 573 } 574 575 /* initialise this disk in the volume group */ 576 g_llvm_add_disk(vg, pp, ll.ll_uuid); 577 return (vg->vg_geom); 578 } 579 580 static int 581 g_llvm_destroy(struct g_llvm_vg *vg, int force) 582 { 583 struct g_provider *pp; 584 struct g_geom *gp; 585 586 g_topology_assert(); 587 if (vg == NULL) 588 return (ENXIO); 589 gp = vg->vg_geom; 590 591 LIST_FOREACH(pp, &gp->provider, provider) { 592 if (pp->acr != 0 || pp->acw != 0 || pp->ace != 0) { 593 G_LLVM_DEBUG(1, "Device %s is still open (r%dw%de%d)", 594 pp->name, pp->acr, pp->acw, pp->ace); 595 if (!force) 596 return (EBUSY); 597 } 598 } 599 600 g_llvm_free_vg(gp->softc); 601 gp->softc = NULL; 602 g_wither_geom(gp, ENXIO); 603 return (0); 604 } 605 606 static int 607 g_llvm_destroy_geom(struct gctl_req *req __unused, struct g_class *mp __unused, 608 struct g_geom *gp) 609 { 610 struct g_llvm_vg *vg; 611 612 vg = gp->softc; 613 return (g_llvm_destroy(vg, 0)); 614 } 615 616 int 617 g_llvm_read_label(struct g_consumer *cp, struct g_llvm_label *ll) 618 { 619 struct g_provider *pp; 620 u_char *buf; 621 int i, error = 0; 622 623 g_topology_assert(); 624 625 /* The LVM label is stored on the first four sectors */ 626 error = g_access(cp, 1, 0, 0); 627 if (error != 0) 628 return (error); 629 pp = cp->provider; 630 g_topology_unlock(); 631 buf = g_read_data(cp, 0, pp->sectorsize * 4, &error); 632 g_topology_lock(); 633 g_access(cp, -1, 0, 0); 634 if (buf == NULL) { 635 G_LLVM_DEBUG(1, "Cannot read metadata from %s (error=%d)", 636 pp->name, error); 637 return (error); 638 } 639 640 /* Search the four sectors for the LVM label. */ 641 for (i = 0; i < 4; i++) { 642 error = llvm_label_decode(&buf[i * pp->sectorsize], ll, i); 643 if (error == 0) 644 break; /* found it */ 645 } 646 g_free(buf); 647 return (error); 648 } 649 650 int 651 g_llvm_read_md(struct g_consumer *cp, struct g_llvm_metadata *md, 652 struct g_llvm_label *ll) 653 { 654 struct g_provider *pp; 655 u_char *buf; 656 int error; 657 int size; 658 659 g_topology_assert(); 660 661 error = g_access(cp, 1, 0, 0); 662 if (error != 0) 663 return (error); 664 pp = cp->provider; 665 g_topology_unlock(); 666 buf = g_read_data(cp, ll->ll_md_offset, pp->sectorsize, &error); 667 g_topology_lock(); 668 g_access(cp, -1, 0, 0); 669 if (buf == NULL) { 670 G_LLVM_DEBUG(0, "Cannot read metadata from %s (error=%d)", 671 cp->provider->name, error); 672 return (error); 673 } 674 675 error = llvm_md_decode(buf, md, ll); 676 g_free(buf); 677 if (error != 0) { 678 return (error); 679 } 680 681 G_LLVM_DEBUG(1, "reading LVM2 config @ %s:%ju", pp->name, 682 ll->ll_md_offset + md->md_reloffset); 683 error = g_access(cp, 1, 0, 0); 684 if (error != 0) 685 return (error); 686 pp = cp->provider; 687 g_topology_unlock(); 688 /* round up to the nearest sector */ 689 size = md->md_relsize + 690 (pp->sectorsize - md->md_relsize % pp->sectorsize); 691 buf = g_read_data(cp, ll->ll_md_offset + md->md_reloffset, size, &error); 692 g_topology_lock(); 693 g_access(cp, -1, 0, 0); 694 if (buf == NULL) { 695 G_LLVM_DEBUG(0, "Cannot read LVM2 config from %s (error=%d)", 696 pp->name, error); 697 return (error); 698 } 699 buf[md->md_relsize] = '\0'; 700 G_LLVM_DEBUG(10, "LVM config:\n%s\n", buf); 701 error = llvm_textconf_decode(buf, md->md_relsize, md); 702 g_free(buf); 703 704 return (error); 705 } 706 707 static int 708 llvm_label_decode(const u_char *data, struct g_llvm_label *ll, int sector) 709 { 710 uint64_t off; 711 char *uuid; 712 713 /* Magic string */ 714 if (bcmp("LABELONE", data , 8) != 0) 715 return (EINVAL); 716 717 /* We only support LVM2 text format */ 718 if (bcmp("LVM2 001", data + 24, 8) != 0) { 719 G_LLVM_DEBUG(0, "Unsupported LVM format"); 720 return (EINVAL); 721 } 722 723 ll->ll_sector = le64dec(data + 8); 724 ll->ll_crc = le32dec(data + 16); 725 ll->ll_offset = le32dec(data + 20); 726 727 if (ll->ll_sector != sector) { 728 G_LLVM_DEBUG(0, "Expected sector %ju, found at %d", 729 ll->ll_sector, sector); 730 return (EINVAL); 731 } 732 733 off = ll->ll_offset; 734 /* 735 * convert the binary uuid to string format, the format is 736 * xxxxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxxxx (6-4-4-4-4-4-6) 737 */ 738 uuid = ll->ll_uuid; 739 bcopy(data + off, uuid, 6); 740 off += 6; 741 uuid += 6; 742 *uuid++ = '-'; 743 for (int i = 0; i < 5; i++) { 744 bcopy(data + off, uuid, 4); 745 off += 4; 746 uuid += 4; 747 *uuid++ = '-'; 748 } 749 bcopy(data + off, uuid, 6); 750 off += 6; 751 uuid += 6; 752 *uuid++ = '\0'; 753 754 ll->ll_size = le64dec(data + off); 755 off += 8; 756 ll->ll_pestart = le64dec(data + off); 757 off += 16; 758 759 /* Only one data section is supported */ 760 if (le64dec(data + off) != 0) { 761 G_LLVM_DEBUG(0, "Only one data section supported"); 762 return (EINVAL); 763 } 764 765 off += 16; 766 ll->ll_md_offset = le64dec(data + off); 767 off += 8; 768 ll->ll_md_size = le64dec(data + off); 769 off += 8; 770 771 G_LLVM_DEBUG(1, "LVM metadata: offset=%ju, size=%ju", ll->ll_md_offset, 772 ll->ll_md_size); 773 774 /* Only one data section is supported */ 775 if (le64dec(data + off) != 0) { 776 G_LLVM_DEBUG(0, "Only one metadata section supported"); 777 return (EINVAL); 778 } 779 780 G_LLVM_DEBUG(2, "label uuid=%s", ll->ll_uuid); 781 G_LLVM_DEBUG(2, "sector=%ju, crc=%u, offset=%u, size=%ju, pestart=%ju", 782 ll->ll_sector, ll->ll_crc, ll->ll_offset, ll->ll_size, 783 ll->ll_pestart); 784 785 return (0); 786 } 787 788 static int 789 llvm_md_decode(const u_char *data, struct g_llvm_metadata *md, 790 struct g_llvm_label *ll) 791 { 792 uint64_t off; 793 char magic[16]; 794 795 off = 0; 796 md->md_csum = le32dec(data + off); 797 off += 4; 798 bcopy(data + off, magic, 16); 799 off += 16; 800 md->md_version = le32dec(data + off); 801 off += 4; 802 md->md_start = le64dec(data + off); 803 off += 8; 804 md->md_size = le64dec(data + off); 805 off += 8; 806 807 if (bcmp(G_LLVM_MAGIC, magic, 16) != 0) { 808 G_LLVM_DEBUG(0, "Incorrect md magic number"); 809 return (EINVAL); 810 } 811 if (md->md_version != 1) { 812 G_LLVM_DEBUG(0, "Incorrect md version number (%u)", 813 md->md_version); 814 return (EINVAL); 815 } 816 if (md->md_start != ll->ll_md_offset) { 817 G_LLVM_DEBUG(0, "Incorrect md offset (%ju)", md->md_start); 818 return (EINVAL); 819 } 820 821 /* Aparently only one is ever returned */ 822 md->md_reloffset = le64dec(data + off); 823 off += 8; 824 md->md_relsize = le64dec(data + off); 825 off += 16; /* XXX skipped checksum */ 826 827 if (le64dec(data + off) != 0) { 828 G_LLVM_DEBUG(0, "Only one reloc supported"); 829 return (EINVAL); 830 } 831 832 G_LLVM_DEBUG(3, "reloc: offset=%ju, size=%ju", 833 md->md_reloffset, md->md_relsize); 834 G_LLVM_DEBUG(3, "md: version=%u, start=%ju, size=%ju", 835 md->md_version, md->md_start, md->md_size); 836 837 return (0); 838 } 839 840 #define GRAB_INT(key, tok1, tok2, v) \ 841 if (tok1 && tok2 && strncmp(tok1, key, sizeof(key)) == 0) { \ 842 v = strtol(tok2, &tok1, 10); \ 843 if (tok1 == tok2) \ 844 /* strtol did not eat any of the buffer */ \ 845 goto bad; \ 846 continue; \ 847 } 848 849 #define GRAB_STR(key, tok1, tok2, v, len) \ 850 if (tok1 && tok2 && strncmp(tok1, key, sizeof(key)) == 0) { \ 851 strsep(&tok2, "\""); \ 852 if (tok2 == NULL) \ 853 continue; \ 854 tok1 = strsep(&tok2, "\""); \ 855 if (tok2 == NULL) \ 856 continue; \ 857 strncpy(v, tok1, len); \ 858 continue; \ 859 } 860 861 #define SPLIT(key, value, str) \ 862 key = strsep(&value, str); \ 863 /* strip trailing whitespace on the key */ \ 864 for (char *t = key; *t != '\0'; t++) \ 865 if (isspace(*t)) { \ 866 *t = '\0'; \ 867 break; \ 868 } 869 870 static size_t 871 llvm_grab_name(char *name, const char *tok) 872 { 873 size_t len; 874 875 len = 0; 876 if (tok == NULL) 877 return (0); 878 if (tok[0] == '-') 879 return (0); 880 if (strcmp(tok, ".") == 0 || strcmp(tok, "..") == 0) 881 return (0); 882 while (tok[len] && (isalpha(tok[len]) || isdigit(tok[len]) || 883 tok[len] == '.' || tok[len] == '_' || tok[len] == '-' || 884 tok[len] == '+') && len < G_LLVM_NAMELEN - 1) 885 len++; 886 bcopy(tok, name, len); 887 name[len] = '\0'; 888 return (len); 889 } 890 891 static int 892 llvm_textconf_decode(u_char *data, int buflen, struct g_llvm_metadata *md) 893 { 894 struct g_llvm_vg *vg; 895 char *buf = data; 896 char *tok, *v; 897 char name[G_LLVM_NAMELEN]; 898 char uuid[G_LLVM_UUIDLEN]; 899 size_t len; 900 901 if (buf == NULL || *buf == '\0') 902 return (EINVAL); 903 904 tok = strsep(&buf, "\n"); 905 if (tok == NULL) 906 return (EINVAL); 907 len = llvm_grab_name(name, tok); 908 if (len == 0) 909 return (EINVAL); 910 911 /* check too see if the vg has already been loaded off another disk */ 912 LIST_FOREACH(vg, &vg_list, vg_next) { 913 if (strcmp(vg->vg_name, name) == 0) { 914 uuid[0] = '\0'; 915 /* grab the volume group uuid */ 916 while ((tok = strsep(&buf, "\n")) != NULL) { 917 if (strstr(tok, "{")) 918 break; 919 if (strstr(tok, "=")) { 920 SPLIT(v, tok, "="); 921 GRAB_STR("id", v, tok, uuid, 922 sizeof(uuid)); 923 } 924 } 925 if (strcmp(vg->vg_uuid, uuid) == 0) { 926 /* existing vg */ 927 md->md_vg = vg; 928 return (0); 929 } 930 /* XXX different volume group with name clash! */ 931 G_LLVM_DEBUG(0, 932 "%s already exists, volume group not loaded", name); 933 return (EINVAL); 934 } 935 } 936 937 vg = malloc(sizeof(*vg), M_GLLVM, M_NOWAIT|M_ZERO); 938 if (vg == NULL) 939 return (ENOMEM); 940 941 strncpy(vg->vg_name, name, sizeof(vg->vg_name)); 942 LIST_INIT(&vg->vg_pvs); 943 LIST_INIT(&vg->vg_lvs); 944 945 #define VOL_FOREACH(func, tok, buf, p) \ 946 while ((tok = strsep(buf, "\n")) != NULL) { \ 947 if (strstr(tok, "{")) { \ 948 func(buf, tok, p); \ 949 continue; \ 950 } \ 951 if (strstr(tok, "}")) \ 952 break; \ 953 } 954 955 while ((tok = strsep(&buf, "\n")) != NULL) { 956 if (strcmp(tok, "physical_volumes {") == 0) { 957 VOL_FOREACH(llvm_textconf_decode_pv, tok, &buf, vg); 958 continue; 959 } 960 if (strcmp(tok, "logical_volumes {") == 0) { 961 VOL_FOREACH(llvm_textconf_decode_lv, tok, &buf, vg); 962 continue; 963 } 964 if (strstr(tok, "{")) { 965 G_LLVM_DEBUG(2, "unknown section %s", tok); 966 continue; 967 } 968 969 /* parse 'key = value' lines */ 970 if (strstr(tok, "=")) { 971 SPLIT(v, tok, "="); 972 GRAB_STR("id", v, tok, vg->vg_uuid, sizeof(vg->vg_uuid)); 973 GRAB_INT("extent_size", v, tok, vg->vg_extentsize); 974 continue; 975 } 976 } 977 /* basic checking */ 978 if (vg->vg_extentsize == 0) 979 goto bad; 980 981 md->md_vg = vg; 982 LIST_INSERT_HEAD(&vg_list, vg, vg_next); 983 G_LLVM_DEBUG(3, "vg: name=%s uuid=%s", vg->vg_name, vg->vg_uuid); 984 return(0); 985 986 bad: 987 g_llvm_free_vg(vg); 988 return (-1); 989 } 990 #undef VOL_FOREACH 991 992 static int 993 llvm_textconf_decode_pv(char **buf, char *tok, struct g_llvm_vg *vg) 994 { 995 struct g_llvm_pv *pv; 996 char *v; 997 size_t len; 998 999 if (*buf == NULL || **buf == '\0') 1000 return (EINVAL); 1001 1002 pv = malloc(sizeof(*pv), M_GLLVM, M_NOWAIT|M_ZERO); 1003 if (pv == NULL) 1004 return (ENOMEM); 1005 1006 pv->pv_vg = vg; 1007 len = 0; 1008 if (tok == NULL) 1009 goto bad; 1010 len = llvm_grab_name(pv->pv_name, tok); 1011 if (len == 0) 1012 goto bad; 1013 1014 while ((tok = strsep(buf, "\n")) != NULL) { 1015 if (strstr(tok, "{")) 1016 goto bad; 1017 1018 if (strstr(tok, "}")) 1019 break; 1020 1021 /* parse 'key = value' lines */ 1022 if (strstr(tok, "=")) { 1023 SPLIT(v, tok, "="); 1024 GRAB_STR("id", v, tok, pv->pv_uuid, sizeof(pv->pv_uuid)); 1025 GRAB_INT("pe_start", v, tok, pv->pv_start); 1026 GRAB_INT("pe_count", v, tok, pv->pv_count); 1027 continue; 1028 } 1029 } 1030 if (tok == NULL) 1031 goto bad; 1032 /* basic checking */ 1033 if (pv->pv_count == 0) 1034 goto bad; 1035 1036 LIST_INSERT_HEAD(&vg->vg_pvs, pv, pv_next); 1037 G_LLVM_DEBUG(3, "pv: name=%s uuid=%s", pv->pv_name, pv->pv_uuid); 1038 1039 return (0); 1040 bad: 1041 free(pv, M_GLLVM); 1042 return (-1); 1043 } 1044 1045 static int 1046 llvm_textconf_decode_lv(char **buf, char *tok, struct g_llvm_vg *vg) 1047 { 1048 struct g_llvm_lv *lv; 1049 struct g_llvm_segment *sg; 1050 char *v; 1051 size_t len; 1052 1053 if (*buf == NULL || **buf == '\0') 1054 return (EINVAL); 1055 1056 lv = malloc(sizeof(*lv), M_GLLVM, M_NOWAIT|M_ZERO); 1057 if (lv == NULL) 1058 return (ENOMEM); 1059 1060 lv->lv_vg = vg; 1061 LIST_INIT(&lv->lv_segs); 1062 1063 if (tok == NULL) 1064 goto bad; 1065 len = llvm_grab_name(lv->lv_name, tok); 1066 if (len == 0) 1067 goto bad; 1068 1069 while ((tok = strsep(buf, "\n")) != NULL) { 1070 if (strstr(tok, "{")) { 1071 if (strstr(tok, "segment")) { 1072 llvm_textconf_decode_sg(buf, tok, lv); 1073 continue; 1074 } else 1075 /* unexpected section */ 1076 goto bad; 1077 } 1078 1079 if (strstr(tok, "}")) 1080 break; 1081 1082 /* parse 'key = value' lines */ 1083 if (strstr(tok, "=")) { 1084 SPLIT(v, tok, "="); 1085 GRAB_STR("id", v, tok, lv->lv_uuid, sizeof(lv->lv_uuid)); 1086 GRAB_INT("segment_count", v, tok, lv->lv_sgcount); 1087 continue; 1088 } 1089 } 1090 if (tok == NULL) 1091 goto bad; 1092 if (lv->lv_sgcount == 0 || lv->lv_sgcount != lv->lv_numsegs) 1093 /* zero or incomplete segment list */ 1094 goto bad; 1095 1096 /* Optimize for only one segment on the pv */ 1097 lv->lv_firstsg = LIST_FIRST(&lv->lv_segs); 1098 LIST_INSERT_HEAD(&vg->vg_lvs, lv, lv_next); 1099 G_LLVM_DEBUG(3, "lv: name=%s uuid=%s", lv->lv_name, lv->lv_uuid); 1100 1101 return (0); 1102 bad: 1103 while ((sg = LIST_FIRST(&lv->lv_segs)) != NULL) { 1104 LIST_REMOVE(sg, sg_next); 1105 free(sg, M_GLLVM); 1106 } 1107 free(lv, M_GLLVM); 1108 return (-1); 1109 } 1110 1111 static int 1112 llvm_textconf_decode_sg(char **buf, char *tok, struct g_llvm_lv *lv) 1113 { 1114 struct g_llvm_segment *sg; 1115 char *v; 1116 int count = 0; 1117 1118 if (*buf == NULL || **buf == '\0') 1119 return (EINVAL); 1120 1121 sg = malloc(sizeof(*sg), M_GLLVM, M_NOWAIT|M_ZERO); 1122 if (sg == NULL) 1123 return (ENOMEM); 1124 1125 while ((tok = strsep(buf, "\n")) != NULL) { 1126 /* only a single linear stripe is supported */ 1127 if (strstr(tok, "stripe_count")) { 1128 SPLIT(v, tok, "="); 1129 GRAB_INT("stripe_count", v, tok, count); 1130 if (count != 1) 1131 goto bad; 1132 } 1133 1134 if (strstr(tok, "{")) 1135 goto bad; 1136 1137 if (strstr(tok, "}")) 1138 break; 1139 1140 if (strcmp(tok, "stripes = [") == 0) { 1141 tok = strsep(buf, "\n"); 1142 if (tok == NULL) 1143 goto bad; 1144 1145 strsep(&tok, "\""); 1146 if (tok == NULL) 1147 goto bad; /* missing open quotes */ 1148 v = strsep(&tok, "\""); 1149 if (tok == NULL) 1150 goto bad; /* missing close quotes */ 1151 strncpy(sg->sg_pvname, v, sizeof(sg->sg_pvname)); 1152 if (*tok != ',') 1153 goto bad; /* missing comma for stripe */ 1154 tok++; 1155 1156 sg->sg_pvstart = strtol(tok, &v, 10); 1157 if (v == tok) 1158 /* strtol did not eat any of the buffer */ 1159 goto bad; 1160 1161 continue; 1162 } 1163 1164 /* parse 'key = value' lines */ 1165 if (strstr(tok, "=")) { 1166 SPLIT(v, tok, "="); 1167 GRAB_INT("start_extent", v, tok, sg->sg_start); 1168 GRAB_INT("extent_count", v, tok, sg->sg_count); 1169 continue; 1170 } 1171 } 1172 if (tok == NULL) 1173 goto bad; 1174 /* basic checking */ 1175 if (count != 1 || sg->sg_count == 0) 1176 goto bad; 1177 1178 sg->sg_end = sg->sg_start + sg->sg_count - 1; 1179 lv->lv_numsegs++; 1180 lv->lv_extentcount += sg->sg_count; 1181 LIST_INSERT_HEAD(&lv->lv_segs, sg, sg_next); 1182 1183 return (0); 1184 bad: 1185 free(sg, M_GLLVM); 1186 return (-1); 1187 } 1188 #undef GRAB_INT 1189 #undef GRAB_STR 1190 #undef SPLIT 1191 1192 static struct g_class g_llvm_class = { 1193 .name = G_LLVM_CLASS_NAME, 1194 .version = G_VERSION, 1195 .init = g_llvm_init, 1196 .taste = g_llvm_taste, 1197 .destroy_geom = g_llvm_destroy_geom 1198 }; 1199 1200 DECLARE_GEOM_CLASS(g_llvm_class, g_linux_lvm); 1201 MODULE_VERSION(geom_linux_lvm, 0); 1202