1 /* $NetBSD: format1.c,v 1.1.1.2 2009/12/02 00:26:48 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 "disk-rep.h"
20 #include "limits.h"
21 #include "display.h"
22 #include "toolcontext.h"
23 #include "lvm1-label.h"
24 #include "format1.h"
25 #include "segtype.h"
26
27 /* VG consistency checks */
_check_vgs(struct dm_list * pvs)28 static int _check_vgs(struct dm_list *pvs)
29 {
30 struct dm_list *pvh, *t;
31 struct disk_list *dl = NULL;
32 struct disk_list *first = NULL;
33
34 uint32_t pv_count = 0;
35 uint32_t exported = 0;
36 int first_time = 1;
37
38 /*
39 * If there are exported and unexported PVs, ignore exported ones.
40 * This means an active VG won't be affected if disks are inserted
41 * bearing an exported VG with the same name.
42 */
43 dm_list_iterate_items(dl, pvs) {
44 if (first_time) {
45 exported = dl->pvd.pv_status & VG_EXPORTED;
46 first_time = 0;
47 continue;
48 }
49
50 if (exported != (dl->pvd.pv_status & VG_EXPORTED)) {
51 /* Remove exported PVs */
52 dm_list_iterate_safe(pvh, t, pvs) {
53 dl = dm_list_item(pvh, struct disk_list);
54 if (dl->pvd.pv_status & VG_EXPORTED)
55 dm_list_del(pvh);
56 }
57 break;
58 }
59 }
60
61 /* Remove any PVs with VG structs that differ from the first */
62 dm_list_iterate_safe(pvh, t, pvs) {
63 dl = dm_list_item(pvh, struct disk_list);
64
65 if (!first)
66 first = dl;
67
68 else if (memcmp(&first->vgd, &dl->vgd, sizeof(first->vgd))) {
69 log_error("VG data differs between PVs %s and %s",
70 dev_name(first->dev), dev_name(dl->dev));
71 log_debug("VG data on %s: %s %s %" PRIu32 " %" PRIu32
72 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
73 PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32
74 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
75 PRIu32 " %" PRIu32 " %" PRIu32,
76 dev_name(first->dev), first->vgd.vg_uuid,
77 first->vgd.vg_name_dummy,
78 first->vgd.vg_number, first->vgd.vg_access,
79 first->vgd.vg_status, first->vgd.lv_max,
80 first->vgd.lv_cur, first->vgd.lv_open,
81 first->vgd.pv_max, first->vgd.pv_cur,
82 first->vgd.pv_act, first->vgd.dummy,
83 first->vgd.vgda, first->vgd.pe_size,
84 first->vgd.pe_total, first->vgd.pe_allocated,
85 first->vgd.pvg_total);
86 log_debug("VG data on %s: %s %s %" PRIu32 " %" PRIu32
87 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
88 PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32
89 " %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
90 PRIu32 " %" PRIu32 " %" PRIu32,
91 dev_name(dl->dev), dl->vgd.vg_uuid,
92 dl->vgd.vg_name_dummy, dl->vgd.vg_number,
93 dl->vgd.vg_access, dl->vgd.vg_status,
94 dl->vgd.lv_max, dl->vgd.lv_cur,
95 dl->vgd.lv_open, dl->vgd.pv_max,
96 dl->vgd.pv_cur, dl->vgd.pv_act, dl->vgd.dummy,
97 dl->vgd.vgda, dl->vgd.pe_size,
98 dl->vgd.pe_total, dl->vgd.pe_allocated,
99 dl->vgd.pvg_total);
100 dm_list_del(pvh);
101 return 0;
102 }
103 pv_count++;
104 }
105
106 /* On entry to fn, list known to be non-empty */
107 if (pv_count != first->vgd.pv_cur) {
108 log_error("%d PV(s) found for VG %s: expected %d",
109 pv_count, first->pvd.vg_name, first->vgd.pv_cur);
110 }
111
112 return 1;
113 }
114
_build_vg(struct format_instance * fid,struct dm_list * pvs,struct dm_pool * mem)115 static struct volume_group *_build_vg(struct format_instance *fid,
116 struct dm_list *pvs,
117 struct dm_pool *mem)
118 {
119 struct volume_group *vg = dm_pool_alloc(mem, sizeof(*vg));
120 struct disk_list *dl;
121
122 if (!vg)
123 goto_bad;
124
125 if (dm_list_empty(pvs))
126 goto_bad;
127
128 memset(vg, 0, sizeof(*vg));
129
130 vg->cmd = fid->fmt->cmd;
131 vg->vgmem = mem;
132 vg->fid = fid;
133 vg->seqno = 0;
134 dm_list_init(&vg->pvs);
135 dm_list_init(&vg->lvs);
136 dm_list_init(&vg->tags);
137 dm_list_init(&vg->removed_pvs);
138
139 if (!_check_vgs(pvs))
140 goto_bad;
141
142 dl = dm_list_item(pvs->n, struct disk_list);
143
144 if (!import_vg(mem, vg, dl))
145 goto_bad;
146
147 if (!import_pvs(fid->fmt, mem, vg, pvs, &vg->pvs, &vg->pv_count))
148 goto_bad;
149
150 if (!import_lvs(mem, vg, pvs))
151 goto_bad;
152
153 if (!import_extents(fid->fmt->cmd, vg, pvs))
154 goto_bad;
155
156 if (!import_snapshots(mem, vg, pvs))
157 goto_bad;
158
159 return vg;
160
161 bad:
162 dm_pool_free(mem, vg);
163 return NULL;
164 }
165
_format1_vg_read(struct format_instance * fid,const char * vg_name,struct metadata_area * mda __attribute ((unused)))166 static struct volume_group *_format1_vg_read(struct format_instance *fid,
167 const char *vg_name,
168 struct metadata_area *mda __attribute((unused)))
169 {
170 struct dm_pool *mem = dm_pool_create("lvm1 vg_read", VG_MEMPOOL_CHUNK);
171 struct dm_list pvs;
172 struct volume_group *vg = NULL;
173 dm_list_init(&pvs);
174
175 if (!mem)
176 return_NULL;
177
178 /* Strip dev_dir if present */
179 vg_name = strip_dir(vg_name, fid->fmt->cmd->dev_dir);
180
181 if (!read_pvs_in_vg
182 (fid->fmt, vg_name, fid->fmt->cmd->filter, mem, &pvs))
183 goto_bad;
184
185 if (!(vg = _build_vg(fid, &pvs, mem)))
186 goto_bad;
187
188 return vg;
189 bad:
190 dm_pool_destroy(mem);
191 return NULL;
192 }
193
_flatten_pv(struct format_instance * fid,struct dm_pool * mem,struct volume_group * vg,struct physical_volume * pv,const char * dev_dir)194 static struct disk_list *_flatten_pv(struct format_instance *fid,
195 struct dm_pool *mem, struct volume_group *vg,
196 struct physical_volume *pv,
197 const char *dev_dir)
198 {
199 struct disk_list *dl = dm_pool_alloc(mem, sizeof(*dl));
200
201 if (!dl)
202 return_NULL;
203
204 dl->mem = mem;
205 dl->dev = pv->dev;
206
207 dm_list_init(&dl->uuids);
208 dm_list_init(&dl->lvds);
209
210 if (!export_pv(fid->fmt->cmd, mem, vg, &dl->pvd, pv) ||
211 !export_vg(&dl->vgd, vg) ||
212 !export_uuids(dl, vg) ||
213 !export_lvs(dl, vg, pv, dev_dir) || !calculate_layout(dl)) {
214 dm_pool_free(mem, dl);
215 return_NULL;
216 }
217
218 return dl;
219 }
220
_flatten_vg(struct format_instance * fid,struct dm_pool * mem,struct volume_group * vg,struct dm_list * pvds,const char * dev_dir,struct dev_filter * filter)221 static int _flatten_vg(struct format_instance *fid, struct dm_pool *mem,
222 struct volume_group *vg,
223 struct dm_list *pvds, const char *dev_dir,
224 struct dev_filter *filter)
225 {
226 struct pv_list *pvl;
227 struct disk_list *data;
228
229 dm_list_iterate_items(pvl, &vg->pvs) {
230 if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir)))
231 return_0;
232
233 dm_list_add(pvds, &data->list);
234 }
235
236 export_numbers(pvds, vg);
237 export_pv_act(pvds);
238
239 if (!export_vg_number(fid, pvds, vg->name, filter))
240 return_0;
241
242 return 1;
243 }
244
_format1_vg_write(struct format_instance * fid,struct volume_group * vg,struct metadata_area * mda __attribute ((unused)))245 static int _format1_vg_write(struct format_instance *fid, struct volume_group *vg,
246 struct metadata_area *mda __attribute((unused)))
247 {
248 struct dm_pool *mem = dm_pool_create("lvm1 vg_write", VG_MEMPOOL_CHUNK);
249 struct dm_list pvds;
250 int r = 0;
251
252 if (!mem)
253 return_0;
254
255 dm_list_init(&pvds);
256
257 r = (_flatten_vg(fid, mem, vg, &pvds, fid->fmt->cmd->dev_dir,
258 fid->fmt->cmd->filter) &&
259 write_disks(fid->fmt, &pvds));
260
261 lvmcache_update_vg(vg, 0);
262 dm_pool_destroy(mem);
263 return r;
264 }
265
_format1_pv_read(const struct format_type * fmt,const char * pv_name,struct physical_volume * pv,struct dm_list * mdas __attribute ((unused)),int scan_label_only __attribute ((unused)))266 static int _format1_pv_read(const struct format_type *fmt, const char *pv_name,
267 struct physical_volume *pv, struct dm_list *mdas __attribute((unused)),
268 int scan_label_only __attribute((unused)))
269 {
270 struct dm_pool *mem = dm_pool_create("lvm1 pv_read", 1024);
271 struct disk_list *dl;
272 struct device *dev;
273 int r = 0;
274
275 log_very_verbose("Reading physical volume data %s from disk", pv_name);
276
277 if (!mem)
278 return_0;
279
280 if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter)))
281 goto_out;
282
283 if (!(dl = read_disk(fmt, dev, mem, NULL)))
284 goto_out;
285
286 if (!import_pv(fmt, fmt->cmd->mem, dl->dev, NULL, pv, &dl->pvd, &dl->vgd))
287 goto_out;
288
289 pv->fmt = fmt;
290
291 r = 1;
292
293 out:
294 dm_pool_destroy(mem);
295 return r;
296 }
297
_format1_pv_setup(const struct format_type * fmt,uint64_t pe_start,uint32_t extent_count,uint32_t extent_size,unsigned long data_alignment __attribute ((unused)),unsigned long data_alignment_offset __attribute ((unused)),int pvmetadatacopies __attribute ((unused)),uint64_t pvmetadatasize __attribute ((unused)),struct dm_list * mdas __attribute ((unused)),struct physical_volume * pv,struct volume_group * vg __attribute ((unused)))298 static int _format1_pv_setup(const struct format_type *fmt,
299 uint64_t pe_start, uint32_t extent_count,
300 uint32_t extent_size,
301 unsigned long data_alignment __attribute((unused)),
302 unsigned long data_alignment_offset __attribute((unused)),
303 int pvmetadatacopies __attribute((unused)),
304 uint64_t pvmetadatasize __attribute((unused)), struct dm_list *mdas __attribute((unused)),
305 struct physical_volume *pv, struct volume_group *vg __attribute((unused)))
306 {
307 if (pv->size > MAX_PV_SIZE)
308 pv->size--;
309 if (pv->size > MAX_PV_SIZE) {
310 log_error("Physical volumes cannot be bigger than %s",
311 display_size(fmt->cmd, (uint64_t) MAX_PV_SIZE));
312 return 0;
313 }
314
315 /* Nothing more to do if extent size isn't provided */
316 if (!extent_size)
317 return 1;
318
319 /*
320 * This works out pe_start and pe_count.
321 */
322 if (!calculate_extent_count(pv, extent_size, extent_count, pe_start))
323 return_0;
324
325 /* Retain existing extent locations exactly */
326 if (((pe_start || extent_count) && (pe_start != pv->pe_start)) ||
327 (extent_count && (extent_count != pv->pe_count))) {
328 log_error("Metadata would overwrite physical extents");
329 return 0;
330 }
331
332 return 1;
333 }
334
_format1_lv_setup(struct format_instance * fid,struct logical_volume * lv)335 static int _format1_lv_setup(struct format_instance *fid, struct logical_volume *lv)
336 {
337 uint64_t max_size = UINT_MAX;
338
339 if (!*lv->lvid.s)
340 lvid_from_lvnum(&lv->lvid, &lv->vg->id, find_free_lvnum(lv));
341
342 if (lv->le_count > MAX_LE_TOTAL) {
343 log_error("logical volumes cannot contain more than "
344 "%d extents.", MAX_LE_TOTAL);
345 return 0;
346 }
347 if (lv->size > max_size) {
348 log_error("logical volumes cannot be larger than %s",
349 display_size(fid->fmt->cmd, max_size));
350 return 0;
351 }
352
353 return 1;
354 }
355
_format1_pv_write(const struct format_type * fmt,struct physical_volume * pv,struct dm_list * mdas __attribute ((unused)),int64_t sector __attribute ((unused)))356 static int _format1_pv_write(const struct format_type *fmt, struct physical_volume *pv,
357 struct dm_list *mdas __attribute((unused)), int64_t sector __attribute((unused)))
358 {
359 struct dm_pool *mem;
360 struct disk_list *dl;
361 struct dm_list pvs;
362 struct label *label;
363 struct lvmcache_info *info;
364
365 if (!(info = lvmcache_add(fmt->labeller, (char *) &pv->id, pv->dev,
366 pv->vg_name, NULL, 0)))
367 return_0;
368 label = info->label;
369 info->device_size = pv->size << SECTOR_SHIFT;
370 info->fmt = fmt;
371
372 dm_list_init(&info->mdas);
373
374 dm_list_init(&pvs);
375
376 /* Ensure any residual PE structure is gone */
377 pv->pe_size = pv->pe_count = 0;
378 pv->pe_start = LVM1_PE_ALIGN;
379
380 if (!(mem = dm_pool_create("lvm1 pv_write", 1024)))
381 return_0;
382
383 if (!(dl = dm_pool_alloc(mem, sizeof(*dl))))
384 goto_bad;
385
386 dl->mem = mem;
387 dl->dev = pv->dev;
388
389 if (!export_pv(fmt->cmd, mem, NULL, &dl->pvd, pv))
390 goto_bad;
391
392 /* must be set to be able to zero gap after PV structure in
393 dev_write in order to make other disk tools happy */
394 dl->pvd.pv_on_disk.base = METADATA_BASE;
395 dl->pvd.pv_on_disk.size = PV_SIZE;
396 dl->pvd.pe_on_disk.base = LVM1_PE_ALIGN << SECTOR_SHIFT;
397
398 dm_list_add(&pvs, &dl->list);
399 if (!write_disks(fmt, &pvs))
400 goto_bad;
401
402 dm_pool_destroy(mem);
403 return 1;
404
405 bad:
406 dm_pool_destroy(mem);
407 return 0;
408 }
409
_format1_vg_setup(struct format_instance * fid,struct volume_group * vg)410 static int _format1_vg_setup(struct format_instance *fid, struct volume_group *vg)
411 {
412 /* just check max_pv and max_lv */
413 if (!vg->max_lv || vg->max_lv >= MAX_LV)
414 vg->max_lv = MAX_LV - 1;
415
416 if (!vg->max_pv || vg->max_pv >= MAX_PV)
417 vg->max_pv = MAX_PV - 1;
418
419 if (vg->extent_size > MAX_PE_SIZE || vg->extent_size < MIN_PE_SIZE) {
420 log_error("Extent size must be between %s and %s",
421 display_size(fid->fmt->cmd, (uint64_t) MIN_PE_SIZE),
422 display_size(fid->fmt->cmd, (uint64_t) MAX_PE_SIZE));
423
424 return 0;
425 }
426
427 if (vg->extent_size % MIN_PE_SIZE) {
428 log_error("Extent size must be multiple of %s",
429 display_size(fid->fmt->cmd, (uint64_t) MIN_PE_SIZE));
430 return 0;
431 }
432
433 /* Redundant? */
434 if (vg->extent_size & (vg->extent_size - 1)) {
435 log_error("Extent size must be power of 2");
436 return 0;
437 }
438
439 return 1;
440 }
441
_format1_segtype_supported(struct format_instance * fid __attribute ((unused)),const struct segment_type * segtype)442 static int _format1_segtype_supported(struct format_instance *fid __attribute((unused)),
443 const struct segment_type *segtype)
444 {
445 if (!(segtype->flags & SEG_FORMAT1_SUPPORT))
446 return_0;
447
448 return 1;
449 }
450
451 static struct metadata_area_ops _metadata_format1_ops = {
452 .vg_read = _format1_vg_read,
453 .vg_write = _format1_vg_write,
454 };
455
_format1_create_instance(const struct format_type * fmt,const char * vgname __attribute ((unused)),const char * vgid __attribute ((unused)),void * private __attribute ((unused)))456 static struct format_instance *_format1_create_instance(const struct format_type *fmt,
457 const char *vgname __attribute((unused)),
458 const char *vgid __attribute((unused)),
459 void *private __attribute((unused)))
460 {
461 struct format_instance *fid;
462 struct metadata_area *mda;
463
464 if (!(fid = dm_pool_alloc(fmt->cmd->mem, sizeof(*fid))))
465 return_NULL;
466
467 fid->fmt = fmt;
468 dm_list_init(&fid->metadata_areas);
469
470 /* Define a NULL metadata area */
471 if (!(mda = dm_pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
472 dm_pool_free(fmt->cmd->mem, fid);
473 return_NULL;
474 }
475
476 mda->ops = &_metadata_format1_ops;
477 mda->metadata_locn = NULL;
478 dm_list_add(&fid->metadata_areas, &mda->list);
479
480 return fid;
481 }
482
_format1_destroy_instance(struct format_instance * fid __attribute ((unused)))483 static void _format1_destroy_instance(struct format_instance *fid __attribute((unused)))
484 {
485 return;
486 }
487
_format1_destroy(const struct format_type * fmt)488 static void _format1_destroy(const struct format_type *fmt)
489 {
490 dm_free((void *) fmt);
491 }
492
493 static struct format_handler _format1_ops = {
494 .pv_read = _format1_pv_read,
495 .pv_setup = _format1_pv_setup,
496 .pv_write = _format1_pv_write,
497 .lv_setup = _format1_lv_setup,
498 .vg_setup = _format1_vg_setup,
499 .segtype_supported = _format1_segtype_supported,
500 .create_instance = _format1_create_instance,
501 .destroy_instance = _format1_destroy_instance,
502 .destroy = _format1_destroy,
503 };
504
505 #ifdef LVM1_INTERNAL
init_lvm1_format(struct cmd_context * cmd)506 struct format_type *init_lvm1_format(struct cmd_context *cmd)
507 #else /* Shared */
508 struct format_type *init_format(struct cmd_context *cmd);
509 struct format_type *init_format(struct cmd_context *cmd)
510 #endif
511 {
512 struct format_type *fmt = dm_malloc(sizeof(*fmt));
513
514 if (!fmt)
515 return_NULL;
516
517 fmt->cmd = cmd;
518 fmt->ops = &_format1_ops;
519 fmt->name = FMT_LVM1_NAME;
520 fmt->alias = NULL;
521 fmt->orphan_vg_name = FMT_LVM1_ORPHAN_VG_NAME;
522 fmt->features = FMT_RESTRICTED_LVIDS | FMT_ORPHAN_ALLOCATABLE |
523 FMT_RESTRICTED_READAHEAD;
524 fmt->private = NULL;
525
526 if (!(fmt->labeller = lvm1_labeller_create(fmt))) {
527 log_error("Couldn't create lvm1 label handler.");
528 return NULL;
529 }
530
531 if (!(label_register_handler(FMT_LVM1_NAME, fmt->labeller))) {
532 log_error("Couldn't register lvm1 label handler.");
533 return NULL;
534 }
535
536 log_very_verbose("Initialised format: %s", fmt->name);
537
538 return fmt;
539 }
540