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
|