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