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