The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/geom/linux_lvm/g_linux_lvm.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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: releng/8.3/sys/geom/linux_lvm/g_linux_lvm.c 194924 2009-06-24 22:09:30Z lulf $");
   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);

Cache object: 2c9b9f218723c5a19a93bd1a87162f66


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.