1 /* $NetBSD: import_vsn1.c,v 1.1.1.2 2009/12/02 00:26:30 haad Exp $ */
2
3 /*
4 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
5 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
6 *
7 * This file is part of LVM2.
8 *
9 * This copyrighted material is made available to anyone wishing to use,
10 * modify, copy, or redistribute it subject to the terms and conditions
11 * of the GNU Lesser General Public License v.2.1.
12 *
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18 #include "lib.h"
19 #include "metadata.h"
20 #include "import-export.h"
21 #include "display.h"
22 #include "toolcontext.h"
23 #include "lvmcache.h"
24 #include "lv_alloc.h"
25 #include "pv_alloc.h"
26 #include "segtype.h"
27 #include "text_import.h"
28
29 typedef int (*section_fn) (struct format_instance * fid, struct dm_pool * mem,
30 struct volume_group * vg, struct config_node * pvn,
31 struct config_node * vgn,
32 struct dm_hash_table * pv_hash);
33
34 #define _read_int32(root, path, result) \
35 get_config_uint32(root, path, (uint32_t *) result)
36
37 #define _read_uint32(root, path, result) \
38 get_config_uint32(root, path, result)
39
40 #define _read_int64(root, path, result) \
41 get_config_uint64(root, path, result)
42
43 /*
44 * Logs an attempt to read an invalid format file.
45 */
_invalid_format(const char * str)46 static void _invalid_format(const char *str)
47 {
48 log_error("Can't process text format file - %s.", str);
49 }
50
51 /*
52 * Checks that the config file contains vg metadata, and that it
53 * we recognise the version number,
54 */
_check_version(struct config_tree * cft)55 static int _check_version(struct config_tree *cft)
56 {
57 struct config_node *cn;
58 struct config_value *cv;
59
60 /*
61 * Check the contents field.
62 */
63 if (!(cn = find_config_node(cft->root, CONTENTS_FIELD))) {
64 _invalid_format("missing contents field");
65 return 0;
66 }
67
68 cv = cn->v;
69 if (!cv || cv->type != CFG_STRING || strcmp(cv->v.str, CONTENTS_VALUE)) {
70 _invalid_format("unrecognised contents field");
71 return 0;
72 }
73
74 /*
75 * Check the version number.
76 */
77 if (!(cn = find_config_node(cft->root, FORMAT_VERSION_FIELD))) {
78 _invalid_format("missing version number");
79 return 0;
80 }
81
82 cv = cn->v;
83 if (!cv || cv->type != CFG_INT || cv->v.i != FORMAT_VERSION_VALUE) {
84 _invalid_format("unrecognised version number");
85 return 0;
86 }
87
88 return 1;
89 }
90
_is_converting(struct logical_volume * lv)91 static int _is_converting(struct logical_volume *lv)
92 {
93 struct lv_segment *seg;
94
95 if (lv->status & MIRRORED) {
96 seg = first_seg(lv);
97 /* Can't use is_temporary_mirror() because the metadata for
98 * seg_lv may not be read in and flags may not be set yet. */
99 if (seg_type(seg, 0) == AREA_LV &&
100 strstr(seg_lv(seg, 0)->name, MIRROR_SYNC_LAYER))
101 return 1;
102 }
103
104 return 0;
105 }
106
_read_id(struct id * id,struct config_node * cn,const char * path)107 static int _read_id(struct id *id, struct config_node *cn, const char *path)
108 {
109 struct config_value *cv;
110
111 if (!(cn = find_config_node(cn, path))) {
112 log_error("Couldn't find uuid.");
113 return 0;
114 }
115
116 cv = cn->v;
117 if (!cv || !cv->v.str) {
118 log_error("uuid must be a string.");
119 return 0;
120 }
121
122 if (!id_read_format(id, cv->v.str)) {
123 log_error("Invalid uuid.");
124 return 0;
125 }
126
127 return 1;
128 }
129
_read_flag_config(struct config_node * n,uint32_t * status,int type)130 static int _read_flag_config(struct config_node *n, uint32_t *status, int type)
131 {
132 struct config_node *cn;
133 *status = 0;
134
135 if (!(cn = find_config_node(n, "status"))) {
136 log_error("Could not find status flags.");
137 return 0;
138 }
139
140 if (!(read_flags(status, type | STATUS_FLAG, cn->v))) {
141 log_error("Could not read status flags.");
142 return 0;
143 }
144
145 if ((cn = find_config_node(n, "flags"))) {
146 if (!(read_flags(status, type, cn->v))) {
147 log_error("Could not read flags.");
148 return 0;
149 }
150 }
151
152 return 1;
153 }
154
_read_pv(struct format_instance * fid,struct dm_pool * mem,struct volume_group * vg,struct config_node * pvn,struct config_node * vgn __attribute ((unused)),struct dm_hash_table * pv_hash)155 static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
156 struct volume_group *vg, struct config_node *pvn,
157 struct config_node *vgn __attribute((unused)),
158 struct dm_hash_table *pv_hash)
159 {
160 struct physical_volume *pv;
161 struct pv_list *pvl;
162 struct config_node *cn;
163 uint64_t size;
164
165 if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) ||
166 !(pvl->pv = dm_pool_zalloc(mem, sizeof(*pvl->pv))))
167 return_0;
168
169 pv = pvl->pv;
170
171 /*
172 * Add the pv to the pv hash for quick lookup when we read
173 * the lv segments.
174 */
175 if (!dm_hash_insert(pv_hash, pvn->key, pv))
176 return_0;
177
178 if (!(pvn = pvn->child)) {
179 log_error("Empty pv section.");
180 return 0;
181 }
182
183 if (!_read_id(&pv->id, pvn, "id")) {
184 log_error("Couldn't read uuid for physical volume.");
185 return 0;
186 }
187
188 /*
189 * Convert the uuid into a device.
190 */
191 if (!(pv->dev = device_from_pvid(fid->fmt->cmd, &pv->id))) {
192 char buffer[64] __attribute((aligned(8)));
193
194 if (!id_write_format(&pv->id, buffer, sizeof(buffer)))
195 log_error("Couldn't find device.");
196 else
197 log_error("Couldn't find device with uuid '%s'.",
198 buffer);
199 }
200
201 if (!(pv->vg_name = dm_pool_strdup(mem, vg->name)))
202 return_0;
203
204 memcpy(&pv->vgid, &vg->id, sizeof(vg->id));
205
206 if (!_read_flag_config(pvn, &pv->status, PV_FLAGS)) {
207 log_error("Couldn't read status flags for physical volume.");
208 return 0;
209 }
210
211 if (!pv->dev)
212 pv->status |= MISSING_PV;
213
214 /* Late addition */
215 _read_int64(pvn, "dev_size", &pv->size);
216
217 if (!_read_int64(pvn, "pe_start", &pv->pe_start)) {
218 log_error("Couldn't read extent size for physical volume.");
219 return 0;
220 }
221
222 if (!_read_int32(pvn, "pe_count", &pv->pe_count)) {
223 log_error("Couldn't find extent count (pe_count) for "
224 "physical volume.");
225 return 0;
226 }
227
228 dm_list_init(&pv->tags);
229 dm_list_init(&pv->segments);
230
231 /* Optional tags */
232 if ((cn = find_config_node(pvn, "tags")) &&
233 !(read_tags(mem, &pv->tags, cn->v))) {
234 log_error("Couldn't read tags for physical volume %s in %s.",
235 pv_dev_name(pv), vg->name);
236 return 0;
237 }
238
239 /* adjust the volume group. */
240 vg->extent_count += pv->pe_count;
241 vg->free_count += pv->pe_count;
242
243 pv->pe_size = vg->extent_size;
244
245 pv->pe_alloc_count = 0;
246 pv->pe_align = 0;
247 pv->fmt = fid->fmt;
248
249 /* Fix up pv size if missing or impossibly large */
250 if ((!pv->size || pv->size > (1ULL << 62)) && pv->dev) {
251 if (!dev_get_size(pv->dev, &pv->size)) {
252 log_error("%s: Couldn't get size.", pv_dev_name(pv));
253 return 0;
254 }
255 log_verbose("Fixing up missing size (%s) "
256 "for PV %s", display_size(fid->fmt->cmd, pv->size),
257 pv_dev_name(pv));
258 if (vg) {
259 size = pv->pe_count * (uint64_t) vg->extent_size +
260 pv->pe_start;
261 if (size > pv->size)
262 log_error("WARNING: Physical Volume %s is too "
263 "large for underlying device",
264 pv_dev_name(pv));
265 }
266 }
267
268 if (!alloc_pv_segment_whole_pv(mem, pv))
269 return_0;
270
271 vg->pv_count++;
272 dm_list_add(&vg->pvs, &pvl->list);
273
274 return 1;
275 }
276
_insert_segment(struct logical_volume * lv,struct lv_segment * seg)277 static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
278 {
279 struct lv_segment *comp;
280
281 dm_list_iterate_items(comp, &lv->segments) {
282 if (comp->le > seg->le) {
283 dm_list_add(&comp->list, &seg->list);
284 return;
285 }
286 }
287
288 lv->le_count += seg->len;
289 dm_list_add(&lv->segments, &seg->list);
290 }
291
_read_segment(struct dm_pool * mem,struct volume_group * vg,struct logical_volume * lv,struct config_node * sn,struct dm_hash_table * pv_hash)292 static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
293 struct logical_volume *lv, struct config_node *sn,
294 struct dm_hash_table *pv_hash)
295 {
296 uint32_t area_count = 0u;
297 struct lv_segment *seg;
298 struct config_node *cn, *sn_child = sn->child;
299 struct config_value *cv;
300 uint32_t start_extent, extent_count;
301 struct segment_type *segtype;
302 const char *segtype_str;
303
304 if (!sn_child) {
305 log_error("Empty segment section.");
306 return 0;
307 }
308
309 if (!_read_int32(sn_child, "start_extent", &start_extent)) {
310 log_error("Couldn't read 'start_extent' for segment '%s' "
311 "of logical volume %s.", sn->key, lv->name);
312 return 0;
313 }
314
315 if (!_read_int32(sn_child, "extent_count", &extent_count)) {
316 log_error("Couldn't read 'extent_count' for segment '%s' "
317 "of logical volume %s.", sn->key, lv->name);
318 return 0;
319 }
320
321 segtype_str = "striped";
322
323 if ((cn = find_config_node(sn_child, "type"))) {
324 cv = cn->v;
325 if (!cv || !cv->v.str) {
326 log_error("Segment type must be a string.");
327 return 0;
328 }
329 segtype_str = cv->v.str;
330 }
331
332 if (!(segtype = get_segtype_from_string(vg->cmd, segtype_str)))
333 return_0;
334
335 if (segtype->ops->text_import_area_count &&
336 !segtype->ops->text_import_area_count(sn_child, &area_count))
337 return_0;
338
339 if (!(seg = alloc_lv_segment(mem, segtype, lv, start_extent,
340 extent_count, 0, 0, NULL, area_count,
341 extent_count, 0, 0, 0))) {
342 log_error("Segment allocation failed");
343 return 0;
344 }
345
346 if (seg->segtype->ops->text_import &&
347 !seg->segtype->ops->text_import(seg, sn_child, pv_hash))
348 return_0;
349
350 /* Optional tags */
351 if ((cn = find_config_node(sn_child, "tags")) &&
352 !(read_tags(mem, &seg->tags, cn->v))) {
353 log_error("Couldn't read tags for a segment of %s/%s.",
354 vg->name, lv->name);
355 return 0;
356 }
357
358 /*
359 * Insert into correct part of segment list.
360 */
361 _insert_segment(lv, seg);
362
363 if (seg_is_mirrored(seg))
364 lv->status |= MIRRORED;
365
366 if (seg_is_virtual(seg))
367 lv->status |= VIRTUAL;
368
369 if (_is_converting(lv))
370 lv->status |= CONVERTING;
371
372 return 1;
373 }
374
text_import_areas(struct lv_segment * seg,const struct config_node * sn,const struct config_node * cn,struct dm_hash_table * pv_hash,uint32_t flags)375 int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
376 const struct config_node *cn, struct dm_hash_table *pv_hash,
377 uint32_t flags)
378 {
379 unsigned int s;
380 struct config_value *cv;
381 struct logical_volume *lv1;
382 struct physical_volume *pv;
383 const char *seg_name = config_parent_name(sn);
384
385 if (!seg->area_count) {
386 log_error("Zero areas not allowed for segment %s", seg_name);
387 return 0;
388 }
389
390 for (cv = cn->v, s = 0; cv && s < seg->area_count; s++, cv = cv->next) {
391
392 /* first we read the pv */
393 if (cv->type != CFG_STRING) {
394 log_error("Bad volume name in areas array for segment %s.", seg_name);
395 return 0;
396 }
397
398 if (!cv->next) {
399 log_error("Missing offset in areas array for segment %s.", seg_name);
400 return 0;
401 }
402
403 if (cv->next->type != CFG_INT) {
404 log_error("Bad offset in areas array for segment %s.", seg_name);
405 return 0;
406 }
407
408 /* FIXME Cope if LV not yet read in */
409 if ((pv = dm_hash_lookup(pv_hash, cv->v.str))) {
410 if (!set_lv_segment_area_pv(seg, s, pv, (uint32_t) cv->next->v.i))
411 return_0;
412 } else if ((lv1 = find_lv(seg->lv->vg, cv->v.str))) {
413 if (!set_lv_segment_area_lv(seg, s, lv1,
414 (uint32_t) cv->next->v.i,
415 flags))
416 return_0;
417 } else {
418 log_error("Couldn't find volume '%s' "
419 "for segment '%s'.",
420 cv->v.str ? : "NULL", seg_name);
421 return 0;
422 }
423
424 cv = cv->next;
425 }
426
427 /*
428 * Check we read the correct number of stripes.
429 */
430 if (cv || (s < seg->area_count)) {
431 log_error("Incorrect number of areas in area array "
432 "for segment '%s'.", seg_name);
433 return 0;
434 }
435
436 return 1;
437 }
438
_read_segments(struct dm_pool * mem,struct volume_group * vg,struct logical_volume * lv,struct config_node * lvn,struct dm_hash_table * pv_hash)439 static int _read_segments(struct dm_pool *mem, struct volume_group *vg,
440 struct logical_volume *lv, struct config_node *lvn,
441 struct dm_hash_table *pv_hash)
442 {
443 struct config_node *sn;
444 int count = 0, seg_count;
445
446 for (sn = lvn; sn; sn = sn->sib) {
447
448 /*
449 * All sub-sections are assumed to be segments.
450 */
451 if (!sn->v) {
452 if (!_read_segment(mem, vg, lv, sn, pv_hash))
453 return_0;
454
455 count++;
456 }
457 /* FIXME Remove this restriction */
458 if ((lv->status & SNAPSHOT) && count > 1) {
459 log_error("Only one segment permitted for snapshot");
460 return 0;
461 }
462 }
463
464 if (!_read_int32(lvn, "segment_count", &seg_count)) {
465 log_error("Couldn't read segment count for logical volume %s.",
466 lv->name);
467 return 0;
468 }
469
470 if (seg_count != count) {
471 log_error("segment_count and actual number of segments "
472 "disagree for logical volume %s.", lv->name);
473 return 0;
474 }
475
476 /*
477 * Check there are no gaps or overlaps in the lv.
478 */
479 if (!check_lv_segments(lv, 0))
480 return_0;
481
482 /*
483 * Merge segments in case someones been editing things by hand.
484 */
485 if (!lv_merge_segments(lv))
486 return_0;
487
488 return 1;
489 }
490
_read_lvnames(struct format_instance * fid __attribute ((unused)),struct dm_pool * mem,struct volume_group * vg,struct config_node * lvn,struct config_node * vgn __attribute ((unused)),struct dm_hash_table * pv_hash __attribute ((unused)))491 static int _read_lvnames(struct format_instance *fid __attribute((unused)),
492 struct dm_pool *mem,
493 struct volume_group *vg, struct config_node *lvn,
494 struct config_node *vgn __attribute((unused)),
495 struct dm_hash_table *pv_hash __attribute((unused)))
496 {
497 struct logical_volume *lv;
498 struct config_node *cn;
499
500 if (!(lv = alloc_lv(mem)))
501 return_0;
502
503 if (!(lv->name = dm_pool_strdup(mem, lvn->key)))
504 return_0;
505
506 if (!(lvn = lvn->child)) {
507 log_error("Empty logical volume section.");
508 return 0;
509 }
510
511 if (!_read_flag_config(lvn, &lv->status, LV_FLAGS)) {
512 log_error("Couldn't read status flags for logical volume %s.",
513 lv->name);
514 return 0;
515 }
516
517 lv->alloc = ALLOC_INHERIT;
518 if ((cn = find_config_node(lvn, "allocation_policy"))) {
519 struct config_value *cv = cn->v;
520 if (!cv || !cv->v.str) {
521 log_error("allocation_policy must be a string.");
522 return 0;
523 }
524
525 lv->alloc = get_alloc_from_string(cv->v.str);
526 if (lv->alloc == ALLOC_INVALID)
527 return_0;
528 }
529
530 if (!_read_int32(lvn, "read_ahead", &lv->read_ahead))
531 /* If not present, choice of auto or none is configurable */
532 lv->read_ahead = vg->cmd->default_settings.read_ahead;
533 else {
534 switch (lv->read_ahead) {
535 case 0:
536 lv->read_ahead = DM_READ_AHEAD_AUTO;
537 break;
538 case (uint32_t) -1:
539 lv->read_ahead = DM_READ_AHEAD_NONE;
540 break;
541 default:
542 ;
543 }
544 }
545
546 /* Optional tags */
547 if ((cn = find_config_node(lvn, "tags")) &&
548 !(read_tags(mem, &lv->tags, cn->v))) {
549 log_error("Couldn't read tags for logical volume %s/%s.",
550 vg->name, lv->name);
551 return 0;
552 }
553
554 return link_lv_to_vg(vg, lv);
555 }
556
_read_lvsegs(struct format_instance * fid __attribute ((unused)),struct dm_pool * mem,struct volume_group * vg,struct config_node * lvn,struct config_node * vgn __attribute ((unused)),struct dm_hash_table * pv_hash)557 static int _read_lvsegs(struct format_instance *fid __attribute((unused)),
558 struct dm_pool *mem,
559 struct volume_group *vg, struct config_node *lvn,
560 struct config_node *vgn __attribute((unused)),
561 struct dm_hash_table *pv_hash)
562 {
563 struct logical_volume *lv;
564 struct lv_list *lvl;
565
566 if (!(lvl = find_lv_in_vg(vg, lvn->key))) {
567 log_error("Lost logical volume reference %s", lvn->key);
568 return 0;
569 }
570
571 lv = lvl->lv;
572
573 if (!(lvn = lvn->child)) {
574 log_error("Empty logical volume section.");
575 return 0;
576 }
577
578 /* FIXME: read full lvid */
579 if (!_read_id(&lv->lvid.id[1], lvn, "id")) {
580 log_error("Couldn't read uuid for logical volume %s.",
581 lv->name);
582 return 0;
583 }
584
585 memcpy(&lv->lvid.id[0], &lv->vg->id, sizeof(lv->lvid.id[0]));
586
587 if (!_read_segments(mem, vg, lv, lvn, pv_hash))
588 return_0;
589
590 lv->size = (uint64_t) lv->le_count * (uint64_t) vg->extent_size;
591
592 lv->minor = -1;
593 if ((lv->status & FIXED_MINOR) &&
594 !_read_int32(lvn, "minor", &lv->minor)) {
595 log_error("Couldn't read minor number for logical "
596 "volume %s.", lv->name);
597 return 0;
598 }
599
600 lv->major = -1;
601 if ((lv->status & FIXED_MINOR) &&
602 !_read_int32(lvn, "major", &lv->major)) {
603 log_error("Couldn't read major number for logical "
604 "volume %s.", lv->name);
605 }
606
607 return 1;
608 }
609
_read_sections(struct format_instance * fid,const char * section,section_fn fn,struct dm_pool * mem,struct volume_group * vg,struct config_node * vgn,struct dm_hash_table * pv_hash,int optional)610 static int _read_sections(struct format_instance *fid,
611 const char *section, section_fn fn,
612 struct dm_pool *mem,
613 struct volume_group *vg, struct config_node *vgn,
614 struct dm_hash_table *pv_hash, int optional)
615 {
616 struct config_node *n;
617
618 if (!(n = find_config_node(vgn, section))) {
619 if (!optional) {
620 log_error("Couldn't find section '%s'.", section);
621 return 0;
622 }
623
624 return 1;
625 }
626
627 for (n = n->child; n; n = n->sib) {
628 if (!fn(fid, mem, vg, n, vgn, pv_hash))
629 return_0;
630 }
631
632 return 1;
633 }
634
_read_vg(struct format_instance * fid,struct config_tree * cft)635 static struct volume_group *_read_vg(struct format_instance *fid,
636 struct config_tree *cft)
637 {
638 struct config_node *vgn, *cn;
639 struct volume_group *vg;
640 struct dm_hash_table *pv_hash = NULL;
641 struct dm_pool *mem = dm_pool_create("lvm2 vg_read", VG_MEMPOOL_CHUNK);
642
643 if (!mem)
644 return_NULL;
645
646 /* skip any top-level values */
647 for (vgn = cft->root; (vgn && vgn->v); vgn = vgn->sib) ;
648
649 if (!vgn) {
650 log_error("Couldn't find volume group in file.");
651 goto bad;
652 }
653
654 if (!(vg = dm_pool_zalloc(mem, sizeof(*vg))))
655 goto_bad;
656
657 vg->vgmem = mem;
658 vg->cmd = fid->fmt->cmd;
659
660 /* FIXME Determine format type from file contents */
661 /* eg Set to instance of fmt1 here if reading a format1 backup? */
662 vg->fid = fid;
663
664 if (!(vg->name = dm_pool_strdup(mem, vgn->key)))
665 goto_bad;
666
667 if (!(vg->system_id = dm_pool_zalloc(mem, NAME_LEN)))
668 goto_bad;
669
670 vgn = vgn->child;
671
672 if ((cn = find_config_node(vgn, "system_id")) && cn->v) {
673 if (!cn->v->v.str) {
674 log_error("system_id must be a string");
675 goto bad;
676 }
677 strncpy(vg->system_id, cn->v->v.str, NAME_LEN);
678 }
679
680 if (!_read_id(&vg->id, vgn, "id")) {
681 log_error("Couldn't read uuid for volume group %s.", vg->name);
682 goto bad;
683 }
684
685 if (!_read_int32(vgn, "seqno", &vg->seqno)) {
686 log_error("Couldn't read 'seqno' for volume group %s.",
687 vg->name);
688 goto bad;
689 }
690
691 if (!_read_flag_config(vgn, &vg->status, VG_FLAGS)) {
692 log_error("Error reading flags of volume group %s.",
693 vg->name);
694 goto bad;
695 }
696
697 if (!_read_int32(vgn, "extent_size", &vg->extent_size)) {
698 log_error("Couldn't read extent size for volume group %s.",
699 vg->name);
700 goto bad;
701 }
702
703 /*
704 * 'extent_count' and 'free_count' get filled in
705 * implicitly when reading in the pv's and lv's.
706 */
707
708 if (!_read_int32(vgn, "max_lv", &vg->max_lv)) {
709 log_error("Couldn't read 'max_lv' for volume group %s.",
710 vg->name);
711 goto bad;
712 }
713
714 if (!_read_int32(vgn, "max_pv", &vg->max_pv)) {
715 log_error("Couldn't read 'max_pv' for volume group %s.",
716 vg->name);
717 goto bad;
718 }
719
720 vg->alloc = ALLOC_NORMAL;
721 if ((cn = find_config_node(vgn, "allocation_policy"))) {
722 struct config_value *cv = cn->v;
723 if (!cv || !cv->v.str) {
724 log_error("allocation_policy must be a string.");
725 return 0;
726 }
727
728 vg->alloc = get_alloc_from_string(cv->v.str);
729 if (vg->alloc == ALLOC_INVALID)
730 return_0;
731 }
732
733 /*
734 * The pv hash memoises the pv section names -> pv
735 * structures.
736 */
737 if (!(pv_hash = dm_hash_create(32))) {
738 log_error("Couldn't create hash table.");
739 goto bad;
740 }
741
742 dm_list_init(&vg->pvs);
743 if (!_read_sections(fid, "physical_volumes", _read_pv, mem, vg,
744 vgn, pv_hash, 0)) {
745 log_error("Couldn't find all physical volumes for volume "
746 "group %s.", vg->name);
747 goto bad;
748 }
749
750 dm_list_init(&vg->lvs);
751 dm_list_init(&vg->tags);
752 dm_list_init(&vg->removed_pvs);
753
754 /* Optional tags */
755 if ((cn = find_config_node(vgn, "tags")) &&
756 !(read_tags(mem, &vg->tags, cn->v))) {
757 log_error("Couldn't read tags for volume group %s.", vg->name);
758 goto bad;
759 }
760
761 if (!_read_sections(fid, "logical_volumes", _read_lvnames, mem, vg,
762 vgn, pv_hash, 1)) {
763 log_error("Couldn't read all logical volume names for volume "
764 "group %s.", vg->name);
765 goto bad;
766 }
767
768 if (!_read_sections(fid, "logical_volumes", _read_lvsegs, mem, vg,
769 vgn, pv_hash, 1)) {
770 log_error("Couldn't read all logical volumes for "
771 "volume group %s.", vg->name);
772 goto bad;
773 }
774
775 if (!fixup_imported_mirrors(vg)) {
776 log_error("Failed to fixup mirror pointers after import for "
777 "volume group %s.", vg->name);
778 goto bad;
779 }
780
781 dm_hash_destroy(pv_hash);
782
783 /*
784 * Finished.
785 */
786 return vg;
787
788 bad:
789 if (pv_hash)
790 dm_hash_destroy(pv_hash);
791
792 dm_pool_destroy(mem);
793 return NULL;
794 }
795
_read_desc(struct dm_pool * mem,struct config_tree * cft,time_t * when,char ** desc)796 static void _read_desc(struct dm_pool *mem,
797 struct config_tree *cft, time_t *when, char **desc)
798 {
799 const char *d;
800 unsigned int u = 0u;
801 int old_suppress;
802
803 old_suppress = log_suppress(1);
804 d = find_config_str(cft->root, "description", "");
805 log_suppress(old_suppress);
806 *desc = dm_pool_strdup(mem, d);
807
808 get_config_uint32(cft->root, "creation_time", &u);
809 *when = u;
810 }
811
_read_vgname(const struct format_type * fmt,struct config_tree * cft,struct id * vgid,uint32_t * vgstatus,char ** creation_host)812 static const char *_read_vgname(const struct format_type *fmt,
813 struct config_tree *cft, struct id *vgid,
814 uint32_t *vgstatus, char **creation_host)
815 {
816 struct config_node *vgn;
817 struct dm_pool *mem = fmt->cmd->mem;
818 char *vgname;
819 int old_suppress;
820
821 old_suppress = log_suppress(2);
822 *creation_host = dm_pool_strdup(mem,
823 find_config_str(cft->root,
824 "creation_host", ""));
825 log_suppress(old_suppress);
826
827 /* skip any top-level values */
828 for (vgn = cft->root; (vgn && vgn->v); vgn = vgn->sib) ;
829
830 if (!vgn) {
831 log_error("Couldn't find volume group in file.");
832 return 0;
833 }
834
835 if (!(vgname = dm_pool_strdup(mem, vgn->key)))
836 return_0;
837
838 vgn = vgn->child;
839
840 if (!_read_id(vgid, vgn, "id")) {
841 log_error("Couldn't read uuid for volume group %s.", vgname);
842 return 0;
843 }
844
845 if (!_read_flag_config(vgn, vgstatus, VG_FLAGS)) {
846 log_error("Couldn't find status flags for volume group %s.",
847 vgname);
848 return 0;
849 }
850
851 return vgname;
852 }
853
854 static struct text_vg_version_ops _vsn1_ops = {
855 .check_version = _check_version,
856 .read_vg = _read_vg,
857 .read_desc = _read_desc,
858 .read_vgname = _read_vgname,
859 };
860
text_vg_vsn1_init(void)861 struct text_vg_version_ops *text_vg_vsn1_init(void)
862 {
863 return &_vsn1_ops;
864 }
865