sys/geom/linux_lvm/g_linux_lvm.c

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