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