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