From 6435b49153f0a56d52af481fd59381ce8c22320f Mon Sep 17 00:00:00 2001 From: Alasdair Kergon Date: Tue, 29 Jan 2002 17:23:33 +0000 Subject: [PATCH] o Basic support for exporting (but importing not completed yet). o When volume group does not have write flag set, prevent changes to it. o Preparation for partial activation (not completed yet). --- lib/format1/disk-rep.c | 51 +++++++++++++---- lib/format1/disk-rep.h | 14 +++-- lib/format1/format1.c | 74 +++++++++++++++++++------ lib/format1/import-export.c | 104 ++++++++++++++++++++++++++++++----- lib/format1/import-extents.c | 1 + lib/format_text/export.c | 2 + lib/format_text/flags.c | 7 ++- lib/log/log.c | 13 +++++ lib/log/log.h | 2 + lib/metadata/metadata.c | 7 +-- lib/metadata/metadata.h | 10 ++-- tools/Makefile.in | 1 + tools/args.h | 1 + tools/commands.h | 6 +- tools/lvchange.c | 8 +++ tools/lvcreate.c | 10 ++++ tools/lvm.c | 7 +++ tools/lvremove.c | 5 ++ tools/lvrename.c | 10 ++++ tools/lvresize.c | 10 ++++ tools/pvchange.c | 14 ++++- tools/pvscan.c | 9 +-- tools/stub.h | 1 - tools/toollib.c | 54 +++++++++--------- tools/vgchange.c | 5 ++ tools/vgexport.c | 68 +++++++++++++++++++++++ tools/vgextend.c | 10 ++++ tools/vgmerge.c | 20 +++++++ tools/vgreduce.c | 10 ++++ tools/vgremove.c | 10 ++++ tools/vgrename.c | 10 ++++ tools/vgscan.c | 4 +- 32 files changed, 465 insertions(+), 93 deletions(-) create mode 100644 tools/vgexport.c diff --git a/lib/format1/disk-rep.c b/lib/format1/disk-rep.c index 8e3fd75d0..56418cfb2 100644 --- a/lib/format1/disk-rep.c +++ b/lib/format1/disk-rep.c @@ -257,6 +257,26 @@ static int _read_extents(struct disk_list *data) return 1; } +/* + * If exported, remove "PV_EXP" from end of VG name + */ +static void _munge_exported_vg(struct disk_list *data) +{ + int l, s; + + /* Return if PV not in a VG or VG not exported */ + if ((!*data->pvd.vg_name) || + !(data->vgd.vg_status & VG_EXPORTED)) + return; + + l = strlen(data->pvd.vg_name); + s = sizeof(EXPORTED_TAG); + if (!strncmp(data->pvd.vg_name + l - s + 1, EXPORTED_TAG, s)) + data->pvd.vg_name[l - s + 1] = '\0'; + + data->pvd.pv_status |= VG_EXPORTED; +} + static struct disk_list *__read_disk(struct device *dev, struct pool *mem, const char *vg_name) { @@ -278,21 +298,16 @@ static struct disk_list *__read_disk(struct device *dev, struct pool *mem, goto bad; } - /* Update VG cache with whatever we found */ - vgcache_add(data->pvd.vg_name, dev); - /* * is it an orphan ? */ if (!*data->pvd.vg_name) { log_very_verbose("%s is not a member of any VG", name); - return (vg_name) ? NULL : data; - } - if (vg_name && strcmp(vg_name, data->pvd.vg_name)) { - log_very_verbose("%s is not a member of the VG %s", - name, vg_name); - goto bad; + /* Update VG cache */ + vgcache_add(data->pvd.vg_name, dev); + + return (vg_name) ? NULL : data; } if (!_read_vgd(data)) { @@ -300,6 +315,18 @@ static struct disk_list *__read_disk(struct device *dev, struct pool *mem, goto bad; } + /* If VG is exported, set VG name back to the real name */ + _munge_exported_vg(data); + + /* Update VG cache with what we found */ + vgcache_add(data->pvd.vg_name, dev); + + if (vg_name && strcmp(vg_name, data->pvd.vg_name)) { + log_very_verbose("%s is not a member of the VG %s", + name, vg_name); + goto bad; + } + if (!_read_uuids(data)) { log_error("Failed to read PV uuid list from %s", name); goto bad; @@ -315,7 +342,9 @@ static struct disk_list *__read_disk(struct device *dev, struct pool *mem, goto bad; } - log_very_verbose("Found %s in VG %s", name, data->pvd.vg_name); + log_very_verbose("Found %s in %sVG %s", name, + (data->vgd.vg_status & VG_EXPORTED) ? "exported " : "", + data->pvd.vg_name); return data; @@ -515,7 +544,7 @@ static int _write_pvd(struct disk_list *data) ulong size = data->pvd.pv_on_disk.size; if(size < sizeof(struct pv_disk)) { - log_err("Invalid PV size."); + log_error("Invalid PV structure size."); return 0; } diff --git a/lib/format1/disk-rep.h b/lib/format1/disk-rep.h index 910597b34..c1fcc825f 100644 --- a/lib/format1/disk-rep.h +++ b/lib/format1/disk-rep.h @@ -55,6 +55,9 @@ #define PV_ACTIVE 0x01 /* pv_status */ #define PV_ALLOCATABLE 0x02 /* pv_allocatable */ +#define EXPORTED_TAG "PV_EXP" /* Identifier for exported PV */ +#define IMPORTED_TAG "PV_IMP" /* Identifier for imported PV */ + struct data_area { uint32_t base; @@ -197,11 +200,14 @@ int write_disks(struct list *pvds); * core structures. */ int import_pv(struct pool *mem, struct device *dev, + struct volume_group *vg, struct physical_volume *pv, struct pv_disk *pvd); -int export_pv(struct pv_disk *pvd, struct physical_volume *pv); +int export_pv(struct pool *mem, struct volume_group *vg, + struct pv_disk *pvd, struct physical_volume *pv); int import_vg(struct pool *mem, - struct volume_group *vg, struct disk_list *dl); + struct volume_group *vg, struct disk_list *dl, + int partial); int export_vg(struct vg_disk *vgd, struct volume_group *vg); int import_lv(struct pool *mem, struct logical_volume *lv, @@ -215,8 +221,8 @@ int export_extents(struct disk_list *dl, int lv_num, struct logical_volume *lv, struct physical_volume *pv); -int import_pvs(struct pool *mem, struct list *pvds, - struct list *results, int *count); +int import_pvs(struct pool *mem, struct volume_group *vg, + struct list *pvds, struct list *results, int *count); int import_lvs(struct pool *mem, struct volume_group *vg, struct list *pvds); diff --git a/lib/format1/format1.c b/lib/format1/format1.c index 7e538a9fb..59121eaef 100644 --- a/lib/format1/format1.c +++ b/lib/format1/format1.c @@ -13,34 +13,69 @@ #include "display.h" /* VG consistency checks */ -static int _check_vgs(struct list *pvs) +static int _check_vgs(struct list *pvs, int *partial) { - struct list *pvh; + struct list *pvh, *t; struct disk_list *dl = NULL; struct disk_list *first = NULL; int pv_count = 0; + int exported = -1; - /* check all the vg's are the same */ + *partial = 0; + + /* + * If there are exported and unexported PVs, ignore exported ones. + * This means an active VG won't be affected if disks are inserted + * bearing an exported VG with the same name. + */ list_iterate(pvh, pvs) { dl = list_item(pvh, struct disk_list); + if (exported < 0) { + exported = dl->pvd.pv_status & VG_EXPORTED; + continue; + } + + if (exported != (dl->pvd.pv_status & VG_EXPORTED)) { + /* Remove exported PVs */ + list_iterate_safe(pvh, t, pvs) { + dl = list_item(pvh, struct disk_list); + if (dl->pvd.pv_status & VG_EXPORTED) + list_del(pvh); + } + break; + } + } + + + /* Remove any PVs with VG structs that differ from the first */ + list_iterate_safe(pvh, t, pvs) { + dl = list_item(pvh, struct disk_list); + if (!first) first = dl; else if (memcmp(&first->vgd, &dl->vgd, sizeof(first->vgd))) { log_error("VG data differs between PVs %s and %s", dev_name(first->dev), dev_name(dl->dev)); + list_del(pvh); + if (partial_mode()) { + *partial = 1; + continue; + } return 0; } pv_count++; } /* On entry to fn, list known to be non-empty */ - if (!(pv_count == dl->vgd.pv_cur)) { - log_error("Only %d out of %d PV(s) found for VG %s", - pv_count, dl->vgd.pv_cur, dl->pvd.vg_name); - return 0; + if (pv_count != dl->vgd.pv_cur) { + log_error("%d PV(s) found for VG %s: expected %d", + pv_count, dl->pvd.vg_name, dl->vgd.pv_cur); + if (!partial_mode()) + return 0; + *partial = 1; } return 1; @@ -50,6 +85,7 @@ static struct volume_group *_build_vg(struct pool *mem, struct list *pvs) { struct volume_group *vg = pool_alloc(mem, sizeof(*vg)); struct disk_list *dl; + int partial; if (!vg) goto bad; @@ -57,20 +93,20 @@ static struct volume_group *_build_vg(struct pool *mem, struct list *pvs) if (list_empty(pvs)) goto bad; - dl = list_item(pvs->n, struct disk_list); - memset(vg, 0, sizeof(*vg)); list_init(&vg->pvs); list_init(&vg->lvs); - if (!_check_vgs(pvs)) + if (!_check_vgs(pvs, &partial)) goto bad; - if (!import_vg(mem, vg, dl)) + dl = list_item(pvs->n, struct disk_list); + + if (!import_vg(mem, vg, dl, partial)) goto bad; - if (!import_pvs(mem, pvs, &vg->pvs, &vg->pv_count)) + if (!import_pvs(mem, vg, pvs, &vg->pvs, &vg->pv_count)) goto bad; if (!import_lvs(mem, vg, pvs)) @@ -137,7 +173,7 @@ static struct disk_list *_flatten_pv(struct pool *mem, struct volume_group *vg, list_init(&dl->uuids); list_init(&dl->lvds); - if (!export_pv(&dl->pvd, pv) || + if (!export_pv(mem, vg, &dl->pvd, pv) || !export_vg(&dl->vgd, vg) || !export_uuids(dl, vg) || !export_lvs(dl, vg, pv, dev_dir) || @@ -191,6 +227,12 @@ static int _vg_write(struct format_instance *fi, struct volume_group *vg) return 0; } + if (vg->status & PARTIAL_VG) { + log_error("Cannot change metadata for partial volume group %s", + vg->name); + return 0; + } + list_init(&pvds); r = (_flatten_vg(mem, vg, &pvds, fi->cmd->dev_dir, fi->cmd->filter) && @@ -229,7 +271,7 @@ static struct physical_volume *_pv_read(struct format_instance *fi, goto out; } - if (!import_pv(fi->cmd->mem, dl->dev, pv, &dl->pvd)) { + if (!import_pv(fi->cmd->mem, dl->dev, NULL, pv, &dl->pvd)) { stack; pool_free(fi->cmd->mem, pv); pv = NULL; @@ -265,7 +307,7 @@ static struct list *_get_pvs(struct format_instance *fi) goto bad; } - if (!import_pvs(fi->cmd->mem, &pvs, results, &count)) { + if (!import_pvs(fi->cmd->mem, NULL, &pvs, results, &count)) { stack; goto bad; } @@ -396,7 +438,7 @@ static int _pv_write(struct format_instance *fi, struct physical_volume *pv) dl->mem = mem; dl->dev = pv->dev; - if (!export_pv(&dl->pvd, pv)) { + if (!export_pv(mem, NULL, &dl->pvd, pv)) { stack; goto bad; } diff --git a/lib/format1/import-export.c b/lib/format1/import-export.c index d244d0f58..e730abd36 100644 --- a/lib/format1/import-export.c +++ b/lib/format1/import-export.c @@ -12,6 +12,7 @@ #include "hash.h" #include "list.h" #include "log.h" +#include "lvm-string.h" #include #include @@ -37,6 +38,7 @@ static char *_create_lv_name(struct pool *mem, const char *full_name) } int import_pv(struct pool *mem, struct device *dev, + struct volume_group *vg, struct physical_volume *pv, struct pv_disk *pvd) { memset(pv, 0, sizeof(*pv)); @@ -48,6 +50,26 @@ int import_pv(struct pool *mem, struct device *dev, return 0; } + /* Store system_id if PV belongs to a VG */ + if (vg && !vg->system_id && + !(vg->system_id = pool_strdup(mem, pvd->system_id))) { + stack; + return 0; + } + + if (vg && vg->system_id && + strncmp(vg->system_id, pvd->system_id, sizeof(pvd->system_id))) + log_very_verbose("System ID %s on %s differs from %s for " + "volume group", pvd->system_id, + dev_name(pv->dev), vg->system_id); + + /* + * If exported, we still need to flag in pv->status too because + * we don't always have a struct volume_group when we need this. + */ + if (pvd->pv_status & VG_EXPORTED) + pv->status |= EXPORTED_VG; + if (pvd->pv_allocatable) pv->status |= ALLOCATABLE_PV; @@ -60,7 +82,7 @@ int import_pv(struct pool *mem, struct device *dev, return 1; } -static int _system_id(char *system_id) +int _system_id(char *s, const char *prefix) { struct utsname uts; @@ -69,11 +91,17 @@ static int _system_id(char *system_id) return 0; } - sprintf(system_id, "%s%lu", uts.nodename, time(NULL)); + if (lvm_snprintf(s, NAME_LEN, "%s%s%lu", + prefix, uts.nodename, time(NULL)) < 0) { + log_error("Generated system_id too long"); + return 0; + } + return 1; } -int export_pv(struct pv_disk *pvd, struct physical_volume *pv) +int export_pv(struct pool *mem, struct volume_group *vg, + struct pv_disk *pvd, struct physical_volume *pv) { memset(pvd, 0, sizeof(*pvd)); @@ -93,6 +121,54 @@ int export_pv(struct pv_disk *pvd, struct physical_volume *pv) if (pv->vg_name) strncpy(pvd->vg_name, pv->vg_name, sizeof(pvd->vg_name)); + /* Preserve existing system_id if it exists */ + if (vg && vg->system_id) + strncpy(pvd->system_id, vg->system_id, sizeof(pvd->system_id)); + + /* Is VG already exported or being exported? */ + if (vg && (vg->status & EXPORTED_VG)) { + /* Does system_id need setting? */ + if (!vg->system_id || + strncmp(vg->system_id, EXPORTED_TAG, + sizeof(EXPORTED_TAG))) { + if (!_system_id(pvd->system_id, EXPORTED_TAG)) { + stack; + return 0; + } + } + if (strlen(pvd->vg_name) + sizeof(EXPORTED_TAG) > + sizeof(pvd->vg_name)) { + log_error("Volume group name %s too long to export", + pvd->vg_name); + return 0; + } + strcat(pvd->vg_name, EXPORTED_TAG); + } + + /* Is VG being imported? */ + if (vg && !(vg->status & EXPORTED_VG) && vg->system_id && + !strncmp(vg->system_id, EXPORTED_TAG, sizeof(EXPORTED_TAG))) { + if (!_system_id(pvd->system_id, IMPORTED_TAG)) { + stack; + return 0; + } + } + + /* Generate system_id if PV is in VG */ + if (!pvd->system_id || !*pvd->system_id) + if (!_system_id(pvd->system_id, "")) { + stack; + return 0; + } + + /* Update internal system_id if we changed it */ + if (vg && + (!vg->system_id || + strncmp(vg->system_id, pvd->system_id, sizeof(pvd->system_id)))) { + if (!(vg->system_id = pool_strdup(mem, pvd->system_id))) + log_error("System ID update failed"); + } + //pvd->pv_major = MAJOR(pv->dev); if (pv->status & ALLOCATABLE_PV) @@ -105,16 +181,12 @@ int export_pv(struct pv_disk *pvd, struct physical_volume *pv) pvd->pe_allocated = pv->pe_allocated; pvd->pe_start = pv->pe_start; - if (!_system_id(pvd->system_id)) { - stack; - return 0; - } - return 1; } int import_vg(struct pool *mem, - struct volume_group *vg, struct disk_list *dl) + struct volume_group *vg, struct disk_list *dl, + int partial) { struct vg_disk *vgd = &dl->vgd; memcpy(vg->id.uuid, vgd->vg_uuid, ID_LEN); @@ -135,10 +207,10 @@ int import_vg(struct pool *mem, if (vgd->vg_status & VG_EXTENDABLE) vg->status |= RESIZEABLE_VG; - if (vgd->vg_access & VG_READ) + if (partial || (vgd->vg_access & VG_READ)) vg->status |= LVM_READ; - if (vgd->vg_access & VG_WRITE) + if (!partial && (vgd->vg_access & VG_WRITE)) vg->status |= LVM_WRITE; if (vgd->vg_access & VG_CLUSTERED) @@ -152,6 +224,10 @@ int import_vg(struct pool *mem, vg->free_count = vgd->pe_total - vgd->pe_allocated; vg->max_lv = vgd->lv_max; vg->max_pv = vgd->pv_max; + + if (partial) + vg->status |= PARTIAL_VG; + return 1; } @@ -307,8 +383,8 @@ int export_extents(struct disk_list *dl, int lv_num, return 1; } -int import_pvs(struct pool *mem, struct list *pvds, - struct list *results, int *count) +int import_pvs(struct pool *mem, struct volume_group *vg, + struct list *pvds, struct list *results, int *count) { struct list *pvdh; struct disk_list *dl; @@ -325,7 +401,7 @@ int import_pvs(struct pool *mem, struct list *pvds, return 0; } - if (!import_pv(mem, dl->dev, pvl->pv, &dl->pvd)) { + if (!import_pv(mem, dl->dev, vg, pvl->pv, &dl->pvd)) { stack; return 0; } diff --git a/lib/format1/import-extents.c b/lib/format1/import-extents.c index f31b1b329..e520c5b3f 100644 --- a/lib/format1/import-extents.c +++ b/lib/format1/import-extents.c @@ -349,6 +349,7 @@ int import_extents(struct pool *mem, struct volume_group *vg, struct list *pvds) goto out; } + /* FIXME Support partial activation if (vg->status & PARTIAL_VG) */ if (!_check_maps_are_complete(maps)) { stack; goto out; diff --git a/lib/format_text/export.c b/lib/format_text/export.c index 10045a213..9eb570888 100644 --- a/lib/format_text/export.c +++ b/lib/format_text/export.c @@ -201,6 +201,8 @@ static int _print_vg(struct formatter *f, struct volume_group *vg) } _out(f, "status = %s", buffer); + if (vg->system_id && *vg->system_id) + _out(f, "system_id = \"%s\"", vg->system_id); _out_size(f, vg->extent_size, "extent_size = %u", vg->extent_size); _out(f, "max_lv = %u", vg->max_lv); _out(f, "max_pv = %u", vg->max_pv); diff --git a/lib/format_text/flags.c b/lib/format_text/flags.c index 0c06e2b94..9a9630e40 100644 --- a/lib/format_text/flags.c +++ b/lib/format_text/flags.c @@ -21,6 +21,7 @@ struct flag { static struct flag _vg_flags[] = { {EXPORTED_VG, "EXPORTED"}, {RESIZEABLE_VG, "RESIZEABLE"}, + {PARTIAL_VG, "PARTIAL"}, {LVM_READ, "READ"}, {LVM_WRITE, "WRITE"}, {CLUSTERED, "CLUSTERED"}, @@ -30,6 +31,7 @@ static struct flag _vg_flags[] = { static struct flag _pv_flags[] = { {ALLOCATABLE_PV, "ALLOCATABLE"}, + {EXPORTED_VG, "EXPORTED"}, {0, NULL} }; @@ -117,9 +119,8 @@ int print_flags(uint32_t status, int type, char *buffer, size_t size) return 0; if (status) - /* FIXME: agk is this the correct log level ? */ - log_print("Not all flags were successfully exported, " - "possible bug."); + log_error("Metadata inconsistency: Not all flags successfully " + "exported."); return 1; } diff --git a/lib/log/log.c b/lib/log/log.c index a4976cb69..8845f69df 100644 --- a/lib/log/log.c +++ b/lib/log/log.c @@ -12,6 +12,7 @@ static FILE *_log = 0; static int _verbose_level = 0; static int _test = 0; +static int _partial = 0; static int _debug_level = 0; static int _syslog = 0; static int _indent = 1; @@ -48,6 +49,14 @@ void init_test(int level) { log_print("Test mode. Metadata will NOT be updated."); } +void init_partial(int level) { + _partial = level; + if (_partial) + log_print("Partial mode. Incomplete volume groups will " + "be activated read-only."); + +} + void init_cmd_name(int status) { _log_cmd_name = status; } @@ -72,6 +81,10 @@ int test_mode() { return _test; } +int partial_mode() { + return _partial; +} + void init_debug(int level) { _debug_level = level; } diff --git a/lib/log/log.h b/lib/log/log.h index ac25974b4..cd4d4afd5 100644 --- a/lib/log/log.h +++ b/lib/log/log.h @@ -48,6 +48,7 @@ void fin_syslog(void); void init_verbose(int level); void init_test(int level); +void init_partial(int level); void init_debug(int level); void init_cmd_name(int status); void init_msg_prefix(const char *prefix); @@ -56,6 +57,7 @@ void init_indent(int indent); void set_cmd_name(const char *cmd_name); int test_mode(void); +int partial_mode(void); int debug_level(void); void print_log(int level, const char *file, int line, const char *format, ...) diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c index 88c40ebf7..816d22ebf 100644 --- a/lib/metadata/metadata.c +++ b/lib/metadata/metadata.c @@ -39,9 +39,6 @@ int _add_pv_to_vg(struct format_instance *fi, struct volume_group *vg, return 0; } - /* FIXME check this */ - pv->exported = NULL; - if (!(pv->vg_name = pool_strdup(mem, vg->name))) { log_error("vg->name allocation failed for '%s'", pv_name); return 0; @@ -132,10 +129,12 @@ struct volume_group *vg_create(struct format_instance *fi, const char *vg_name, } /* is this vg name already in use ? */ + init_partial(1); if (fi->ops->vg_read(fi, vg_name)) { log_err("A volume group called '%s' already exists.", vg_name); goto bad; } + init_partial(0); if (!id_create(&vg->id)) { log_err("Couldn't create uuid for volume group '%s'.", @@ -154,6 +153,7 @@ struct volume_group *vg_create(struct format_instance *fi, const char *vg_name, } vg->status = (RESIZEABLE_VG | LVM_READ | LVM_WRITE); + vg->system_id = NULL; vg->extent_size = extent_size; vg->extent_count = 0; @@ -213,7 +213,6 @@ struct physical_volume *pv_create(struct format_instance *fi, } *pv->vg_name = 0; - pv->exported = NULL; pv->status = ALLOCATABLE_PV; if (!dev_get_size(pv->dev, &pv->size)) { diff --git a/lib/metadata/metadata.h b/lib/metadata/metadata.h index eb10f39b1..cdd18b11a 100644 --- a/lib/metadata/metadata.h +++ b/lib/metadata/metadata.h @@ -27,8 +27,9 @@ /* Various flags */ /* Note that the bits no longer necessarily correspond to LVM1 disk format */ -#define EXPORTED_VG 0x00000002 /* VG */ +#define EXPORTED_VG 0x00000002 /* VG PV */ #define RESIZEABLE_VG 0x00000004 /* VG */ +#define PARTIAL_VG 0x00000040 /* VG */ /* May any free extents on this PV be used or must they be left free? */ #define ALLOCATABLE_PV 0x00000008 /* PV */ @@ -52,14 +53,10 @@ #define SNAPSHOT_ORG 0x00020000 /* LV */ -#define EXPORTED_TAG "PV_EXP" /* Identifier of exported PV */ -#define IMPORTED_TAG "PV_IMP" /* Identifier of imported PV */ - struct physical_volume { struct id id; struct device *dev; char *vg_name; - char *exported; uint32_t status; uint64_t size; @@ -78,6 +75,7 @@ struct volume_group { struct id id; char *name; + char *system_id; uint32_t status; @@ -267,7 +265,7 @@ struct logical_volume *lv_create(struct format_instance *fi, struct volume_group *vg, struct list *acceptable_pvs); -int lv_reduce(struct format_instance *fi, +int lv_reduce(struct format_instance *fi, struct logical_volume *lv, uint32_t extents); int lv_extend(struct format_instance *fi, diff --git a/tools/Makefile.in b/tools/Makefile.in index f0aee60a6..11141b2e5 100644 --- a/tools/Makefile.in +++ b/tools/Makefile.in @@ -44,6 +44,7 @@ SOURCES=\ vgck.c \ vgcreate.c \ vgdisplay.c \ + vgexport.c \ vgextend.c \ vgmerge.c \ vgreduce.c \ diff --git a/tools/args.h b/tools/args.h index 2fd2cc313..700c90ef2 100644 --- a/tools/args.h +++ b/tools/args.h @@ -51,6 +51,7 @@ arg(nofsck_ARG, 'n', "nofsck", NULL) arg(novolumegroup_ARG, 'n', "novolumegroup", NULL) arg(permission_ARG, 'p', "permission", permission_arg) arg(maxphysicalvolumes_ARG, 'p', "maxphysicalvolumes", int_arg) +arg(partial_ARG, 'P', "partial", NULL) arg(physicalvolume_ARG, 'P', "physicalvolume", NULL) arg(readahead_ARG, 'r', "readahead", int_arg) arg(reset_ARG, 'R', "reset", NULL) diff --git a/tools/commands.h b/tools/commands.h index c77774a8b..af7971d62 100644 --- a/tools/commands.h +++ b/tools/commands.h @@ -53,13 +53,14 @@ xx(lvchange, "\t[-C/--contiguous y/n]\n" "\t[-d/--debug]\n" "\t[-h/-?/--help]\n" + "\t[-P/--partial] " "\n" "\t[-p/--permission r/rw]\n" "\t[-r/--readahead ReadAheadSectors]\n" "\t[-t/--test]\n" "\t[-v/--verbose]\n" "\tLogicalVolume[Path] [LogicalVolume[Path]...]\n", - autobackup_ARG, available_ARG, contiguous_ARG, + autobackup_ARG, available_ARG, contiguous_ARG, partial_ARG, permission_ARG, readahead_ARG, test_ARG) xx(lvcreate, @@ -358,6 +359,7 @@ xx(vgchange, "Change volume group attributes", "vgchange" "\n" "\t[-A|--autobackup {y|n}] " "\n" + "\t[-P|--partial] " "\n" "\t[-d|--debug] " "\n" "\t[-h|--help] " "\n" "\t[-t|--test]" "\n" @@ -368,7 +370,7 @@ xx(vgchange, "\t -l|--logicalvolume MaxLogicalVolumes}" "\n" "\t[VolumeGroupName...]\n", - autobackup_ARG, available_ARG, logicalvolume_ARG, + autobackup_ARG, available_ARG, logicalvolume_ARG, partial_ARG, resizeable_ARG, resizable_ARG, allocation_ARG, test_ARG) diff --git a/tools/lvchange.c b/tools/lvchange.c index 0b307e3fa..df27b6184 100644 --- a/tools/lvchange.c +++ b/tools/lvchange.c @@ -47,6 +47,14 @@ static int lvchange_single(struct logical_volume *lv) int doit = 0; int archived = 0; + if ((lv->vg->status & PARTIAL_VG) && + (arg_count(contiguous_ARG) || arg_count(permission_ARG) || + arg_count(readahead_ARG))) { + log_error("Only -a permitted with partial volume group %s", + lv->vg->name); + return EINVALID_CMD_LINE; + } + if (lv->status & SNAPSHOT_ORG) { log_error("Can't change logical volume %s under snapshot", lv->name); diff --git a/tools/lvcreate.c b/tools/lvcreate.c index 07ab256f8..0337d0c56 100644 --- a/tools/lvcreate.c +++ b/tools/lvcreate.c @@ -122,6 +122,16 @@ int lvcreate(int argc, char **argv) return ECMD_FAILED; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg_name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + return ECMD_FAILED; + } + if (lv_name && find_lv_in_vg(vg, lv_name)) { log_error("Logical volume %s already exists in " "volume group %s", lv_name, vg_name); diff --git a/tools/lvm.c b/tools/lvm.c index d8b34ea3e..006c14fdc 100644 --- a/tools/lvm.c +++ b/tools/lvm.c @@ -132,6 +132,8 @@ int main(int argc, char **argv) namebase = strdup(argv[0]); base = basename(namebase); + while (*base == '/') + base++; if (strcmp(base, "lvm")) alias = 1; free(namebase); @@ -611,6 +613,11 @@ static int process_common_commands(struct command *com) _current_settings.backup = 1; } + if (arg_count(partial_ARG)) + init_partial(1); + else + init_partial(0); + /* Handle synonyms */ if (!merge_synonym(resizable_ARG, resizeable_ARG) || !merge_synonym(allocation_ARG, allocatable_ARG) || diff --git a/tools/lvremove.c b/tools/lvremove.c index facadf2bf..0eef4c88e 100644 --- a/tools/lvremove.c +++ b/tools/lvremove.c @@ -39,6 +39,11 @@ static int lvremove_single(struct logical_volume *lv) vg = lv->vg; + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg->name); + return ECMD_FAILED; + } + if (lv->status & SNAPSHOT_ORG) { log_error("Can't remove logical volume %s under snapshot", lv->name); diff --git a/tools/lvrename.c b/tools/lvrename.c index 15f5257b2..5a67c10df 100644 --- a/tools/lvrename.c +++ b/tools/lvrename.c @@ -90,6 +90,16 @@ int lvrename(int argc, char **argv) return ECMD_FAILED; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + return ECMD_FAILED; + } + if (find_lv_in_vg(vg, lv_name_new)) { log_error("Logical volume %s already exists in " "volume group %s", lv_name_new, vg_name); diff --git a/tools/lvresize.c b/tools/lvresize.c index 07f1a636c..4f5845521 100644 --- a/tools/lvresize.c +++ b/tools/lvresize.c @@ -110,6 +110,16 @@ int lvresize(int argc, char **argv) return ECMD_FAILED; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + return ECMD_FAILED; + } + /* does LV exist? */ if (!(lvl = find_lv_in_vg(vg, lv_name))) { log_error("Logical volume %s not found in volume group %s", diff --git a/tools/pvchange.c b/tools/pvchange.c index d5c876b09..5274ad36c 100644 --- a/tools/pvchange.c +++ b/tools/pvchange.c @@ -88,8 +88,7 @@ int pvchange_single(struct physical_volume *pv) int allocatable = !strcmp(arg_str_value(allocatable_ARG, "n"), "y"); - /* If in a VG, must change using volume group. Pointless. */ - /* FIXME: Provide a direct pv_write_pv that *only* touches PV structs*/ + /* If in a VG, must change using volume group. */ if (*pv->vg_name) { log_verbose("Finding volume group of physical volume %s", pv_name); @@ -97,6 +96,17 @@ int pvchange_single(struct physical_volume *pv) log_error("Unable to find volume group of %s", pv_name); return 0; } + + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg->name); + return ECMD_FAILED; + } + if (!(pvl = find_pv_in_vg(vg, pv_name))) { log_error("Unable to find %s in volume group %s", pv_name, vg->name); diff --git a/tools/pvscan.c b/tools/pvscan.c index 2c37d03b8..3162c551a 100644 --- a/tools/pvscan.c +++ b/tools/pvscan.c @@ -150,7 +150,8 @@ void pvscan_display_single(struct physical_volume *pv) /* FIXME As per pv_display! Drop through for now. */ /* pv_show(pv); */ - log_print("System Id %s", pv->exported); + /* FIXME - Moved to Volume Group structure */ + /* log_print("System Id %s", pv->vg->system_id); */ /* log_print(" "); */ /* return; */ @@ -158,7 +159,7 @@ void pvscan_display_single(struct physical_volume *pv) memset(pv_tmp_name, 0, sizeof (pv_tmp_name)); - vg_name_len = strlen(pv->vg_name) - sizeof (EXPORTED_TAG) + 1; + vg_name_len = strlen(pv->vg_name) + 1; if (arg_count(uuid_ARG)) { if (!id_write_format(&pv->id, uuid, sizeof(uuid))) { @@ -181,9 +182,9 @@ void pvscan_display_single(struct physical_volume *pv) return; } - if (strcmp(&pv->vg_name[vg_name_len], EXPORTED_TAG) == 0) { + if (pv->status & EXPORTED_VG) { strncpy(vg_name_this, pv->vg_name, vg_name_len); - log_print("PV %-*s is in EXPORTED VG %s [%s / %s free]", + log_print("PV %-*s is in exported VG %s [%s / %s free]", pv_max_name_len, pv_tmp_name, vg_name_this, (s1 = display_size(pv->pe_count * diff --git a/tools/stub.h b/tools/stub.h index efe07807f..10e9cea82 100644 --- a/tools/stub.h +++ b/tools/stub.h @@ -10,7 +10,6 @@ int lvmsadc(int argc, char **argv) {return 1;} int lvmsar(int argc, char **argv) {return 1;} int pvdata(int argc, char **argv) {return 1;} int pvmove(int argc, char **argv) {return 1;} -int vgexport(int argc, char **argv) {return 1;} int vgimport(int argc, char **argv) {return 1;} int vgmknodes(int argc, char **argv) {return 1;} int vgsplit(int argc, char **argv) {return 1;} diff --git a/tools/toollib.c b/tools/toollib.c index 8ccc89b61..19bd5afc6 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -10,13 +10,13 @@ int check_dir(const char *dir) { - struct stat info; + struct stat info; if (!*dir) return 1; - if (stat(dir, &info) != -1 ) { - log_error("%s exists", dir); + if (stat(dir, &info) != -1) { + log_error("%s exists", dir); return 0; } @@ -25,27 +25,26 @@ int check_dir(const char *dir) int create_dir(const char *dir) { - struct stat info; + struct stat info; if (!*dir) return 1; - if (stat(dir, &info) < 0 ) { - log_verbose("Creating directory %s", dir); - if (!mkdir(dir, 0777)); - return 1; - log_sys_error("mkdir", dir); - return 0; - } + if (stat(dir, &info) < 0) { + log_verbose("Creating directory %s", dir); + if (!mkdir(dir, 0777)) + return 1; + log_sys_error("mkdir", dir); + return 0; + } - if (S_ISDIR(info.st_mode)) - return 1; + if (S_ISDIR(info.st_mode)) + return 1; - log_error("Directory %s not found", dir); - return 0; + log_error("Directory %s not found", dir); + return 0; } - int process_each_lv_in_vg(struct volume_group *vg, int (*process_single) (struct logical_volume *lv)) { @@ -55,11 +54,11 @@ int process_each_lv_in_vg(struct volume_group *vg, struct list *lvh; struct logical_volume *lv; - /* FIXME Export-handling */ if (vg->status & EXPORTED_VG) { log_error("Volume group %s is exported", vg->name); return ECMD_FAILED; } + list_iterate(lvh, &vg->lvs) { lv = list_item(lvh, struct lv_list)->lv; ret = process_single(lv); @@ -72,7 +71,7 @@ int process_each_lv_in_vg(struct volume_group *vg, } int process_each_lv(int argc, char **argv, - int (*process_single) (struct logical_volume * lv)) + int (*process_single) (struct logical_volume *lv)) { int opt = 0; int ret_max = 0; @@ -107,6 +106,12 @@ int process_each_lv(int argc, char **argv, continue; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", + vg->name); + return ECMD_FAILED; + } + if (!(lvl = find_lv_in_vg(vg, lv_name))) { log_error("Can't find logical volume %s " "in volume group %s", @@ -179,8 +184,8 @@ int process_each_vg(int argc, char **argv, } int process_each_pv_in_vg(struct volume_group *vg, - int (*process_single) (struct volume_group * vg, - struct physical_volume * pv)) + int (*process_single) (struct volume_group *vg, + struct physical_volume *pv)) { int ret_max = 0; int ret = 0; @@ -198,8 +203,8 @@ int process_each_pv_in_vg(struct volume_group *vg, } int process_each_pv(int argc, char **argv, struct volume_group *vg, - int (*process_single) (struct volume_group * vg, - struct physical_volume * pv)) + int (*process_single) (struct volume_group *vg, + struct physical_volume *pv)) { int opt = 0; int ret_max = 0; @@ -301,8 +306,7 @@ char *default_vgname(struct format_instance *fi) } struct list *create_pv_list(struct pool *mem, - struct volume_group *vg, - int argc, char **argv) + struct volume_group *vg, int argc, char **argv) { struct list *r; struct pv_list *pvl, *new_pvl; @@ -338,5 +342,5 @@ struct list *create_pv_list(struct pool *mem, list_add(r, &new_pvl->list); } - return list_empty(r) ? NULL: r; + return list_empty(r) ? NULL : r; } diff --git a/tools/vgchange.c b/tools/vgchange.c index b58ee11ed..f6f1c11d0 100644 --- a/tools/vgchange.c +++ b/tools/vgchange.c @@ -56,6 +56,11 @@ static int vgchange_single(const char *vg_name) return ECMD_FAILED; } + if (!(vg->status & LVM_WRITE) && !arg_count(available_ARG)) { + log_error("Volume group %s is read-only", vg->name); + return ECMD_FAILED; + } + if (vg->status & EXPORTED_VG) { log_error("Volume group %s is exported", vg_name); return ECMD_FAILED; diff --git a/tools/vgexport.c b/tools/vgexport.c new file mode 100644 index 000000000..9ece85a13 --- /dev/null +++ b/tools/vgexport.c @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2001 Sistina Software + * + * LVM is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * LVM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with LVM; see the file COPYING. If not, write to + * the Free Software Foundation, 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + */ + +#include "tools.h" + +static int vgexport_single(const char *vg_name); + +int vgexport(int argc, char **argv) +{ + return process_each_vg(argc, argv, &vgexport_single); +} + +static int vgexport_single(const char *vg_name) +{ + struct volume_group *vg; + + if (!(vg = fid->ops->vg_read(fid, vg_name))) { + log_error("Unable to find volume group %s", vg_name); + return ECMD_FAILED; + } + + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is already exported", vg_name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + return ECMD_FAILED; + } + + if (lvs_in_vg_activated(vg)) { + log_error("Volume group %s has active logical volumes", + vg_name); + return ECMD_FAILED; + } + + if (!archive(vg)) + return ECMD_FAILED; + + vg->status |= EXPORTED_VG; + + if (!fid->ops->vg_write(fid,vg)) + return ECMD_FAILED; + + backup(vg); + + log_print("Volume group %s successfully exported", vg->name); + + return 0; +} diff --git a/tools/vgextend.c b/tools/vgextend.c index 1938cb008..6d81f2711 100644 --- a/tools/vgextend.c +++ b/tools/vgextend.c @@ -46,6 +46,16 @@ int vgextend(int argc, char **argv) return ECMD_FAILED; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + return ECMD_FAILED; + } + if (!(vg->status & RESIZEABLE_VG)) { log_error("Volume group '%s' is not resizeable.", vg_name); return ECMD_FAILED; diff --git a/tools/vgmerge.c b/tools/vgmerge.c index 08c98d92e..825b706d0 100644 --- a/tools/vgmerge.c +++ b/tools/vgmerge.c @@ -63,12 +63,32 @@ int vgmerge_single(const char *vg_name_to, const char *vg_name_from) return ECMD_FAILED; } + if (vg_to->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg_to->name); + return ECMD_FAILED; + } + + if (!(vg_to->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_to->name); + return ECMD_FAILED; + } + log_verbose("Checking for volume group %s", vg_name_from); if (!(vg_from = fid->ops->vg_read(fid, vg_name_from))) { log_error("Volume group %s doesn't exist", vg_name_from); return ECMD_FAILED; } + if (vg_from->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg_from->name); + return ECMD_FAILED; + } + + if (!(vg_from->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_from->name); + return ECMD_FAILED; + } + if ((active = lvs_in_vg_activated(vg_from))) { log_error("Logical volumes in %s must be inactive", vg_name_from); diff --git a/tools/vgreduce.c b/tools/vgreduce.c index 0aa88b858..d16fa0682 100644 --- a/tools/vgreduce.c +++ b/tools/vgreduce.c @@ -54,6 +54,16 @@ int vgreduce(int argc, char **argv) return ECMD_FAILED; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + return ECMD_FAILED; + } + + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + return ECMD_FAILED; + } + if (!(vg->status & RESIZEABLE_VG)) { log_error("Volume group %s is not reducable", vg_name); return ECMD_FAILED; diff --git a/tools/vgremove.c b/tools/vgremove.c index b73504950..13dcf0cef 100644 --- a/tools/vgremove.c +++ b/tools/vgremove.c @@ -40,6 +40,16 @@ static int vgremove_single(const char *vg_name) return ECMD_FAILED; } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + return ECMD_FAILED; + } + + if (vg->status & PARTIAL_VG) { + log_error("Cannot remove partial volume group %s", vg->name); + return ECMD_FAILED; + } + if (vg->lv_count) { log_error("Volume group %s still contains %d logical volume(s)", vg_name, vg->lv_count); diff --git a/tools/vgrename.c b/tools/vgrename.c index a98452426..4183df484 100644 --- a/tools/vgrename.c +++ b/tools/vgrename.c @@ -73,6 +73,16 @@ int vgrename(int argc, char **argv) return ECMD_FAILED; } + if (vg_old->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg_old->name); + return ECMD_FAILED; + } + + if (!(vg_old->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_old->name); + return ECMD_FAILED; + } + if (lvs_in_vg_activated(vg_old)) { log_error("Volume group %s still has active LVs", vg_name_old); /***** FIXME Handle this with multiple LV renames! diff --git a/tools/vgscan.c b/tools/vgscan.c index a60243b39..b09f0b6f7 100644 --- a/tools/vgscan.c +++ b/tools/vgscan.c @@ -50,7 +50,9 @@ static int vgscan_single(const char *vg_name) return ECMD_FAILED; } - log_print("Found volume group %s", vg_name); + log_print("Found %svolume group %s", + (vg->status & EXPORTED_VG) ? "exported " : "", + vg_name); return 0; }