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

Cache object: dcc036e2f234f2cb08a46cc8156c52f0


[ 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.