shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2025-01-02 01:18:26 +03:00
Code Releases Activity

tools: Use arg_is_set instead of arg_count.

Browse Source
This commit is contained in:
Alasdair G Kergon 2016-06-21 22:24:52 +01:00
parent 6c269e639a
commit 7e671e5dd0
29 changed files with 432 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
tools/dumpconfig.c
View File

@ -20,9 +20,9 @@ static int _get_vsn(struct cmd_context *cmd, uint16_t *version_int)
const char *vsn; const char *vsn;
unsigned int major, minor, patchlevel; unsigned int major, minor, patchlevel;
if (arg_count(cmd, atversion_ARG)) if (arg_is_set(cmd, atversion_ARG))
vsn = arg_str_value(cmd, atversion_ARG, NULL); vsn = arg_str_value(cmd, atversion_ARG, NULL);
else if (arg_count(cmd, sinceversion_ARG)) else if (arg_is_set(cmd, sinceversion_ARG))
vsn = arg_str_value(cmd, sinceversion_ARG, NULL); vsn = arg_str_value(cmd, sinceversion_ARG, NULL);
else else
vsn = LVM_VERSION; vsn = LVM_VERSION;
@ -98,7 +98,7 @@ static int _config_validate(struct cmd_context *cmd, struct dm_config_tree *cft)
int dumpconfig(struct cmd_context *cmd, int argc, char **argv) int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
{ {
const char *file = arg_str_value(cmd, file_ARG, NULL); const char *file = arg_str_value(cmd, file_ARG, NULL);
const char *type = arg_str_value(cmd, configtype_ARG, arg_count(cmd, list_ARG) ? "list" : "current"); const char *type = arg_str_value(cmd, configtype_ARG, arg_is_set(cmd, list_ARG) ? "list" : "current");
struct config_def_tree_spec tree_spec = {0}; struct config_def_tree_spec tree_spec = {0};
struct dm_config_tree *cft = NULL; struct dm_config_tree *cft = NULL;
struct cft_check_handle *cft_check_handle = NULL; struct cft_check_handle *cft_check_handle = NULL;
@ -107,43 +107,43 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
tree_spec.cmd = cmd; tree_spec.cmd = cmd;
if (arg_count(cmd, configtype_ARG) && arg_count(cmd, validate_ARG)) { if (arg_is_set(cmd, configtype_ARG) && arg_is_set(cmd, validate_ARG)) {
log_error("Only one of --type and --validate permitted."); log_error("Only one of --type and --validate permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, configtype_ARG) && arg_count(cmd, list_ARG)) { if (arg_is_set(cmd, configtype_ARG) && arg_is_set(cmd, list_ARG)) {
log_error("Only one of --type and --list permitted."); log_error("Only one of --type and --list permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, atversion_ARG)) { if (arg_is_set(cmd, atversion_ARG)) {
if (arg_count(cmd, sinceversion_ARG)) { if (arg_is_set(cmd, sinceversion_ARG)) {
log_error("Only one of --atversion and --sinceversion permitted."); log_error("Only one of --atversion and --sinceversion permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (!arg_count(cmd, configtype_ARG) && !arg_count(cmd, list_ARG)) { if (!arg_is_set(cmd, configtype_ARG) && !arg_is_set(cmd, list_ARG)) {
log_error("--atversion requires --type or --list"); log_error("--atversion requires --type or --list");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
} else if (arg_count(cmd, sinceversion_ARG)) { } else if (arg_is_set(cmd, sinceversion_ARG)) {
if (!arg_count(cmd, configtype_ARG) || strcmp(type, "new")) { if (!arg_is_set(cmd, configtype_ARG) || strcmp(type, "new")) {
log_error("--sinceversion requires --type new"); log_error("--sinceversion requires --type new");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
} }
if (arg_count(cmd, ignoreadvanced_ARG)) if (arg_is_set(cmd, ignoreadvanced_ARG))
tree_spec.ignoreadvanced = 1; tree_spec.ignoreadvanced = 1;
if (arg_count(cmd, ignoreunsupported_ARG)) { if (arg_is_set(cmd, ignoreunsupported_ARG)) {
if (arg_count(cmd, showunsupported_ARG)) { if (arg_is_set(cmd, showunsupported_ARG)) {
log_error("Only one of --ignoreunsupported and --showunsupported permitted."); log_error("Only one of --ignoreunsupported and --showunsupported permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
tree_spec.ignoreunsupported = 1; tree_spec.ignoreunsupported = 1;
} else if (arg_count(cmd, showunsupported_ARG)) { } else if (arg_is_set(cmd, showunsupported_ARG)) {
tree_spec.ignoreunsupported = 0; tree_spec.ignoreunsupported = 0;
} else if (strcmp(type, "current") && strcmp(type, "diff")) { } else if (strcmp(type, "current") && strcmp(type, "diff")) {
/* /*
@ -165,28 +165,28 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
* is lower than the version in which the * is lower than the version in which the
* setting was deprecated. * setting was deprecated.
*/ */
if (!arg_count(cmd, showdeprecated_ARG)) if (!arg_is_set(cmd, showdeprecated_ARG))
tree_spec.ignoredeprecated = 1; tree_spec.ignoredeprecated = 1;
} }
if (arg_count(cmd, ignorelocal_ARG)) if (arg_is_set(cmd, ignorelocal_ARG))
tree_spec.ignorelocal = 1; tree_spec.ignorelocal = 1;
if (!strcmp(type, "current") || !strcmp(type, "full")) { if (!strcmp(type, "current") || !strcmp(type, "full")) {
if (arg_count(cmd, atversion_ARG)) { if (arg_is_set(cmd, atversion_ARG)) {
log_error("--atversion has no effect with --type %s", type); log_error("--atversion has no effect with --type %s", type);
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, ignoreunsupported_ARG) || if ((arg_is_set(cmd, ignoreunsupported_ARG) ||
arg_count(cmd, ignoreadvanced_ARG)) && arg_is_set(cmd, ignoreadvanced_ARG)) &&
!strcmp(type, "current")) { !strcmp(type, "current")) {
/* FIXME: allow these even for --type current */ /* FIXME: allow these even for --type current */
log_error("--ignoreadvanced and --ignoreunsupported has " log_error("--ignoreadvanced and --ignoreunsupported has "
"no effect with --type current"); "no effect with --type current");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
} else if (arg_count(cmd, mergedconfig_ARG)) { } else if (arg_is_set(cmd, mergedconfig_ARG)) {
log_error("--mergedconfig has no effect without --type current or --type full"); log_error("--mergedconfig has no effect without --type current or --type full");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -199,7 +199,7 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
* but it is used just for dumping the profile content and not for * but it is used just for dumping the profile content and not for
* application. * application.
*/ */
if (arg_count(cmd, profile_ARG) && if (arg_is_set(cmd, profile_ARG) &&
(!(profile = add_profile(cmd, arg_str_value(cmd, profile_ARG, NULL), CONFIG_PROFILE_COMMAND)) || (!(profile = add_profile(cmd, arg_str_value(cmd, profile_ARG, NULL), CONFIG_PROFILE_COMMAND)) ||
!override_config_tree_from_profile(cmd, profile))) { !override_config_tree_from_profile(cmd, profile))) {
log_error("Failed to load profile %s.", arg_str_value(cmd, profile_ARG, NULL)); log_error("Failed to load profile %s.", arg_str_value(cmd, profile_ARG, NULL));
@ -210,7 +210,7 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
* Set the 'cft' to work with based on whether we need the plain * Set the 'cft' to work with based on whether we need the plain
* config tree or merged config tree cascade if --mergedconfig is used. * config tree or merged config tree cascade if --mergedconfig is used.
*/ */
if ((arg_count(cmd, mergedconfig_ARG) || !strcmp(type, "full") || !strcmp(type, "diff")) && cmd->cft->cascade) { if ((arg_is_set(cmd, mergedconfig_ARG) || !strcmp(type, "full") || !strcmp(type, "diff")) && cmd->cft->cascade) {
if (!_merge_config_cascade(cmd, cmd->cft, &cft)) { if (!_merge_config_cascade(cmd, cmd->cft, &cft)) {
log_error("Failed to merge configuration."); log_error("Failed to merge configuration.");
r = ECMD_FAILED; r = ECMD_FAILED;
@ -220,7 +220,7 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
cft = cmd->cft; cft = cmd->cft;
tree_spec.current_cft = cft; tree_spec.current_cft = cft;
if (arg_count(cmd, validate_ARG)) { if (arg_is_set(cmd, validate_ARG)) {
if (_config_validate(cmd, cft)) { if (_config_validate(cmd, cft)) {
log_print("LVM configuration valid."); log_print("LVM configuration valid.");
goto out; goto out;
@ -231,9 +231,9 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
} }
} }
if (!strcmp(type, "list") || arg_count(cmd, list_ARG)) { if (!strcmp(type, "list") || arg_is_set(cmd, list_ARG)) {
tree_spec.type = CFG_DEF_TREE_LIST; tree_spec.type = CFG_DEF_TREE_LIST;
if (arg_count(cmd, withcomments_ARG)) { if (arg_is_set(cmd, withcomments_ARG)) {
log_error("--withcomments has no effect with --type list"); log_error("--withcomments has no effect with --type list");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -270,7 +270,7 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
} }
} }
else if (!strcmp(type, "new")) { else if (!strcmp(type, "new")) {
tree_spec.type = arg_count(cmd, sinceversion_ARG) ? CFG_DEF_TREE_NEW_SINCE tree_spec.type = arg_is_set(cmd, sinceversion_ARG) ? CFG_DEF_TREE_NEW_SINCE
: CFG_DEF_TREE_NEW; : CFG_DEF_TREE_NEW;
/* new type does not require check status */ /* new type does not require check status */
} }
@ -294,17 +294,17 @@ int dumpconfig(struct cmd_context *cmd, int argc, char **argv)
goto out; goto out;
} }
if (arg_count(cmd, withsummary_ARG) || arg_count(cmd, list_ARG)) if (arg_is_set(cmd, withsummary_ARG) || arg_is_set(cmd, list_ARG))
tree_spec.withsummary = 1; tree_spec.withsummary = 1;
if (arg_count(cmd, withcomments_ARG)) if (arg_is_set(cmd, withcomments_ARG))
tree_spec.withcomments = 1; tree_spec.withcomments = 1;
if (arg_count(cmd, unconfigured_ARG)) if (arg_is_set(cmd, unconfigured_ARG))
tree_spec.unconfigured = 1; tree_spec.unconfigured = 1;
if (arg_count(cmd, withversions_ARG)) if (arg_is_set(cmd, withversions_ARG))
tree_spec.withversions = 1; tree_spec.withversions = 1;
if (arg_count(cmd, withspaces_ARG)) if (arg_is_set(cmd, withspaces_ARG))
tree_spec.withspaces = 1; tree_spec.withspaces = 1;
if (cft_check_handle) if (cft_check_handle)

116
tools/lvchange.c
View File

@ -108,7 +108,7 @@ static int _lvchange_pool_update(struct cmd_context *cmd,
return 0; return 0;
} }
if (arg_count(cmd, discards_ARG)) { if (arg_is_set(cmd, discards_ARG)) {
discards = (thin_discards_t) arg_uint_value(cmd, discards_ARG, THIN_DISCARDS_IGNORE); discards = (thin_discards_t) arg_uint_value(cmd, discards_ARG, THIN_DISCARDS_IGNORE);
if (discards != first_seg(lv)->discards) { if (discards != first_seg(lv)->discards) {
if (((discards == THIN_DISCARDS_IGNORE) || if (((discards == THIN_DISCARDS_IGNORE) ||
@ -124,7 +124,7 @@ static int _lvchange_pool_update(struct cmd_context *cmd,
lv->name, get_pool_discards_name(discards)); lv->name, get_pool_discards_name(discards));
} }
if (arg_count(cmd, zero_ARG)) { if (arg_is_set(cmd, zero_ARG)) {
val = arg_uint_value(cmd, zero_ARG, 1); val = arg_uint_value(cmd, zero_ARG, 1);
if (val != first_seg(lv)->zero_new_blocks) { if (val != first_seg(lv)->zero_new_blocks) {
first_seg(lv)->zero_new_blocks = val; first_seg(lv)->zero_new_blocks = val;
@ -200,7 +200,7 @@ static int _lvchange_activate(struct cmd_context *cmd, struct logical_volume *lv
return ECMD_FAILED; return ECMD_FAILED;
} }
if (lv_activation_skip(lv, activate, arg_count(cmd, ignoreactivationskip_ARG))) if (lv_activation_skip(lv, activate, arg_is_set(cmd, ignoreactivationskip_ARG)))
return 1; return 1;
if (lv_is_cow(lv) && !lv_is_virtual_origin(origin_from_cow(lv))) if (lv_is_cow(lv) && !lv_is_virtual_origin(origin_from_cow(lv)))
@ -350,7 +350,7 @@ static int _lvchange_resync(struct cmd_context *cmd, struct logical_volume *lv)
return 0; return 0;
} }
if (!arg_count(cmd, yes_ARG) && if (!arg_is_set(cmd, yes_ARG) &&
yes_no_prompt("Do you really want to deactivate " yes_no_prompt("Do you really want to deactivate "
"logical volume %s to resync it? [y/n]: ", "logical volume %s to resync it? [y/n]: ",
lv->name) == 'n') { lv->name) == 'n') {
@ -625,8 +625,8 @@ static int _lvchange_persistent(struct cmd_context *cmd,
display_lvname(lv)); display_lvname(lv));
} else { } else {
if (lv_is_active(lv)) { if (lv_is_active(lv)) {
if (!arg_count(cmd, force_ARG) && if (!arg_is_set(cmd, force_ARG) &&
!arg_count(cmd, yes_ARG) && !arg_is_set(cmd, yes_ARG) &&
yes_no_prompt("Logical volume %s will be " yes_no_prompt("Logical volume %s will be "
"deactivated temporarily. " "deactivated temporarily. "
"Continue? [y/n]: ", lv->name) == 'n') { "Continue? [y/n]: ", lv->name) == 'n') {
@ -760,11 +760,11 @@ static int _lvchange_writemostly(struct logical_volume *lv)
if (!seg_is_raid1(raid_seg)) { if (!seg_is_raid1(raid_seg)) {
log_error("--write%s can only be used with 'raid1' segment type", log_error("--write%s can only be used with 'raid1' segment type",
arg_count(cmd, writemostly_ARG) ? "mostly" : "behind"); arg_is_set(cmd, writemostly_ARG) ? "mostly" : "behind");
return 0; return 0;
} }
if (arg_count(cmd, writebehind_ARG)) if (arg_is_set(cmd, writebehind_ARG))
raid_seg->writebehind = arg_uint_value(cmd, writebehind_ARG, 0); raid_seg->writebehind = arg_uint_value(cmd, writebehind_ARG, 0);
if ((pv_count = arg_count(cmd, writemostly_ARG))) { if ((pv_count = arg_count(cmd, writemostly_ARG))) {
@ -858,10 +858,10 @@ static int _lvchange_recovery_rate(struct logical_volume *lv)
return 0; return 0;
} }
if (arg_count(cmd, minrecoveryrate_ARG)) if (arg_is_set(cmd, minrecoveryrate_ARG))
raid_seg->min_recovery_rate = raid_seg->min_recovery_rate =
arg_uint_value(cmd, minrecoveryrate_ARG, 0) / 2; arg_uint_value(cmd, minrecoveryrate_ARG, 0) / 2;
if (arg_count(cmd, maxrecoveryrate_ARG)) if (arg_is_set(cmd, maxrecoveryrate_ARG))
raid_seg->max_recovery_rate = raid_seg->max_recovery_rate =
arg_uint_value(cmd, maxrecoveryrate_ARG, 0) / 2; arg_uint_value(cmd, maxrecoveryrate_ARG, 0) / 2;
@ -885,11 +885,11 @@ static int _lvchange_profile(struct logical_volume *lv)
old_profile_name = lv->profile ? lv->profile->name : "(inherited)"; old_profile_name = lv->profile ? lv->profile->name : "(inherited)";
if (arg_count(lv->vg->cmd, detachprofile_ARG)) { if (arg_is_set(lv->vg->cmd, detachprofile_ARG)) {
new_profile_name = "(inherited)"; new_profile_name = "(inherited)";
lv->profile = NULL; lv->profile = NULL;
} else { } else {
if (arg_count(lv->vg->cmd, metadataprofile_ARG)) if (arg_is_set(lv->vg->cmd, metadataprofile_ARG))
new_profile_name = arg_str_value(lv->vg->cmd, metadataprofile_ARG, NULL); new_profile_name = arg_str_value(lv->vg->cmd, metadataprofile_ARG, NULL);
else else
new_profile_name = arg_str_value(lv->vg->cmd, profile_ARG, NULL); new_profile_name = arg_str_value(lv->vg->cmd, profile_ARG, NULL);
@ -971,7 +971,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
if (lv_is_pvmove(lv)) { if (lv_is_pvmove(lv)) {
log_error("Unable to change pvmove LV %s", lv->name); log_error("Unable to change pvmove LV %s", lv->name);
if (arg_count(cmd, activate_ARG)) if (arg_is_set(cmd, activate_ARG))
log_error("Use 'pvmove --abort' to abandon a pvmove"); log_error("Use 'pvmove --abort' to abandon a pvmove");
return ECMD_FAILED; return ECMD_FAILED;
} }
@ -988,15 +988,15 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* If LV is sparse, activate origin instead */ /* If LV is sparse, activate origin instead */
if (arg_count(cmd, activate_ARG) && lv_is_cow(lv) && if (arg_is_set(cmd, activate_ARG) && lv_is_cow(lv) &&
lv_is_virtual_origin(origin = origin_from_cow(lv))) lv_is_virtual_origin(origin = origin_from_cow(lv)))
lv = origin; lv = origin;
if ((lv_is_thin_pool_data(lv) || lv_is_thin_pool_metadata(lv) || if ((lv_is_thin_pool_data(lv) || lv_is_thin_pool_metadata(lv) ||
lv_is_cache_pool_data(lv) || lv_is_cache_pool_metadata(lv)) && lv_is_cache_pool_data(lv) || lv_is_cache_pool_metadata(lv)) &&
!arg_count(cmd, activate_ARG) && !arg_is_set(cmd, activate_ARG) &&
!arg_count(cmd, permission_ARG) && !arg_is_set(cmd, permission_ARG) &&
!arg_count(cmd, setactivationskip_ARG)) !arg_is_set(cmd, setactivationskip_ARG))
/* Rest can be changed for stacked thin pool meta/data volumes */ /* Rest can be changed for stacked thin pool meta/data volumes */
; ;
else if (!lv_is_visible(lv) && !lv_is_virtual_origin(lv)) { else if (!lv_is_visible(lv) && !lv_is_virtual_origin(lv)) {
@ -1005,7 +1005,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
return ECMD_FAILED; return ECMD_FAILED;
} }
if (lv_is_cow(lv) && arg_count(cmd, activate_ARG)) { if (lv_is_cow(lv) && arg_is_set(cmd, activate_ARG)) {
origin = origin_from_cow(lv); origin = origin_from_cow(lv);
if (origin->origin_count < 2) if (origin->origin_count < 2)
snaps_msg[0] = '\0'; snaps_msg[0] = '\0';
@ -1016,7 +1016,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
return ECMD_FAILED; return ECMD_FAILED;
} }
if (!arg_count(cmd, yes_ARG) && if (!arg_is_set(cmd, yes_ARG) &&
(yes_no_prompt("Change of snapshot %s will also change its " (yes_no_prompt("Change of snapshot %s will also change its "
"origin %s%s. Proceed? [y/n]: ", "origin %s%s. Proceed? [y/n]: ",
display_lvname(lv), display_lvname(origin), display_lvname(lv), display_lvname(origin),
@ -1031,12 +1031,12 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
return ECMD_FAILED; return ECMD_FAILED;
} }
if (arg_count(cmd, persistent_ARG) && lv_is_pool(lv)) { if (arg_is_set(cmd, persistent_ARG) && lv_is_pool(lv)) {
log_error("Persistent major and minor numbers are not supported with pools."); log_error("Persistent major and minor numbers are not supported with pools.");
return ECMD_FAILED; return ECMD_FAILED;
} }
if (!arg_count(cmd, activate_ARG) && !arg_count(cmd, refresh_ARG)) { if (!arg_is_set(cmd, activate_ARG) && !arg_is_set(cmd, refresh_ARG)) {
/* /*
* If a persistent lv lock already exists from activation * If a persistent lv lock already exists from activation
* (with the needed mode or higher), this will be a no-op. * (with the needed mode or higher), this will be a no-op.
@ -1061,12 +1061,12 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
* *
* Do not initiate any polling if --sysinit option is used. * Do not initiate any polling if --sysinit option is used.
*/ */
init_background_polling(arg_count(cmd, sysinit_ARG) ? 0 : init_background_polling(arg_is_set(cmd, sysinit_ARG) ? 0 :
arg_int_value(cmd, poll_ARG, arg_int_value(cmd, poll_ARG,
DEFAULT_BACKGROUND_POLLING)); DEFAULT_BACKGROUND_POLLING));
/* access permission change */ /* access permission change */
if (arg_count(cmd, permission_ARG)) { if (arg_is_set(cmd, permission_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_permission(cmd, lv); doit += _lvchange_permission(cmd, lv);
@ -1074,7 +1074,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* allocation policy change */ /* allocation policy change */
if (arg_count(cmd, contiguous_ARG) || arg_count(cmd, alloc_ARG)) { if (arg_is_set(cmd, contiguous_ARG) || arg_is_set(cmd, alloc_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_alloc(cmd, lv); doit += _lvchange_alloc(cmd, lv);
@ -1082,7 +1082,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* error when full change */ /* error when full change */
if (arg_count(cmd, errorwhenfull_ARG)) { if (arg_is_set(cmd, errorwhenfull_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_errorwhenfull(cmd, lv); doit += _lvchange_errorwhenfull(cmd, lv);
@ -1090,7 +1090,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* read ahead sector change */ /* read ahead sector change */
if (arg_count(cmd, readahead_ARG)) { if (arg_is_set(cmd, readahead_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_readahead(cmd, lv); doit += _lvchange_readahead(cmd, lv);
@ -1098,15 +1098,15 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* persistent device number change */ /* persistent device number change */
if (arg_count(cmd, persistent_ARG)) { if (arg_is_set(cmd, persistent_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_persistent(cmd, lv); doit += _lvchange_persistent(cmd, lv);
docmds++; docmds++;
} }
if (arg_count(cmd, discards_ARG) || if (arg_is_set(cmd, discards_ARG) ||
arg_count(cmd, zero_ARG)) { arg_is_set(cmd, zero_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_pool_update(cmd, lv); doit += _lvchange_pool_update(cmd, lv);
@ -1114,7 +1114,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* add tag */ /* add tag */
if (arg_count(cmd, addtag_ARG)) { if (arg_is_set(cmd, addtag_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_tag(cmd, lv, addtag_ARG); doit += _lvchange_tag(cmd, lv, addtag_ARG);
@ -1122,7 +1122,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* del tag */ /* del tag */
if (arg_count(cmd, deltag_ARG)) { if (arg_is_set(cmd, deltag_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_tag(cmd, lv, deltag_ARG); doit += _lvchange_tag(cmd, lv, deltag_ARG);
@ -1130,7 +1130,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* change writemostly/writebehind */ /* change writemostly/writebehind */
if (arg_count(cmd, writemostly_ARG) || arg_count(cmd, writebehind_ARG)) { if (arg_is_set(cmd, writemostly_ARG) || arg_is_set(cmd, writebehind_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_writemostly(lv); doit += _lvchange_writemostly(lv);
@ -1138,8 +1138,8 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* change [min|max]_recovery_rate */ /* change [min|max]_recovery_rate */
if (arg_count(cmd, minrecoveryrate_ARG) || if (arg_is_set(cmd, minrecoveryrate_ARG) ||
arg_count(cmd, maxrecoveryrate_ARG)) { arg_is_set(cmd, maxrecoveryrate_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_recovery_rate(lv); doit += _lvchange_recovery_rate(lv);
@ -1147,15 +1147,15 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
/* change configuration profile */ /* change configuration profile */
if (arg_count(cmd, profile_ARG) || arg_count(cmd, metadataprofile_ARG) || if (arg_is_set(cmd, profile_ARG) || arg_is_set(cmd, metadataprofile_ARG) ||
arg_count(cmd, detachprofile_ARG)) { arg_is_set(cmd, detachprofile_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_profile(lv); doit += _lvchange_profile(lv);
docmds++; docmds++;
} }
if (arg_count(cmd, setactivationskip_ARG)) { if (arg_is_set(cmd, setactivationskip_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_activation_skip(lv); doit += _lvchange_activation_skip(lv);
@ -1163,7 +1163,7 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
} }
if (arg_is_set(cmd, cachemode_ARG) || if (arg_is_set(cmd, cachemode_ARG) ||
arg_count(cmd, cachepolicy_ARG) || arg_count(cmd, cachesettings_ARG)) { arg_is_set(cmd, cachepolicy_ARG) || arg_is_set(cmd, cachesettings_ARG)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
doit += _lvchange_cache(cmd, lv); doit += _lvchange_cache(cmd, lv);
@ -1173,27 +1173,27 @@ static int _lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
if (doit) if (doit)
log_print_unless_silent("Logical volume %s changed.", display_lvname(lv)); log_print_unless_silent("Logical volume %s changed.", display_lvname(lv));
if (arg_count(cmd, resync_ARG) && if (arg_is_set(cmd, resync_ARG) &&
!_lvchange_resync(cmd, lv)) !_lvchange_resync(cmd, lv))
return_ECMD_FAILED; return_ECMD_FAILED;
if (arg_count(cmd, syncaction_ARG) && if (arg_is_set(cmd, syncaction_ARG) &&
!lv_raid_message(lv, arg_str_value(cmd, syncaction_ARG, NULL))) !lv_raid_message(lv, arg_str_value(cmd, syncaction_ARG, NULL)))
return_ECMD_FAILED; return_ECMD_FAILED;
/* activation change */ /* activation change */
if (arg_count(cmd, activate_ARG)) { if (arg_is_set(cmd, activate_ARG)) {
if (!_lvchange_activate(cmd, lv)) if (!_lvchange_activate(cmd, lv))
return_ECMD_FAILED; return_ECMD_FAILED;
} else if (arg_count(cmd, refresh_ARG)) { } else if (arg_is_set(cmd, refresh_ARG)) {
if (!_lvchange_refresh(cmd, lv)) if (!_lvchange_refresh(cmd, lv))
return_ECMD_FAILED; return_ECMD_FAILED;
} else { } else {
if (arg_count(cmd, monitor_ARG) && if (arg_is_set(cmd, monitor_ARG) &&
!_lvchange_monitoring(cmd, lv)) !_lvchange_monitoring(cmd, lv))
return_ECMD_FAILED; return_ECMD_FAILED;
if (arg_count(cmd, poll_ARG) && if (arg_is_set(cmd, poll_ARG) &&
!_lvchange_background_polling(cmd, lv)) !_lvchange_background_polling(cmd, lv))
return_ECMD_FAILED; return_ECMD_FAILED;
} }
@ -1243,27 +1243,27 @@ int lvchange(struct cmd_context *cmd, int argc, char **argv)
int update = update_partial_safe || update_partial_unsafe; int update = update_partial_safe || update_partial_unsafe;
if (!update && if (!update &&
!arg_count(cmd, activate_ARG) && !arg_count(cmd, refresh_ARG) && !arg_is_set(cmd, activate_ARG) && !arg_is_set(cmd, refresh_ARG) &&
!arg_count(cmd, monitor_ARG) && !arg_count(cmd, poll_ARG)) { !arg_is_set(cmd, monitor_ARG) && !arg_is_set(cmd, poll_ARG)) {
log_error("Need 1 or more of -a, -C, -M, -p, -r, -Z, " log_error("Need 1 or more of -a, -C, -M, -p, -r, -Z, "
"--resync, --refresh, --alloc, --addtag, --deltag, " "--resync, --refresh, --alloc, --addtag, --deltag, "
"--monitor, --poll or --discards"); "--monitor, --poll or --discards");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, profile_ARG) || arg_count(cmd, metadataprofile_ARG)) && if ((arg_is_set(cmd, profile_ARG) || arg_is_set(cmd, metadataprofile_ARG)) &&
arg_count(cmd, detachprofile_ARG)) { arg_is_set(cmd, detachprofile_ARG)) {
log_error("Only one of --metadataprofile and --detachprofile permitted."); log_error("Only one of --metadataprofile and --detachprofile permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, activate_ARG) && arg_count(cmd, refresh_ARG)) { if (arg_is_set(cmd, activate_ARG) && arg_is_set(cmd, refresh_ARG)) {
log_error("Only one of -a and --refresh permitted."); log_error("Only one of -a and --refresh permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, ignorelockingfailure_ARG) || if ((arg_is_set(cmd, ignorelockingfailure_ARG) ||
arg_count(cmd, sysinit_ARG)) && update) { arg_is_set(cmd, sysinit_ARG)) && update) {
log_error("Only -a permitted with --ignorelockingfailure and --sysinit"); log_error("Only -a permitted with --ignorelockingfailure and --sysinit");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -1276,23 +1276,23 @@ int lvchange(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, minor_ARG) || arg_count(cmd, major_ARG)) && if ((arg_is_set(cmd, minor_ARG) || arg_is_set(cmd, major_ARG)) &&
!arg_count(cmd, persistent_ARG)) { !arg_is_set(cmd, persistent_ARG)) {
log_error("--major and --minor require -My"); log_error("--major and --minor require -My");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, minor_ARG) && argc != 1) { if (arg_is_set(cmd, minor_ARG) && argc != 1) {
log_error("Only give one logical volume when specifying minor"); log_error("Only give one logical volume when specifying minor");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, contiguous_ARG) && arg_count(cmd, alloc_ARG)) { if (arg_is_set(cmd, contiguous_ARG) && arg_is_set(cmd, alloc_ARG)) {
log_error("Only one of --alloc and --contiguous permitted"); log_error("Only one of --alloc and --contiguous permitted");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, poll_ARG) && arg_count(cmd, sysinit_ARG)) { if (arg_is_set(cmd, poll_ARG) && arg_is_set(cmd, sysinit_ARG)) {
log_error("Only one of --poll and --sysinit permitted"); log_error("Only one of --poll and --sysinit permitted");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -1304,7 +1304,7 @@ int lvchange(struct cmd_context *cmd, int argc, char **argv)
* not neet to be running at this moment yet - it could be * not neet to be running at this moment yet - it could be
* just too early during system initialization time. * just too early during system initialization time.
*/ */
if (arg_count(cmd, sysinit_ARG) && (arg_uint_value(cmd, activate_ARG, 0) == CHANGE_AAY)) { if (arg_is_set(cmd, sysinit_ARG) && (arg_uint_value(cmd, activate_ARG, 0) == CHANGE_AAY)) {
if (lvmetad_used()) { if (lvmetad_used()) {
log_warn("WARNING: lvmetad is active, skipping direct activation during sysinit"); log_warn("WARNING: lvmetad is active, skipping direct activation during sysinit");
return ECMD_PROCESSED; return ECMD_PROCESSED;
@ -1324,7 +1324,7 @@ int lvchange(struct cmd_context *cmd, int argc, char **argv)
* are cases where lvchange does not modify the vg, so they can use * are cases where lvchange does not modify the vg, so they can use
* the sh lock mode. * the sh lock mode.
*/ */
if (arg_count(cmd, activate_ARG) || arg_count(cmd, refresh_ARG)) { if (arg_is_set(cmd, activate_ARG) || arg_is_set(cmd, refresh_ARG)) {
cmd->lockd_vg_default_sh = 1; cmd->lockd_vg_default_sh = 1;
/* Allow deactivating if locks fail. */ /* Allow deactivating if locks fail. */
if (is_change_activating((activation_change_t)arg_uint_value(cmd, activate_ARG, CHANGE_AY))) if (is_change_activating((activation_change_t)arg_uint_value(cmd, activate_ARG, CHANGE_AY)))

122
tools/lvconvert.c
View File

@ -191,7 +191,7 @@ static int _lvconvert_name_params(struct lvconvert_params *lp,
if (!lp->merge_mirror && if (!lp->merge_mirror &&
!lp->repair && !lp->repair &&
!arg_count(cmd, splitmirrors_ARG) && !arg_is_set(cmd, splitmirrors_ARG) &&
!strstr(lp->lv_name, "_tdata") && !strstr(lp->lv_name, "_tdata") &&
!strstr(lp->lv_name, "_tmeta") && !strstr(lp->lv_name, "_tmeta") &&
!strstr(lp->lv_name, "_cdata") && !strstr(lp->lv_name, "_cdata") &&
@ -238,7 +238,7 @@ static int _check_conversion_type(struct cmd_context *cmd, const char *type_str)
return 1; return 1;
if (!strcmp(type_str, "mirror")) { if (!strcmp(type_str, "mirror")) {
if (!arg_count(cmd, mirrors_ARG)) { if (!arg_is_set(cmd, mirrors_ARG)) {
log_error("Conversions to --type mirror require -m/--mirrors"); log_error("Conversions to --type mirror require -m/--mirrors");
return 0; return 0;
} }
@ -258,11 +258,11 @@ static int _check_conversion_type(struct cmd_context *cmd, const char *type_str)
/* -s/--snapshot and --type snapshot are synonyms */ /* -s/--snapshot and --type snapshot are synonyms */
static int _snapshot_type_requested(struct cmd_context *cmd, const char *type_str) { static int _snapshot_type_requested(struct cmd_context *cmd, const char *type_str) {
return (arg_count(cmd, snapshot_ARG) || !strcmp(type_str, "snapshot")); return (arg_is_set(cmd, snapshot_ARG) || !strcmp(type_str, "snapshot"));
} }
/* mirror/raid* (1,10,4,5,6 and their variants) reshape */ /* mirror/raid* (1,10,4,5,6 and their variants) reshape */
static int _mirror_or_raid_type_requested(struct cmd_context *cmd, const char *type_str) { static int _mirror_or_raid_type_requested(struct cmd_context *cmd, const char *type_str) {
return (arg_count(cmd, mirrors_ARG) || !strncmp(type_str, "raid", 4) || !strcmp(type_str, "mirror")); return (arg_is_set(cmd, mirrors_ARG) || !strncmp(type_str, "raid", 4) || !strcmp(type_str, "mirror"));
} }
static int _read_pool_params(struct cmd_context *cmd, int *pargc, char ***pargv, static int _read_pool_params(struct cmd_context *cmd, int *pargc, char ***pargv,
@ -379,7 +379,7 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
if (!_check_conversion_type(cmd, type_str)) if (!_check_conversion_type(cmd, type_str))
return_0; return_0;
if (arg_count(cmd, repair_ARG)) { if (arg_is_set(cmd, repair_ARG)) {
if (arg_outside_list_is_set(cmd, "cannot be used with --repair", if (arg_outside_list_is_set(cmd, "cannot be used with --repair",
repair_ARG, repair_ARG,
alloc_ARG, usepolicies_ARG, alloc_ARG, usepolicies_ARG,
@ -432,25 +432,25 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
lp->uncache = 1; lp->uncache = 1;
} }
if ((_snapshot_type_requested(cmd, type_str) || arg_count(cmd, merge_ARG)) && if ((_snapshot_type_requested(cmd, type_str) || arg_is_set(cmd, merge_ARG)) &&
(arg_count(cmd, mirrorlog_ARG) || _mirror_or_raid_type_requested(cmd, type_str) || (arg_is_set(cmd, mirrorlog_ARG) || _mirror_or_raid_type_requested(cmd, type_str) ||
lp->repair || arg_count(cmd, thinpool_ARG))) { lp->repair || arg_is_set(cmd, thinpool_ARG))) {
log_error("--snapshot/--type snapshot or --merge argument " log_error("--snapshot/--type snapshot or --merge argument "
"cannot be mixed with --mirrors/--type mirror/--type raid*, " "cannot be mixed with --mirrors/--type mirror/--type raid*, "
"--mirrorlog, --repair or --thinpool."); "--mirrorlog, --repair or --thinpool.");
return 0; return 0;
} }
if ((arg_count(cmd, stripes_long_ARG) || arg_count(cmd, stripesize_ARG)) && if ((arg_is_set(cmd, stripes_long_ARG) || arg_is_set(cmd, stripesize_ARG)) &&
!(_mirror_or_raid_type_requested(cmd, type_str) || !(_mirror_or_raid_type_requested(cmd, type_str) ||
lp->repair || lp->repair ||
arg_count(cmd, thinpool_ARG))) { arg_is_set(cmd, thinpool_ARG))) {
log_error("--stripes or --stripesize argument is only valid " log_error("--stripes or --stripesize argument is only valid "
"with --mirrors/--type mirror/--type raid*, --repair and --thinpool"); "with --mirrors/--type mirror/--type raid*, --repair and --thinpool");
return 0; return 0;
} }
if (arg_count(cmd, cache_ARG)) if (arg_is_set(cmd, cache_ARG))
lp->cache = 1; lp->cache = 1;
if (!strcmp(type_str, "cache")) if (!strcmp(type_str, "cache"))
@ -463,7 +463,7 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
type_str = "cache"; type_str = "cache";
} }
if (arg_count(cmd, thin_ARG)) if (arg_is_set(cmd, thin_ARG))
lp->thin = 1; lp->thin = 1;
if (!strcmp(type_str, "thin")) if (!strcmp(type_str, "thin"))
@ -479,11 +479,11 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
if (!_read_pool_params(cmd, &argc, &argv, type_str, lp)) if (!_read_pool_params(cmd, &argc, &argv, type_str, lp))
return_0; return_0;
if (!arg_count(cmd, background_ARG)) if (!arg_is_set(cmd, background_ARG))
lp->wait_completion = 1; lp->wait_completion = 1;
if (_snapshot_type_requested(cmd, type_str)) { if (_snapshot_type_requested(cmd, type_str)) {
if (arg_count(cmd, merge_ARG)) { if (arg_is_set(cmd, merge_ARG)) {
log_error("--snapshot and --merge are mutually exclusive."); log_error("--snapshot and --merge are mutually exclusive.");
return 0; return 0;
} }
@ -499,14 +499,14 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
* intent to keep the mimage that is detached, rather than * intent to keep the mimage that is detached, rather than
* discarding it. * discarding it.
*/ */
} else if (arg_count(cmd, splitmirrors_ARG)) { } else if (arg_is_set(cmd, splitmirrors_ARG)) {
if (_mirror_or_raid_type_requested(cmd, type_str)) { if (_mirror_or_raid_type_requested(cmd, type_str)) {
log_error("--mirrors/--type mirror/--type raid* and --splitmirrors are " log_error("--mirrors/--type mirror/--type raid* and --splitmirrors are "
"mutually exclusive."); "mutually exclusive.");
return 0; return 0;
} }
if (!arg_count(cmd, name_ARG) && if (!arg_is_set(cmd, name_ARG) &&
!arg_count(cmd, trackchanges_ARG)) { !arg_is_set(cmd, trackchanges_ARG)) {
log_error("Please name the new logical volume using '--name'"); log_error("Please name the new logical volume using '--name'");
return 0; return 0;
} }
@ -515,20 +515,20 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
lp->keep_mimages = 1; lp->keep_mimages = 1;
lp->mirrors = arg_uint_value(cmd, splitmirrors_ARG, 0); lp->mirrors = arg_uint_value(cmd, splitmirrors_ARG, 0);
lp->mirrors_sign = SIGN_MINUS; lp->mirrors_sign = SIGN_MINUS;
} else if (arg_count(cmd, name_ARG)) { } else if (arg_is_set(cmd, name_ARG)) {
log_error("The 'name' argument is only valid" log_error("The 'name' argument is only valid"
" with --splitmirrors"); " with --splitmirrors");
return 0; return 0;
} }
if (arg_count(cmd, merge_ARG)) { if (arg_is_set(cmd, merge_ARG)) {
if ((argc == 1) && strstr(argv[0], "_rimage_")) if ((argc == 1) && strstr(argv[0], "_rimage_"))
lp->merge_mirror = 1; lp->merge_mirror = 1;
else else
lp->merge = 1; lp->merge = 1;
} }
if (arg_count(cmd, mirrors_ARG)) { if (arg_is_set(cmd, mirrors_ARG)) {
/* /*
* --splitmirrors has been chosen as the mechanism for * --splitmirrors has been chosen as the mechanism for
* specifying the intent of detaching and keeping a mimage * specifying the intent of detaching and keeping a mimage
@ -561,17 +561,17 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
lp->origin_name = argv[0]; lp->origin_name = argv[0];
argv++, argc--; argv++, argc--;
if (arg_count(cmd, regionsize_ARG)) { if (arg_is_set(cmd, regionsize_ARG)) {
log_error("--regionsize is only available with mirrors"); log_error("--regionsize is only available with mirrors");
return 0; return 0;
} }
if (arg_count(cmd, stripesize_ARG) || arg_count(cmd, stripes_long_ARG)) { if (arg_is_set(cmd, stripesize_ARG) || arg_is_set(cmd, stripes_long_ARG)) {
log_error("--stripes and --stripesize are only available with striped mirrors"); log_error("--stripes and --stripesize are only available with striped mirrors");
return 0; return 0;
} }
if (arg_count(cmd, chunksize_ARG) && if (arg_is_set(cmd, chunksize_ARG) &&
(arg_sign_value(cmd, chunksize_ARG, SIGN_NONE) == SIGN_MINUS)) { (arg_sign_value(cmd, chunksize_ARG, SIGN_NONE) == SIGN_MINUS)) {
log_error("Negative chunk size is invalid."); log_error("Negative chunk size is invalid.");
return 0; return 0;
@ -592,7 +592,7 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
lp->zero = (lp->segtype->flags & SEG_CANNOT_BE_ZEROED) lp->zero = (lp->segtype->flags & SEG_CANNOT_BE_ZEROED)
? 0 : arg_int_value(cmd, zero_ARG, 1); ? 0 : arg_int_value(cmd, zero_ARG, 1);
} else if (arg_count(cmd, replace_ARG)) { /* RAID device replacement */ } else if (arg_is_set(cmd, replace_ARG)) { /* RAID device replacement */
lp->replace_pv_count = arg_count(cmd, replace_ARG); lp->replace_pv_count = arg_count(cmd, replace_ARG);
lp->replace_pvs = dm_pool_alloc(cmd->mem, sizeof(char *) * lp->replace_pv_count); lp->replace_pvs = dm_pool_alloc(cmd->mem, sizeof(char *) * lp->replace_pv_count);
if (!lp->replace_pvs) if (!lp->replace_pvs)
@ -616,12 +616,12 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
arg_is_set(cmd, repair_ARG) || arg_is_set(cmd, repair_ARG) ||
arg_is_set(cmd, mirrorlog_ARG) || arg_is_set(cmd, mirrorlog_ARG) ||
arg_is_set(cmd, corelog_ARG)) { /* Mirrors (and some RAID functions) */ arg_is_set(cmd, corelog_ARG)) { /* Mirrors (and some RAID functions) */
if (arg_count(cmd, chunksize_ARG)) { if (arg_is_set(cmd, chunksize_ARG)) {
log_error("--chunksize is only available with snapshots or pools."); log_error("--chunksize is only available with snapshots or pools.");
return 0; return 0;
} }
if (arg_count(cmd, zero_ARG)) { if (arg_is_set(cmd, zero_ARG)) {
log_error("--zero is only available with snapshots or thin pools."); log_error("--zero is only available with snapshots or thin pools.");
return 0; return 0;
} }
@ -631,7 +631,7 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
* Checked when we know the state of the LV being converted. * Checked when we know the state of the LV being converted.
*/ */
if (arg_count(cmd, regionsize_ARG)) { if (arg_is_set(cmd, regionsize_ARG)) {
if (arg_sign_value(cmd, regionsize_ARG, SIGN_NONE) == if (arg_sign_value(cmd, regionsize_ARG, SIGN_NONE) ==
SIGN_MINUS) { SIGN_MINUS) {
log_error("Negative regionsize is invalid"); log_error("Negative regionsize is invalid");
@ -671,12 +671,12 @@ static int _read_params(struct cmd_context *cmd, int argc, char **argv,
if (!get_stripe_params(cmd, &lp->stripes, &lp->stripe_size)) if (!get_stripe_params(cmd, &lp->stripes, &lp->stripe_size))
return_0; return_0;
if (arg_count(cmd, mirrors_ARG) && !lp->mirrors) { if (arg_is_set(cmd, mirrors_ARG) && !lp->mirrors) {
/* down-converting to linear/stripe? */ /* down-converting to linear/stripe? */
if (!(lp->segtype = if (!(lp->segtype =
get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED))) get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED)))
return_0; return_0;
} else if (arg_count(cmd, type_ARG)) { } else if (arg_is_set(cmd, type_ARG)) {
/* changing mirror type? */ /* changing mirror type? */
if (!(lp->segtype = get_segtype_from_string(cmd, arg_str_value(cmd, type_ARG, find_config_tree_str(cmd, global_mirror_segtype_default_CFG, NULL))))) if (!(lp->segtype = get_segtype_from_string(cmd, arg_str_value(cmd, type_ARG, find_config_tree_str(cmd, global_mirror_segtype_default_CFG, NULL)))))
return_0; return_0;
@ -945,7 +945,7 @@ static void _lvconvert_mirrors_repair_ask(struct cmd_context *cmd,
int force = arg_count(cmd, force_ARG); int force = arg_count(cmd, force_ARG);
int yes = arg_count(cmd, yes_ARG); int yes = arg_count(cmd, yes_ARG);
if (arg_count(cmd, usepolicies_ARG)) { if (arg_is_set(cmd, usepolicies_ARG)) {
leg_policy = find_config_tree_str(cmd, activation_mirror_image_fault_policy_CFG, NULL); leg_policy = find_config_tree_str(cmd, activation_mirror_image_fault_policy_CFG, NULL);
log_policy = find_config_tree_str(cmd, activation_mirror_log_fault_policy_CFG, NULL); log_policy = find_config_tree_str(cmd, activation_mirror_log_fault_policy_CFG, NULL);
*replace_mirrors = strcmp(leg_policy, "remove"); *replace_mirrors = strcmp(leg_policy, "remove");
@ -1139,7 +1139,7 @@ static int _lvconvert_mirrors_parse_params(struct cmd_context *cmd,
*old_mimage_count = lv_mirror_count(lv); *old_mimage_count = lv_mirror_count(lv);
*old_log_count = _get_log_count(lv); *old_log_count = _get_log_count(lv);
if (is_lockd_type(lv->vg->lock_type) && arg_count(cmd, splitmirrors_ARG)) { if (is_lockd_type(lv->vg->lock_type) && arg_is_set(cmd, splitmirrors_ARG)) {
/* FIXME: we need to create a lock for the new LV. */ /* FIXME: we need to create a lock for the new LV. */
log_error("Unable to split mirrors in VG with lock_type %s", lv->vg->lock_type); log_error("Unable to split mirrors in VG with lock_type %s", lv->vg->lock_type);
return 0; return 0;
@ -1150,9 +1150,9 @@ static int _lvconvert_mirrors_parse_params(struct cmd_context *cmd,
* *
* If called with no argument, try collapsing the resync layers * If called with no argument, try collapsing the resync layers
*/ */
if (!arg_count(cmd, mirrors_ARG) && !arg_count(cmd, mirrorlog_ARG) && if (!arg_is_set(cmd, mirrors_ARG) && !arg_is_set(cmd, mirrorlog_ARG) &&
!arg_count(cmd, corelog_ARG) && !arg_count(cmd, regionsize_ARG) && !arg_is_set(cmd, corelog_ARG) && !arg_is_set(cmd, regionsize_ARG) &&
!arg_count(cmd, splitmirrors_ARG) && !lp->repair) { !arg_is_set(cmd, splitmirrors_ARG) && !lp->repair) {
*new_mimage_count = *old_mimage_count; *new_mimage_count = *old_mimage_count;
*new_log_count = *old_log_count; *new_log_count = *old_log_count;
@ -1164,7 +1164,7 @@ static int _lvconvert_mirrors_parse_params(struct cmd_context *cmd,
/* /*
* Adjusting mimage count? * Adjusting mimage count?
*/ */
if (!arg_count(cmd, mirrors_ARG) && !arg_count(cmd, splitmirrors_ARG)) if (!arg_is_set(cmd, mirrors_ARG) && !arg_is_set(cmd, splitmirrors_ARG))
lp->mirrors = *old_mimage_count; lp->mirrors = *old_mimage_count;
else if (lp->mirrors_sign == SIGN_PLUS) else if (lp->mirrors_sign == SIGN_PLUS)
lp->mirrors = *old_mimage_count + lp->mirrors; lp->mirrors = *old_mimage_count + lp->mirrors;
@ -1207,7 +1207,7 @@ static int _lvconvert_mirrors_parse_params(struct cmd_context *cmd,
* position that the user would like a 'disk' log. * position that the user would like a 'disk' log.
*/ */
*new_log_count = (*old_mimage_count > 1) ? *old_log_count : 1; *new_log_count = (*old_mimage_count > 1) ? *old_log_count : 1;
if (!arg_count(cmd, corelog_ARG) && !arg_count(cmd, mirrorlog_ARG)) if (!arg_is_set(cmd, corelog_ARG) && !arg_is_set(cmd, mirrorlog_ARG))
return 1; return 1;
*new_log_count = arg_int_value(cmd, mirrorlog_ARG, *new_log_count = arg_int_value(cmd, mirrorlog_ARG,
@ -1227,7 +1227,7 @@ static int _lvconvert_mirrors_parse_params(struct cmd_context *cmd,
/* /*
* Region size must not change on existing mirrors * Region size must not change on existing mirrors
*/ */
if (arg_count(cmd, regionsize_ARG) && lv_is_mirrored(lv) && if (arg_is_set(cmd, regionsize_ARG) && lv_is_mirrored(lv) &&
(lp->region_size != first_seg(lv)->region_size)) { (lp->region_size != first_seg(lv)->region_size)) {
log_error("Mirror log region size cannot be changed on " log_error("Mirror log region size cannot be changed on "
"an existing mirror."); "an existing mirror.");
@ -1395,7 +1395,7 @@ static int _lvconvert_mirrors_aux(struct cmd_context *cmd,
/* Reduce number of mirrors */ /* Reduce number of mirrors */
if (lp->keep_mimages) { if (lp->keep_mimages) {
if (arg_count(cmd, trackchanges_ARG)) { if (arg_is_set(cmd, trackchanges_ARG)) {
log_error("--trackchanges is not available " log_error("--trackchanges is not available "
"to 'mirror' segment type"); "to 'mirror' segment type");
return 0; return 0;
@ -1559,7 +1559,7 @@ static int _lvconvert_mirrors_repair(struct cmd_context *cmd,
original_logs - _get_log_count(lv), original_logs, original_logs - _get_log_count(lv), original_logs,
display_lvname(lv)); display_lvname(lv));
/* if (!arg_count(cmd, use_policies_ARG) && (lp->mirrors != old_mimage_count /* if (!arg_is_set(cmd, use_policies_ARG) && (lp->mirrors != old_mimage_count
|| log_count != old_log_count)) || log_count != old_log_count))
return 0; */ return 0; */
@ -1679,7 +1679,7 @@ static void _lvconvert_raid_repair_ask(struct cmd_context *cmd,
*replace_dev = 1; *replace_dev = 1;
if (arg_count(cmd, usepolicies_ARG)) { if (arg_is_set(cmd, usepolicies_ARG)) {
dev_policy = find_config_tree_str(cmd, activation_raid_fault_policy_CFG, NULL); dev_policy = find_config_tree_str(cmd, activation_raid_fault_policy_CFG, NULL);
if (!strcmp(dev_policy, "allocate") || if (!strcmp(dev_policy, "allocate") ||
@ -1706,11 +1706,11 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
struct lv_segment *seg = first_seg(lv); struct lv_segment *seg = first_seg(lv);
dm_percent_t sync_percent; dm_percent_t sync_percent;
if (!arg_count(cmd, type_ARG)) if (!arg_is_set(cmd, type_ARG))
lp->segtype = seg->segtype; lp->segtype = seg->segtype;
/* Can only change image count for raid1 and linear */ /* Can only change image count for raid1 and linear */
if (arg_count(cmd, mirrors_ARG) && if (arg_is_set(cmd, mirrors_ARG) &&
!seg_is_mirrored(seg) && !seg_is_linear(seg)) { !seg_is_mirrored(seg) && !seg_is_linear(seg)) {
log_error("'--mirrors/-m' is not compatible with %s", log_error("'--mirrors/-m' is not compatible with %s",
lvseg_name(seg)); lvseg_name(seg));
@ -1727,13 +1727,13 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
return 0; return 0;
} }
if (seg_is_linear(seg) && !lp->merge_mirror && !arg_count(cmd, mirrors_ARG)) { if (seg_is_linear(seg) && !lp->merge_mirror && !arg_is_set(cmd, mirrors_ARG)) {
log_error("Raid conversions require -m/--mirrors"); log_error("Raid conversions require -m/--mirrors");
return 0; return 0;
} }
/* Change number of RAID1 images */ /* Change number of RAID1 images */
if (arg_count(cmd, mirrors_ARG) || arg_count(cmd, splitmirrors_ARG)) { if (arg_is_set(cmd, mirrors_ARG) || arg_is_set(cmd, splitmirrors_ARG)) {
image_count = lv_raid_image_count(lv); image_count = lv_raid_image_count(lv);
if (lp->mirrors_sign == SIGN_PLUS) if (lp->mirrors_sign == SIGN_PLUS)
image_count += lp->mirrors; image_count += lp->mirrors;
@ -1744,7 +1744,7 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
if (image_count < 1) { if (image_count < 1) {
log_error("Unable to %s images by specified amount", log_error("Unable to %s images by specified amount",
arg_count(cmd, splitmirrors_ARG) ? arg_is_set(cmd, splitmirrors_ARG) ?
"split" : "reduce"); "split" : "reduce");
return 0; return 0;
} }
@ -1753,20 +1753,20 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
if (lp->merge_mirror) if (lp->merge_mirror)
return lv_raid_merge(lv); return lv_raid_merge(lv);
if (arg_count(cmd, trackchanges_ARG)) if (arg_is_set(cmd, trackchanges_ARG))
return lv_raid_split_and_track(lv, lp->pvh); return lv_raid_split_and_track(lv, lp->pvh);
if (arg_count(cmd, splitmirrors_ARG)) if (arg_is_set(cmd, splitmirrors_ARG))
return lv_raid_split(lv, lp->lv_split_name, return lv_raid_split(lv, lp->lv_split_name,
image_count, lp->pvh); image_count, lp->pvh);
if (arg_count(cmd, mirrors_ARG)) if (arg_is_set(cmd, mirrors_ARG))
return lv_raid_change_image_count(lv, image_count, lp->pvh); return lv_raid_change_image_count(lv, image_count, lp->pvh);
if (arg_count(cmd, type_ARG)) if (arg_is_set(cmd, type_ARG))
return lv_raid_reshape(lv, lp->segtype); return lv_raid_reshape(lv, lp->segtype);
if (arg_count(cmd, replace_ARG)) if (arg_is_set(cmd, replace_ARG))
return lv_raid_replace(lv, lp->replace_pvh, lp->pvh); return lv_raid_replace(lv, lp->replace_pvh, lp->pvh);
if (lp->repair) { if (lp->repair) {
@ -1815,7 +1815,7 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
} }
/* "warn" if policy not set to replace */ /* "warn" if policy not set to replace */
if (arg_count(cmd, usepolicies_ARG)) if (arg_is_set(cmd, usepolicies_ARG))
log_warn("Use 'lvconvert --repair %s/%s' to replace " log_warn("Use 'lvconvert --repair %s/%s' to replace "
"failed device.", lv->vg->name, lv->name); "failed device.", lv->vg->name, lv->name);
return 1; return 1;
@ -2905,7 +2905,7 @@ static int _lvconvert_pool(struct cmd_context *cmd,
seg = first_seg(pool_lv); seg = first_seg(pool_lv);
/* Normally do NOT change chunk size when swapping */ /* Normally do NOT change chunk size when swapping */
if (arg_count(cmd, chunksize_ARG) && if (arg_is_set(cmd, chunksize_ARG) &&
(lp->chunk_size != seg->chunk_size) && (lp->chunk_size != seg->chunk_size) &&
!dm_list_empty(&pool_lv->segs_using_this_lv)) { !dm_list_empty(&pool_lv->segs_using_this_lv)) {
if (lp->force == PROMPT) { if (lp->force == PROMPT) {
@ -2934,9 +2934,9 @@ static int _lvconvert_pool(struct cmd_context *cmd,
if (metadata_lv->le_count < lp->pool_metadata_extents) if (metadata_lv->le_count < lp->pool_metadata_extents)
log_print_unless_silent("Continuing with swap..."); log_print_unless_silent("Continuing with swap...");
if (!arg_count(cmd, discards_ARG)) if (!arg_is_set(cmd, discards_ARG))
lp->discards = seg->discards; lp->discards = seg->discards;
if (!arg_count(cmd, zero_ARG)) if (!arg_is_set(cmd, zero_ARG))
lp->zero = seg->zero_new_blocks; lp->zero = seg->zero_new_blocks;
if (!lp->yes && if (!lp->yes &&
@ -3321,7 +3321,7 @@ static int _lvconvert(struct cmd_context *cmd, struct logical_volume *lv,
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
if (!lv_is_mirrored(lv) && !lv_is_raid(lv)) { if (!lv_is_mirrored(lv) && !lv_is_raid(lv)) {
if (arg_count(cmd, usepolicies_ARG)) if (arg_is_set(cmd, usepolicies_ARG))
return ECMD_PROCESSED; /* nothing to be done here */ return ECMD_PROCESSED; /* nothing to be done here */
log_error("Cannot repair logical volume %s of segtype %s.", log_error("Cannot repair logical volume %s of segtype %s.",
display_lvname(lv), lvseg_name(first_seg(lv))); display_lvname(lv), lvseg_name(first_seg(lv)));
@ -3331,7 +3331,7 @@ static int _lvconvert(struct cmd_context *cmd, struct logical_volume *lv,
/* forward splitmirror operations to the cache origin, which may be raid /* forward splitmirror operations to the cache origin, which may be raid
* or old-style mirror */ * or old-style mirror */
if (arg_count(cmd, splitmirrors_ARG) && lv_is_cache_type(lv) if (arg_is_set(cmd, splitmirrors_ARG) && lv_is_cache_type(lv)
&& (origin = seg_lv(first_seg(lv), 0)) && lv_is_cache_origin(origin)) { && (origin = seg_lv(first_seg(lv), 0)) && lv_is_cache_origin(origin)) {
log_warn("WARNING: Selected operation does not work with cache-type LVs."); log_warn("WARNING: Selected operation does not work with cache-type LVs.");
log_warn("WARNING: Proceeding using the cache origin volume %s instead.", log_warn("WARNING: Proceeding using the cache origin volume %s instead.",
@ -3348,7 +3348,7 @@ static int _lvconvert(struct cmd_context *cmd, struct logical_volume *lv,
* the segtype was not specified, then we need * the segtype was not specified, then we need
* to consult the default. * to consult the default.
*/ */
if (arg_count(cmd, mirrors_ARG) && !lv_is_mirrored(lv)) { if (arg_is_set(cmd, mirrors_ARG) && !lv_is_mirrored(lv)) {
if (!(lp->segtype = get_segtype_from_string(cmd, find_config_tree_str(cmd, global_mirror_segtype_default_CFG, NULL)))) if (!(lp->segtype = get_segtype_from_string(cmd, find_config_tree_str(cmd, global_mirror_segtype_default_CFG, NULL))))
return_ECMD_FAILED; return_ECMD_FAILED;
} }
@ -3382,10 +3382,10 @@ static int _lvconvert(struct cmd_context *cmd, struct logical_volume *lv,
return_ECMD_FAILED; return_ECMD_FAILED;
/* If repairing and using policies, remove missing PVs from VG */ /* If repairing and using policies, remove missing PVs from VG */
if (lp->repair && arg_count(cmd, usepolicies_ARG)) if (lp->repair && arg_is_set(cmd, usepolicies_ARG))
_remove_missing_empty_pv(lv->vg, failed_pvs); _remove_missing_empty_pv(lv->vg, failed_pvs);
} else if (arg_count(cmd, mirrors_ARG) || } else if (arg_is_set(cmd, mirrors_ARG) ||
arg_count(cmd, splitmirrors_ARG) || arg_is_set(cmd, splitmirrors_ARG) ||
lv_is_mirrored(lv)) { lv_is_mirrored(lv)) {
if (!archive(lv->vg)) if (!archive(lv->vg))
return_ECMD_FAILED; return_ECMD_FAILED;
@ -3397,7 +3397,7 @@ static int _lvconvert(struct cmd_context *cmd, struct logical_volume *lv,
return_ECMD_FAILED; return_ECMD_FAILED;
/* If repairing and using policies, remove missing PVs from VG */ /* If repairing and using policies, remove missing PVs from VG */
if (lp->repair && arg_count(cmd, usepolicies_ARG)) if (lp->repair && arg_is_set(cmd, usepolicies_ARG))
_remove_missing_empty_pv(lv->vg, failed_pvs); _remove_missing_empty_pv(lv->vg, failed_pvs);
} }

18
tools/lvcreate.c
View File

@ -131,7 +131,7 @@ static int _lvcreate_name_params(struct cmd_context *cmd,
"in one command is not yet supported."); "in one command is not yet supported.");
return 0; return 0;
} }
} else if (lp->snapshot && !arg_count(cmd, virtualsize_ARG)) { } else if (lp->snapshot && !arg_is_set(cmd, virtualsize_ARG)) {
/* argv[0] might be [vg/]origin */ /* argv[0] might be [vg/]origin */
if (!argc) { if (!argc) {
log_error("Please specify a logical volume to act as " log_error("Please specify a logical volume to act as "
@ -414,14 +414,14 @@ static int _read_size_params(struct cmd_context *cmd,
lcp->virtual_size = arg_uint64_value(cmd, virtualsize_ARG, UINT64_C(0)); lcp->virtual_size = arg_uint64_value(cmd, virtualsize_ARG, UINT64_C(0));
if (arg_count(cmd, extents_ARG)) { if (arg_is_set(cmd, extents_ARG)) {
if (arg_count(cmd, size_ARG)) { if (arg_is_set(cmd, size_ARG)) {
log_error("Please specify either size or extents (not both)."); log_error("Please specify either size or extents (not both).");
return 0; return 0;
} }
lp->extents = arg_uint_value(cmd, extents_ARG, 0); lp->extents = arg_uint_value(cmd, extents_ARG, 0);
lcp->percent = arg_percent_value(cmd, extents_ARG, PERCENT_NONE); lcp->percent = arg_percent_value(cmd, extents_ARG, PERCENT_NONE);
} else if (arg_count(cmd, size_ARG)) { } else if (arg_is_set(cmd, size_ARG)) {
lcp->size = arg_uint64_value(cmd, size_ARG, UINT64_C(0)); lcp->size = arg_uint64_value(cmd, size_ARG, UINT64_C(0));
lcp->percent = PERCENT_NONE; lcp->percent = PERCENT_NONE;
} else if (!lp->snapshot && !seg_is_thin_volume(lp)) { } else if (!lp->snapshot && !seg_is_thin_volume(lp)) {
@ -459,7 +459,7 @@ static int _read_raid_params(struct cmd_context *cmd,
struct lvcreate_params *lp) struct lvcreate_params *lp)
{ {
if ((lp->stripes < 2) && segtype_is_raid10(lp->segtype)) { if ((lp->stripes < 2) && segtype_is_raid10(lp->segtype)) {
if (arg_count(cmd, stripes_ARG)) { if (arg_is_set(cmd, stripes_ARG)) {
/* User supplied the bad argument */ /* User supplied the bad argument */
log_error("Segment type 'raid10' requires 2 or more stripes."); log_error("Segment type 'raid10' requires 2 or more stripes.");
return 0; return 0;
@ -479,7 +479,7 @@ static int _read_raid_params(struct cmd_context *cmd,
return 0; return 0;
} }
if (arg_count(cmd, mirrors_ARG) && segtype_is_raid(lp->segtype) && if (arg_is_set(cmd, mirrors_ARG) && segtype_is_raid(lp->segtype) &&
!segtype_is_raid1(lp->segtype) && !segtype_is_raid10(lp->segtype)) { !segtype_is_raid1(lp->segtype) && !segtype_is_raid10(lp->segtype)) {
log_error("Mirror argument cannot be used with segment type, %s", log_error("Mirror argument cannot be used with segment type, %s",
lp->segtype->name); lp->segtype->name);
@ -509,7 +509,7 @@ static int _read_mirror_and_raid_params(struct cmd_context *cmd,
const char *segtype_name; const char *segtype_name;
/* Common mirror and raid params */ /* Common mirror and raid params */
if (arg_count(cmd, mirrors_ARG)) { if (arg_is_set(cmd, mirrors_ARG)) {
lp->mirrors = arg_uint_value(cmd, mirrors_ARG, 0) + 1; lp->mirrors = arg_uint_value(cmd, mirrors_ARG, 0) + 1;
if (segtype_is_raid1(lp->segtype)) { if (segtype_is_raid1(lp->segtype)) {
segtype_name = SEG_TYPE_NAME_RAID1; segtype_name = SEG_TYPE_NAME_RAID1;
@ -1228,7 +1228,7 @@ static int _check_raid_parameters(struct volume_group *vg,
* If number of devices was not supplied, we can infer from * If number of devices was not supplied, we can infer from
* the PVs given. * the PVs given.
*/ */
if (!arg_count(cmd, stripes_ARG) && if (!arg_is_set(cmd, stripes_ARG) &&
(devs > 2 * lp->segtype->parity_devs)) (devs > 2 * lp->segtype->parity_devs))
lp->stripes = devs - lp->segtype->parity_devs; lp->stripes = devs - lp->segtype->parity_devs;
@ -1239,7 +1239,7 @@ static int _check_raid_parameters(struct volume_group *vg,
return 0; return 0;
} }
} else if (segtype_is_raid10(lp->segtype)) { } else if (segtype_is_raid10(lp->segtype)) {
if (!arg_count(cmd, stripes_ARG)) if (!arg_is_set(cmd, stripes_ARG))
lp->stripes = devs / lp->mirrors; lp->stripes = devs / lp->mirrors;
if (lp->stripes < 2) { if (lp->stripes < 2) {
log_error("Unable to create RAID10 LV," log_error("Unable to create RAID10 LV,"

26
tools/lvdisplay.c
View File

@ -18,14 +18,14 @@
static int _lvdisplay_single(struct cmd_context *cmd, struct logical_volume *lv, static int _lvdisplay_single(struct cmd_context *cmd, struct logical_volume *lv,
struct processing_handle *handle __attribute__ ((unused))) struct processing_handle *handle __attribute__ ((unused)))
{ {
if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) if (!arg_is_set(cmd, all_ARG) && !lv_is_visible(lv))
return ECMD_PROCESSED; return ECMD_PROCESSED;
if (arg_count(cmd, colon_ARG)) if (arg_is_set(cmd, colon_ARG))
lvdisplay_colons(lv); lvdisplay_colons(lv);
else { else {
lvdisplay_full(cmd, lv, NULL); lvdisplay_full(cmd, lv, NULL);
if (arg_count(cmd, maps_ARG)) if (arg_is_set(cmd, maps_ARG))
lvdisplay_segments(lv); lvdisplay_segments(lv);
} }
@ -34,26 +34,26 @@ static int _lvdisplay_single(struct cmd_context *cmd, struct logical_volume *lv,
int lvdisplay(struct cmd_context *cmd, int argc, char **argv) int lvdisplay(struct cmd_context *cmd, int argc, char **argv)
{ {
if (arg_count(cmd, columns_ARG)) { if (arg_is_set(cmd, columns_ARG)) {
if (arg_count(cmd, colon_ARG) || arg_count(cmd, maps_ARG)) { if (arg_is_set(cmd, colon_ARG) || arg_is_set(cmd, maps_ARG)) {
log_error("Incompatible options selected"); log_error("Incompatible options selected");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
return lvs(cmd, argc, argv); return lvs(cmd, argc, argv);
} }
if (arg_count(cmd, aligned_ARG) || if (arg_is_set(cmd, aligned_ARG) ||
arg_count(cmd, binary_ARG) || arg_is_set(cmd, binary_ARG) ||
arg_count(cmd, noheadings_ARG) || arg_is_set(cmd, noheadings_ARG) ||
arg_count(cmd, options_ARG) || arg_is_set(cmd, options_ARG) ||
arg_count(cmd, separator_ARG) || arg_is_set(cmd, separator_ARG) ||
arg_count(cmd, sort_ARG) || arg_is_set(cmd, sort_ARG) ||
arg_count(cmd, unbuffered_ARG)) { arg_is_set(cmd, unbuffered_ARG)) {
log_error("Incompatible options selected."); log_error("Incompatible options selected.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, colon_ARG) && arg_count(cmd, maps_ARG)) { if (arg_is_set(cmd, colon_ARG) && arg_is_set(cmd, maps_ARG)) {
log_error("Options -c and -m are incompatible."); log_error("Options -c and -m are incompatible.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }

98
tools/lvmcmdline.c
View File

@ -82,7 +82,7 @@ int arg_from_list_is_set(const struct cmd_context *cmd, const char *err_found, .
va_list ap; va_list ap;
va_start(ap, err_found); va_start(ap, err_found);
while ((arg = va_arg(ap, int)) != -1 && !arg_count(cmd, arg)) while ((arg = va_arg(ap, int)) != -1 && !arg_is_set(cmd, arg))
/* empty */; /* empty */;
va_end(ap); va_end(ap);
@ -116,7 +116,7 @@ int arg_outside_list_is_set(const struct cmd_context *cmd, const char *err_found
case yes_ARG: case yes_ARG:
continue; continue;
} }
if (!arg_count(cmd, i)) if (!arg_is_set(cmd, i))
continue; /* unset */ continue; /* unset */
va_start(ap, err_found); va_start(ap, err_found);
while (((arg = va_arg(ap, int)) != -1) && (arg != i)) while (((arg = va_arg(ap, int)) != -1) && (arg != i))
@ -187,7 +187,7 @@ const char *arg_value(const struct cmd_context *cmd, int a)
const char *arg_str_value(const struct cmd_context *cmd, int a, const char *def) const char *arg_str_value(const struct cmd_context *cmd, int a, const char *def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].value : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].value : def;
} }
const char *grouped_arg_str_value(const struct arg_values *av, int a, const char *def) const char *grouped_arg_str_value(const struct arg_values *av, int a, const char *def)
@ -217,39 +217,39 @@ int32_t first_grouped_arg_int_value(const struct cmd_context *cmd, int a, const
int32_t arg_int_value(const struct cmd_context *cmd, int a, const int32_t def) int32_t arg_int_value(const struct cmd_context *cmd, int a, const int32_t def)
{ {
return (_cmdline.arg_props[a].flags & ARG_GROUPABLE) ? return (_cmdline.arg_props[a].flags & ARG_GROUPABLE) ?
first_grouped_arg_int_value(cmd, a, def) : (arg_count(cmd, a) ? cmd->arg_values[a].i_value : def); first_grouped_arg_int_value(cmd, a, def) : (arg_is_set(cmd, a) ? cmd->arg_values[a].i_value : def);
} }
uint32_t arg_uint_value(const struct cmd_context *cmd, int a, const uint32_t def) uint32_t arg_uint_value(const struct cmd_context *cmd, int a, const uint32_t def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].ui_value : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].ui_value : def;
} }
int64_t arg_int64_value(const struct cmd_context *cmd, int a, const int64_t def) int64_t arg_int64_value(const struct cmd_context *cmd, int a, const int64_t def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].i64_value : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].i64_value : def;
} }
uint64_t arg_uint64_value(const struct cmd_context *cmd, int a, const uint64_t def) uint64_t arg_uint64_value(const struct cmd_context *cmd, int a, const uint64_t def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].ui64_value : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].ui64_value : def;
} }
/* No longer used. /* No longer used.
const void *arg_ptr_value(struct cmd_context *cmd, int a, const void *def) const void *arg_ptr_value(struct cmd_context *cmd, int a, const void *def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].ptr : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].ptr : def;
} }
*/ */
sign_t arg_sign_value(const struct cmd_context *cmd, int a, const sign_t def) sign_t arg_sign_value(const struct cmd_context *cmd, int a, const sign_t def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].sign : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].sign : def;
} }
percent_type_t arg_percent_value(const struct cmd_context *cmd, int a, const percent_type_t def) percent_type_t arg_percent_value(const struct cmd_context *cmd, int a, const percent_type_t def)
{ {
return arg_count(cmd, a) ? cmd->arg_values[a].percent : def; return arg_is_set(cmd, a) ? cmd->arg_values[a].percent : def;
} }
int arg_count_increment(struct cmd_context *cmd, int a) int arg_count_increment(struct cmd_context *cmd, int a)
@ -993,7 +993,7 @@ static int _merge_synonym(struct cmd_context *cmd, int oldarg, int newarg)
struct arg_values *av; struct arg_values *av;
struct arg_value_group_list *current_group; struct arg_value_group_list *current_group;
if (arg_count(cmd, oldarg) && arg_count(cmd, newarg)) { if (arg_is_set(cmd, oldarg) && arg_is_set(cmd, newarg)) {
log_error("%s and %s are synonyms. Please only supply one.", log_error("%s and %s are synonyms. Please only supply one.",
_cmdline.arg_props[oldarg].long_arg, _cmdline.arg_props[newarg].long_arg); _cmdline.arg_props[oldarg].long_arg, _cmdline.arg_props[newarg].long_arg);
return 0; return 0;
@ -1001,12 +1001,12 @@ static int _merge_synonym(struct cmd_context *cmd, int oldarg, int newarg)
/* Not groupable? */ /* Not groupable? */
if (!(_cmdline.arg_props[oldarg].flags & ARG_GROUPABLE)) { if (!(_cmdline.arg_props[oldarg].flags & ARG_GROUPABLE)) {
if (arg_count(cmd, oldarg)) if (arg_is_set(cmd, oldarg))
_copy_arg_values(cmd->arg_values, oldarg, newarg); _copy_arg_values(cmd->arg_values, oldarg, newarg);
return 1; return 1;
} }
if (arg_count(cmd, oldarg)) if (arg_is_set(cmd, oldarg))
cmd->arg_values[newarg].count = cmd->arg_values[oldarg].count; cmd->arg_values[newarg].count = cmd->arg_values[oldarg].count;
/* Groupable */ /* Groupable */
@ -1050,23 +1050,23 @@ static int _get_settings(struct cmd_context *cmd)
cmd->current_settings = cmd->default_settings; cmd->current_settings = cmd->default_settings;
if (arg_count(cmd, debug_ARG)) if (arg_is_set(cmd, debug_ARG))
cmd->current_settings.debug = _LOG_FATAL + cmd->current_settings.debug = _LOG_FATAL +
(arg_count(cmd, debug_ARG) - 1); (arg_count(cmd, debug_ARG) - 1);
if (arg_count(cmd, verbose_ARG)) if (arg_is_set(cmd, verbose_ARG))
cmd->current_settings.verbose = arg_count(cmd, verbose_ARG); cmd->current_settings.verbose = arg_count(cmd, verbose_ARG);
if (arg_count(cmd, quiet_ARG)) { if (arg_is_set(cmd, quiet_ARG)) {
cmd->current_settings.debug = 0; cmd->current_settings.debug = 0;
cmd->current_settings.verbose = 0; cmd->current_settings.verbose = 0;
cmd->current_settings.silent = (arg_count(cmd, quiet_ARG) > 1) ? 1 : 0; cmd->current_settings.silent = (arg_count(cmd, quiet_ARG) > 1) ? 1 : 0;
} }
if (arg_count(cmd, test_ARG)) if (arg_is_set(cmd, test_ARG))
cmd->current_settings.test = arg_count(cmd, test_ARG); cmd->current_settings.test = arg_is_set(cmd, test_ARG);
if (arg_count(cmd, driverloaded_ARG)) { if (arg_is_set(cmd, driverloaded_ARG)) {
cmd->current_settings.activation = cmd->current_settings.activation =
arg_int_value(cmd, driverloaded_ARG, arg_int_value(cmd, driverloaded_ARG,
cmd->default_settings.activation); cmd->default_settings.activation);
@ -1076,7 +1076,7 @@ static int _get_settings(struct cmd_context *cmd)
cmd->current_settings.backup = arg_int_value(cmd, autobackup_ARG, cmd->current_settings.backup); cmd->current_settings.backup = arg_int_value(cmd, autobackup_ARG, cmd->current_settings.backup);
cmd->current_settings.cache_vgmetadata = cmd->command->flags & CACHE_VGMETADATA ? 1 : 0; cmd->current_settings.cache_vgmetadata = cmd->command->flags & CACHE_VGMETADATA ? 1 : 0;
if (arg_count(cmd, readonly_ARG)) { if (arg_is_set(cmd, readonly_ARG)) {
cmd->current_settings.activation = 0; cmd->current_settings.activation = 0;
cmd->current_settings.archive = 0; cmd->current_settings.archive = 0;
cmd->current_settings.backup = 0; cmd->current_settings.backup = 0;
@ -1091,18 +1091,18 @@ static int _get_settings(struct cmd_context *cmd)
if (!activation_mode) if (!activation_mode)
activation_mode = DEFAULT_ACTIVATION_MODE; activation_mode = DEFAULT_ACTIVATION_MODE;
if (arg_count(cmd, activationmode_ARG)) { if (arg_is_set(cmd, activationmode_ARG)) {
activation_mode = arg_str_value(cmd, activationmode_ARG, activation_mode = arg_str_value(cmd, activationmode_ARG,
activation_mode); activation_mode);
/* complain only if the two arguments conflict */ /* complain only if the two arguments conflict */
if (arg_count(cmd, partial_ARG) && if (arg_is_set(cmd, partial_ARG) &&
strcmp(activation_mode, "partial")) { strcmp(activation_mode, "partial")) {
log_error("--partial and --activationmode are mutually" log_error("--partial and --activationmode are mutually"
" exclusive arguments"); " exclusive arguments");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
} else if (arg_count(cmd, partial_ARG)) } else if (arg_is_set(cmd, partial_ARG))
activation_mode = "partial"; activation_mode = "partial";
if (!strcmp(activation_mode, "partial")) { if (!strcmp(activation_mode, "partial")) {
@ -1115,7 +1115,7 @@ static int _get_settings(struct cmd_context *cmd)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, ignorelockingfailure_ARG) || arg_count(cmd, sysinit_ARG)) if (arg_is_set(cmd, ignorelockingfailure_ARG) || arg_is_set(cmd, sysinit_ARG))
init_ignorelockingfailure(1); init_ignorelockingfailure(1);
else else
init_ignorelockingfailure(0); init_ignorelockingfailure(0);
@ -1133,10 +1133,10 @@ static int _get_settings(struct cmd_context *cmd)
*/ */
cmd->vg_read_print_access_error = 1; cmd->vg_read_print_access_error = 1;
if (arg_count(cmd, nosuffix_ARG)) if (arg_is_set(cmd, nosuffix_ARG))
cmd->current_settings.suffix = 0; cmd->current_settings.suffix = 0;
if (arg_count(cmd, units_ARG)) if (arg_is_set(cmd, units_ARG))
if (!(cmd->current_settings.unit_factor = if (!(cmd->current_settings.unit_factor =
dm_units_to_factor(arg_str_value(cmd, units_ARG, ""), dm_units_to_factor(arg_str_value(cmd, units_ARG, ""),
&cmd->current_settings.unit_type, 1, NULL))) { &cmd->current_settings.unit_type, 1, NULL))) {
@ -1144,11 +1144,11 @@ static int _get_settings(struct cmd_context *cmd)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, binary_ARG)) if (arg_is_set(cmd, binary_ARG))
cmd->report_binary_values_as_numeric = 1; cmd->report_binary_values_as_numeric = 1;
if (arg_count(cmd, trustcache_ARG)) { if (arg_is_set(cmd, trustcache_ARG)) {
if (arg_count(cmd, all_ARG)) { if (arg_is_set(cmd, all_ARG)) {
log_error("--trustcache is incompatible with --all"); log_error("--trustcache is incompatible with --all");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -1158,7 +1158,7 @@ static int _get_settings(struct cmd_context *cmd)
} else } else
init_trust_cache(0); init_trust_cache(0);
if (arg_count(cmd, noudevsync_ARG)) if (arg_is_set(cmd, noudevsync_ARG))
cmd->current_settings.udev_sync = 0; cmd->current_settings.udev_sync = 0;
/* Handle synonyms */ /* Handle synonyms */
@ -1186,12 +1186,12 @@ static int _get_settings(struct cmd_context *cmd)
static int _process_common_commands(struct cmd_context *cmd) static int _process_common_commands(struct cmd_context *cmd)
{ {
if (arg_count(cmd, help_ARG) || arg_count(cmd, help2_ARG)) { if (arg_is_set(cmd, help_ARG) || arg_is_set(cmd, help2_ARG)) {
_usage(cmd->command->name); _usage(cmd->command->name);
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
if (arg_count(cmd, version_ARG)) { if (arg_is_set(cmd, version_ARG)) {
return version(cmd, 0, (char **) NULL); return version(cmd, 0, (char **) NULL);
} }
@ -1325,14 +1325,14 @@ static int _prepare_profiles(struct cmd_context *cmd)
env_cmd_profile_name); env_cmd_profile_name);
} }
if (!arg_count(cmd, profile_ARG) && if (!arg_is_set(cmd, profile_ARG) &&
!arg_count(cmd, commandprofile_ARG) && !arg_is_set(cmd, commandprofile_ARG) &&
!arg_count(cmd, metadataprofile_ARG) && !arg_is_set(cmd, metadataprofile_ARG) &&
!env_cmd_profile_name) !env_cmd_profile_name)
/* nothing to do */ /* nothing to do */
return 1; return 1;
if (arg_count(cmd, profile_ARG)) { if (arg_is_set(cmd, profile_ARG)) {
/* /*
* If --profile is used with dumpconfig, it's used * If --profile is used with dumpconfig, it's used
* to dump the profile without the profile being applied. * to dump the profile without the profile being applied.
@ -1351,7 +1351,7 @@ static int _prepare_profiles(struct cmd_context *cmd)
!strcmp(cmd->command->name, "vgcreate") || !strcmp(cmd->command->name, "vgcreate") ||
!strcmp(cmd->command->name, "lvchange") || !strcmp(cmd->command->name, "lvchange") ||
!strcmp(cmd->command->name, "vgchange")) { !strcmp(cmd->command->name, "vgchange")) {
if (arg_count(cmd, metadataprofile_ARG)) { if (arg_is_set(cmd, metadataprofile_ARG)) {
log_error("Only one of --profile or " log_error("Only one of --profile or "
" --metadataprofile allowed."); " --metadataprofile allowed.");
return 0; return 0;
@ -1360,7 +1360,7 @@ static int _prepare_profiles(struct cmd_context *cmd)
source_name = _metadata_profile_source_name; source_name = _metadata_profile_source_name;
} }
else { else {
if (arg_count(cmd, commandprofile_ARG)) { if (arg_is_set(cmd, commandprofile_ARG)) {
log_error("Only one of --profile or " log_error("Only one of --profile or "
"--commandprofile allowed."); "--commandprofile allowed.");
return 0; return 0;
@ -1401,8 +1401,8 @@ static int _prepare_profiles(struct cmd_context *cmd)
} }
if (arg_count(cmd, commandprofile_ARG) || env_cmd_profile_name) { if (arg_is_set(cmd, commandprofile_ARG) || env_cmd_profile_name) {
if (arg_count(cmd, commandprofile_ARG)) { if (arg_is_set(cmd, commandprofile_ARG)) {
/* /*
* Prefer command profile specified on command * Prefer command profile specified on command
* line over the profile specified via * line over the profile specified via
@ -1429,7 +1429,7 @@ static int _prepare_profiles(struct cmd_context *cmd)
} }
if (arg_count(cmd, metadataprofile_ARG)) { if (arg_is_set(cmd, metadataprofile_ARG)) {
name = arg_str_value(cmd, metadataprofile_ARG, NULL); name = arg_str_value(cmd, metadataprofile_ARG, NULL);
source_name = _metadata_profile_source_name; source_name = _metadata_profile_source_name;
@ -1457,7 +1457,7 @@ static int _init_lvmlockd(struct cmd_context *cmd)
const char *lvmlockd_socket; const char *lvmlockd_socket;
int use_lvmlockd = find_config_tree_bool(cmd, global_use_lvmlockd_CFG, NULL); int use_lvmlockd = find_config_tree_bool(cmd, global_use_lvmlockd_CFG, NULL);
if (use_lvmlockd && arg_count(cmd, nolocking_ARG)) { if (use_lvmlockd && arg_is_set(cmd, nolocking_ARG)) {
/* --nolocking is only allowed with vgs/lvs/pvs commands */ /* --nolocking is only allowed with vgs/lvs/pvs commands */
cmd->lockd_gl_disable = 1; cmd->lockd_gl_disable = 1;
cmd->lockd_vg_disable = 1; cmd->lockd_vg_disable = 1;
@ -1555,7 +1555,7 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
set_cmd_name(cmd->command->name); set_cmd_name(cmd->command->name);
if (arg_count(cmd, backgroundfork_ARG)) { if (arg_is_set(cmd, backgroundfork_ARG)) {
if (!become_daemon(cmd, 1)) { if (!become_daemon(cmd, 1)) {
/* parent - quit immediately */ /* parent - quit immediately */
ret = ECMD_PROCESSED; ret = ECMD_PROCESSED;
@ -1563,13 +1563,13 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
} }
} }
if (arg_count(cmd, config_ARG)) if (arg_is_set(cmd, config_ARG))
if (!override_config_tree_from_string(cmd, arg_str_value(cmd, config_ARG, ""))) { if (!override_config_tree_from_string(cmd, arg_str_value(cmd, config_ARG, ""))) {
ret = EINVALID_CMD_LINE; ret = EINVALID_CMD_LINE;
goto_out; goto_out;
} }
if (arg_count(cmd, config_ARG) || !cmd->initialized.config || config_files_changed(cmd)) { if (arg_is_set(cmd, config_ARG) || !cmd->initialized.config || config_files_changed(cmd)) {
/* Reinitialise various settings inc. logging, filters */ /* Reinitialise various settings inc. logging, filters */
if (!refresh_toolcontext(cmd)) { if (!refresh_toolcontext(cmd)) {
if ((config_string_cft = remove_config_tree_by_source(cmd, CONFIG_STRING))) if ((config_string_cft = remove_config_tree_by_source(cmd, CONFIG_STRING)))
@ -1593,7 +1593,7 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
if (!cmd->initialized.filters && !_cmd_no_meta_proc(cmd) && !init_filters(cmd, !refresh_done)) if (!cmd->initialized.filters && !_cmd_no_meta_proc(cmd) && !init_filters(cmd, !refresh_done))
return_ECMD_FAILED; return_ECMD_FAILED;
if (arg_count(cmd, readonly_ARG)) if (arg_is_set(cmd, readonly_ARG))
cmd->metadata_read_only = 1; cmd->metadata_read_only = 1;
if ((ret = _get_settings(cmd))) if ((ret = _get_settings(cmd)))
@ -1636,7 +1636,7 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
if (_cmd_no_meta_proc(cmd)) if (_cmd_no_meta_proc(cmd))
locking_type = 0; locking_type = 0;
else if (arg_count(cmd, readonly_ARG)) { else if (arg_is_set(cmd, readonly_ARG)) {
if (find_config_tree_bool(cmd, global_use_lvmlockd_CFG, NULL)) { if (find_config_tree_bool(cmd, global_use_lvmlockd_CFG, NULL)) {
/* /*
* FIXME: we could use locking_type 5 here if that didn't * FIXME: we could use locking_type 5 here if that didn't
@ -1654,12 +1654,12 @@ int lvm_run_command(struct cmd_context *cmd, int argc, char **argv)
lvmetad_make_unused(cmd); lvmetad_make_unused(cmd);
log_verbose("Not using lvmetad because read-only is set."); log_verbose("Not using lvmetad because read-only is set.");
} }
} else if (arg_count(cmd, nolocking_ARG)) } else if (arg_is_set(cmd, nolocking_ARG))
locking_type = 0; locking_type = 0;
else else
locking_type = -1; locking_type = -1;
if (!init_locking(locking_type, cmd, _cmd_no_meta_proc(cmd) || arg_count(cmd, sysinit_ARG))) { if (!init_locking(locking_type, cmd, _cmd_no_meta_proc(cmd) || arg_is_set(cmd, sysinit_ARG))) {
ret = ECMD_FAILED; ret = ECMD_FAILED;
goto_out; goto_out;
} }

6
tools/lvmdiskscan.c
View File

@ -108,7 +108,7 @@ int lvmdiskscan(struct cmd_context *cmd, int argc __attribute__((unused)),
pv_disks_found = 0; pv_disks_found = 0;
pv_parts_found = 0; pv_parts_found = 0;
if (arg_count(cmd, lvmpartition_ARG)) if (arg_is_set(cmd, lvmpartition_ARG))
log_warn("WARNING: only considering LVM devices"); log_warn("WARNING: only considering LVM devices");
max_len = _get_max_dev_name_len(cmd->full_filter); max_len = _get_max_dev_name_len(cmd->full_filter);
@ -132,7 +132,7 @@ int lvmdiskscan(struct cmd_context *cmd, int argc __attribute__((unused)),
continue; continue;
} }
/* If user just wants PVs we are done */ /* If user just wants PVs we are done */
if (arg_count(cmd, lvmpartition_ARG)) if (arg_is_set(cmd, lvmpartition_ARG))
continue; continue;
/* What other device is it? */ /* What other device is it? */
@ -142,7 +142,7 @@ int lvmdiskscan(struct cmd_context *cmd, int argc __attribute__((unused)),
dev_iter_destroy(iter); dev_iter_destroy(iter);
/* Display totals */ /* Display totals */
if (!arg_count(cmd, lvmpartition_ARG)) { if (!arg_is_set(cmd, lvmpartition_ARG)) {
log_print("%d disk%s", log_print("%d disk%s",
disks_found, disks_found == 1 ? "" : "s"); disks_found, disks_found == 1 ? "" : "s");
log_print("%d partition%s", log_print("%d partition%s",

22
tools/lvresize.c
View File

@ -20,7 +20,7 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
{ {
const char *cmd_name; const char *cmd_name;
char *st; char *st;
int use_policy = arg_count(cmd, usepolicies_ARG); int use_policy = arg_is_set(cmd, usepolicies_ARG);
lp->sign = SIGN_NONE; lp->sign = SIGN_NONE;
lp->poolmetadatasign = SIGN_NONE; lp->poolmetadatasign = SIGN_NONE;
@ -45,7 +45,7 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
* If only --poolmetadatasize is specified with list of PVs, * If only --poolmetadatasize is specified with list of PVs,
* then metadata will be extended there. * then metadata will be extended there.
*/ */
lp->sizeargs = arg_count(cmd, extents_ARG) + arg_count(cmd, size_ARG); lp->sizeargs = arg_is_set(cmd, extents_ARG) + arg_is_set(cmd, size_ARG);
if (arg_from_list_is_zero(cmd, "may not be zero", if (arg_from_list_is_zero(cmd, "may not be zero",
chunksize_ARG, extents_ARG, chunksize_ARG, extents_ARG,
@ -57,7 +57,7 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
-1)) -1))
return_0; return_0;
if (arg_count(cmd, poolmetadatasize_ARG)) { if (arg_is_set(cmd, poolmetadatasize_ARG)) {
lp->poolmetadatasize = arg_uint64_value(cmd, poolmetadatasize_ARG, 0); lp->poolmetadatasize = arg_uint64_value(cmd, poolmetadatasize_ARG, 0);
lp->poolmetadatasign = arg_sign_value(cmd, poolmetadatasize_ARG, SIGN_NONE); lp->poolmetadatasign = arg_sign_value(cmd, poolmetadatasize_ARG, SIGN_NONE);
if (lp->poolmetadatasign == SIGN_MINUS) { if (lp->poolmetadatasign == SIGN_MINUS) {
@ -73,20 +73,20 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
lp->sizeargs = !lp->poolmetadatasize ? 1 : 0; lp->sizeargs = !lp->poolmetadatasize ? 1 : 0;
} else if ((lp->sizeargs != 1) && } else if ((lp->sizeargs != 1) &&
((lp->sizeargs == 2) || ((lp->sizeargs == 2) ||
!arg_count(cmd, poolmetadatasize_ARG))) { !arg_is_set(cmd, poolmetadatasize_ARG))) {
log_error("Please specify either size or extents but not " log_error("Please specify either size or extents but not "
"both."); "both.");
return 0; return 0;
} }
if (arg_count(cmd, extents_ARG)) { if (arg_is_set(cmd, extents_ARG)) {
lp->extents = arg_uint_value(cmd, extents_ARG, 0); lp->extents = arg_uint_value(cmd, extents_ARG, 0);
lp->sign = arg_sign_value(cmd, extents_ARG, SIGN_NONE); lp->sign = arg_sign_value(cmd, extents_ARG, SIGN_NONE);
lp->percent = arg_percent_value(cmd, extents_ARG, PERCENT_NONE); lp->percent = arg_percent_value(cmd, extents_ARG, PERCENT_NONE);
} }
/* Size returned in kilobyte units; held in sectors */ /* Size returned in kilobyte units; held in sectors */
if (arg_count(cmd, size_ARG)) { if (arg_is_set(cmd, size_ARG)) {
lp->size = arg_uint64_value(cmd, size_ARG, 0); lp->size = arg_uint64_value(cmd, size_ARG, 0);
lp->sign = arg_sign_value(cmd, size_ARG, SIGN_NONE); lp->sign = arg_sign_value(cmd, size_ARG, SIGN_NONE);
lp->percent = PERCENT_NONE; lp->percent = PERCENT_NONE;
@ -134,15 +134,15 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
lp->argc = argc; lp->argc = argc;
lp->argv = argv; lp->argv = argv;
lp->ac_policy = arg_count(cmd, usepolicies_ARG); lp->ac_policy = arg_is_set(cmd, usepolicies_ARG);
lp->ac_stripes = arg_count(cmd, stripes_ARG); lp->ac_stripes = arg_is_set(cmd, stripes_ARG);
if (lp->ac_stripes) { if (lp->ac_stripes) {
lp->ac_stripes_value = arg_uint_value(cmd, stripes_ARG, 1); lp->ac_stripes_value = arg_uint_value(cmd, stripes_ARG, 1);
} else { } else {
lp->ac_stripes_value = 0; lp->ac_stripes_value = 0;
} }
lp->ac_mirrors = arg_count(cmd, mirrors_ARG); lp->ac_mirrors = arg_is_set(cmd, mirrors_ARG);
if (lp->ac_mirrors) { if (lp->ac_mirrors) {
if (arg_sign_value(cmd, mirrors_ARG, SIGN_NONE) == SIGN_MINUS) { if (arg_sign_value(cmd, mirrors_ARG, SIGN_NONE) == SIGN_MINUS) {
@ -155,7 +155,7 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
lp->ac_mirrors_value = 0; lp->ac_mirrors_value = 0;
} }
lp->ac_stripesize = arg_count(cmd, stripesize_ARG); lp->ac_stripesize = arg_is_set(cmd, stripesize_ARG);
if (lp->ac_stripesize) { if (lp->ac_stripesize) {
if (arg_sign_value(cmd, stripesize_ARG, SIGN_NONE) == SIGN_MINUS) { if (arg_sign_value(cmd, stripesize_ARG, SIGN_NONE) == SIGN_MINUS) {
log_error("Stripesize may not be negative."); log_error("Stripesize may not be negative.");
@ -165,7 +165,7 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv,
lp->ac_stripesize_value = arg_uint64_value(cmd, stripesize_ARG, 0); lp->ac_stripesize_value = arg_uint64_value(cmd, stripesize_ARG, 0);
} }
lp->ac_no_sync = arg_count(cmd, nosync_ARG); lp->ac_no_sync = arg_is_set(cmd, nosync_ARG);
lp->ac_alloc = (alloc_policy_t) arg_uint_value(cmd, alloc_ARG, 0); lp->ac_alloc = (alloc_policy_t) arg_uint_value(cmd, alloc_ARG, 0);
lp->ac_type = arg_str_value(cmd, type_ARG, NULL); lp->ac_type = arg_str_value(cmd, type_ARG, NULL);

6
tools/lvscan.c
View File

@ -54,10 +54,10 @@ static int lvscan_single(struct cmd_context *cmd, struct logical_volume *lv,
const char *active_str, *snapshot_str; const char *active_str, *snapshot_str;
if (arg_count(cmd, cache_long_ARG)) if (arg_is_set(cmd, cache_long_ARG))
return _lvscan_single_lvmetad(cmd, lv); return _lvscan_single_lvmetad(cmd, lv);
if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) if (!arg_is_set(cmd, all_ARG) && !lv_is_visible(lv))
return ECMD_PROCESSED; return ECMD_PROCESSED;
inkernel = lv_info(cmd, lv, 0, &info, 0, 0) && info.exists; inkernel = lv_info(cmd, lv, 0, &info, 0, 0) && info.exists;
@ -93,7 +93,7 @@ int lvscan(struct cmd_context *cmd, int argc, char **argv)
{ {
const char *reason = NULL; const char *reason = NULL;
if (argc && !arg_count(cmd, cache_long_ARG)) { if (argc && !arg_is_set(cmd, cache_long_ARG)) {
log_error("No additional command line arguments allowed"); log_error("No additional command line arguments allowed");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }

26
tools/pvchange.c
View File

@ -31,7 +31,7 @@ static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
int allocatable = arg_int_value(cmd, allocatable_ARG, 0); int allocatable = arg_int_value(cmd, allocatable_ARG, 0);
int mda_ignore = arg_int_value(cmd, metadataignore_ARG, 0); int mda_ignore = arg_int_value(cmd, metadataignore_ARG, 0);
int tagargs = arg_count(cmd, addtag_ARG) + arg_count(cmd, deltag_ARG); int tagargs = arg_is_set(cmd, addtag_ARG) + arg_is_set(cmd, deltag_ARG);
params->total++; params->total++;
@ -51,7 +51,7 @@ static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
vg->name); vg->name);
goto bad; goto bad;
} }
if (arg_count(cmd, uuid_ARG)) { if (arg_is_set(cmd, uuid_ARG)) {
log_error("Resolve duplicate PV UUIDs with vgimportclone (or filters)."); log_error("Resolve duplicate PV UUIDs with vgimportclone (or filters).");
goto bad; goto bad;
} }
@ -64,7 +64,7 @@ static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
"support tags", pv_name); "support tags", pv_name);
goto bad; goto bad;
} }
if (arg_count(cmd, uuid_ARG) && lvs_in_vg_activated(vg)) { if (arg_is_set(cmd, uuid_ARG) && lvs_in_vg_activated(vg)) {
log_error("Volume group containing %s has active " log_error("Volume group containing %s has active "
"logical volumes", pv_name); "logical volumes", pv_name);
goto bad; goto bad;
@ -88,7 +88,7 @@ static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
} }
} }
if (arg_count(cmd, allocatable_ARG)) { if (arg_is_set(cmd, allocatable_ARG)) {
if (is_orphan(pv) && if (is_orphan(pv) &&
!(pv->fmt->features & FMT_ORPHAN_ALLOCATABLE)) { !(pv->fmt->features & FMT_ORPHAN_ALLOCATABLE)) {
log_error("Allocatability not supported by orphan " log_error("Allocatability not supported by orphan "
@ -129,16 +129,16 @@ static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
if (tagargs) { if (tagargs) {
/* tag or deltag */ /* tag or deltag */
if (arg_count(cmd, addtag_ARG) && !change_tag(cmd, NULL, NULL, pv, addtag_ARG)) if (arg_is_set(cmd, addtag_ARG) && !change_tag(cmd, NULL, NULL, pv, addtag_ARG))
goto_bad; goto_bad;
if (arg_count(cmd, deltag_ARG) && !change_tag(cmd, NULL, NULL, pv, deltag_ARG)) if (arg_is_set(cmd, deltag_ARG) && !change_tag(cmd, NULL, NULL, pv, deltag_ARG))
goto_bad; goto_bad;
done = 1; done = 1;
} }
if (arg_count(cmd, metadataignore_ARG)) { if (arg_is_set(cmd, metadataignore_ARG)) {
if ((vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) && if ((vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) &&
(arg_count(cmd, force_ARG) == PROMPT) && (arg_count(cmd, force_ARG) == PROMPT) &&
yes_no_prompt("Override preferred number of copies " yes_no_prompt("Override preferred number of copies "
@ -151,7 +151,7 @@ static int _pvchange_single(struct cmd_context *cmd, struct volume_group *vg,
done = 1; done = 1;
} }
if (arg_count(cmd, uuid_ARG)) { if (arg_is_set(cmd, uuid_ARG)) {
/* --uuid: Change PV ID randomly */ /* --uuid: Change PV ID randomly */
memcpy(&pv->old_id, &pv->id, sizeof(pv->id)); memcpy(&pv->old_id, &pv->id, sizeof(pv->id));
if (!id_create(&pv->id)) { if (!id_create(&pv->id)) {
@ -207,9 +207,9 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
struct processing_handle *handle = NULL; struct processing_handle *handle = NULL;
int ret; int ret;
if (!(arg_count(cmd, allocatable_ARG) + arg_is_set(cmd, addtag_ARG) + if (!(arg_is_set(cmd, allocatable_ARG) + arg_is_set(cmd, addtag_ARG) +
arg_is_set(cmd, deltag_ARG) + arg_count(cmd, uuid_ARG) + arg_is_set(cmd, deltag_ARG) + arg_is_set(cmd, uuid_ARG) +
arg_count(cmd, metadataignore_ARG))) { arg_is_set(cmd, metadataignore_ARG))) {
log_error("Please give one or more of -x, -uuid, " log_error("Please give one or more of -x, -uuid, "
"--addtag, --deltag or --metadataignore"); "--addtag, --deltag or --metadataignore");
ret = EINVALID_CMD_LINE; ret = EINVALID_CMD_LINE;
@ -224,13 +224,13 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv)
handle->custom_handle = &params; handle->custom_handle = &params;
if (!(arg_count(cmd, all_ARG)) && !argc && !handle->internal_report_for_select) { if (!(arg_is_set(cmd, all_ARG)) && !argc && !handle->internal_report_for_select) {
log_error("Please give a physical volume path or use --select for selection."); log_error("Please give a physical volume path or use --select for selection.");
ret = EINVALID_CMD_LINE; ret = EINVALID_CMD_LINE;
goto out; goto out;
} }
if (arg_count(cmd, all_ARG) && argc) { if (arg_is_set(cmd, all_ARG) && argc) {
log_error("Option --all and PhysicalVolumePath are exclusive."); log_error("Option --all and PhysicalVolumePath are exclusive.");
ret = EINVALID_CMD_LINE; ret = EINVALID_CMD_LINE;
goto out; goto out;

12
tools/pvcreate.c
View File

@ -27,25 +27,25 @@ static int pvcreate_restore_params_from_args(struct cmd_context *cmd, int argc,
{ {
pp->restorefile = arg_str_value(cmd, restorefile_ARG, NULL); pp->restorefile = arg_str_value(cmd, restorefile_ARG, NULL);
if (arg_count(cmd, restorefile_ARG) && !arg_count(cmd, uuidstr_ARG)) { if (arg_is_set(cmd, restorefile_ARG) && !arg_is_set(cmd, uuidstr_ARG)) {
log_error("--uuid is required with --restorefile"); log_error("--uuid is required with --restorefile");
return 0; return 0;
} }
if (!arg_count(cmd, restorefile_ARG) && arg_count(cmd, uuidstr_ARG)) { if (!arg_is_set(cmd, restorefile_ARG) && arg_is_set(cmd, uuidstr_ARG)) {
if (!arg_count(cmd, norestorefile_ARG) && if (!arg_is_set(cmd, norestorefile_ARG) &&
find_config_tree_bool(cmd, devices_require_restorefile_with_uuid_CFG, NULL)) { find_config_tree_bool(cmd, devices_require_restorefile_with_uuid_CFG, NULL)) {
log_error("--restorefile is required with --uuid"); log_error("--restorefile is required with --uuid");
return 0; return 0;
} }
} }
if (arg_count(cmd, uuidstr_ARG) && argc != 1) { if (arg_is_set(cmd, uuidstr_ARG) && argc != 1) {
log_error("Can only set uuid on one volume at once"); log_error("Can only set uuid on one volume at once");
return 0; return 0;
} }
if (arg_count(cmd, uuidstr_ARG)) { if (arg_is_set(cmd, uuidstr_ARG)) {
pp->uuid_str = arg_str_value(cmd, uuidstr_ARG, ""); pp->uuid_str = arg_str_value(cmd, uuidstr_ARG, "");
if (!id_read_format(&pp->pva.id, pp->uuid_str)) if (!id_read_format(&pp->pva.id, pp->uuid_str))
return 0; return 0;
@ -58,7 +58,7 @@ static int pvcreate_restore_params_from_args(struct cmd_context *cmd, int argc,
} }
pp->pva.size = arg_uint64_value(cmd, physicalvolumesize_ARG, UINT64_C(0)); pp->pva.size = arg_uint64_value(cmd, physicalvolumesize_ARG, UINT64_C(0));
if (arg_count(cmd, restorefile_ARG) || arg_count(cmd, uuidstr_ARG)) if (arg_is_set(cmd, restorefile_ARG) || arg_is_set(cmd, uuidstr_ARG))
pp->zero = 0; pp->zero = 0;
return 1; return 1;
} }

32
tools/pvdisplay.c
View File

@ -30,7 +30,7 @@ static int _pvdisplay_single(struct cmd_context *cmd,
size = (uint64_t)(pv_pe_count(pv) - pv_pe_alloc_count(pv)) * size = (uint64_t)(pv_pe_count(pv) - pv_pe_alloc_count(pv)) *
pv_pe_size(pv); pv_pe_size(pv);
if (arg_count(cmd, short_ARG)) { if (arg_is_set(cmd, short_ARG)) {
log_print("Device \"%s\" has a capacity of %s", pv_name, log_print("Device \"%s\" has a capacity of %s", pv_name,
display_size(cmd, size)); display_size(cmd, size));
goto out; goto out;
@ -44,14 +44,14 @@ static int _pvdisplay_single(struct cmd_context *cmd,
log_print_unless_silent("\"%s\" is a new physical volume of \"%s\"", log_print_unless_silent("\"%s\" is a new physical volume of \"%s\"",
pv_name, display_size(cmd, size)); pv_name, display_size(cmd, size));
if (arg_count(cmd, colon_ARG)) { if (arg_is_set(cmd, colon_ARG)) {
pvdisplay_colons(pv); pvdisplay_colons(pv);
goto out; goto out;
} }
pvdisplay_full(cmd, pv, NULL); pvdisplay_full(cmd, pv, NULL);
if (arg_count(cmd, maps_ARG)) if (arg_is_set(cmd, maps_ARG))
pvdisplay_segments(pv); pvdisplay_segments(pv);
out: out:
@ -63,33 +63,33 @@ int pvdisplay(struct cmd_context *cmd, int argc, char **argv)
int lock_global = 0; int lock_global = 0;
int ret; int ret;
if (arg_count(cmd, columns_ARG)) { if (arg_is_set(cmd, columns_ARG)) {
if (arg_count(cmd, colon_ARG) || arg_count(cmd, maps_ARG) || if (arg_is_set(cmd, colon_ARG) || arg_is_set(cmd, maps_ARG) ||
arg_count(cmd, short_ARG)) { arg_is_set(cmd, short_ARG)) {
log_error("Incompatible options selected"); log_error("Incompatible options selected");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
return pvs(cmd, argc, argv); return pvs(cmd, argc, argv);
} }
if (arg_count(cmd, aligned_ARG) || if (arg_is_set(cmd, aligned_ARG) ||
arg_count(cmd, all_ARG) || arg_is_set(cmd, all_ARG) ||
arg_count(cmd, binary_ARG) || arg_is_set(cmd, binary_ARG) ||
arg_count(cmd, noheadings_ARG) || arg_is_set(cmd, noheadings_ARG) ||
arg_count(cmd, options_ARG) || arg_is_set(cmd, options_ARG) ||
arg_count(cmd, separator_ARG) || arg_is_set(cmd, separator_ARG) ||
arg_count(cmd, sort_ARG) || arg_is_set(cmd, sort_ARG) ||
arg_count(cmd, unbuffered_ARG)) { arg_is_set(cmd, unbuffered_ARG)) {
log_error("Incompatible options selected"); log_error("Incompatible options selected");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, colon_ARG) && arg_count(cmd, maps_ARG)) { if (arg_is_set(cmd, colon_ARG) && arg_is_set(cmd, maps_ARG)) {
log_error("Option -c not allowed with option -m"); log_error("Option -c not allowed with option -m");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, colon_ARG) && arg_count(cmd, short_ARG)) { if (arg_is_set(cmd, colon_ARG) && arg_is_set(cmd, short_ARG)) {
log_error("Option -c is not allowed with option -s"); log_error("Option -c is not allowed with option -s");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }

4
tools/pvmove.c
View File

@ -493,7 +493,7 @@ static struct logical_volume *_set_up_pvmove_lv(struct cmd_context *cmd,
if (!lv_add_mirrors(cmd, lv_mirr, 1, 1, 0, 0, log_count, if (!lv_add_mirrors(cmd, lv_mirr, 1, 1, 0, 0, log_count,
allocatable_pvs, alloc, allocatable_pvs, alloc,
(arg_count(cmd, atomic_ARG)) ? (arg_is_set(cmd, atomic_ARG)) ?
MIRROR_BY_SEGMENTED_LV : MIRROR_BY_SEG)) { MIRROR_BY_SEGMENTED_LV : MIRROR_BY_SEG)) {
log_error("Failed to convert pvmove LV to mirrored"); log_error("Failed to convert pvmove LV to mirrored");
return_NULL; return_NULL;
@ -862,7 +862,7 @@ int pvmove(struct cmd_context *cmd, int argc, char **argv)
pp.pv_count = argc; pp.pv_count = argc;
pp.pv_names = argv; pp.pv_names = argv;
if (arg_count(cmd, name_ARG)) { if (arg_is_set(cmd, name_ARG)) {
if (!(pp.lv_name_arg = dm_pool_strdup(cmd->mem, arg_value(cmd, name_ARG)))) { if (!(pp.lv_name_arg = dm_pool_strdup(cmd->mem, arg_value(cmd, name_ARG)))) {
log_error("Failed to clone LV name."); log_error("Failed to clone LV name.");
return ECMD_FAILED; return ECMD_FAILED;

24
tools/pvscan.c
View File

@ -46,7 +46,7 @@ static int _pvscan_display_single(struct cmd_context *cmd,
const char *pvdevname = pv_dev_name(pv); const char *pvdevname = pv_dev_name(pv);
/* short listing? */ /* short listing? */
if (arg_count(cmd, short_ARG) > 0) { if (arg_is_set(cmd, short_ARG)) {
log_print_unless_silent("%s", pvdevname); log_print_unless_silent("%s", pvdevname);
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
@ -65,7 +65,7 @@ static int _pvscan_display_single(struct cmd_context *cmd,
pv_len = params->pv_max_name_len; pv_len = params->pv_max_name_len;
memset(params->pv_tmp_name, 0, params->pv_tmp_namelen); memset(params->pv_tmp_name, 0, params->pv_tmp_namelen);
if (arg_count(cmd, uuid_ARG)) { if (arg_is_set(cmd, uuid_ARG)) {
if (!id_write_format(&pv->id, uuid, sizeof(uuid))) { if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
stack; stack;
return ECMD_FAILED; return ECMD_FAILED;
@ -106,8 +106,8 @@ static int _pvscan_single(struct cmd_context *cmd, struct volume_group *vg,
{ {
struct pvscan_params *params = (struct pvscan_params *)handle->custom_handle; struct pvscan_params *params = (struct pvscan_params *)handle->custom_handle;
if ((arg_count(cmd, exported_ARG) && !(pv_status(pv) & EXPORTED_VG)) || if ((arg_is_set(cmd, exported_ARG) && !(pv_status(pv) & EXPORTED_VG)) ||
(arg_count(cmd, novolumegroup_ARG) && (!is_orphan(pv)))) { (arg_is_set(cmd, novolumegroup_ARG) && (!is_orphan(pv)))) {
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
@ -332,10 +332,10 @@ static int _pvscan_cache(struct cmd_context *cmd, int argc, char **argv)
return ret; return ret;
} }
if (arg_count(cmd, major_ARG) + arg_count(cmd, minor_ARG)) if (arg_is_set(cmd, major_ARG) + arg_is_set(cmd, minor_ARG))
devno_args = 1; devno_args = 1;
if (devno_args && (!arg_count(cmd, major_ARG) || !arg_count(cmd, minor_ARG))) { if (devno_args && (!arg_is_set(cmd, major_ARG) || !arg_is_set(cmd, minor_ARG))) {
log_error("Both --major and --minor required to identify devices."); log_error("Both --major and --minor required to identify devices.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -587,7 +587,7 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv)
const char *reason = NULL; const char *reason = NULL;
int ret; int ret;
if (arg_count(cmd, cache_long_ARG)) if (arg_is_set(cmd, cache_long_ARG))
return _pvscan_cache(cmd, argc, argv); return _pvscan_cache(cmd, argc, argv);
if (argc) { if (argc) {
@ -595,24 +595,24 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, activate_ARG)) { if (arg_is_set(cmd, activate_ARG)) {
log_error("--activate is only valid with --cache."); log_error("--activate is only valid with --cache.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, major_ARG) || arg_count(cmd, minor_ARG)) { if (arg_is_set(cmd, major_ARG) || arg_is_set(cmd, minor_ARG)) {
log_error("--major and --minor are only valid with --cache."); log_error("--major and --minor are only valid with --cache.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, novolumegroup_ARG) && arg_count(cmd, exported_ARG)) { if (arg_is_set(cmd, novolumegroup_ARG) && arg_is_set(cmd, exported_ARG)) {
log_error("Options -e and -n are incompatible"); log_error("Options -e and -n are incompatible");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, exported_ARG) || arg_count(cmd, novolumegroup_ARG)) if (arg_is_set(cmd, exported_ARG) || arg_is_set(cmd, novolumegroup_ARG))
log_warn("WARNING: only considering physical volumes %s", log_warn("WARNING: only considering physical volumes %s",
arg_count(cmd, exported_ARG) ? arg_is_set(cmd, exported_ARG) ?
"of exported volume group(s)" : "in no volume group"); "of exported volume group(s)" : "in no volume group");
/* Needed because this command has NO_LVMETAD_AUTOSCAN. */ /* Needed because this command has NO_LVMETAD_AUTOSCAN. */

42
tools/reporter.c
View File

@ -235,7 +235,7 @@ static int _segs_with_info_and_status_single(struct cmd_context *cmd, struct lv_
static int _lvsegs_single(struct cmd_context *cmd, struct logical_volume *lv, static int _lvsegs_single(struct cmd_context *cmd, struct logical_volume *lv,
struct processing_handle *handle) struct processing_handle *handle)
{ {
if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) if (!arg_is_set(cmd, all_ARG) && !lv_is_visible(lv))
return ECMD_PROCESSED; return ECMD_PROCESSED;
return process_each_segment_in_lv(cmd, lv, handle, _segs_single); return process_each_segment_in_lv(cmd, lv, handle, _segs_single);
@ -244,7 +244,7 @@ static int _lvsegs_single(struct cmd_context *cmd, struct logical_volume *lv,
static int _lvsegs_with_info_single(struct cmd_context *cmd, struct logical_volume *lv, static int _lvsegs_with_info_single(struct cmd_context *cmd, struct logical_volume *lv,
struct processing_handle *handle) struct processing_handle *handle)
{ {
if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) if (!arg_is_set(cmd, all_ARG) && !lv_is_visible(lv))
return ECMD_PROCESSED; return ECMD_PROCESSED;
return process_each_segment_in_lv(cmd, lv, handle, _segs_with_info_single); return process_each_segment_in_lv(cmd, lv, handle, _segs_with_info_single);
@ -253,7 +253,7 @@ static int _lvsegs_with_info_single(struct cmd_context *cmd, struct logical_volu
static int _lvsegs_with_status_single(struct cmd_context *cmd, struct logical_volume *lv, static int _lvsegs_with_status_single(struct cmd_context *cmd, struct logical_volume *lv,
struct processing_handle *handle) struct processing_handle *handle)
{ {
if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) if (!arg_is_set(cmd, all_ARG) && !lv_is_visible(lv))
return ECMD_PROCESSED; return ECMD_PROCESSED;
return process_each_segment_in_lv(cmd, lv, handle, _segs_with_status_single); return process_each_segment_in_lv(cmd, lv, handle, _segs_with_status_single);
@ -262,7 +262,7 @@ static int _lvsegs_with_status_single(struct cmd_context *cmd, struct logical_vo
static int _lvsegs_with_info_and_status_single(struct cmd_context *cmd, struct logical_volume *lv, static int _lvsegs_with_info_and_status_single(struct cmd_context *cmd, struct logical_volume *lv,
struct processing_handle *handle) struct processing_handle *handle)
{ {
if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv)) if (!arg_is_set(cmd, all_ARG) && !lv_is_visible(lv))
return ECMD_PROCESSED; return ECMD_PROCESSED;
return process_each_segment_in_lv(cmd, lv, handle, _segs_with_info_and_status_single); return process_each_segment_in_lv(cmd, lv, handle, _segs_with_info_and_status_single);
@ -810,7 +810,7 @@ static int _get_report_options(struct cmd_context *cmd,
report_idx_t idx = REPORT_IDX_SINGLE; report_idx_t idx = REPORT_IDX_SINGLE;
int r = ECMD_FAILED; int r = ECMD_FAILED;
if (!arg_count(cmd, options_ARG)) if (!arg_is_set(cmd, options_ARG))
return ECMD_PROCESSED; return ECMD_PROCESSED;
if (!(mem = dm_pool_create("report_options", 128))) { if (!(mem = dm_pool_create("report_options", 128))) {
@ -1252,21 +1252,21 @@ static int _config_report(struct cmd_context *cmd, struct report_args *args, str
switch (single_args->report_type) { switch (single_args->report_type) {
case DEVTYPES: case DEVTYPES:
single_args->keys = find_config_tree_str(cmd, report_devtypes_sort_CFG, NULL); single_args->keys = find_config_tree_str(cmd, report_devtypes_sort_CFG, NULL);
if (!arg_count(cmd, verbose_ARG)) if (!arg_is_set(cmd, verbose_ARG))
single_args->options = find_config_tree_str(cmd, report_devtypes_cols_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_devtypes_cols_CFG, NULL);
else else
single_args->options = find_config_tree_str(cmd, report_devtypes_cols_verbose_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_devtypes_cols_verbose_CFG, NULL);
break; break;
case LVS: case LVS:
single_args->keys = find_config_tree_str(cmd, report_lvs_sort_CFG, NULL); single_args->keys = find_config_tree_str(cmd, report_lvs_sort_CFG, NULL);
if (!arg_count(cmd, verbose_ARG)) if (!arg_is_set(cmd, verbose_ARG))
single_args->options = find_config_tree_str(cmd, report_lvs_cols_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_lvs_cols_CFG, NULL);
else else
single_args->options = find_config_tree_str(cmd, report_lvs_cols_verbose_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_lvs_cols_verbose_CFG, NULL);
break; break;
case VGS: case VGS:
single_args->keys = find_config_tree_str(cmd, report_vgs_sort_CFG, NULL); single_args->keys = find_config_tree_str(cmd, report_vgs_sort_CFG, NULL);
if (!arg_count(cmd, verbose_ARG)) if (!arg_is_set(cmd, verbose_ARG))
single_args->options = find_config_tree_str(cmd, report_vgs_cols_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_vgs_cols_CFG, NULL);
else else
single_args->options = find_config_tree_str(cmd, report_vgs_cols_verbose_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_vgs_cols_verbose_CFG, NULL);
@ -1274,21 +1274,21 @@ static int _config_report(struct cmd_context *cmd, struct report_args *args, str
case LABEL: case LABEL:
case PVS: case PVS:
single_args->keys = find_config_tree_str(cmd, report_pvs_sort_CFG, NULL); single_args->keys = find_config_tree_str(cmd, report_pvs_sort_CFG, NULL);
if (!arg_count(cmd, verbose_ARG)) if (!arg_is_set(cmd, verbose_ARG))
single_args->options = find_config_tree_str(cmd, report_pvs_cols_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_pvs_cols_CFG, NULL);
else else
single_args->options = find_config_tree_str(cmd, report_pvs_cols_verbose_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_pvs_cols_verbose_CFG, NULL);
break; break;
case SEGS: case SEGS:
single_args->keys = find_config_tree_str(cmd, report_segs_sort_CFG, NULL); single_args->keys = find_config_tree_str(cmd, report_segs_sort_CFG, NULL);
if (!arg_count(cmd, verbose_ARG)) if (!arg_is_set(cmd, verbose_ARG))
single_args->options = find_config_tree_str(cmd, report_segs_cols_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_segs_cols_CFG, NULL);
else else
single_args->options = find_config_tree_str(cmd, report_segs_cols_verbose_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_segs_cols_verbose_CFG, NULL);
break; break;
case PVSEGS: case PVSEGS:
single_args->keys = find_config_tree_str(cmd, report_pvsegs_sort_CFG, NULL); single_args->keys = find_config_tree_str(cmd, report_pvsegs_sort_CFG, NULL);
if (!arg_count(cmd, verbose_ARG)) if (!arg_is_set(cmd, verbose_ARG))
single_args->options = find_config_tree_str(cmd, report_pvsegs_cols_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_pvsegs_cols_CFG, NULL);
else else
single_args->options = find_config_tree_str(cmd, report_pvsegs_cols_verbose_CFG, NULL); single_args->options = find_config_tree_str(cmd, report_pvsegs_cols_verbose_CFG, NULL);
@ -1325,21 +1325,21 @@ static int _config_report(struct cmd_context *cmd, struct report_args *args, str
return_0; return_0;
args->separator = arg_str_value(cmd, separator_ARG, args->separator); args->separator = arg_str_value(cmd, separator_ARG, args->separator);
if (arg_count(cmd, separator_ARG)) if (arg_is_set(cmd, separator_ARG))
args->aligned = 0; args->aligned = 0;
if (arg_count(cmd, aligned_ARG)) if (arg_is_set(cmd, aligned_ARG))
args->aligned = 1; args->aligned = 1;
if (arg_count(cmd, unbuffered_ARG) && !arg_count(cmd, sort_ARG)) if (arg_is_set(cmd, unbuffered_ARG) && !arg_is_set(cmd, sort_ARG))
args->buffered = 0; args->buffered = 0;
if (arg_count(cmd, noheadings_ARG)) if (arg_is_set(cmd, noheadings_ARG))
args->headings = 0; args->headings = 0;
if (arg_count(cmd, nameprefixes_ARG)) { if (arg_is_set(cmd, nameprefixes_ARG)) {
args->aligned = 0; args->aligned = 0;
args->field_prefixes = 1; args->field_prefixes = 1;
} }
if (arg_count(cmd, unquoted_ARG)) if (arg_is_set(cmd, unquoted_ARG))
args->quoted = 0; args->quoted = 0;
if (arg_count(cmd, rows_ARG)) if (arg_is_set(cmd, rows_ARG))
args->columns_as_rows = 1; args->columns_as_rows = 1;
return 1; return 1;
@ -1399,7 +1399,7 @@ int lvs(struct cmd_context *cmd, int argc, char **argv)
{ {
report_type_t type; report_type_t type;
if (arg_count(cmd, segments_ARG)) if (arg_is_set(cmd, segments_ARG))
type = SEGS; type = SEGS;
else else
type = LVS; type = LVS;
@ -1416,7 +1416,7 @@ int pvs(struct cmd_context *cmd, int argc, char **argv)
{ {
report_type_t type; report_type_t type;
if (arg_count(cmd, segments_ARG)) if (arg_is_set(cmd, segments_ARG))
type = PVSEGS; type = PVSEGS;
else else
type = LABEL; type = LABEL;
@ -1538,7 +1538,7 @@ int lastlog(struct cmd_context *cmd, int argc, char **argv)
if (!report_format_init(cmd, NULL, &report_group, &cmd->log_rh, NULL, NULL)) if (!report_format_init(cmd, NULL, &report_group, &cmd->log_rh, NULL, NULL))
goto_out; goto_out;
if (arg_count(cmd, select_ARG) && if (arg_is_set(cmd, select_ARG) &&
!_do_report_get_selection(cmd, NULL, NULL, expected_idxs, &selection)) !_do_report_get_selection(cmd, NULL, NULL, expected_idxs, &selection))
goto_out; goto_out;

46
tools/toollib.c
View File

@ -801,10 +801,10 @@ int vgcreate_params_set_from_args(struct cmd_context *cmd,
return 0; return 0;
} }
if (arg_count(cmd, metadatacopies_ARG)) if (arg_is_set(cmd, metadatacopies_ARG))
vp_new->vgmetadatacopies = arg_int_value(cmd, metadatacopies_ARG, vp_new->vgmetadatacopies = arg_int_value(cmd, metadatacopies_ARG,
DEFAULT_VGMETADATACOPIES); DEFAULT_VGMETADATACOPIES);
else if (arg_count(cmd, vgmetadatacopies_ARG)) else if (arg_is_set(cmd, vgmetadatacopies_ARG))
vp_new->vgmetadatacopies = arg_int_value(cmd, vgmetadatacopies_ARG, vp_new->vgmetadatacopies = arg_int_value(cmd, vgmetadatacopies_ARG,
DEFAULT_VGMETADATACOPIES); DEFAULT_VGMETADATACOPIES);
else else
@ -1175,18 +1175,18 @@ int get_activation_monitoring_mode(struct cmd_context *cmd,
{ {
*monitoring_mode = DEFAULT_DMEVENTD_MONITOR; *monitoring_mode = DEFAULT_DMEVENTD_MONITOR;
if (arg_count(cmd, monitor_ARG) && if (arg_is_set(cmd, monitor_ARG) &&
(arg_count(cmd, ignoremonitoring_ARG) || (arg_is_set(cmd, ignoremonitoring_ARG) ||
arg_count(cmd, sysinit_ARG))) { arg_is_set(cmd, sysinit_ARG))) {
log_error("--ignoremonitoring or --sysinit option not allowed with --monitor option."); log_error("--ignoremonitoring or --sysinit option not allowed with --monitor option.");
return 0; return 0;
} }
if (arg_count(cmd, monitor_ARG)) if (arg_is_set(cmd, monitor_ARG))
*monitoring_mode = arg_int_value(cmd, monitor_ARG, *monitoring_mode = arg_int_value(cmd, monitor_ARG,
DEFAULT_DMEVENTD_MONITOR); DEFAULT_DMEVENTD_MONITOR);
else if (is_static() || arg_count(cmd, ignoremonitoring_ARG) || else if (is_static() || arg_is_set(cmd, ignoremonitoring_ARG) ||
arg_count(cmd, sysinit_ARG) || arg_is_set(cmd, sysinit_ARG) ||
!find_config_tree_bool(cmd, activation_monitoring_CFG, NULL)) !find_config_tree_bool(cmd, activation_monitoring_CFG, NULL))
*monitoring_mode = DMEVENTD_MONITOR_IGNORE; *monitoring_mode = DMEVENTD_MONITOR_IGNORE;
@ -1246,13 +1246,13 @@ int get_pool_params(struct cmd_context *cmd,
display_size(cmd, *chunk_size)); display_size(cmd, *chunk_size));
} }
if (arg_count(cmd, poolmetadatasize_ARG)) { if (arg_is_set(cmd, poolmetadatasize_ARG)) {
if (arg_sign_value(cmd, poolmetadatasize_ARG, SIGN_NONE) == SIGN_MINUS) { if (arg_sign_value(cmd, poolmetadatasize_ARG, SIGN_NONE) == SIGN_MINUS) {
log_error("Negative pool metadata size is invalid."); log_error("Negative pool metadata size is invalid.");
return 0; return 0;
} }
if (arg_count(cmd, poolmetadata_ARG)) { if (arg_is_set(cmd, poolmetadata_ARG)) {
log_error("Please specify either metadata logical volume or its size."); log_error("Please specify either metadata logical volume or its size.");
return 0; return 0;
} }
@ -1260,7 +1260,7 @@ int get_pool_params(struct cmd_context *cmd,
*passed_args |= PASS_ARG_POOL_METADATA_SIZE; *passed_args |= PASS_ARG_POOL_METADATA_SIZE;
*pool_metadata_size = arg_uint64_value(cmd, poolmetadatasize_ARG, *pool_metadata_size = arg_uint64_value(cmd, poolmetadatasize_ARG,
UINT64_C(0)); UINT64_C(0));
} else if (arg_count(cmd, poolmetadata_ARG)) } else if (arg_is_set(cmd, poolmetadata_ARG))
*passed_args |= PASS_ARG_POOL_METADATA_SIZE; /* fixed size */ *passed_args |= PASS_ARG_POOL_METADATA_SIZE; /* fixed size */
/* TODO: default in lvm.conf ? */ /* TODO: default in lvm.conf ? */
@ -1312,7 +1312,7 @@ static int _validate_stripe_params(struct cmd_context *cmd, uint32_t *stripes,
int get_stripe_params(struct cmd_context *cmd, uint32_t *stripes, uint32_t *stripe_size) int get_stripe_params(struct cmd_context *cmd, uint32_t *stripes, uint32_t *stripe_size)
{ {
/* stripes_long_ARG takes precedence (for lvconvert) */ /* stripes_long_ARG takes precedence (for lvconvert) */
*stripes = arg_uint_value(cmd, arg_count(cmd, stripes_long_ARG) ? stripes_long_ARG : stripes_ARG, 1); *stripes = arg_uint_value(cmd, arg_is_set(cmd, stripes_long_ARG) ? stripes_long_ARG : stripes_ARG, 1);
*stripe_size = arg_uint_value(cmd, stripesize_ARG, 0); *stripe_size = arg_uint_value(cmd, stripesize_ARG, 0);
if (*stripe_size) { if (*stripe_size) {
@ -2398,11 +2398,11 @@ int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
/* Skip availability change for non-virt snaps when processing all LVs */ /* Skip availability change for non-virt snaps when processing all LVs */
/* FIXME: pass process_all to process_single_lv() */ /* FIXME: pass process_all to process_single_lv() */
if (process_all && arg_count(cmd, activate_ARG) && if (process_all && arg_is_set(cmd, activate_ARG) &&
lv_is_cow(lvl->lv) && !lv_is_virtual_origin(origin_from_cow(lvl->lv))) lv_is_cow(lvl->lv) && !lv_is_virtual_origin(origin_from_cow(lvl->lv)))
continue; continue;
if (lv_is_virtual_origin(lvl->lv) && !arg_count(cmd, all_ARG)) { if (lv_is_virtual_origin(lvl->lv) && !arg_is_set(cmd, all_ARG)) {
if (lvargs_supplied && if (lvargs_supplied &&
str_list_match_item(arg_lvnames, lvl->lv->name)) str_list_match_item(arg_lvnames, lvl->lv->name))
log_print_unless_silent("Ignoring virtual origin logical volume %s.", log_print_unless_silent("Ignoring virtual origin logical volume %s.",
@ -2414,7 +2414,7 @@ int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
* Only let hidden LVs through if --all was used or the LVs * Only let hidden LVs through if --all was used or the LVs
* were specifically named on the command line. * were specifically named on the command line.
*/ */
if (!lvargs_supplied && !lv_is_visible(lvl->lv) && !arg_count(cmd, all_ARG)) if (!lvargs_supplied && !lv_is_visible(lvl->lv) && !arg_is_set(cmd, all_ARG))
continue; continue;
/* /*
@ -2422,7 +2422,7 @@ int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
* it is named on the command line. * it is named on the command line.
*/ */
if (lv_is_lockd_sanlock_lv(lvl->lv)) { if (lv_is_lockd_sanlock_lv(lvl->lv)) {
if (arg_count(cmd, all_ARG) || if (arg_is_set(cmd, all_ARG) ||
(lvargs_supplied && str_list_match_item(arg_lvnames, lvl->lv->name))) { (lvargs_supplied && str_list_match_item(arg_lvnames, lvl->lv->name))) {
log_very_verbose("Processing lockd_sanlock_lv %s/%s.", vg->name, lvl->lv->name); log_very_verbose("Processing lockd_sanlock_lv %s/%s.", vg->name, lvl->lv->name);
} else { } else {
@ -3840,29 +3840,29 @@ int pvcreate_params_from_args(struct cmd_context *cmd, struct pvcreate_params *p
} }
if (!(cmd->fmt->features & FMT_MDAS) && if (!(cmd->fmt->features & FMT_MDAS) &&
(arg_count(cmd, pvmetadatacopies_ARG) || (arg_is_set(cmd, pvmetadatacopies_ARG) ||
arg_count(cmd, metadatasize_ARG) || arg_is_set(cmd, metadatasize_ARG) ||
arg_count(cmd, dataalignment_ARG) || arg_is_set(cmd, dataalignment_ARG) ||
arg_count(cmd, dataalignmentoffset_ARG))) { arg_is_set(cmd, dataalignmentoffset_ARG))) {
log_error("Metadata and data alignment parameters only " log_error("Metadata and data alignment parameters only "
"apply to text format."); "apply to text format.");
return 0; return 0;
} }
if (!(cmd->fmt->features & FMT_BAS) && if (!(cmd->fmt->features & FMT_BAS) &&
arg_count(cmd, bootloaderareasize_ARG)) { arg_is_set(cmd, bootloaderareasize_ARG)) {
log_error("Bootloader area parameters only " log_error("Bootloader area parameters only "
"apply to text format."); "apply to text format.");
return 0; return 0;
} }
if (arg_count(cmd, metadataignore_ARG)) if (arg_is_set(cmd, metadataignore_ARG))
pp->pva.metadataignore = arg_int_value(cmd, metadataignore_ARG, pp->pva.metadataignore = arg_int_value(cmd, metadataignore_ARG,
DEFAULT_PVMETADATAIGNORE); DEFAULT_PVMETADATAIGNORE);
else else
pp->pva.metadataignore = find_config_tree_bool(cmd, metadata_pvmetadataignore_CFG, NULL); pp->pva.metadataignore = find_config_tree_bool(cmd, metadata_pvmetadataignore_CFG, NULL);
if (arg_count(cmd, pvmetadatacopies_ARG) && if (arg_is_set(cmd, pvmetadatacopies_ARG) &&
!arg_int_value(cmd, pvmetadatacopies_ARG, -1) && !arg_int_value(cmd, pvmetadatacopies_ARG, -1) &&
pp->pva.metadataignore) { pp->pva.metadataignore) {
log_error("metadataignore only applies to metadatacopies > 0"); log_error("metadataignore only applies to metadatacopies > 0");

2
tools/vgcfgbackup.c
View File

@ -54,7 +54,7 @@ static int vg_backup_single(struct cmd_context *cmd, const char *vg_name,
char **last_filename = (char **)handle->custom_handle; char **last_filename = (char **)handle->custom_handle;
char *filename; char *filename;
if (arg_count(cmd, file_ARG)) { if (arg_is_set(cmd, file_ARG)) {
if (!(filename = _expand_filename(arg_value(cmd, file_ARG), if (!(filename = _expand_filename(arg_value(cmd, file_ARG),
vg->name, last_filename))) vg->name, last_filename)))
return_ECMD_FAILED; return_ECMD_FAILED;

8
tools/vgcfgrestore.c
View File

@ -28,7 +28,7 @@ int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
log_error("Volume group name \"%s\" is invalid", vg_name); log_error("Volume group name \"%s\" is invalid", vg_name);
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
} else if (!(arg_count(cmd, list_ARG) && arg_count(cmd, file_ARG))) { } else if (!(arg_is_set(cmd, list_ARG) && arg_is_set(cmd, file_ARG))) {
log_error("Please specify a *single* volume group to restore."); log_error("Please specify a *single* volume group to restore.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -37,8 +37,8 @@ int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
* FIXME: overloading the -l arg for now to display a * FIXME: overloading the -l arg for now to display a
* list of archive files for a particular vg * list of archive files for a particular vg
*/ */
if (arg_count(cmd, list_ARG)) { if (arg_is_set(cmd, list_ARG)) {
if (!(arg_count(cmd,file_ARG) ? if (!(arg_is_set(cmd,file_ARG) ?
archive_display_file(cmd, archive_display_file(cmd,
arg_str_value(cmd, file_ARG, "")) : arg_str_value(cmd, file_ARG, "")) :
archive_display(cmd, vg_name))) archive_display(cmd, vg_name)))
@ -76,7 +76,7 @@ int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv)
cmd->handles_unknown_segments = 1; cmd->handles_unknown_segments = 1;
if (!(arg_count(cmd, file_ARG) ? if (!(arg_is_set(cmd, file_ARG) ?
backup_restore_from_file(cmd, vg_name, backup_restore_from_file(cmd, vg_name,
arg_str_value(cmd, file_ARG, ""), arg_str_value(cmd, file_ARG, ""),
arg_count(cmd, force_long_ARG)) : arg_count(cmd, force_long_ARG)) :

98
tools/vgchange.c
View File

@ -114,7 +114,7 @@ static int _activate_lvs_in_vg(struct cmd_context *cmd, struct volume_group *vg,
if (lv_is_replicator_dev(lv) && (lv != first_replicator_dev(lv))) if (lv_is_replicator_dev(lv) && (lv != first_replicator_dev(lv)))
continue; continue;
if (lv_activation_skip(lv, activate, arg_count(cmd, ignoreactivationskip_ARG))) if (lv_activation_skip(lv, activate, arg_is_set(cmd, ignoreactivationskip_ARG)))
continue; continue;
if ((activate == CHANGE_AAY) && if ((activate == CHANGE_AAY) &&
@ -346,7 +346,7 @@ static int _vgchange_clustered(struct cmd_context *cmd,
} }
} }
if (clustered && !arg_count(cmd, yes_ARG)) { if (clustered && !arg_is_set(cmd, yes_ARG)) {
if (!clvmd_is_running()) { if (!clvmd_is_running()) {
if (yes_no_prompt("LVM cluster daemon (clvmd) is not running. " if (yes_no_prompt("LVM cluster daemon (clvmd) is not running. "
"Make volume group \"%s\" clustered " "Make volume group \"%s\" clustered "
@ -501,11 +501,11 @@ static int _vgchange_profile(struct cmd_context *cmd,
old_profile_name = vg->profile ? vg->profile->name : "(no profile)"; old_profile_name = vg->profile ? vg->profile->name : "(no profile)";
if (arg_count(cmd, detachprofile_ARG)) { if (arg_is_set(cmd, detachprofile_ARG)) {
new_profile_name = "(no profile)"; new_profile_name = "(no profile)";
vg->profile = NULL; vg->profile = NULL;
} else { } else {
if (arg_count(cmd, metadataprofile_ARG)) if (arg_is_set(cmd, metadataprofile_ARG))
new_profile_name = arg_str_value(cmd, metadataprofile_ARG, NULL); new_profile_name = arg_str_value(cmd, metadataprofile_ARG, NULL);
else else
new_profile_name = arg_str_value(cmd, profile_ARG, NULL); new_profile_name = arg_str_value(cmd, profile_ARG, NULL);
@ -769,7 +769,7 @@ static int _vgchange_system_id(struct cmd_context *cmd, struct volume_group *vg)
if (!*system_id && cmd->system_id && strcmp(system_id, cmd->system_id)) { if (!*system_id && cmd->system_id && strcmp(system_id, cmd->system_id)) {
log_warn("WARNING: Removing the system ID allows unsafe access from other hosts."); log_warn("WARNING: Removing the system ID allows unsafe access from other hosts.");
if (!arg_count(cmd, yes_ARG) && if (!arg_is_set(cmd, yes_ARG) &&
yes_no_prompt("Remove system ID %s from volume group %s? [y/n]: ", yes_no_prompt("Remove system ID %s from volume group %s? [y/n]: ",
vg->system_id, vg->name) == 'n') { vg->system_id, vg->name) == 'n') {
log_error("System ID of volume group %s not changed.", vg->name); log_error("System ID of volume group %s not changed.", vg->name);
@ -792,7 +792,7 @@ static int _vgchange_system_id(struct cmd_context *cmd, struct volume_group *vg)
log_warn("WARNING: Volume group %s might become inaccessible from this machine.", log_warn("WARNING: Volume group %s might become inaccessible from this machine.",
vg->name); vg->name);
if (!arg_count(cmd, yes_ARG) && if (!arg_is_set(cmd, yes_ARG) &&
yes_no_prompt("Set foreign system ID %s on volume group %s? [y/n]: ", yes_no_prompt("Set foreign system ID %s on volume group %s? [y/n]: ",
system_id, vg->name) == 'n') { system_id, vg->name) == 'n') {
log_error("Volume group %s system ID not changed.", vg->name); log_error("Volume group %s system ID not changed.", vg->name);
@ -930,12 +930,12 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name,
* *
* Do not initiate any polling if --sysinit option is used. * Do not initiate any polling if --sysinit option is used.
*/ */
init_background_polling(arg_count(cmd, sysinit_ARG) ? 0 : init_background_polling(arg_is_set(cmd, sysinit_ARG) ? 0 :
arg_int_value(cmd, poll_ARG, arg_int_value(cmd, poll_ARG,
DEFAULT_BACKGROUND_POLLING)); DEFAULT_BACKGROUND_POLLING));
for (i = 0; i < DM_ARRAY_SIZE(_vgchange_args); ++i) { for (i = 0; i < DM_ARRAY_SIZE(_vgchange_args); ++i) {
if (arg_count(cmd, _vgchange_args[i].arg)) { if (arg_is_set(cmd, _vgchange_args[i].arg)) {
if (!archive(vg)) if (!archive(vg))
return_ECMD_FAILED; return_ECMD_FAILED;
if (!_vgchange_args[i].fn(cmd, vg)) if (!_vgchange_args[i].fn(cmd, vg))
@ -977,27 +977,27 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name,
} }
} }
if (arg_count(cmd, activate_ARG)) { if (arg_is_set(cmd, activate_ARG)) {
if (!vgchange_activate(cmd, vg, (activation_change_t) if (!vgchange_activate(cmd, vg, (activation_change_t)
arg_uint_value(cmd, activate_ARG, CHANGE_AY))) arg_uint_value(cmd, activate_ARG, CHANGE_AY)))
return_ECMD_FAILED; return_ECMD_FAILED;
} }
if (arg_count(cmd, refresh_ARG)) { if (arg_is_set(cmd, refresh_ARG)) {
/* refreshes the visible LVs (which starts polling) */ /* refreshes the visible LVs (which starts polling) */
if (!_vgchange_refresh(cmd, vg)) if (!_vgchange_refresh(cmd, vg))
return_ECMD_FAILED; return_ECMD_FAILED;
} }
if (!arg_count(cmd, activate_ARG) && if (!arg_is_set(cmd, activate_ARG) &&
!arg_count(cmd, refresh_ARG) && !arg_is_set(cmd, refresh_ARG) &&
arg_count(cmd, monitor_ARG)) { arg_is_set(cmd, monitor_ARG)) {
/* -ay* will have already done monitoring changes */ /* -ay* will have already done monitoring changes */
if (!_vgchange_monitoring(cmd, vg)) if (!_vgchange_monitoring(cmd, vg))
return_ECMD_FAILED; return_ECMD_FAILED;
} }
if (!arg_count(cmd, refresh_ARG) && if (!arg_is_set(cmd, refresh_ARG) &&
!vgchange_background_polling(cmd, vg)) !vgchange_background_polling(cmd, vg))
return_ECMD_FAILED; return_ECMD_FAILED;
@ -1096,31 +1096,31 @@ int vgchange(struct cmd_context *cmd, int argc, char **argv)
int ret; int ret;
int noupdate = int noupdate =
arg_count(cmd, activate_ARG) || arg_is_set(cmd, activate_ARG) ||
arg_count(cmd, lockstart_ARG) || arg_is_set(cmd, lockstart_ARG) ||
arg_count(cmd, lockstop_ARG) || arg_is_set(cmd, lockstop_ARG) ||
arg_count(cmd, monitor_ARG) || arg_is_set(cmd, monitor_ARG) ||
arg_count(cmd, poll_ARG) || arg_is_set(cmd, poll_ARG) ||
arg_count(cmd, refresh_ARG); arg_is_set(cmd, refresh_ARG);
int update_partial_safe = int update_partial_safe =
arg_count(cmd, deltag_ARG) || arg_is_set(cmd, deltag_ARG) ||
arg_count(cmd, addtag_ARG) || arg_is_set(cmd, addtag_ARG) ||
arg_count(cmd, metadataprofile_ARG) || arg_is_set(cmd, metadataprofile_ARG) ||
arg_count(cmd, profile_ARG) || arg_is_set(cmd, profile_ARG) ||
arg_count(cmd, detachprofile_ARG); arg_is_set(cmd, detachprofile_ARG);
int update_partial_unsafe = int update_partial_unsafe =
arg_count(cmd, logicalvolume_ARG) || arg_is_set(cmd, logicalvolume_ARG) ||
arg_count(cmd, maxphysicalvolumes_ARG) || arg_is_set(cmd, maxphysicalvolumes_ARG) ||
arg_count(cmd, resizeable_ARG) || arg_is_set(cmd, resizeable_ARG) ||
arg_count(cmd, uuid_ARG) || arg_is_set(cmd, uuid_ARG) ||
arg_count(cmd, physicalextentsize_ARG) || arg_is_set(cmd, physicalextentsize_ARG) ||
arg_count(cmd, clustered_ARG) || arg_is_set(cmd, clustered_ARG) ||
arg_count(cmd, alloc_ARG) || arg_is_set(cmd, alloc_ARG) ||
arg_count(cmd, vgmetadatacopies_ARG) || arg_is_set(cmd, vgmetadatacopies_ARG) ||
arg_count(cmd, locktype_ARG) || arg_is_set(cmd, locktype_ARG) ||
arg_count(cmd, systemid_ARG); arg_is_set(cmd, systemid_ARG);
int update = update_partial_safe || update_partial_unsafe; int update = update_partial_safe || update_partial_unsafe;
@ -1129,49 +1129,49 @@ int vgchange(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, profile_ARG) || arg_count(cmd, metadataprofile_ARG)) && if ((arg_is_set(cmd, profile_ARG) || arg_is_set(cmd, metadataprofile_ARG)) &&
arg_count(cmd, detachprofile_ARG)) { arg_is_set(cmd, detachprofile_ARG)) {
log_error("Only one of --metadataprofile and --detachprofile permitted."); log_error("Only one of --metadataprofile and --detachprofile permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, activate_ARG) && arg_count(cmd, refresh_ARG)) { if (arg_is_set(cmd, activate_ARG) && arg_is_set(cmd, refresh_ARG)) {
log_error("Only one of -a and --refresh permitted."); log_error("Only one of -a and --refresh permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, ignorelockingfailure_ARG) || if ((arg_is_set(cmd, ignorelockingfailure_ARG) ||
arg_count(cmd, sysinit_ARG)) && update) { arg_is_set(cmd, sysinit_ARG)) && update) {
log_error("Only -a permitted with --ignorelockingfailure and --sysinit"); log_error("Only -a permitted with --ignorelockingfailure and --sysinit");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, activate_ARG) && if (arg_is_set(cmd, activate_ARG) &&
(arg_count(cmd, monitor_ARG) || arg_count(cmd, poll_ARG))) { (arg_is_set(cmd, monitor_ARG) || arg_is_set(cmd, poll_ARG))) {
if (!is_change_activating((activation_change_t) arg_uint_value(cmd, activate_ARG, 0))) { if (!is_change_activating((activation_change_t) arg_uint_value(cmd, activate_ARG, 0))) {
log_error("Only -ay* allowed with --monitor or --poll."); log_error("Only -ay* allowed with --monitor or --poll.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
} }
if (arg_count(cmd, poll_ARG) && arg_count(cmd, sysinit_ARG)) { if (arg_is_set(cmd, poll_ARG) && arg_is_set(cmd, sysinit_ARG)) {
log_error("Only one of --poll and --sysinit permitted."); log_error("Only one of --poll and --sysinit permitted.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if ((arg_count(cmd, activate_ARG) == 1) && if (arg_is_set(cmd, activate_ARG) &&
arg_count(cmd, autobackup_ARG)) { arg_is_set(cmd, autobackup_ARG)) {
log_error("-A option not necessary with -a option"); log_error("-A option not necessary with -a option");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, maxphysicalvolumes_ARG) && if (arg_is_set(cmd, maxphysicalvolumes_ARG) &&
arg_sign_value(cmd, maxphysicalvolumes_ARG, SIGN_NONE) == SIGN_MINUS) { arg_sign_value(cmd, maxphysicalvolumes_ARG, SIGN_NONE) == SIGN_MINUS) {
log_error("MaxPhysicalVolumes may not be negative"); log_error("MaxPhysicalVolumes may not be negative");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, physicalextentsize_ARG) && if (arg_is_set(cmd, physicalextentsize_ARG) &&
arg_sign_value(cmd, physicalextentsize_ARG, SIGN_NONE) == SIGN_MINUS) { arg_sign_value(cmd, physicalextentsize_ARG, SIGN_NONE) == SIGN_MINUS) {
log_error("Physical extent size may not be negative"); log_error("Physical extent size may not be negative");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
@ -1184,14 +1184,14 @@ int vgchange(struct cmd_context *cmd, int argc, char **argv)
* not neet to be running at this moment yet - it could be * not neet to be running at this moment yet - it could be
* just too early during system initialization time. * just too early during system initialization time.
*/ */
if (arg_count(cmd, sysinit_ARG) && (arg_uint_value(cmd, activate_ARG, 0) == CHANGE_AAY)) { if (arg_is_set(cmd, sysinit_ARG) && (arg_uint_value(cmd, activate_ARG, 0) == CHANGE_AAY)) {
if (lvmetad_used()) { if (lvmetad_used()) {
log_warn("WARNING: lvmetad is active, skipping direct activation during sysinit"); log_warn("WARNING: lvmetad is active, skipping direct activation during sysinit");
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
} }
if (arg_count(cmd, clustered_ARG) && !argc && !arg_count(cmd, yes_ARG) && if (arg_is_set(cmd, clustered_ARG) && !argc && !arg_is_set(cmd, yes_ARG) &&
(yes_no_prompt("Change clustered property of all volumes groups? [y/n]: ") == 'n')) { (yes_no_prompt("Change clustered property of all volumes groups? [y/n]: ") == 'n')) {
log_error("No volume groups changed."); log_error("No volume groups changed.");
return ECMD_FAILED; return ECMD_FAILED;

10
tools/vgconvert.c
View File

@ -157,26 +157,26 @@ int vgconvert(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, metadatacopies_ARG)) { if (arg_is_set(cmd, metadatacopies_ARG)) {
log_error("Invalid option --metadatacopies, " log_error("Invalid option --metadatacopies, "
"use --pvmetadatacopies instead."); "use --pvmetadatacopies instead.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (!(cmd->fmt->features & FMT_MDAS) && if (!(cmd->fmt->features & FMT_MDAS) &&
(arg_count(cmd, pvmetadatacopies_ARG) || (arg_is_set(cmd, pvmetadatacopies_ARG) ||
arg_count(cmd, metadatasize_ARG))) { arg_is_set(cmd, metadatasize_ARG))) {
log_error("Metadata parameters only apply to text format"); log_error("Metadata parameters only apply to text format");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, pvmetadatacopies_ARG) && if (arg_is_set(cmd, pvmetadatacopies_ARG) &&
arg_int_value(cmd, pvmetadatacopies_ARG, -1) > 2) { arg_int_value(cmd, pvmetadatacopies_ARG, -1) > 2) {
log_error("Metadatacopies may only be 0, 1 or 2"); log_error("Metadatacopies may only be 0, 1 or 2");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (!(cmd->fmt->features & FMT_BAS) && if (!(cmd->fmt->features & FMT_BAS) &&
arg_count(cmd, bootloaderareasize_ARG)) { arg_is_set(cmd, bootloaderareasize_ARG)) {
log_error("Bootloader area parameters only apply to text format"); log_error("Bootloader area parameters only apply to text format");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }

2
tools/vgcreate.c
View File

@ -141,7 +141,7 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
log_warn("WARNING: Setting maxphysicalvolumes to %d " log_warn("WARNING: Setting maxphysicalvolumes to %d "
"(0 means unlimited)", vg->max_pv); "(0 means unlimited)", vg->max_pv);
if (arg_count(cmd, addtag_ARG)) { if (arg_is_set(cmd, addtag_ARG)) {
dm_list_iterate_items(current_group, &cmd->arg_value_groups) { dm_list_iterate_items(current_group, &cmd->arg_value_groups) {
if (!grouped_arg_is_set(current_group->arg_values, addtag_ARG)) if (!grouped_arg_is_set(current_group->arg_values, addtag_ARG))
continue; continue;

36
tools/vgdisplay.c
View File

@ -19,22 +19,22 @@ static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name,
struct volume_group *vg, struct volume_group *vg,
struct processing_handle *handle __attribute__((unused))) struct processing_handle *handle __attribute__((unused)))
{ {
if (arg_count(cmd, activevolumegroups_ARG) && !lvs_in_vg_activated(vg)) if (arg_is_set(cmd, activevolumegroups_ARG) && !lvs_in_vg_activated(vg))
return ECMD_PROCESSED; return ECMD_PROCESSED;
if (arg_count(cmd, colon_ARG)) { if (arg_is_set(cmd, colon_ARG)) {
vgdisplay_colons(vg); vgdisplay_colons(vg);
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
if (arg_count(cmd, short_ARG)) { if (arg_is_set(cmd, short_ARG)) {
vgdisplay_short(vg); vgdisplay_short(vg);
return ECMD_PROCESSED; return ECMD_PROCESSED;
} }
vgdisplay_full(vg); /* was vg_show */ vgdisplay_full(vg); /* was vg_show */
if (arg_count(cmd, verbose_ARG)) { if (arg_is_set(cmd, verbose_ARG)) {
vgdisplay_extents(vg); vgdisplay_extents(vg);
process_each_lv_in_vg(cmd, vg, NULL, NULL, 0, NULL, process_each_lv_in_vg(cmd, vg, NULL, NULL, 0, NULL,
@ -52,30 +52,30 @@ static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name,
int vgdisplay(struct cmd_context *cmd, int argc, char **argv) int vgdisplay(struct cmd_context *cmd, int argc, char **argv)
{ {
if (arg_count(cmd, columns_ARG)) { if (arg_is_set(cmd, columns_ARG)) {
if (arg_count(cmd, colon_ARG) || if (arg_is_set(cmd, colon_ARG) ||
arg_count(cmd, activevolumegroups_ARG) || arg_is_set(cmd, activevolumegroups_ARG) ||
arg_count(cmd, short_ARG)) { arg_is_set(cmd, short_ARG)) {
log_error("Incompatible options selected"); log_error("Incompatible options selected");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
return vgs(cmd, argc, argv); return vgs(cmd, argc, argv);
} else if (arg_count(cmd, aligned_ARG) || } else if (arg_is_set(cmd, aligned_ARG) ||
arg_count(cmd, binary_ARG) || arg_is_set(cmd, binary_ARG) ||
arg_count(cmd, noheadings_ARG) || arg_is_set(cmd, noheadings_ARG) ||
arg_count(cmd, options_ARG) || arg_is_set(cmd, options_ARG) ||
arg_count(cmd, separator_ARG) || arg_is_set(cmd, separator_ARG) ||
arg_count(cmd, sort_ARG) || arg_count(cmd, unbuffered_ARG)) { arg_is_set(cmd, sort_ARG) || arg_is_set(cmd, unbuffered_ARG)) {
log_error("Incompatible options selected"); log_error("Incompatible options selected");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, colon_ARG) && arg_count(cmd, short_ARG)) { if (arg_is_set(cmd, colon_ARG) && arg_is_set(cmd, short_ARG)) {
log_error("Option -c is not allowed with option -s"); log_error("Option -c is not allowed with option -s");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (argc && arg_count(cmd, activevolumegroups_ARG)) { if (argc && arg_is_set(cmd, activevolumegroups_ARG)) {
log_error("Option -A is not allowed with volume group names"); log_error("Option -A is not allowed with volume group names");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
@ -93,11 +93,11 @@ int vgdisplay(struct cmd_context *cmd, int argc, char **argv)
vgdisplay_single); vgdisplay_single);
/******** FIXME Need to count number processed /******** FIXME Need to count number processed
Add this to process_each_vg if arg_count(cmd,activevolumegroups_ARG) ? Add this to process_each_vg if arg_is_set(cmd,activevolumegroups_ARG) ?
if (opt == argc) { if (opt == argc) {
log_print("no "); log_print("no ");
if (arg_count(cmd,activevolumegroups_ARG)) if (arg_is_set(cmd,activevolumegroups_ARG))
printf("active "); printf("active ");
printf("volume groups found\n\n"); printf("volume groups found\n\n");
return LVM_E_NO_VG; return LVM_E_NO_VG;

4
tools/vgexport.c
View File

@ -70,12 +70,12 @@ bad:
int vgexport(struct cmd_context *cmd, int argc, char **argv) int vgexport(struct cmd_context *cmd, int argc, char **argv)
{ {
if (!argc && !arg_count(cmd, all_ARG) && !arg_is_set(cmd, select_ARG)) { if (!argc && !arg_is_set(cmd, all_ARG) && !arg_is_set(cmd, select_ARG)) {
log_error("Please supply volume groups or use --select for selection or use -a for all."); log_error("Please supply volume groups or use --select for selection or use -a for all.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, all_ARG) && (argc || arg_is_set(cmd, select_ARG))) { if (arg_is_set(cmd, all_ARG) && (argc || arg_is_set(cmd, select_ARG))) {
log_error("No arguments permitted when using -a for all."); log_error("No arguments permitted when using -a for all.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }

6
tools/vgextend.c
View File

@ -82,7 +82,7 @@ static int _vgextend_single(struct cmd_context *cmd, const char *vg_name,
uint32_t mda_used; uint32_t mda_used;
int ret = ECMD_FAILED; int ret = ECMD_FAILED;
if (arg_count(cmd, metadataignore_ARG) && if (arg_is_set(cmd, metadataignore_ARG) &&
(pp->force == PROMPT) && !pp->yes && (pp->force == PROMPT) && !pp->yes &&
(vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) && (vg_mda_copies(vg) != VGMETADATACOPIES_UNMANAGED) &&
(yes_no_prompt("Override preferred number of copies of VG %s metadata? [y/n]: ", vg_name) == 'n')) { (yes_no_prompt("Override preferred number of copies of VG %s metadata? [y/n]: ", vg_name) == 'n')) {
@ -96,7 +96,7 @@ static int _vgextend_single(struct cmd_context *cmd, const char *vg_name,
if (!vg_extend_each_pv(vg, pp)) if (!vg_extend_each_pv(vg, pp))
goto_out; goto_out;
if (arg_count(cmd, metadataignore_ARG)) { if (arg_is_set(cmd, metadataignore_ARG)) {
mda_copies = vg_mda_copies(vg); mda_copies = vg_mda_copies(vg);
mda_used = vg_mda_used_count(vg); mda_used = vg_mda_used_count(vg);
@ -136,7 +136,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, metadatacopies_ARG)) { if (arg_is_set(cmd, metadatacopies_ARG)) {
log_error("Invalid option --metadatacopies, " log_error("Invalid option --metadatacopies, "
"use --pvmetadatacopies instead."); "use --pvmetadatacopies instead.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;

6
tools/vgimport.c
View File

@ -63,17 +63,17 @@ int vgimport(struct cmd_context *cmd, int argc, char **argv)
{ {
const char *reason = NULL; const char *reason = NULL;
if (!argc && !arg_count(cmd, all_ARG) && !arg_is_set(cmd, select_ARG)) { if (!argc && !arg_is_set(cmd, all_ARG) && !arg_is_set(cmd, select_ARG)) {
log_error("Please supply volume groups or -S for selection or use -a for all."); log_error("Please supply volume groups or -S for selection or use -a for all.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, all_ARG) && (argc || arg_is_set(cmd, select_ARG))) { if (arg_is_set(cmd, all_ARG) && (argc || arg_is_set(cmd, select_ARG))) {
log_error("No arguments permitted when using -a for all."); log_error("No arguments permitted when using -a for all.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, force_ARG)) { if (arg_is_set(cmd, force_ARG)) {
/* /*
* The volume group cannot be repaired unless it is first * The volume group cannot be repaired unless it is first
* imported. If we don't allow the user a way to import the * imported. If we don't allow the user a way to import the

2
tools/vgmknodes.c
View File

@ -18,7 +18,7 @@
static int _vgmknodes_single(struct cmd_context *cmd, struct logical_volume *lv, static int _vgmknodes_single(struct cmd_context *cmd, struct logical_volume *lv,
struct processing_handle *handle __attribute__((unused))) struct processing_handle *handle __attribute__((unused)))
{ {
if (arg_count(cmd, refresh_ARG) && lv_is_visible(lv)) if (arg_is_set(cmd, refresh_ARG) && lv_is_visible(lv))
if (!lv_refresh(cmd, lv)) if (!lv_refresh(cmd, lv))
return_ECMD_FAILED; return_ECMD_FAILED;

10
tools/vgreduce.c
View File

@ -107,7 +107,7 @@ static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
goto restart; goto restart;
} }
if (arg_count(cmd, mirrorsonly_ARG) && !lv_is_mirrored(lv)) { if (arg_is_set(cmd, mirrorsonly_ARG) && !lv_is_mirrored(lv)) {
log_error("Non-mirror-image LV %s found: can't remove.", lv->name); log_error("Non-mirror-image LV %s found: can't remove.", lv->name);
continue; continue;
} }
@ -177,7 +177,7 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
struct processing_handle *handle; struct processing_handle *handle;
struct vgreduce_params vp = { 0 }; struct vgreduce_params vp = { 0 };
const char *vg_name; const char *vg_name;
int repairing = arg_count(cmd, removemissing_ARG); int repairing = arg_is_set(cmd, removemissing_ARG);
int saved_ignore_suspended_devices = ignore_suspended_devices(); int saved_ignore_suspended_devices = ignore_suspended_devices();
int ret; int ret;
@ -192,17 +192,17 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, mirrorsonly_ARG) && !repairing) { if (arg_is_set(cmd, mirrorsonly_ARG) && !repairing) {
log_error("--mirrorsonly requires --removemissing"); log_error("--mirrorsonly requires --removemissing");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (argc == 1 && !arg_count(cmd, all_ARG) && !repairing) { if (argc == 1 && !arg_is_set(cmd, all_ARG) && !repairing) {
log_error("Please enter physical volume paths or option -a"); log_error("Please enter physical volume paths or option -a");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (argc > 1 && arg_count(cmd, all_ARG)) { if (argc > 1 && arg_is_set(cmd, all_ARG)) {
log_error("Option -a and physical volume paths mutually " log_error("Option -a and physical volume paths mutually "
"exclusive"); "exclusive");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;

2
tools/vgscan.c
View File

@ -119,7 +119,7 @@ int vgscan(struct cmd_context *cmd, int argc, char **argv)
maxret = process_each_vg(cmd, argc, argv, NULL, NULL, 0, 0, NULL, &vgscan_single); maxret = process_each_vg(cmd, argc, argv, NULL, NULL, 0, 0, NULL, &vgscan_single);
if (arg_count(cmd, mknodes_ARG)) { if (arg_is_set(cmd, mknodes_ARG)) {
ret = vgmknodes(cmd, argc, argv); ret = vgmknodes(cmd, argc, argv);
if (ret > maxret) if (ret > maxret)
maxret = ret; maxret = ret;

16
tools/vgsplit.c
View File

@ -468,11 +468,11 @@ static struct volume_group *_vgsplit_from(struct cmd_context *cmd,
*/ */
static int new_vg_option_specified(struct cmd_context *cmd) static int new_vg_option_specified(struct cmd_context *cmd)
{ {
return(arg_count(cmd, clustered_ARG) || return(arg_is_set(cmd, clustered_ARG) ||
arg_count(cmd, alloc_ARG) || arg_is_set(cmd, alloc_ARG) ||
arg_count(cmd, maxphysicalvolumes_ARG) || arg_is_set(cmd, maxphysicalvolumes_ARG) ||
arg_count(cmd, maxlogicalvolumes_ARG) || arg_is_set(cmd, maxlogicalvolumes_ARG) ||
arg_count(cmd, vgmetadatacopies_ARG)); arg_is_set(cmd, vgmetadatacopies_ARG));
} }
int vgsplit(struct cmd_context *cmd, int argc, char **argv) int vgsplit(struct cmd_context *cmd, int argc, char **argv)
@ -487,13 +487,13 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
const char *lv_name; const char *lv_name;
int lock_vg_from_first = 1; int lock_vg_from_first = 1;
if ((arg_count(cmd, name_ARG) + argc) < 3) { if ((arg_is_set(cmd, name_ARG) + argc) < 3) {
log_error("Existing VG, new VG and either physical volumes " log_error("Existing VG, new VG and either physical volumes "
"or logical volume required."); "or logical volume required.");
return EINVALID_CMD_LINE; return EINVALID_CMD_LINE;
} }
if (arg_count(cmd, name_ARG) && (argc > 2)) { if (arg_is_set(cmd, name_ARG) && (argc > 2)) {
log_error("A logical volume name cannot be given with " log_error("A logical volume name cannot be given with "
"physical volumes."); "physical volumes.");
return ECMD_FAILED; return ECMD_FAILED;
@ -503,7 +503,7 @@ int vgsplit(struct cmd_context *cmd, int argc, char **argv)
if (!lockd_gl(cmd, "ex", LDGL_UPDATE_NAMES)) if (!lockd_gl(cmd, "ex", LDGL_UPDATE_NAMES))
return_ECMD_FAILED; return_ECMD_FAILED;
if (arg_count(cmd, name_ARG)) if (arg_is_set(cmd, name_ARG))
lv_name = arg_value(cmd, name_ARG); lv_name = arg_value(cmd, name_ARG);
else else
lv_name = NULL; lv_name = NULL;