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