From 651ff9b32865373f9f6298fbe7b0ea5419da3746 Mon Sep 17 00:00:00 2001 From: Alasdair Kergon Date: Mon, 14 Sep 2009 22:47:49 +0000 Subject: [PATCH] Add lots of missing stack debug messages to tools. Make readonly locking available as locking type 4. Fix readonly locking to permit writeable global locks (for vgscan). (2.02.49) --- WHATS_NEW | 4 ++ lib/locking/locking.c | 8 +++- lib/locking/no_locking.c | 5 ++- tools/dumpconfig.c | 4 +- tools/lvchange.c | 48 +++++++++++++++++------ tools/lvconvert.c | 16 ++++++-- tools/lvcreate.c | 9 ++++- tools/lvmcmdline.c | 4 +- tools/lvremove.c | 4 +- tools/lvrename.c | 1 + tools/polldaemon.c | 8 +++- tools/pvchange.c | 1 + tools/pvcreate.c | 4 +- tools/pvresize.c | 4 +- tools/pvscan.c | 1 + tools/reporter.c | 36 ++++++++++++----- tools/toollib.c | 12 +++--- tools/vgcfgbackup.c | 7 ++-- tools/vgcfgrestore.c | 8 ++-- tools/vgchange.c | 84 ++++++++++++++++++++++++++++++---------- tools/vgck.c | 12 ++++-- tools/vgconvert.c | 12 ++++-- tools/vgcreate.c | 10 ++--- tools/vgdisplay.c | 4 +- tools/vgexport.c | 10 ++--- tools/vgextend.c | 9 +++-- tools/vgimport.c | 12 +++--- tools/vgmerge.c | 10 ++++- tools/vgmknodes.c | 12 ++++-- tools/vgreduce.c | 14 +++---- tools/vgremove.c | 20 +++++++--- tools/vgrename.c | 4 +- tools/vgscan.c | 4 +- tools/vgsplit.c | 20 ++++++---- 34 files changed, 298 insertions(+), 123 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index a3d6e583c..d268403ef 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,8 @@ Version 2.02.52 - ================================= + Add lots of missing stack debug messages to tools. + Make readonly locking available as locking type 4. + Fix readonly locking to permit writeable global locks (for vgscan). (2.02.49) Add manpage entry for dmsetup's udevcomplete_all and udevcookies commands. Add DM_UDEV_RULES_VSN udev enviroment variable. Check that udev is running and set internal state appropriately. @@ -97,6 +100,7 @@ Version 2.02.50 - 28th July 2009 Version 2.02.49 - 15th July 2009 ================================ + Add readonly locking type to replace implementation of --ignorelockingfailure. Exclude VG_GLOBAL from vg_write_lock_held so scans open devs read-only again. Add unit test case for liblvm VG create/delete APIs. Add liblvm APIs to implement creation and deletion of VGs. diff --git a/lib/locking/locking.c b/lib/locking/locking.c index 121797443..9d864332f 100644 --- a/lib/locking/locking.c +++ b/lib/locking/locking.c @@ -261,6 +261,13 @@ int init_locking(int type, struct cmd_context *cmd) return 1; #endif + case 4: + log_verbose("Read-only locking selected. " + "Only read operations permitted."); + if (!init_readonly_locking(&_locking, cmd)) + break; + return 1; + default: log_error("Unknown locking type requested."); return 0; @@ -280,7 +287,6 @@ int init_locking(int type, struct cmd_context *cmd) if (!ignorelockingfailure()) return 0; - /* FIXME Ensure only read ops are permitted */ log_verbose("Locking disabled - only read operations permitted."); init_readonly_locking(&_locking, cmd); diff --git a/lib/locking/no_locking.c b/lib/locking/no_locking.c index 583ab5c26..f4a14ad6d 100644 --- a/lib/locking/no_locking.c +++ b/lib/locking/no_locking.c @@ -71,10 +71,13 @@ static int _readonly_lock_resource(struct cmd_context *cmd, uint32_t flags) { if ((flags & LCK_TYPE_MASK) == LCK_WRITE && - (flags & LCK_SCOPE_MASK) == LCK_VG) { + (flags & LCK_SCOPE_MASK) == LCK_VG && + !(flags & LCK_CACHE) && + strcmp(resource, VG_GLOBAL)) { log_error("Write locks are prohibited with --ignorelockingfailure."); return 0; } + return _no_lock_resource(cmd, resource, flags); } diff --git a/tools/dumpconfig.c b/tools/dumpconfig.c index 8cf1d84bf..c7c58c15e 100644 --- a/tools/dumpconfig.c +++ b/tools/dumpconfig.c @@ -22,8 +22,10 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv) if (arg_count(cmd, file_ARG)) file = arg_str_value(cmd, file_ARG, ""); - if (!write_config_file(cmd->cft, file, argc, argv)) + if (!write_config_file(cmd->cft, file, argc, argv)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/lvchange.c b/tools/lvchange.c index b16fd14a7..b9be0c2a1 100644 --- a/tools/lvchange.c +++ b/tools/lvchange.c @@ -591,8 +591,10 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv, /* access permission change */ if (arg_count(cmd, permission_ARG)) { - if (!archive(lv->vg)) + if (!archive(lv->vg)) { + stack; return ECMD_FAILED; + } archived = 1; doit += lvchange_permission(cmd, lv); docmds++; @@ -600,8 +602,10 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv, /* allocation policy change */ if (arg_count(cmd, contiguous_ARG) || arg_count(cmd, alloc_ARG)) { - if (!archived && !archive(lv->vg)) + if (!archived && !archive(lv->vg)) { + stack; return ECMD_FAILED; + } archived = 1; doit += lvchange_alloc(cmd, lv); docmds++; @@ -609,8 +613,10 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv, /* read ahead sector change */ if (arg_count(cmd, readahead_ARG)) { - if (!archived && !archive(lv->vg)) + if (!archived && !archive(lv->vg)) { + stack; return ECMD_FAILED; + } archived = 1; doit += lvchange_readahead(cmd, lv); docmds++; @@ -618,19 +624,25 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv, /* read ahead sector change */ if (arg_count(cmd, persistent_ARG)) { - if (!archived && !archive(lv->vg)) + if (!archived && !archive(lv->vg)) { + stack; return ECMD_FAILED; + } archived = 1; doit += lvchange_persistent(cmd, lv); docmds++; - if (sigint_caught()) + if (sigint_caught()) { + stack; return ECMD_FAILED; + } } /* add tag */ if (arg_count(cmd, addtag_ARG)) { - if (!archived && !archive(lv->vg)) + if (!archived && !archive(lv->vg)) { + stack; return ECMD_FAILED; + } archived = 1; doit += lvchange_tag(cmd, lv, addtag_ARG); docmds++; @@ -638,8 +650,10 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv, /* del tag */ if (arg_count(cmd, deltag_ARG)) { - if (!archived && !archive(lv->vg)) + if (!archived && !archive(lv->vg)) { + stack; return ECMD_FAILED; + } archived = 1; doit += lvchange_tag(cmd, lv, deltag_ARG); docmds++; @@ -649,28 +663,38 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv, log_print("Logical volume \"%s\" changed", lv->name); if (arg_count(cmd, resync_ARG)) - if (!lvchange_resync(cmd, lv)) + if (!lvchange_resync(cmd, lv)) { + stack; return ECMD_FAILED; + } /* availability change */ if (arg_count(cmd, available_ARG)) { - if (!lvchange_availability(cmd, lv)) + if (!lvchange_availability(cmd, lv)) { + stack; return ECMD_FAILED; + } } if (arg_count(cmd, refresh_ARG)) - if (!lvchange_refresh(cmd, lv)) + if (!lvchange_refresh(cmd, lv)) { + stack; return ECMD_FAILED; + } if (!arg_count(cmd, available_ARG) && !arg_count(cmd, refresh_ARG) && arg_count(cmd, monitor_ARG)) { - if (!lvchange_monitoring(cmd, lv)) + if (!lvchange_monitoring(cmd, lv)) { + stack; return ECMD_FAILED; + } } - if (doit != docmds) + if (doit != docmds) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/lvconvert.c b/tools/lvconvert.c index b3deebcd0..79a459cd1 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -904,15 +904,23 @@ static int lvconvert_single(struct cmd_context *cmd, struct logical_volume *lv, log_error("Unable to convert mirrored LV \"%s\" into a snapshot.", lv->name); return ECMD_FAILED; } - if (!archive(lv->vg)) + if (!archive(lv->vg)) { + stack; return ECMD_FAILED; - if (!lvconvert_snapshot(cmd, lv, lp)) + } + if (!lvconvert_snapshot(cmd, lv, lp)) { + stack; return ECMD_FAILED; + } } else if (arg_count(cmd, mirrors_ARG) || (lv->status & MIRRORED)) { - if (!archive(lv->vg)) + if (!archive(lv->vg)) { + stack; return ECMD_FAILED; - if (!_lvconvert_mirrors(cmd, lv, lp)) + } + if (!_lvconvert_mirrors(cmd, lv, lp)) { + stack; return ECMD_FAILED; + } } return ECMD_PROCESSED; diff --git a/tools/lvcreate.c b/tools/lvcreate.c index 53943d7b5..be6b5ccea 100644 --- a/tools/lvcreate.c +++ b/tools/lvcreate.c @@ -586,14 +586,19 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) vg = vg_read_for_update(cmd, lp.vg_name, NULL, 0); if (vg_read_error(vg)) { vg_release(vg); + stack; return ECMD_FAILED; } - if (!_update_extents_params(vg, &lp, &lcp)) + if (!_update_extents_params(vg, &lp, &lcp)) { + stack; return ECMD_FAILED; + } - if (!lv_create_single(vg, &lp)) + if (!lv_create_single(vg, &lp)) { + stack; r = ECMD_FAILED; + } unlock_and_release_vg(cmd, vg, lp.vg_name); return r; diff --git a/tools/lvmcmdline.c b/tools/lvmcmdline.c index d13c57c08..80c1a4695 100644 --- a/tools/lvmcmdline.c +++ b/tools/lvmcmdline.c @@ -963,8 +963,10 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv) /* each command should start out with sigint flag cleared */ sigint_clear(); - if (!(cmd->cmd_line = _copy_command_line(cmd, argc, argv))) + if (!(cmd->cmd_line = _copy_command_line(cmd, argc, argv))) { + stack; return ECMD_FAILED; + } log_debug("Parsing: %s", cmd->cmd_line); diff --git a/tools/lvremove.c b/tools/lvremove.c index be2107a04..fd8a677cc 100644 --- a/tools/lvremove.c +++ b/tools/lvremove.c @@ -26,8 +26,10 @@ static int lvremove_single(struct cmd_context *cmd, struct logical_volume *lv, if (lv_is_cow(lv) && lv_is_virtual_origin(origin = origin_from_cow(lv))) lv = origin; - if (!lv_remove_with_dependencies(cmd, lv, arg_count(cmd, force_ARG))) + if (!lv_remove_with_dependencies(cmd, lv, arg_count(cmd, force_ARG))) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/lvrename.c b/tools/lvrename.c index 74118546b..2342ad0ed 100644 --- a/tools/lvrename.c +++ b/tools/lvrename.c @@ -105,6 +105,7 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv) vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) { vg_release(vg); + stack; return ECMD_FAILED; } diff --git a/tools/polldaemon.c b/tools/polldaemon.c index 4dcbc22ee..bd2ac20fb 100644 --- a/tools/polldaemon.c +++ b/tools/polldaemon.c @@ -185,8 +185,10 @@ static int _poll_vg(struct cmd_context *cmd, const char *vgname, const char *name; int finished; - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } dm_list_iterate_items(lvl, &vg->lvs) { lv_mirr = lvl->lv; @@ -253,8 +255,10 @@ int poll_daemon(struct cmd_context *cmd, const char *name, const char *uuid, } if (name) { - if (!_wait_for_single_mirror(cmd, name, uuid, &parms)) + if (!_wait_for_single_mirror(cmd, name, uuid, &parms)) { + stack; return ECMD_FAILED; + } } else _poll_for_all_vgs(cmd, &parms); diff --git a/tools/pvchange.c b/tools/pvchange.c index def78cc26..cba9dd255 100644 --- a/tools/pvchange.c +++ b/tools/pvchange.c @@ -274,6 +274,7 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv) } else { log_verbose("Scanning for physical volume names"); if (!(pvslist = get_pvs(cmd))) { + stack; return ECMD_FAILED; } diff --git a/tools/pvcreate.c b/tools/pvcreate.c index a22190d76..994963191 100644 --- a/tools/pvcreate.c +++ b/tools/pvcreate.c @@ -195,8 +195,10 @@ int pvcreate(struct cmd_context *cmd, int argc, char **argv) return ECMD_FAILED; } - if (!pvcreate_single(cmd, argv[i], &pp)) + if (!pvcreate_single(cmd, argv[i], &pp)) { + stack; ret = ECMD_FAILED; + } unlock_vg(cmd, VG_ORPHANS); if (sigint_caught()) diff --git a/tools/pvresize.c b/tools/pvresize.c index eafbd56d8..7a911ac83 100644 --- a/tools/pvresize.c +++ b/tools/pvresize.c @@ -176,8 +176,10 @@ static int _pvresize_single(struct cmd_context *cmd, params->total++; - if (!_pv_resize_single(cmd, vg, pv, params->new_size)) + if (!_pv_resize_single(cmd, vg, pv, params->new_size)) { + stack; return ECMD_FAILED; + } params->done++; diff --git a/tools/pvscan.c b/tools/pvscan.c index 494af3d98..775ba291f 100644 --- a/tools/pvscan.c +++ b/tools/pvscan.c @@ -135,6 +135,7 @@ int pvscan(struct cmd_context *cmd, int argc __attribute((unused)), log_verbose("Walking through all physical volumes"); if (!(pvslist = get_pvs(cmd))) { unlock_vg(cmd, VG_GLOBAL); + stack; return ECMD_FAILED; } diff --git a/tools/reporter.c b/tools/reporter.c index e391ee20e..b200a9647 100644 --- a/tools/reporter.c +++ b/tools/reporter.c @@ -20,11 +20,15 @@ static int _vgs_single(struct cmd_context *cmd __attribute((unused)), const char *vg_name, struct volume_group *vg, void *handle) { - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } - if (!report_object(handle, vg, NULL, NULL, NULL, NULL)) + if (!report_object(handle, vg, NULL, NULL, NULL, NULL)) { + stack; return ECMD_FAILED; + } check_current_backup(vg); @@ -37,8 +41,10 @@ static int _lvs_single(struct cmd_context *cmd, struct logical_volume *lv, if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) return ECMD_PROCESSED; - if (!report_object(handle, lv->vg, lv, NULL, NULL, NULL)) + if (!report_object(handle, lv->vg, lv, NULL, NULL, NULL)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } @@ -46,8 +52,10 @@ static int _lvs_single(struct cmd_context *cmd, struct logical_volume *lv, static int _segs_single(struct cmd_context *cmd __attribute((unused)), struct lv_segment *seg, void *handle) { - if (!report_object(handle, seg->lv->vg, seg->lv, NULL, seg, NULL)) + if (!report_object(handle, seg->lv->vg, seg->lv, NULL, seg, NULL)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } @@ -102,8 +110,10 @@ static int _pvsegs_sub_single(struct cmd_context *cmd, dm_list_init(&_free_logical_volume.snapshot_segs); if (!report_object(handle, vg, seg ? seg->lv : &_free_logical_volume, pvseg->pv, - seg ? : &_free_lv_segment, pvseg)) + seg ? : &_free_lv_segment, pvseg)) { + stack; ret = ECMD_FAILED; + } return ret; } @@ -155,8 +165,10 @@ static int _pvs_single(struct cmd_context *cmd, struct volume_group *vg, pv = pvl->pv; } - if (!report_object(handle, vg, NULL, pv, NULL, NULL)) + if (!report_object(handle, vg, NULL, pv, NULL, NULL)) { + stack; ret = ECMD_FAILED; + } out: if (vg_name) @@ -171,8 +183,10 @@ out: static int _label_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv, void *handle) { - if (!report_object(handle, vg, NULL, pv, NULL, NULL)) + if (!report_object(handle, vg, NULL, pv, NULL, NULL)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } @@ -181,8 +195,10 @@ static int _pvs_in_vg(struct cmd_context *cmd, const char *vg_name, struct volume_group *vg, void *handle) { - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } return process_each_pv_in_vg(cmd, vg, NULL, handle, &_pvs_single); } @@ -191,8 +207,10 @@ static int _pvsegs_in_vg(struct cmd_context *cmd, const char *vg_name, struct volume_group *vg, void *handle) { - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } return process_each_pv_in_vg(cmd, vg, NULL, handle, &_pvsegs_single); } diff --git a/tools/toollib.c b/tools/toollib.c index 54539ee26..d45e3a01c 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -293,7 +293,8 @@ int process_each_lv(struct cmd_context *cmd, int argc, char **argv, if (ret_max < ECMD_FAILED) { log_error("Skipping volume group %s", vgname); ret_max = ECMD_FAILED; - } + } else + stack; continue; } @@ -431,9 +432,10 @@ static int _process_one_vg(struct cmd_context *cmd, const char *vg_name, log_verbose("Finding volume group \"%s\"", vg_name); vg = vg_read(cmd, vg_name, vgid, flags); - if (vg_read_error(vg) == FAILED_ALLOCATION || - vg_read_error(vg) == FAILED_NOTFOUND) { + /* Allow FAILED_INCONSISTENT through only for vgcfgrestore */ + if (vg_read_error(vg) && (vg_read_error(vg) != FAILED_INCONSISTENT)) { vg_release(vg); + stack; return ECMD_FAILED; } @@ -445,9 +447,8 @@ static int _process_one_vg(struct cmd_context *cmd, const char *vg_name, } if ((ret = process_single(cmd, vg_name, vg, - handle)) > ret_max) { + handle)) > ret_max) ret_max = ret; - } out: unlock_and_release_vg(cmd, vg, vg_name); @@ -728,6 +729,7 @@ int process_each_pv(struct cmd_context *cmd, int argc, char **argv, if (vg_read_error(vg)) { ret_max = ECMD_FAILED; vg_release(vg); + stack; continue; } diff --git a/tools/vgcfgbackup.c b/tools/vgcfgbackup.c index 2491b8ce9..4c61714e3 100644 --- a/tools/vgcfgbackup.c +++ b/tools/vgcfgbackup.c @@ -54,9 +54,6 @@ static int vg_backup_single(struct cmd_context *cmd, const char *vg_name, char **last_filename = (char **)handle; char *filename; - if (vg_read_error(vg) && (vg_read_error(vg) != FAILED_INCONSISTENT)) - return ECMD_FAILED; - if (arg_count(cmd, file_ARG)) { if (!(filename = _expand_filename(arg_value(cmd, file_ARG), vg->name, last_filename))) { @@ -64,8 +61,10 @@ static int vg_backup_single(struct cmd_context *cmd, const char *vg_name, return ECMD_FAILED; } - if (!backup_to_file(filename, vg->cmd->cmd_line, vg)) + if (!backup_to_file(filename, vg->cmd->cmd_line, vg)) { + stack; return ECMD_FAILED; + } } else { if (vg_read_error(vg) == FAILED_INCONSISTENT) { log_error("No backup taken: specify filename with -f " diff --git a/tools/vgcfgrestore.c b/tools/vgcfgrestore.c index dda22beac..90e15174d 100644 --- a/tools/vgcfgrestore.c +++ b/tools/vgcfgrestore.c @@ -36,10 +36,12 @@ int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv) */ if (arg_count(cmd, list_ARG)) { if (!(arg_count(cmd,file_ARG) ? - archive_display_file(cmd, - arg_str_value(cmd, file_ARG, "")) : - archive_display(cmd, vg_name))) + archive_display_file(cmd, + arg_str_value(cmd, file_ARG, "")) : + archive_display(cmd, vg_name))) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/vgchange.c b/tools/vgchange.c index b3177eb43..8a3c2031e 100644 --- a/tools/vgchange.c +++ b/tools/vgchange.c @@ -179,8 +179,10 @@ static int _vgchange_alloc(struct cmd_context *cmd, struct volume_group *vg) alloc = arg_uint_value(cmd, alloc_ARG, ALLOC_NORMAL); - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } /* FIXME: make consistent with vg_set_alloc_policy() */ if (alloc == vg->alloc) { @@ -188,11 +190,15 @@ static int _vgchange_alloc(struct cmd_context *cmd, struct volume_group *vg) get_alloc_string(vg->alloc)); return ECMD_FAILED; } - if (!vg_set_alloc_policy(vg, alloc)) + if (!vg_set_alloc_policy(vg, alloc)) { + stack; return ECMD_FAILED; + } - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -218,16 +224,20 @@ static int _vgchange_resizeable(struct cmd_context *cmd, return ECMD_FAILED; } - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } if (resizeable) vg->status |= RESIZEABLE_VG; else vg->status &= ~RESIZEABLE_VG; - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -265,16 +275,20 @@ static int _vgchange_clustered(struct cmd_context *cmd, } } - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } if (clustered) vg->status |= CLUSTERED; else vg->status &= ~CLUSTERED; - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -288,14 +302,20 @@ static int _vgchange_logicalvolume(struct cmd_context *cmd, { uint32_t max_lv = arg_uint_value(cmd, logicalvolume_ARG, 0); - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } - if (!vg_set_max_lv(vg, max_lv)) + if (!vg_set_max_lv(vg, max_lv)) { + stack; return ECMD_FAILED; + } - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -314,14 +334,20 @@ static int _vgchange_physicalvolumes(struct cmd_context *cmd, return EINVALID_CMD_LINE; } - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } - if (!vg_set_max_pv(vg, max_pv)) + if (!vg_set_max_pv(vg, max_pv)) { + stack; return ECMD_FAILED; + } - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -347,16 +373,20 @@ static int _vgchange_pesize(struct cmd_context *cmd, struct volume_group *vg) return ECMD_PROCESSED; } - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } if (!vg_set_extent_size(vg, extent_size)) { stack; return EINVALID_CMD_LINE; } - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -380,8 +410,10 @@ static int _vgchange_tag(struct cmd_context *cmd, struct volume_group *vg, return ECMD_FAILED; } - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } if ((arg == addtag_ARG)) { if (!str_list_add(cmd->mem, &vg->tags, tag)) { @@ -397,8 +429,10 @@ static int _vgchange_tag(struct cmd_context *cmd, struct volume_group *vg, } } - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -417,8 +451,10 @@ static int _vgchange_uuid(struct cmd_context *cmd __attribute((unused)), return ECMD_FAILED; } - if (!archive(vg)) + if (!archive(vg)) { + stack; return ECMD_FAILED; + } if (!id_create(&vg->id)) { log_error("Failed to generate new random UUID for VG %s.", @@ -430,8 +466,10 @@ static int _vgchange_uuid(struct cmd_context *cmd __attribute((unused)), memcpy(&lvl->lv->lvid, &vg->id, sizeof(vg->id)); } - if (!vg_write(vg) || !vg_commit(vg)) + if (!vg_write(vg) || !vg_commit(vg)) { + stack; return ECMD_FAILED; + } backup(vg); @@ -444,8 +482,10 @@ static int _vgchange_refresh(struct cmd_context *cmd, struct volume_group *vg) { log_verbose("Refreshing volume group \"%s\"", vg->name); - if (!vg_refresh_visible(cmd, vg)) + if (!vg_refresh_visible(cmd, vg)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } @@ -456,8 +496,10 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name, { int r = ECMD_FAILED; - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } if (vg_is_exported(vg)) { log_error("Volume group \"%s\" is exported", vg_name); diff --git a/tools/vgck.c b/tools/vgck.c index 0c867ce68..690e48d61 100644 --- a/tools/vgck.c +++ b/tools/vgck.c @@ -21,14 +21,20 @@ static int vgck_single(struct cmd_context *cmd __attribute((unused)), struct volume_group *vg, void *handle __attribute((unused))) { - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } - if (!vg_check_status(vg, EXPORTED_VG)) + if (!vg_check_status(vg, EXPORTED_VG)) { + stack; return ECMD_FAILED; + } - if (!vg_validate(vg)) + if (!vg_validate(vg)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/vgconvert.c b/tools/vgconvert.c index d24b010ff..2263baa44 100644 --- a/tools/vgconvert.c +++ b/tools/vgconvert.c @@ -32,11 +32,15 @@ static int vgconvert_single(struct cmd_context *cmd, const char *vg_name, struct lvinfo info; int active = 0; - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } - if (!vg_check_status(vg, LVM_WRITE | EXPORTED_VG)) + if (!vg_check_status(vg, LVM_WRITE | EXPORTED_VG)) { + stack; return ECMD_FAILED; + } if (vg->fid->fmt == cmd->fmt) { log_error("Volume group \"%s\" already uses format %s", @@ -111,8 +115,10 @@ static int vgconvert_single(struct cmd_context *cmd, const char *vg_name, } } - if (active) + if (active) { + stack; return ECMD_FAILED; + } dm_list_iterate_items(pvl, &vg->pvs) { existing_pv = pvl->pv; diff --git a/tools/vgcreate.c b/tools/vgcreate.c index dff3a5d13..2100877c1 100644 --- a/tools/vgcreate.c +++ b/tools/vgcreate.c @@ -102,14 +102,12 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv) clustered_message = "Non-clustered "; } - if (!archive(vg)) { - goto bad; - } + if (!archive(vg)) + goto_bad; /* Store VG on disk(s) */ - if (!vg_write(vg) || !vg_commit(vg)) { - goto bad; - } + if (!vg_write(vg) || !vg_commit(vg)) + goto_bad; unlock_vg(cmd, VG_ORPHANS); unlock_vg(cmd, vp_new.vg_name); diff --git a/tools/vgdisplay.c b/tools/vgdisplay.c index bbabceefb..3876d3511 100644 --- a/tools/vgdisplay.c +++ b/tools/vgdisplay.c @@ -20,8 +20,10 @@ static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name, void *handle __attribute((unused))) { /* FIXME Do the active check here if activevolumegroups_ARG ? */ - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } vg_check_status(vg, EXPORTED_VG); diff --git a/tools/vgexport.c b/tools/vgexport.c index 59627b971..e3b1890eb 100644 --- a/tools/vgexport.c +++ b/tools/vgexport.c @@ -24,16 +24,16 @@ static int vgexport_single(struct cmd_context *cmd __attribute((unused)), struct physical_volume *pv; if (vg_read_error(vg)) - goto error; + goto_bad; if (lvs_in_vg_activated(vg)) { log_error("Volume group \"%s\" has active logical volumes", vg_name); - goto error; + goto bad; } if (!archive(vg)) - goto error; + goto_bad; vg->status |= EXPORTED_VG; @@ -43,7 +43,7 @@ static int vgexport_single(struct cmd_context *cmd __attribute((unused)), } if (!vg_write(vg) || !vg_commit(vg)) - goto error; + goto_bad; backup(vg); @@ -51,7 +51,7 @@ static int vgexport_single(struct cmd_context *cmd __attribute((unused)), return ECMD_PROCESSED; - error: +bad: return ECMD_FAILED; } diff --git a/tools/vgextend.c b/tools/vgextend.c index 20c05c3d7..b659492eb 100644 --- a/tools/vgextend.c +++ b/tools/vgextend.c @@ -40,6 +40,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) { vg_release(vg); + stack; return ECMD_FAILED; } @@ -50,11 +51,11 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) } if (!archive(vg)) - goto error; + goto_bad; /* extend vg */ if (!vg_extend(vg, argc, argv)) - goto error; + goto_bad; /* ret > 0 */ log_verbose("Volume group \"%s\" will be extended by %d new " @@ -62,13 +63,13 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) /* store vg on disk(s) */ if (!vg_write(vg) || !vg_commit(vg)) - goto error; + goto_bad; backup(vg); log_print("Volume group \"%s\" successfully extended", vg_name); r = ECMD_PROCESSED; -error: +bad: unlock_vg(cmd, VG_ORPHANS); unlock_and_release_vg(cmd, vg, vg_name); return r; diff --git a/tools/vgimport.c b/tools/vgimport.c index 5161b6236..7eeb5db3f 100644 --- a/tools/vgimport.c +++ b/tools/vgimport.c @@ -24,20 +24,20 @@ static int vgimport_single(struct cmd_context *cmd __attribute((unused)), struct physical_volume *pv; if (vg_read_error(vg)) - goto error; + goto_bad; if (!vg_is_exported(vg)) { log_error("Volume group \"%s\" is not exported", vg_name); - goto error; + goto bad; } if (vg_status(vg) & PARTIAL_VG) { log_error("Volume group \"%s\" is partially missing", vg_name); - goto error; + goto bad; } if (!archive(vg)) - goto error; + goto_bad; vg->status &= ~EXPORTED_VG; @@ -47,7 +47,7 @@ static int vgimport_single(struct cmd_context *cmd __attribute((unused)), } if (!vg_write(vg) || !vg_commit(vg)) - goto error; + goto_bad; backup(vg); @@ -55,7 +55,7 @@ static int vgimport_single(struct cmd_context *cmd __attribute((unused)), return ECMD_PROCESSED; - error: +bad: return ECMD_FAILED; } diff --git a/tools/vgmerge.c b/tools/vgmerge.c index e147d27b2..4a6721d17 100644 --- a/tools/vgmerge.c +++ b/tools/vgmerge.c @@ -46,20 +46,26 @@ static int _vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, if (lock_vg_from_first) { vg_from = _vgmerge_vg_read(cmd, vg_name_from); - if (!vg_from) + if (!vg_from) { + stack; return ECMD_FAILED; + } vg_to = _vgmerge_vg_read(cmd, vg_name_to); if (!vg_to) { + stack; unlock_and_release_vg(cmd, vg_from, vg_name_from); return ECMD_FAILED; } } else { vg_to = _vgmerge_vg_read(cmd, vg_name_to); - if (!vg_to) + if (!vg_to) { + stack; return ECMD_FAILED; + } vg_from = _vgmerge_vg_read(cmd, vg_name_from); if (!vg_from) { + stack; unlock_and_release_vg(cmd, vg_to, vg_name_to); return ECMD_FAILED; } diff --git a/tools/vgmknodes.c b/tools/vgmknodes.c index fce925b49..f62b58934 100644 --- a/tools/vgmknodes.c +++ b/tools/vgmknodes.c @@ -19,19 +19,25 @@ static int _vgmknodes_single(struct cmd_context *cmd, struct logical_volume *lv, void *handle __attribute((unused))) { if (arg_count(cmd, refresh_ARG) && lv_is_visible(lv)) - if (!lv_refresh(cmd, lv)) + if (!lv_refresh(cmd, lv)) { + stack; return ECMD_FAILED; + } - if (!lv_mknodes(cmd, lv)) + if (!lv_mknodes(cmd, lv)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } int vgmknodes(struct cmd_context *cmd, int argc, char **argv) { - if (!lv_mknodes(cmd, NULL)) + if (!lv_mknodes(cmd, NULL)) { + stack; return ECMD_FAILED; + } return process_each_lv(cmd, argc, argv, LCK_VG_READ, NULL, &_vgmknodes_single); diff --git a/tools/vgreduce.c b/tools/vgreduce.c index 8b66a9927..e80fa9adb 100644 --- a/tools/vgreduce.c +++ b/tools/vgreduce.c @@ -404,7 +404,7 @@ static int _vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, pvl = find_pv_in_vg(vg, name); if (!archive(vg)) - goto bad; + goto_bad; log_verbose("Removing \"%s\" from volume group \"%s\"", name, vg->name); @@ -512,12 +512,12 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv) vg = vg_read_for_update(cmd, vg_name, NULL, READ_ALLOW_EXPORTED); if (vg_read_error(vg) == FAILED_ALLOCATION || vg_read_error(vg) == FAILED_NOTFOUND) - goto out; + goto_out; /* FIXME We want to allow read-only VGs to be changed here? */ if (vg_read_error(vg) && vg_read_error(vg) != FAILED_READ_ONLY && !arg_count(cmd, removemissing_ARG)) - goto out; + goto_out; if (repairing) { if (!vg_read_error(vg) && !vg_missing_pv_count(vg)) { @@ -536,14 +536,14 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv) if (vg_read_error(vg) && vg_read_error(vg) != FAILED_READ_ONLY && vg_read_error(vg) != FAILED_INCONSISTENT) - goto out; + goto_out; if (!archive(vg)) - goto out; + goto_out; if (arg_count(cmd, force_ARG)) { if (!_make_vg_consistent(cmd, vg)) - goto out; + goto_out; } else fixed = _consolidate_vg(cmd, vg); @@ -563,7 +563,7 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv) } else { if (!vg_check_status(vg, EXPORTED_VG | LVM_WRITE | RESIZEABLE_VG)) - goto out; + goto_out; /* FIXME: Pass private struct through to all these functions */ /* and update in batch here? */ diff --git a/tools/vgremove.c b/tools/vgremove.c index abcd9400c..c5b5dcfe9 100644 --- a/tools/vgremove.c +++ b/tools/vgremove.c @@ -22,11 +22,15 @@ static int vgremove_single(struct cmd_context *cmd, const char *vg_name, unsigned lv_count; force_t force; - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } - if (!vg_check_status(vg, EXPORTED_VG)) + if (!vg_check_status(vg, EXPORTED_VG)) { + stack; return ECMD_FAILED; + } lv_count = vg_visible_lvs(vg); @@ -40,15 +44,21 @@ static int vgremove_single(struct cmd_context *cmd, const char *vg_name, log_print("Volume group \"%s\" not removed", vg_name); return ECMD_FAILED; } - if (!remove_lvs_in_vg(cmd, vg, force)) + if (!remove_lvs_in_vg(cmd, vg, force)) { + stack; return ECMD_FAILED; + } } - if (!vg_remove_check(vg)) + if (!vg_remove_check(vg)) { + stack; return ECMD_FAILED; + } - if (!vg_remove(vg)) + if (!vg_remove(vg)) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/vgrename.c b/tools/vgrename.c index e6f12b467..f1c477995 100644 --- a/tools/vgrename.c +++ b/tools/vgrename.c @@ -206,8 +206,10 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } - if (!vg_rename_path(cmd, argv[0], argv[1])) + if (!vg_rename_path(cmd, argv[0], argv[1])) { + stack; return ECMD_FAILED; + } return ECMD_PROCESSED; } diff --git a/tools/vgscan.c b/tools/vgscan.c index a7aef5f05..c0f079082 100644 --- a/tools/vgscan.c +++ b/tools/vgscan.c @@ -19,8 +19,10 @@ static int vgscan_single(struct cmd_context *cmd, const char *vg_name, struct volume_group *vg, void *handle __attribute((unused))) { - if (vg_read_error(vg)) + if (vg_read_error(vg)) { + stack; return ECMD_FAILED; + } log_print("Found %svolume group \"%s\" using metadata type %s", vg_is_exported(vg) ? "exported " : "", vg_name, diff --git a/tools/vgsplit.c b/tools/vgsplit.c index 751c970d8..c00561bb6 100644 --- a/tools/vgsplit.c +++ b/tools/vgsplit.c @@ -319,8 +319,10 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv) if (lock_vg_from_first) { vg_from = _vgsplit_from(cmd, vg_name_from); - if (!vg_from) + if (!vg_from) { + stack; return ECMD_FAILED; + } /* * Set metadata format of original VG. * NOTE: We must set the format before calling vg_create() @@ -331,15 +333,19 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv) vg_to = _vgsplit_to(cmd, vg_name_to, &existing_vg); if (!vg_to) { unlock_and_release_vg(cmd, vg_from, vg_name_from); + stack; return ECMD_FAILED; } } else { vg_to = _vgsplit_to(cmd, vg_name_to, &existing_vg); - if (!vg_to) + if (!vg_to) { + stack; return ECMD_FAILED; + } vg_from = _vgsplit_from(cmd, vg_name_from); if (!vg_from) { unlock_and_release_vg(cmd, vg_to, vg_name_to); + stack; return ECMD_FAILED; } @@ -355,7 +361,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv) if (new_vg_option_specified(cmd)) { log_error("Volume group \"%s\" exists, but new VG " "option specified", vg_name_to); - goto_bad; + goto bad; } if (!vgs_are_compatible(cmd, vg_from,vg_to)) goto_bad; @@ -369,12 +375,12 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv) if (fill_vg_create_params(cmd, vg_name_to, &vp_new, &vp_def)) { r = EINVALID_CMD_LINE; - goto bad; + goto_bad; } if (validate_vg_create_params(cmd, &vp_new)) { r = EINVALID_CMD_LINE; - goto bad; + goto_bad; } if (!vg_set_extent_size(vg_to, vp_new.extent_size) || @@ -416,7 +422,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv) /* Split metadata areas and check if both vgs have at least one area */ if (!(vg_split_mdas(cmd, vg_from, vg_to)) && vg_from->pv_count) { log_error("Cannot split: Nowhere to store metadata for new Volume Group"); - goto_bad; + goto bad; } /* Set proper name for all PVs in new VG */ @@ -465,7 +471,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv) if (vg_read_error(vg_to)) { log_error("Volume group \"%s\" became inconsistent: " "please fix manually", vg_name_to); - goto_bad; + goto bad; } }