From 6fda126dd700f6ef7fef71283c12b23c7a06a1d2 Mon Sep 17 00:00:00 2001 From: Alasdair Kergon Date: Mon, 11 Feb 2002 21:00:35 +0000 Subject: [PATCH] Run through indent - no (intentional) changes to any code. --- tools/archive.c | 14 ++---- tools/archive.h | 3 +- tools/cmdnames.h | 1 - tools/lvchange.c | 106 ++++++++++++++++++++++++------------------- tools/lvcreate.c | 93 ++++++++++++++++++------------------- tools/lvdisplay.c | 7 ++- tools/lvm.c | 100 ++++++++++++++++++---------------------- tools/lvmdiskscan.c | 99 +++++++++++++++++++++------------------- tools/lvremove.c | 8 ++-- tools/lvrename.c | 17 +++---- tools/lvresize.c | 44 +++++++++--------- tools/lvscan.c | 2 +- tools/pvchange.c | 50 +++++++++++--------- tools/pvcreate.c | 19 ++++---- tools/pvdisplay.c | 41 ++++++++--------- tools/pvscan.c | 27 +++++------ tools/toollib.c | 37 +++++++++------ tools/toollib.h | 27 ++++++----- tools/tools.h | 25 +++++----- tools/vgcfgbackup.c | 5 +- tools/vgcfgrestore.c | 8 ++-- tools/vgchange.c | 36 ++++++++------- tools/vgck.c | 3 +- tools/vgcreate.c | 47 +++++++++---------- tools/vgdisplay.c | 11 ++--- tools/vgexport.c | 12 ++--- tools/vgextend.c | 20 ++++---- tools/vgimport.c | 20 ++++---- tools/vgmerge.c | 25 +++++----- tools/vgreduce.c | 21 +++++---- tools/vgremove.c | 18 ++++---- tools/vgrename.c | 18 ++++---- tools/vgscan.c | 5 +- 33 files changed, 494 insertions(+), 475 deletions(-) diff --git a/tools/archive.c b/tools/archive.c index 5a44f6dd2..e505818f3 100644 --- a/tools/archive.c +++ b/tools/archive.c @@ -16,7 +16,6 @@ #include #include - static struct { int enabled; char *dir; @@ -25,8 +24,7 @@ static struct { } _archive_params; -int archive_init(const char *dir, - unsigned int keep_days, unsigned int keep_min) +int archive_init(const char *dir, unsigned int keep_days, unsigned int keep_min) { _archive_params.dir = NULL; @@ -118,8 +116,6 @@ int archive_display(struct cmd_context *cmd, const char *vg_name) return archive_list(cmd, cmd->um, _archive_params.dir, vg_name); } - - static struct { int enabled; char *dir; @@ -227,13 +223,12 @@ int backup_remove(const char *vg_name) } static struct volume_group *_read_vg(struct cmd_context *cmd, - const char *vg_name, const char *file) + const char *vg_name, const char *file) { struct volume_group *vg; struct format_instance *tf; - if (!(tf = text_format_create(cmd, file, cmd->um, - cmd->cmd_line))) { + if (!(tf = text_format_create(cmd, file, cmd->um, cmd->cmd_line))) { log_error("Couldn't create text format object."); return NULL; } @@ -245,7 +240,8 @@ static struct volume_group *_read_vg(struct cmd_context *cmd, return vg; } -int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name, const char *file) +int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name, + const char *file) { struct volume_group *vg; diff --git a/tools/archive.h b/tools/archive.h index b910cc080..f0f34eb25 100644 --- a/tools/archive.h +++ b/tools/archive.h @@ -42,7 +42,8 @@ void backup_enable(int flag); int backup(struct volume_group *vg); int backup_remove(const char *vg_name); -int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name, const char *file); +int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name, + const char *file); int backup_restore(struct cmd_context *cmd, const char *vg_name); #endif diff --git a/tools/cmdnames.h b/tools/cmdnames.h index eadbe4d59..351bb6f71 100644 --- a/tools/cmdnames.h +++ b/tools/cmdnames.h @@ -2,4 +2,3 @@ #define xx(a, b, c...) a #include "commands.h" - diff --git a/tools/lvchange.c b/tools/lvchange.c index aaea3bea5..bc688dbb1 100644 --- a/tools/lvchange.c +++ b/tools/lvchange.c @@ -21,17 +21,22 @@ #include "tools.h" static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv); -static int lvchange_permission(struct cmd_context *cmd, struct logical_volume *lv); -static int lvchange_availability(struct cmd_context *cmd, struct logical_volume *lv); -static int lvchange_contiguous(struct cmd_context *cmd, struct logical_volume *lv); -static int lvchange_readahead(struct cmd_context *cmd, struct logical_volume *lv); -static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *lv); +static int lvchange_permission(struct cmd_context *cmd, + struct logical_volume *lv); +static int lvchange_availability(struct cmd_context *cmd, + struct logical_volume *lv); +static int lvchange_contiguous(struct cmd_context *cmd, + struct logical_volume *lv); +static int lvchange_readahead(struct cmd_context *cmd, + struct logical_volume *lv); +static int lvchange_persistent(struct cmd_context *cmd, + struct logical_volume *lv); int lvchange(struct cmd_context *cmd, int argc, char **argv) { - if (!arg_count(cmd,available_ARG) && !arg_count(cmd,contiguous_ARG) - && !arg_count(cmd,permission_ARG) && !arg_count(cmd,readahead_ARG) - && !arg_count(cmd,minor_ARG) && !arg_count(cmd,persistent_ARG)) { + if (!arg_count(cmd, available_ARG) && !arg_count(cmd, contiguous_ARG) + && !arg_count(cmd, permission_ARG) && !arg_count(cmd, readahead_ARG) + && !arg_count(cmd, minor_ARG) && !arg_count(cmd, persistent_ARG)) { log_error("One or more of -a, -C, -m, -M, -p or -r required"); return EINVALID_CMD_LINE; } @@ -41,7 +46,7 @@ int lvchange(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } - if (arg_count(cmd,minor_ARG) && argc != 1) { + if (arg_count(cmd, minor_ARG) && argc != 1) { log_error("Only give one logical volume when specifying minor"); return EINVALID_CMD_LINE; } @@ -54,9 +59,9 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv) int doit = 0; int archived = 0; - if (!(lv->vg->status & LVM_WRITE) && - (arg_count(cmd,contiguous_ARG) || arg_count(cmd,permission_ARG) || - arg_count(cmd,readahead_ARG) || arg_count(cmd,persistent_ARG))) { + if (!(lv->vg->status & LVM_WRITE) && + (arg_count(cmd, contiguous_ARG) || arg_count(cmd, permission_ARG) || + arg_count(cmd, readahead_ARG) || arg_count(cmd, persistent_ARG))) { log_error("Only -a permitted with read-only volume " "group \"%s\"", lv->vg->name); return EINVALID_CMD_LINE; @@ -69,13 +74,13 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv) } if (lv->status & SNAPSHOT) { - log_error("Can't change snapshot logical volume \"%s\"", + log_error("Can't change snapshot logical volume \"%s\"", lv->name); return ECMD_FAILED; } /* access permission change */ - if (arg_count(cmd,permission_ARG)) { + if (arg_count(cmd, permission_ARG)) { if (!archive(lv->vg)) return ECMD_FAILED; archived = 1; @@ -83,7 +88,7 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv) } /* allocation policy change */ - if (arg_count(cmd,contiguous_ARG)) { + if (arg_count(cmd, contiguous_ARG)) { if (!archived && !archive(lv->vg)) return ECMD_FAILED; archived = 1; @@ -91,7 +96,7 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv) } /* read ahead sector change */ - if (arg_count(cmd,readahead_ARG)) { + if (arg_count(cmd, readahead_ARG)) { if (!archived && !archive(lv->vg)) return ECMD_FAILED; archived = 1; @@ -99,7 +104,7 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv) } /* read ahead sector change */ - if (arg_count(cmd,persistent_ARG)) { + if (arg_count(cmd, persistent_ARG)) { if (!archived && !archive(lv->vg)) return ECMD_FAILED; archived = 1; @@ -110,38 +115,42 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv) log_print("Logical volume \"%s\" changed", lv->name); /* availability change */ - if (arg_count(cmd,available_ARG)) + if (arg_count(cmd, available_ARG)) if (!lvchange_availability(cmd, lv)) return ECMD_FAILED; return 0; } -static int lvchange_permission(struct cmd_context *cmd, struct logical_volume *lv) +static int lvchange_permission(struct cmd_context *cmd, + struct logical_volume *lv) { int lv_access; - lv_access = arg_int_value(cmd,permission_ARG, 0); + lv_access = arg_int_value(cmd, permission_ARG, 0); if ((lv_access & LVM_WRITE) && (lv->status & LVM_WRITE)) { - log_error("Logical volume \"%s\" is already writable", lv->name); + log_error("Logical volume \"%s\" is already writable", + lv->name); return 0; } if (!(lv_access & LVM_WRITE) && !(lv->status & LVM_WRITE)) { - log_error("Logical volume \"%s\" is already read only", lv->name); + log_error("Logical volume \"%s\" is already read only", + lv->name); return 0; } if (lv_access & LVM_WRITE) { lv->status |= LVM_WRITE; - log_verbose("Setting logical volume \"%s\" read/write", lv->name); + log_verbose("Setting logical volume \"%s\" read/write", + lv->name); } else { lv->status &= ~LVM_WRITE; - log_verbose("Setting logical volume \"%s\" read-only", lv->name); + log_verbose("Setting logical volume \"%s\" read-only", + lv->name); } - log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name); if (!cmd->fid->ops->vg_write(cmd->fid, lv->vg)) return 0; @@ -155,16 +164,17 @@ static int lvchange_permission(struct cmd_context *cmd, struct logical_volume *l return 1; } -static int lvchange_availability(struct cmd_context *cmd, struct logical_volume *lv) +static int lvchange_availability(struct cmd_context *cmd, + struct logical_volume *lv) { int activate = 0; int active; - if (strcmp(arg_str_value(cmd,available_ARG, "n"), "n")) + if (strcmp(arg_str_value(cmd, available_ARG, "n"), "n")) activate = 1; - if (arg_count(cmd,minor_ARG)) { - lv->minor = arg_int_value(cmd,minor_ARG, -1); + if (arg_count(cmd, minor_ARG)) { + lv->minor = arg_int_value(cmd, minor_ARG, -1); } if ((active = lv_active(lv)) < 0) { @@ -173,24 +183,24 @@ static int lvchange_availability(struct cmd_context *cmd, struct logical_volume } if (activate && active) { - log_verbose("Logical volume \"%s\" is already active", + log_verbose("Logical volume \"%s\" is already active", lv->name); return 0; } if (!activate && !active) { - log_verbose("Logical volume \"%s\" is already inactive", + log_verbose("Logical volume \"%s\" is already inactive", lv->name); return 0; } - + if (activate & lv_suspended(lv)) { - log_verbose("Reactivating logical volume \"%s\"", lv->name); + log_verbose("Reactivating logical volume \"%s\"", lv->name); if (!lv_reactivate(lv)) return 0; return 1; } - + if (activate) { log_verbose("Activating logical volume \"%s\"", lv->name); if (!lv_activate(lv)) @@ -204,11 +214,12 @@ static int lvchange_availability(struct cmd_context *cmd, struct logical_volume return 1; } -static int lvchange_contiguous(struct cmd_context *cmd, struct logical_volume *lv) +static int lvchange_contiguous(struct cmd_context *cmd, + struct logical_volume *lv) { int lv_allocation = 0; - if (strcmp(arg_str_value(cmd,contiguous_ARG, "n"), "n")) + if (strcmp(arg_str_value(cmd, contiguous_ARG, "n"), "n")) lv_allocation |= ALLOC_CONTIGUOUS; if ((lv_allocation & ALLOC_CONTIGUOUS) && @@ -220,8 +231,9 @@ static int lvchange_contiguous(struct cmd_context *cmd, struct logical_volume *l if (!(lv_allocation & ALLOC_CONTIGUOUS) && !(lv->status & ALLOC_CONTIGUOUS)) { - log_error("Allocation policy of logical volume \"%s\" is already" - " not contiguous", lv->name); + log_error + ("Allocation policy of logical volume \"%s\" is already" + " not contiguous", lv->name); return 0; } @@ -252,11 +264,12 @@ static int lvchange_contiguous(struct cmd_context *cmd, struct logical_volume *l return 1; } -static int lvchange_readahead(struct cmd_context *cmd, struct logical_volume *lv) +static int lvchange_readahead(struct cmd_context *cmd, + struct logical_volume *lv) { int read_ahead = 0; - read_ahead = arg_int_value(cmd,readahead_ARG, 0); + read_ahead = arg_int_value(cmd, readahead_ARG, 0); /******* FIXME Ranges? if (read_ahead < LVM_MIN_READ_AHEAD || read_ahead > LVM_MAX_READ_AHEAD) { @@ -272,7 +285,8 @@ static int lvchange_readahead(struct cmd_context *cmd, struct logical_volume *lv } lv->read_ahead = read_ahead; - log_verbose("Setting read ahead to %u for \"%s\"", read_ahead, lv->name); + log_verbose("Setting read ahead to %u for \"%s\"", read_ahead, + lv->name); log_verbose("Updating logical volume \"%s\" on disk(s)", lv->name); @@ -284,9 +298,10 @@ static int lvchange_readahead(struct cmd_context *cmd, struct logical_volume *lv return 1; } -static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *lv) +static int lvchange_persistent(struct cmd_context *cmd, + struct logical_volume *lv) { - if (!strcmp(arg_str_value(cmd,persistent_ARG, "n"), "n")) { + if (!strcmp(arg_str_value(cmd, persistent_ARG, "n"), "n")) { if (!(lv->status & FIXED_MINOR)) { log_error("Minor number is already not persistent " "for \"%s\"", lv->name); @@ -300,12 +315,12 @@ static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *l log_error("Cannot change minor number when active"); return 0; } - if (!arg_count(cmd,minor_ARG)) { + if (!arg_count(cmd, minor_ARG)) { log_error("Minor number must be specified with -My"); return 0; } lv->status |= FIXED_MINOR; - lv->minor = arg_int_value(cmd,minor_ARG, -1); + lv->minor = arg_int_value(cmd, minor_ARG, -1); log_verbose("Setting persistent minor number to %d for \"%s\"", lv->minor, lv->name); } @@ -319,4 +334,3 @@ static int lvchange_persistent(struct cmd_context *cmd, struct logical_volume *l return 1; } - diff --git a/tools/lvcreate.c b/tools/lvcreate.c index dc86fb0c1..470052103 100644 --- a/tools/lvcreate.c +++ b/tools/lvcreate.c @@ -28,38 +28,38 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) char *vg_name; char *st; - if (arg_count(cmd,snapshot_ARG) || arg_count(cmd,chunksize_ARG)) { + if (arg_count(cmd, snapshot_ARG) || arg_count(cmd, chunksize_ARG)) { log_error("Snapshots are not yet supported in LVM2."); return EINVALID_CMD_LINE; } /* mutually exclusive */ - if ((arg_count(cmd,zero_ARG) && arg_count(cmd,snapshot_ARG)) || - (arg_count(cmd,extents_ARG) && arg_count(cmd,size_ARG))) { + if ((arg_count(cmd, zero_ARG) && arg_count(cmd, snapshot_ARG)) || + (arg_count(cmd, extents_ARG) && arg_count(cmd, size_ARG))) { log_error("Invalid combination of arguments"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,size_ARG) + arg_count(cmd,extents_ARG) == 0) { + if (arg_count(cmd, size_ARG) + arg_count(cmd, extents_ARG) == 0) { log_error("Please indicate size using option -l or -L"); return EINVALID_CMD_LINE; } - if (strcmp(arg_str_value(cmd,contiguous_ARG, "n"), "n")) + if (strcmp(arg_str_value(cmd, contiguous_ARG, "n"), "n")) status |= ALLOC_CONTIGUOUS; else status |= ALLOC_SIMPLE; - zero = strcmp(arg_str_value(cmd,zero_ARG, "y"), "n"); + zero = strcmp(arg_str_value(cmd, zero_ARG, "y"), "n"); - if (arg_count(cmd,stripes_ARG)) { - stripes = arg_int_value(cmd,stripes_ARG, 1); + if (arg_count(cmd, stripes_ARG)) { + stripes = arg_int_value(cmd, stripes_ARG, 1); if (stripes == 1) log_print("Redundant stripes argument: default is 1"); } - if (arg_count(cmd,stripesize_ARG)) - stripesize = 2 * arg_int_value(cmd,stripesize_ARG, 0); + if (arg_count(cmd, stripesize_ARG)) + stripesize = 2 * arg_int_value(cmd, stripesize_ARG, 0); if (stripes == 1 && stripesize) { log_print("Ignoring stripesize argument with single stripe"); @@ -71,23 +71,23 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) log_print("Using default stripesize %dKB", stripesize / 2); } - if (arg_count(cmd,permission_ARG)) - status |= arg_int_value(cmd,permission_ARG, 0); + if (arg_count(cmd, permission_ARG)) + status |= arg_int_value(cmd, permission_ARG, 0); else status |= LVM_READ | LVM_WRITE; - if (arg_count(cmd,readahead_ARG)) - read_ahead = arg_int_value(cmd,readahead_ARG, 0); + if (arg_count(cmd, readahead_ARG)) + read_ahead = arg_int_value(cmd, readahead_ARG, 0); - if (arg_count(cmd,extents_ARG)) - extents = arg_int_value(cmd,extents_ARG, 0); + if (arg_count(cmd, extents_ARG)) + extents = arg_int_value(cmd, extents_ARG, 0); /* Size returned in kilobyte units; held in sectors */ - if (arg_count(cmd,size_ARG)) - size = arg_int_value(cmd,size_ARG, 0); + if (arg_count(cmd, size_ARG)) + size = arg_int_value(cmd, size_ARG, 0); - if (arg_count(cmd,name_ARG)) - lv_name = arg_value(cmd,name_ARG); + if (arg_count(cmd, name_ARG)) + lv_name = arg_value(cmd, name_ARG); /* If VG not on command line, try -n arg and then environment */ if (!argc) { @@ -104,7 +104,7 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) if (strcmp(vg_name, argv[0])) { log_error("Inconsistent volume group names " "given: \"%s\" and \"%s\"", - vg_name, argv[0]); + vg_name, argv[0]); return EINVALID_CMD_LINE; } } @@ -119,10 +119,10 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) /* does VG exist? */ log_verbose("Finding volume group \"%s\"", vg_name); - if (!lock_vol(vg_name, LCK_VG | LCK_WRITE)) { - log_error("Can't get lock for %s", vg_name); - return ECMD_FAILED; - } + if (!lock_vol(vg_name, LCK_VG | LCK_WRITE)) { + log_error("Can't get lock for %s", vg_name); + return ECMD_FAILED; + } if (!(vg = cmd->fid->ops->vg_read(cmd->fid, vg_name))) { log_error("Volume group \"%s\" doesn't exist", vg_name); @@ -157,7 +157,7 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) } } - if (argc && argc < stripes ) { + if (argc && argc < stripes) { log_error("Too few physical volumes on " "command line for %d-way striping", stripes); goto error_cmdline; @@ -178,8 +178,7 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) if (stripesize > vg->extent_size) { log_error("Setting stripe size %d KB to physical extent " - "size %u KB", - stripesize / 2, vg->extent_size / 2); + "size %u KB", stripesize / 2, vg->extent_size / 2); stripesize = vg->extent_size; } @@ -199,42 +198,40 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) extents /= vg->extent_size; } - if ((size_rest = extents % stripes)) { - log_print("Rounding size (%d extents) up to stripe boundary " - "size (%d extents)", extents, - extents - size_rest + stripes); - extents = extents - size_rest + stripes; - } + if ((size_rest = extents % stripes)) { + log_print("Rounding size (%d extents) up to stripe boundary " + "size (%d extents)", extents, + extents - size_rest + stripes); + extents = extents - size_rest + stripes; + } if (!archive(vg)) goto error; if (!(lv = lv_create(cmd->fid, lv_name, status, - stripes, stripesize, extents, - vg, pvh))) + stripes, stripesize, extents, vg, pvh))) goto error; - if (arg_count(cmd,readahead_ARG)) { + if (arg_count(cmd, readahead_ARG)) { log_verbose("Setting read ahead sectors"); lv->read_ahead = read_ahead; } - if (arg_count(cmd,minor_ARG)) { + if (arg_count(cmd, minor_ARG)) { lv->status |= FIXED_MINOR; - lv->minor = arg_int_value(cmd,minor_ARG, -1); + lv->minor = arg_int_value(cmd, minor_ARG, -1); log_verbose("Setting minor number to %d", lv->minor); } - if (arg_count(cmd,persistent_ARG)) { - if (!strcmp(arg_str_value(cmd,persistent_ARG, "n"), "n")) + if (arg_count(cmd, persistent_ARG)) { + if (!strcmp(arg_str_value(cmd, persistent_ARG, "n"), "n")) lv->status &= ~FIXED_MINOR; - else - if (!arg_count(cmd,minor_ARG)) { - log_error("Please specify minor number with " - "--minor when using -My"); - goto error; - } - lv->status |= FIXED_MINOR; + else if (!arg_count(cmd, minor_ARG)) { + log_error("Please specify minor number with " + "--minor when using -My"); + goto error; + } + lv->status |= FIXED_MINOR; } /* store vg on disk(s) */ diff --git a/tools/lvdisplay.c b/tools/lvdisplay.c index d7063f09e..c1fef9a65 100644 --- a/tools/lvdisplay.c +++ b/tools/lvdisplay.c @@ -22,11 +22,11 @@ int lvdisplay_single(struct cmd_context *cmd, struct logical_volume *lv) { - if (arg_count(cmd,colon_ARG)) + if (arg_count(cmd, colon_ARG)) lvdisplay_colons(lv); else { lvdisplay_full(cmd, lv); - if (arg_count(cmd,maps_ARG)) + if (arg_count(cmd, maps_ARG)) lvdisplay_segments(lv); } @@ -37,11 +37,10 @@ int lvdisplay(struct cmd_context *cmd, int argc, char **argv) { /* FIXME Allow VG args via process_each */ - if (arg_count(cmd,colon_ARG) && arg_count(cmd,verbose_ARG)) { + if (arg_count(cmd, colon_ARG) && arg_count(cmd, verbose_ARG)) { log_error("Options -v and -c are incompatible"); return EINVALID_CMD_LINE; } return process_each_lv(cmd, argc, argv, &lvdisplay_single); } - diff --git a/tools/lvm.c b/tools/lvm.c index 18bcb40b8..6542ba2e6 100644 --- a/tools/lvm.c +++ b/tools/lvm.c @@ -24,11 +24,11 @@ #include #ifdef READLINE_SUPPORT - #include - #include - #ifndef HAVE_RL_COMPLETION_MATCHES - #define rl_completion_matches(a, b) completion_matches((char *)a, b) - #endif +#include +#include +#ifndef HAVE_RL_COMPLETION_MATCHES +#define rl_completion_matches(a, b) completion_matches((char *)a, b) +#endif #endif /* @@ -42,7 +42,6 @@ struct arg the_args[ARG_COUNT + 1] = { }; - static int _array_size; static int _num_commands; static struct command *_commands; @@ -57,7 +56,6 @@ static FILE *_log; /* lvm1 label handler */ static struct labeller *_lvm1_label; - /* * This structure only contains those options that * can have a default and per command setting. @@ -77,7 +75,6 @@ struct config_info { static struct config_info _default_settings; static struct config_info _current_settings; - /* * The lvm_sys_dir contains: * @@ -551,14 +548,13 @@ static int merge_synonym(int oldarg, int newarg) { struct arg *old, *new; - if (arg_count(cmd,oldarg) && arg_count(cmd,newarg)) { + if (arg_count(cmd, oldarg) && arg_count(cmd, newarg)) { log_error("%s and %s are synonyms. Please only supply one.", - the_args[oldarg].long_arg, - the_args[newarg].long_arg); + the_args[oldarg].long_arg, the_args[newarg].long_arg); return 0; } - if (!arg_count(cmd,oldarg)) + if (!arg_count(cmd, oldarg)) return 1; old = the_args + oldarg; @@ -589,44 +585,43 @@ static int process_common_commands(struct command *com) { _current_settings = _default_settings; - if (arg_count(cmd,suspend_ARG)) + if (arg_count(cmd, suspend_ARG)) kill(getpid(), SIGSTOP); - if (arg_count(cmd,debug_ARG)) + if (arg_count(cmd, debug_ARG)) _current_settings.debug = _LOG_FATAL + - (arg_count(cmd,debug_ARG) - 1); + (arg_count(cmd, debug_ARG) - 1); - if (arg_count(cmd,verbose_ARG)) - _current_settings.verbose = arg_count(cmd,verbose_ARG); + if (arg_count(cmd, verbose_ARG)) + _current_settings.verbose = arg_count(cmd, verbose_ARG); - if (arg_count(cmd,quiet_ARG)) { + if (arg_count(cmd, quiet_ARG)) { _current_settings.debug = 0; _current_settings.verbose = 0; } - if (arg_count(cmd,test_ARG)) - _current_settings.test = arg_count(cmd,test_ARG); + if (arg_count(cmd, test_ARG)) + _current_settings.test = arg_count(cmd, test_ARG); - if (arg_count(cmd,help_ARG)) { + if (arg_count(cmd, help_ARG)) { usage(com->name); return ECMD_PROCESSED; } - if (arg_count(cmd,version_ARG)) { - return version(cmd, 0, (char **)NULL); + if (arg_count(cmd, version_ARG)) { + return version(cmd, 0, (char **) NULL); } - if (arg_count(cmd,autobackup_ARG)) { + if (arg_count(cmd, autobackup_ARG)) { _current_settings.archive = 1; _current_settings.backup = 1; } - if (arg_count(cmd,partial_ARG)) { + if (arg_count(cmd, partial_ARG)) { init_partial(1); log_print("Partial mode. Incomplete volume groups will " "be activated read-only."); - } - else + } else init_partial(0); /* Handle synonyms */ @@ -693,18 +688,18 @@ static char *_copy_command_line(struct pool *mem, int argc, char **argv) goto bad; if (i < (argc - 1)) - if (!pool_grow_object(cmd->mem, " ", 1)); + if (!pool_grow_object(cmd->mem, " ", 1)) ; } /* * Terminate. */ if (!pool_grow_object(mem, "\0", 1)) - goto bad; + goto bad; return pool_end_object(mem); - bad: + bad: log_err("Couldn't copy command line."); pool_abandon_object(mem); return NULL; @@ -733,7 +728,7 @@ static int run_command(int argc, char **argv) _use_settings(&_current_settings); - locking_type = find_config_int(cmd->cf->root, "global/locking_type", + locking_type = find_config_int(cmd->cf->root, "global/locking_type", '/', 1); if (!init_locking(locking_type, cmd->cf)) { log_error("Locking type %d initialisation failed.", @@ -761,7 +756,6 @@ static int run_command(int argc, char **argv) if (ret == EINVALID_CMD_LINE && !_interactive) usage(cmd->command->name); - return ret; } @@ -804,9 +798,8 @@ static void __init_log(struct config_file *cf) const char *log_file, *prefix; - _default_settings.syslog = - find_config_int(cf->root, "log/syslog", '/', 1); + find_config_int(cf->root, "log/syslog", '/', 1); if (_default_settings.syslog != 1) fin_syslog(); @@ -814,11 +807,11 @@ static void __init_log(struct config_file *cf) init_syslog(_default_settings.syslog); _default_settings.debug = - find_config_int(cf->root, "log/level", '/', 0); + find_config_int(cf->root, "log/level", '/', 0); init_debug(_default_settings.debug); _default_settings.verbose = - find_config_int(cf->root, "log/verbose", '/', 0); + find_config_int(cf->root, "log/verbose", '/', 0); init_verbose(_default_settings.verbose); init_indent(find_config_int(cf->root, "log/indent", '/', 1)); @@ -858,14 +851,14 @@ static int _init_backup(struct config_file *cf) /* set up archiving */ _default_settings.archive = - find_config_bool(cmd->cf->root, "backup/archive", '/', - DEFAULT_ARCHIVE_ENABLED); + find_config_bool(cmd->cf->root, "backup/archive", '/', + DEFAULT_ARCHIVE_ENABLED); days = find_config_int(cmd->cf->root, "backup/retain_days", '/', DEFAULT_ARCHIVE_DAYS); min = find_config_int(cmd->cf->root, "backup/retain_min", '/', - DEFAULT_ARCHIVE_NUMBER); + DEFAULT_ARCHIVE_NUMBER); if (lvm_snprintf(default_dir, sizeof(default_dir), "%s/%s", _sys_dir, DEFAULT_ARCHIVE_SUBDIR) == -1) { @@ -884,8 +877,8 @@ static int _init_backup(struct config_file *cf) /* set up the backup */ _default_settings.backup = - find_config_bool(cmd->cf->root, "backup/backup", '/', - DEFAULT_BACKUP_ENABLED); + find_config_bool(cmd->cf->root, "backup/backup", '/', + DEFAULT_BACKUP_ENABLED); if (lvm_snprintf(default_dir, sizeof(default_dir), "%s/%s", _sys_dir, DEFAULT_BACKUP_SUBDIR) == -1) { @@ -989,8 +982,7 @@ static struct dev_filter *filter_setup(struct config_file *cf) return 0; } - lvm_cache = find_config_str(cf->root, "devices/cache", '/', - cache_file); + lvm_cache = find_config_str(cf->root, "devices/cache", '/', cache_file); if (!(f4 = persistent_filter_create(f3, lvm_cache))) { log_error("Failed to create persistent device filter"); @@ -1092,8 +1084,7 @@ static int init(void) if (stat(config_file, &info) != -1) { /* we've found a config file */ if (!read_config(cmd->cf, config_file)) { - log_error("Failed to load config file %s", - config_file); + log_error("Failed to load config file %s", config_file); return 0; } @@ -1101,15 +1092,15 @@ static int init(void) } _default_settings.umask = find_config_int(cmd->cf->root, - "global/umask", '/', - DEFAULT_UMASK); + "global/umask", '/', + DEFAULT_UMASK); - if ((old_umask = umask((mode_t)_default_settings.umask)) != - (mode_t)_default_settings.umask) - log_verbose("Set umask to %04o", _default_settings.umask); + if ((old_umask = umask((mode_t) _default_settings.umask)) != + (mode_t) _default_settings.umask) + log_verbose("Set umask to %04o", _default_settings.umask); if (lvm_snprintf(_dev_dir, sizeof(_dev_dir), "%s/", - find_config_str(cmd->cf->root, "devices/dir", + find_config_str(cmd->cf->root, "devices/dir", '/', DEFAULT_DEV_DIR)) < 0) { log_error("Device directory given in config file too long"); return 0; @@ -1121,7 +1112,7 @@ static int init(void) dm_log_init(print_log); if (lvm_snprintf(_proc_dir, sizeof(_proc_dir), "%s", - find_config_str(cmd->cf->root, "global/proc", + find_config_str(cmd->cf->root, "global/proc", '/', DEFAULT_PROC_DIR)) < 0) { log_error("Device directory given in config file too long"); return 0; @@ -1301,7 +1292,7 @@ static char *_list_args(const char *text, int state) char c; if (!(c = (the_args + com->valid_args[match_no++])->short_arg)) - continue; + continue; sprintf(s, "-%c", c); if (!strncmp(text, s, len)) @@ -1358,7 +1349,6 @@ static int _hist_file(char *buffer, size_t size) return 1; } - static void _read_history(void) { char hist_file[PATH_MAX]; @@ -1369,7 +1359,7 @@ static void _read_history(void) if (read_history(hist_file)) log_very_verbose("Couldn't read history from %s.", hist_file); - stifle_history(find_config_int(cmd->cf->root, "shell/history_size", + stifle_history(find_config_int(cmd->cf->root, "shell/history_size", '/', DEFAULT_MAX_HISTORY)); } diff --git a/tools/lvmdiskscan.c b/tools/lvmdiskscan.c index ab793967d..91d165cad 100644 --- a/tools/lvmdiskscan.c +++ b/tools/lvmdiskscan.c @@ -14,9 +14,9 @@ #include "tools.h" int _get_max_dev_name_len(struct dev_filter *filter); -void _count(struct device*, int*, int*); -void _print(struct device*, uint64_t, char*); -int _check_device(struct device*); +void _count(struct device *, int *, int *); +void _print(struct device *, uint64_t, char *); +int _check_device(struct device *); int disks_found = 0; int parts_found = 0; @@ -27,25 +27,25 @@ int max_len; int lvmdiskscan(struct cmd_context *cmd, int argc, char **argv) { uint64_t size; - struct dev_iter *iter; - struct device *dev; + struct dev_iter *iter; + struct device *dev; struct physical_volume *pv; - if (arg_count(cmd,lvmpartition_ARG)) + if (arg_count(cmd, lvmpartition_ARG)) log_print("WARNING: only considering LVM devices"); max_len = _get_max_dev_name_len(cmd->filter); - if (!(iter = dev_iter_create(cmd->filter))) { - log_error("dev_iter_create failed"); - return 0; - } + if (!(iter = dev_iter_create(cmd->filter))) { + log_error("dev_iter_create failed"); + return 0; + } - /* Do scan */ - for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) { + /* Do scan */ + for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) { /* Try if it is a PV first */ - if((pv = cmd->fid->ops->pv_read(cmd->fid, dev_name(dev)))) { - if(!dev_get_size(dev, &size)) { + if ((pv = cmd->fid->ops->pv_read(cmd->fid, dev_name(dev)))) { + if (!dev_get_size(dev, &size)) { log_error("Couldn't get size of \"%s\"", dev_name(dev)); continue; @@ -55,15 +55,17 @@ int lvmdiskscan(struct cmd_context *cmd, int argc, char **argv) continue; } /* If user just wants PVs we are done */ - if (arg_count(cmd,lvmpartition_ARG)) continue; - + if (arg_count(cmd, lvmpartition_ARG)) + continue; + /* What other device is it? */ - if(!_check_device(dev)) continue; - } - dev_iter_destroy(iter); + if (!_check_device(dev)) + continue; + } + dev_iter_destroy(iter); /* Display totals */ - if (!arg_count(cmd,lvmpartition_ARG)) { + if (!arg_count(cmd, lvmpartition_ARG)) { log_print("%d disk%s", disks_found, disks_found == 1 ? "" : "s"); log_print("%d partition%s", @@ -77,8 +79,8 @@ int lvmdiskscan(struct cmd_context *cmd, int argc, char **argv) return 0; } - -int _check_device(struct device *dev) { +int _check_device(struct device *dev) +{ char buffer; uint64_t size; @@ -89,55 +91,58 @@ int _check_device(struct device *dev) { dev_close(dev); return 0; } - if(!dev_get_size(dev, &size)) { - log_error("Couldn't get size of \"%s\"", - dev_name(dev)); + if (!dev_get_size(dev, &size)) { + log_error("Couldn't get size of \"%s\"", dev_name(dev)); } _print(dev, size, NULL); _count(dev, &disks_found, &parts_found); if (!dev_close(dev)) { - log_error("dev_close on \"%s\" failed", dev_name(dev)); + log_error("dev_close on \"%s\" failed", dev_name(dev)); return 0; } return 1; } - -int _get_max_dev_name_len(struct dev_filter *filter) { +int _get_max_dev_name_len(struct dev_filter *filter) +{ int len = 0; int max_len = 0; - struct dev_iter *iter; - struct device *dev; + struct dev_iter *iter; + struct device *dev; - if (!(iter = dev_iter_create(filter))) { - log_error("dev_iter_create failed"); - return 0; - } + if (!(iter = dev_iter_create(filter))) { + log_error("dev_iter_create failed"); + return 0; + } - /* Do scan */ - for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) { + /* Do scan */ + for (dev = dev_iter_get(iter); dev; dev = dev_iter_get(iter)) { len = strlen(dev_name(dev)); - if (len > max_len) max_len = len; + if (len > max_len) + max_len = len; } - dev_iter_destroy(iter); + dev_iter_destroy(iter); return max_len; } +void _count(struct device *dev, int *disks, int *parts) +{ + int c = dev_name(dev)[strlen(dev_name(dev)) - 1]; -void _count(struct device *dev, int *disks, int *parts) { - int c = dev_name(dev)[strlen(dev_name(dev))-1]; - - if(!isdigit(c)) (*disks)++; - else (*parts)++; + if (!isdigit(c)) + (*disks)++; + else + (*parts)++; } -void _print(struct device *dev, uint64_t size, char *what) { - char *dummy = display_size(size/2, SIZE_SHORT); +void _print(struct device *dev, uint64_t size, char *what) +{ + char *dummy = display_size(size / 2, SIZE_SHORT); const char *name = dev_name(dev); - if(!what) { - + if (!what) { + what = ""; } diff --git a/tools/lvremove.c b/tools/lvremove.c index 117094987..718d9b1d6 100644 --- a/tools/lvremove.c +++ b/tools/lvremove.c @@ -57,11 +57,12 @@ static int lvremove_single(struct cmd_context *cmd, struct logical_volume *lv) active = lv_active(lv); - if (active && !arg_count(cmd,force_ARG)) { + if (active && !arg_count(cmd, force_ARG)) { if (yes_no_prompt ("Do you really want to remove active logical volume \"%s\"? " "[y/n]: ", lv->name) == 'n') { - log_print("Logical volume \"%s\" not removed", lv->name); + log_print("Logical volume \"%s\" not removed", + lv->name); return 0; } } @@ -70,7 +71,8 @@ static int lvremove_single(struct cmd_context *cmd, struct logical_volume *lv) return ECMD_FAILED; if (active && !lv_deactivate(lv)) { - log_error("Unable to deactivate logical volume \"%s\"", lv->name); + log_error("Unable to deactivate logical volume \"%s\"", + lv->name); } log_verbose("Releasing logical volume \"%s\"", lv->name); diff --git a/tools/lvrename.c b/tools/lvrename.c index 3adb02229..f7d704f58 100644 --- a/tools/lvrename.c +++ b/tools/lvrename.c @@ -74,8 +74,9 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv) } if (!is_valid_chars(lv_name_new)) { - log_error("New logical volume name \"%s\" has invalid characters", - lv_name_new); + log_error + ("New logical volume name \"%s\" has invalid characters", + lv_name_new); return EINVALID_CMD_LINE; } @@ -96,15 +97,15 @@ int lvrename(struct cmd_context *cmd, int argc, char **argv) goto error; } - if (vg->status & EXPORTED_VG) { - log_error("Volume group \"%s\" is exported", vg->name); + if (vg->status & EXPORTED_VG) { + log_error("Volume group \"%s\" is exported", vg->name); goto error; - } + } - if (!(vg->status & LVM_WRITE)) { - log_error("Volume group \"%s\" is read-only", vg_name); + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group \"%s\" is read-only", vg_name); goto error; - } + } if (find_lv_in_vg(vg, lv_name_new)) { log_error("Logical volume \"%s\" already exists in " diff --git a/tools/lvresize.c b/tools/lvresize.c index 0c432b6a4..a313164fb 100644 --- a/tools/lvresize.c +++ b/tools/lvresize.c @@ -51,19 +51,19 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) if (!strcmp(cmd_name, "lvextend")) resize = LV_EXTEND; - if (arg_count(cmd,extents_ARG) + arg_count(cmd,size_ARG) != 1) { + if (arg_count(cmd, extents_ARG) + arg_count(cmd, size_ARG) != 1) { log_error("Please specify either size or extents (not both)"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,extents_ARG)) { - extents = arg_int_value(cmd,extents_ARG, 0); - sign = arg_sign_value(cmd,extents_ARG, SIGN_NONE); + if (arg_count(cmd, extents_ARG)) { + extents = arg_int_value(cmd, extents_ARG, 0); + sign = arg_sign_value(cmd, extents_ARG, SIGN_NONE); } - if (arg_count(cmd,size_ARG)) { - size = arg_int_value(cmd,size_ARG, 0); - sign = arg_sign_value(cmd,size_ARG, SIGN_NONE); + if (arg_count(cmd, size_ARG)) { + size = arg_int_value(cmd, size_ARG, 0); + sign = arg_sign_value(cmd, size_ARG, SIGN_NONE); } if (resize == LV_EXTEND && sign == SIGN_MINUS) { @@ -76,12 +76,12 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } - if (arg_count(cmd,stripes_ARG)) { + if (arg_count(cmd, stripes_ARG)) { log_print("Varied striping not yet supported. Ignoring."); /* FUTURE stripes = arg_int_value(cmd,stripes_ARG, 1); */ } - if (arg_count(cmd,stripesize_ARG)) { + if (arg_count(cmd, stripesize_ARG)) { log_print("Varied stripesize not yet supported. Ignoring."); /* FUTURE stripesize = 2 * arg_int_value(cmd,stripesize_ARG, 0); */ } @@ -115,15 +115,15 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) goto error; } - if (vg->status & EXPORTED_VG) { - log_error("Volume group %s is exported", vg->name); - goto error; - } + if (vg->status & EXPORTED_VG) { + log_error("Volume group %s is exported", vg->name); + goto error; + } - if (!(vg->status & LVM_WRITE)) { - log_error("Volume group %s is read-only", vg_name); - goto error; - } + if (!(vg->status & LVM_WRITE)) { + log_error("Volume group %s is read-only", vg_name); + goto error; + } /* does LV exist? */ if (!(lvl = find_lv_in_vg(vg, lv_name))) { @@ -186,7 +186,7 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) struct stripe_segment *seg; uint32_t sz, str; - seg = list_item(segh, struct stripe_segment); + seg = list_item(segh, struct stripe_segment); sz = seg->stripe_size; str = seg->stripes; @@ -290,7 +290,7 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) dbg_free(dummy); } - if (!arg_count(cmd,force_ARG)) { + if (!arg_count(cmd, force_ARG)) { if (yes_no_prompt("Do you really want to reduce %s?" " [y/n]: ", lv_name) == 'n') { log_print("Logical volume %s NOT reduced", @@ -307,8 +307,7 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) } if ((resize == LV_EXTEND && argc) && - !(pvh = create_pv_list(cmd->mem, vg, - argc - opt, argv + opt))) { + !(pvh = create_pv_list(cmd->mem, vg, argc - opt, argv + opt))) { stack; goto error; } @@ -330,7 +329,6 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) goto error; } - active = lv_active(lv); /********* FIXME Suspend lv ***********/ @@ -339,7 +337,7 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv) if (!cmd->fid->ops->vg_write(cmd->fid, vg)) goto error; - backup(vg); + backup(vg); if (active && !lv_reactivate(lv)) goto error; diff --git a/tools/lvscan.c b/tools/lvscan.c index a0dd9c865..953303a0b 100644 --- a/tools/lvscan.c +++ b/tools/lvscan.c @@ -95,7 +95,7 @@ static int lvscan_single(struct cmd_context *cmd, struct logical_volume *lv) dbg_free(dummy); /* FIXME sprintf? */ - + /*********** FIXME Handle segments? if (lv->segments[0]->stripes > 1 && !(lv->status & SNAPSHOT)) log_print(" striped[%u]", lv->segments[0]->stripes); diff --git a/tools/pvchange.c b/tools/pvchange.c index cb36a4d13..358d88a7a 100644 --- a/tools/pvchange.c +++ b/tools/pvchange.c @@ -33,17 +33,17 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv) struct list *pvh, *pvs; - if (arg_count(cmd,allocatable_ARG) == 0) { + if (arg_count(cmd, allocatable_ARG) == 0) { log_error("Please give the x option"); return EINVALID_CMD_LINE; } - if (!(arg_count(cmd,all_ARG)) && !argc) { + if (!(arg_count(cmd, all_ARG)) && !argc) { log_error("Please give a physical volume path"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,all_ARG) && argc) { + if (arg_count(cmd, all_ARG) && argc) { log_error("Option a and PhysicalVolumePath are exclusive"); return EINVALID_CMD_LINE; } @@ -53,8 +53,9 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv) for (; opt < argc; opt++) { pv_name = argv[opt]; if (!(pv = cmd->fid->ops->pv_read(cmd->fid, pv_name))) { - log_error("Failed to read physical volume \"%s\"", - pv_name); + log_error + ("Failed to read physical volume \"%s\"", + pv_name); continue; } total++; @@ -69,14 +70,15 @@ int pvchange(struct cmd_context *cmd, int argc, char **argv) list_iterate(pvh, pvs) { total++; done += pvchange_single(cmd, - list_item(pvh, struct pv_list)->pv); + list_item(pvh, + struct pv_list)->pv); } } log_print("%d physical volume%s changed / %d physical volume%s " "not changed", - done, done > 1 ? "s" : "", - total - done, total - done > 1 ? "s" : ""); + done, done > 1 ? "s" : "", + total - done, total - done > 1 ? "s" : ""); return 0; } @@ -88,11 +90,12 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) const char *pv_name = dev_name(pv->dev); - int allocatable = !strcmp(arg_str_value(cmd,allocatable_ARG, "n"), "y"); + int allocatable = + !strcmp(arg_str_value(cmd, allocatable_ARG, "n"), "y"); /* If in a VG, must change using volume group. */ if (*pv->vg_name) { - log_verbose("Finding volume group of physical volume \"%s\"", + log_verbose("Finding volume group of physical volume \"%s\"", pv_name); if (!lock_vol(pv->vg_name, LCK_VG | LCK_WRITE)) { @@ -103,17 +106,17 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) if (!(vg = cmd->fid->ops->vg_read(cmd->fid, pv->vg_name))) { lock_vol(pv->vg_name, LCK_VG | LCK_NONE); log_error("Unable to find volume group of \"%s\"", - pv_name); + pv_name); return 0; } - if (vg->status & EXPORTED_VG) { + if (vg->status & EXPORTED_VG) { lock_vol(pv->vg_name, LCK_VG | LCK_NONE); - log_error("Volume group \"%s\" is exported", vg->name); - return ECMD_FAILED; - } + log_error("Volume group \"%s\" is exported", vg->name); + return ECMD_FAILED; + } - if (!(vg->status & LVM_WRITE)) { + if (!(vg->status & LVM_WRITE)) { lock_vol(pv->vg_name, LCK_VG | LCK_NONE); log_error("Volume group \"%s\" is read-only", vg->name); return ECMD_FAILED; @@ -121,8 +124,9 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) if (!(pvl = find_pv_in_vg(vg, pv_name))) { lock_vol(pv->vg_name, LCK_VG | LCK_NONE); - log_error("Unable to find \"%s\" in volume group \"%s\"", - pv_name, vg->name); + log_error + ("Unable to find \"%s\" in volume group \"%s\"", + pv_name, vg->name); return 0; } pv = pvl->pv; @@ -132,7 +136,8 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) /* change allocatability for a PV */ if (allocatable && (pv->status & ALLOCATABLE_PV)) { - log_error("Physical volume \"%s\" is already allocatable", pv_name); + log_error("Physical volume \"%s\" is already allocatable", + pv_name); if (*pv->vg_name) lock_vol(pv->vg_name, LCK_VG | LCK_NONE); return 0; @@ -147,7 +152,8 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) } if (allocatable) { - log_verbose("Setting physical volume \"%s\" allocatable", pv_name); + log_verbose("Setting physical volume \"%s\" allocatable", + pv_name); pv->status |= ALLOCATABLE_PV; } else { log_verbose("Setting physical volume \"%s\" NOT allocatable", @@ -157,7 +163,7 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) log_verbose("Updating physical volume \"%s\"", pv_name); if (*pv->vg_name) { - if (!(cmd->fid->ops->vg_write(cmd->fid,vg))) { + if (!(cmd->fid->ops->vg_write(cmd->fid, vg))) { lock_vol(pv->vg_name, LCK_VG | LCK_NONE); log_error("Failed to store physical volume \"%s\" in " "volume group \"%s\"", pv_name, vg->name); @@ -167,7 +173,7 @@ int pvchange_single(struct cmd_context *cmd, struct physical_volume *pv) lock_vol(pv->vg_name, LCK_VG | LCK_NONE); } else { if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) { - log_error("Failed to store physical volume \"%s\"", + log_error("Failed to store physical volume \"%s\"", pv_name); return 0; } diff --git a/tools/pvcreate.c b/tools/pvcreate.c index b0c7e1a2e..1d8c5d1ec 100644 --- a/tools/pvcreate.c +++ b/tools/pvcreate.c @@ -32,7 +32,7 @@ static int pvcreate_check(struct cmd_context *cmd, const char *name) struct physical_volume *pv; /* is the partition type set correctly ? */ - if ((arg_count(cmd,force_ARG) < 1) && !is_lvm_partition(name)) + if ((arg_count(cmd, force_ARG) < 1) && !is_lvm_partition(name)) return 0; /* is there a pv here already */ @@ -45,20 +45,20 @@ static int pvcreate_check(struct cmd_context *cmd, const char *name) /* Allow partial & exported VGs to be destroyed. */ /* we must have -ff to overwrite a non orphan */ - if (arg_count(cmd,force_ARG) < 2) { + if (arg_count(cmd, force_ARG) < 2) { log_error("Can't initialize physical volume \"%s\" of " "volume group \"%s\" without -ff", name, pv->vg_name); return 0; } /* prompt */ - if (!arg_count(cmd,yes_ARG) && + if (!arg_count(cmd, yes_ARG) && yes_no_prompt(_really_init, name, pv->vg_name) == 'n') { log_print("Physical volume \"%s\" not initialized", name); return 0; } - if (arg_count(cmd,force_ARG)) { + if (arg_count(cmd, force_ARG)) { log_print("WARNING: Forcing physical volume creation on " "%s%s%s%s", name, pv->vg_name[0] ? " of volume group \"" : "", @@ -76,8 +76,8 @@ static void pvcreate_single(struct cmd_context *cmd, const char *pv_name) char *uuid; struct device *dev; - if (arg_count(cmd,uuidstr_ARG)) { - uuid = arg_str_value(cmd,uuidstr_ARG,""); + if (arg_count(cmd, uuidstr_ARG)) { + uuid = arg_str_value(cmd, uuidstr_ARG, ""); if (!id_read_format(&id, uuid)) return; if ((dev = uuid_map_lookup(cmd->um, &id))) { @@ -97,8 +97,7 @@ static void pvcreate_single(struct cmd_context *cmd, const char *pv_name) } log_verbose("Set up physical volume for \"%s\" with %" PRIu64 - " sectors", - pv_name, pv->size); + " sectors", pv_name, pv->size); log_verbose("Writing physical volume data to disk \"%s\"", pv_name); if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) { @@ -118,12 +117,12 @@ int pvcreate(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } - if (arg_count(cmd,uuidstr_ARG) && argc != 1) { + if (arg_count(cmd, uuidstr_ARG) && argc != 1) { log_error("Can only set uuid on one volume at once"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,yes_ARG) && !arg_count(cmd,force_ARG)) { + if (arg_count(cmd, yes_ARG) && !arg_count(cmd, force_ARG)) { log_error("Option y can only be given with option f"); return EINVALID_CMD_LINE; } diff --git a/tools/pvdisplay.c b/tools/pvdisplay.c index 70e5977ab..5f729dee7 100644 --- a/tools/pvdisplay.c +++ b/tools/pvdisplay.c @@ -24,35 +24,34 @@ void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv); int pvdisplay(struct cmd_context *cmd, int argc, char **argv) { - int opt=0; + int opt = 0; struct list *pvh, *pvs; struct physical_volume *pv; - if (arg_count(cmd,colon_ARG) && arg_count(cmd,maps_ARG)) { + if (arg_count(cmd, colon_ARG) && arg_count(cmd, maps_ARG)) { log_error("Option -v not allowed with option -c"); return EINVALID_CMD_LINE; } - if (argc) { - log_very_verbose("Using physical volume(s) on command line"); + if (argc) { + log_very_verbose("Using physical volume(s) on command line"); for (; opt < argc; opt++) { if (!(pv = cmd->fid->ops->pv_read(cmd->fid, argv[opt]))) { - log_error("Failed to read physical " - "volume \"%s\"", - argv[opt]); + log_error("Failed to read physical " + "volume \"%s\"", argv[opt]); continue; } pvdisplay_single(cmd, pv); } } else { - log_verbose("Scanning for physical volume names"); - if (!(pvs = cmd->fid->ops->get_pvs(cmd->fid))) - return ECMD_FAILED; + log_verbose("Scanning for physical volume names"); + if (!(pvs = cmd->fid->ops->get_pvs(cmd->fid))) + return ECMD_FAILED; - list_iterate(pvh, pvs) - pvdisplay_single(cmd, list_item(pvh, struct pv_list)->pv); + list_iterate(pvh, pvs) + pvdisplay_single(cmd, list_item(pvh, struct pv_list)->pv); } return 0; @@ -61,7 +60,7 @@ int pvdisplay(struct cmd_context *cmd, int argc, char **argv) void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv) { char *sz; - uint64_t size; + uint64_t size; const char *pv_name = dev_name(pv->dev); @@ -70,7 +69,7 @@ void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv) else size = (pv->pe_count - pv->pe_allocated) * pv->pe_size; - if (arg_count(cmd,short_ARG)) { + if (arg_count(cmd, short_ARG)) { sz = display_size(size / 2, SIZE_SHORT); log_print("Device \"%s\" has a capacity of %s", pv_name, sz); dbg_free(sz); @@ -78,17 +77,16 @@ void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv) } if (pv->status & EXPORTED_VG) - log_print("Physical volume \"%s\" of volume group \"%s\" " - "is exported" , pv_name, pv->vg_name); + log_print("Physical volume \"%s\" of volume group \"%s\" " + "is exported", pv_name, pv->vg_name); /********* FIXME log_error("no physical volume identifier on \"%s\"" , pv_name); *********/ if (!pv->vg_name) { - log_print ( "\"%s\" is a new physical volume of \"%s\"", - pv_name, ( sz = display_size ( size / 2, - SIZE_SHORT))); + log_print("\"%s\" is a new physical volume of \"%s\"", + pv_name, (sz = display_size(size / 2, SIZE_SHORT))); dbg_free(sz); } @@ -103,14 +101,14 @@ void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv) ret = pv_check_consistency (pv) */ - if (arg_count(cmd,colon_ARG)) { + if (arg_count(cmd, colon_ARG)) { pvdisplay_colons(pv); return; } pvdisplay_full(pv); - if (!arg_count(cmd,maps_ARG)) + if (!arg_count(cmd, maps_ARG)) return; /******* FIXME @@ -129,4 +127,3 @@ void pvdisplay_single(struct cmd_context *cmd, struct physical_volume *pv) return; } - diff --git a/tools/pvscan.c b/tools/pvscan.c index 9704675aa..42edbc382 100644 --- a/tools/pvscan.c +++ b/tools/pvscan.c @@ -43,14 +43,14 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv) pv_max_name_len = 0; vg_max_name_len = 0; - if (arg_count(cmd,novolumegroup_ARG) && arg_count(cmd,exported_ARG)) { + if (arg_count(cmd, novolumegroup_ARG) && arg_count(cmd, exported_ARG)) { log_error("Options -e and -n are incompatible"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,exported_ARG) || arg_count(cmd,novolumegroup_ARG)) + if (arg_count(cmd, exported_ARG) || arg_count(cmd, novolumegroup_ARG)) log_print("WARNING: only considering physical volumes %s", - arg_count(cmd,exported_ARG) ? + arg_count(cmd, exported_ARG) ? "of exported volume group(s)" : "in no volume group"); log_verbose("Wiping cache of LVM-capable devices"); @@ -65,8 +65,10 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv) pvl = list_item(pvh, struct pv_list); pv = pvl->pv; - if ((arg_count(cmd,exported_ARG) && !(pv->status & EXPORTED_VG)) - || (arg_count(cmd,novolumegroup_ARG) && (*pv->vg_name))) { + if ( + (arg_count(cmd, exported_ARG) + && !(pv->status & EXPORTED_VG)) + || (arg_count(cmd, novolumegroup_ARG) && (*pv->vg_name))) { list_del(&pvl->list); continue; } @@ -83,14 +85,13 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv) ********/ pvs_found++; - if (!*pv->vg_name) { new_pvs_found++; size_new += pv->size; size_total += pv->size; } else size_total += (pv->pe_count - pv->pe_allocated) - * pv->pe_size; + * pv->pe_size; } /* find maximum pv name length */ @@ -108,7 +109,7 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv) vg_max_name_len += 2; list_iterate(pvh, pvs) - pvscan_display_single(cmd, list_item(pvh, struct pv_list)->pv); + pvscan_display_single(cmd, list_item(pvh, struct pv_list)->pv); if (!pvs_found) { log_print("No matching physical volumes found"); @@ -141,12 +142,12 @@ void pvscan_display_single(struct cmd_context *cmd, struct physical_volume *pv) char vg_name_this[NAME_LEN] = { 0, }; /* short listing? */ - if (arg_count(cmd,short_ARG) > 0) { + if (arg_count(cmd, short_ARG) > 0) { log_print("%s", dev_name(pv->dev)); return; } - if (arg_count(cmd,verbose_ARG) > 1) { + if (arg_count(cmd, verbose_ARG) > 1) { /* FIXME As per pv_display! Drop through for now. */ /* pv_show(pv); */ @@ -157,11 +158,11 @@ void pvscan_display_single(struct cmd_context *cmd, struct physical_volume *pv) /* return; */ } - memset(pv_tmp_name, 0, sizeof (pv_tmp_name)); + memset(pv_tmp_name, 0, sizeof(pv_tmp_name)); vg_name_len = strlen(pv->vg_name) + 1; - if (arg_count(cmd,uuid_ARG)) { + if (arg_count(cmd, uuid_ARG)) { if (!id_write_format(&pv->id, uuid, sizeof(uuid))) { stack; return; @@ -174,7 +175,7 @@ void pvscan_display_single(struct cmd_context *cmd, struct physical_volume *pv) } if (!*pv->vg_name) { - log_print("PV %-*s %-*s [%s]", + log_print("PV %-*s %-*s [%s]", pv_max_name_len, pv_tmp_name, vg_max_name_len, " ", (s1 = display_size(pv->size / 2, SIZE_SHORT))); diff --git a/tools/toollib.c b/tools/toollib.c index 7e1783180..9b5402bf6 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -9,7 +9,8 @@ #include int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg, - int (*process_single) (struct cmd_context *cmd, struct logical_volume *lv)) + int (*process_single) (struct cmd_context * cmd, + struct logical_volume * lv)) { int ret_max = 0; int ret = 0; @@ -34,7 +35,8 @@ int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg, } int process_each_lv(struct cmd_context *cmd, int argc, char **argv, - int (*process_single) (struct cmd_context *cmd, struct logical_volume *lv)) + int (*process_single) (struct cmd_context * cmd, + struct logical_volume * lv)) { int opt = 0; int ret_max = 0; @@ -114,8 +116,10 @@ int process_each_lv(struct cmd_context *cmd, int argc, char **argv, return ret_max; } -int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_type, - int (*process_single) (struct cmd_context *cmd, const char *vg_name)) +int process_each_vg(struct cmd_context *cmd, int argc, char **argv, + int lock_type, + int (*process_single) (struct cmd_context * cmd, + const char *vg_name)) { int opt = 0; int ret_max = 0; @@ -130,13 +134,13 @@ int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_typ log_verbose("Using volume group(s) on command line"); for (; opt < argc; opt++) { vg_name = argv[opt]; - if (!lock_vol((void *)vg_name, LCK_VG | lock_type)) { + if (!lock_vol((void *) vg_name, LCK_VG | lock_type)) { log_error("Can't lock %s: skipping", vg_name); continue; } if ((ret = process_single(cmd, vg_name)) > ret_max) ret_max = ret; - lock_vol((void *)vg_name, LCK_VG | LCK_NONE); + lock_vol((void *) vg_name, LCK_VG | LCK_NONE); } } else { log_verbose("Finding all volume groups"); @@ -145,16 +149,16 @@ int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_typ return ECMD_FAILED; } list_iterate(vgh, vgs) { - vg_name = list_item (vgh, struct name_list)->name; - if (!lock_vol((void *)vg_name, LCK_VG | lock_type)) { + vg_name = list_item(vgh, struct name_list)->name; + if (!lock_vol((void *) vg_name, LCK_VG | lock_type)) { log_error("Can't lock %s: skipping", vg_name); continue; } ret = process_single(cmd, vg_name); - + if (ret > ret_max) ret_max = ret; - lock_vol((void *)vg_name, LCK_VG | LCK_NONE); + lock_vol((void *) vg_name, LCK_VG | LCK_NONE); } } @@ -162,8 +166,9 @@ int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_typ } int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg, - int (*process_single) (struct cmd_context *cmd, struct volume_group *vg, - struct physical_volume *pv)) + int (*process_single) (struct cmd_context * cmd, + struct volume_group * vg, + struct physical_volume * pv)) { int ret_max = 0; int ret = 0; @@ -180,9 +185,11 @@ int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg, return ret_max; } -int process_each_pv(struct cmd_context *cmd, int argc, char **argv, struct volume_group *vg, - int (*process_single) (struct cmd_context *cmd, struct volume_group *vg, - struct physical_volume *pv)) +int process_each_pv(struct cmd_context *cmd, int argc, char **argv, + struct volume_group *vg, + int (*process_single) (struct cmd_context * cmd, + struct volume_group * vg, + struct physical_volume * pv)) { int opt = 0; int ret_max = 0; diff --git a/tools/toollib.h b/tools/toollib.h index ae1544690..3a1aa5b45 100644 --- a/tools/toollib.h +++ b/tools/toollib.h @@ -29,21 +29,27 @@ int autobackup_init(const char *backup_dir, int keep_days, int keep_number, int autobackup); int autobackup(struct volume_group *vg); -int process_each_vg(struct cmd_context *cmd, int argc, char **argv, int lock_type, - int (*process_single) (struct cmd_context *cmd, const char *vg_name)); +int process_each_vg(struct cmd_context *cmd, int argc, char **argv, + int lock_type, + int (*process_single) (struct cmd_context * cmd, + const char *vg_name)); -int process_each_pv(struct cmd_context *cmd, int argc, char **argv, struct volume_group *vg, - int (*process_single) (struct cmd_context *cmd, struct volume_group * vg, +int process_each_pv(struct cmd_context *cmd, int argc, char **argv, + struct volume_group *vg, + int (*process_single) (struct cmd_context * cmd, + struct volume_group * vg, struct physical_volume * pv)); int process_each_lv(struct cmd_context *cmd, int argc, char **argv, - int (*process_single) (struct cmd_context *cmd, struct logical_volume * lv)); - + int (*process_single) (struct cmd_context * cmd, + struct logical_volume * lv)); int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg, - int (*process_single) (struct cmd_context *cmd, struct volume_group * vg, - struct physical_volume * pv)); + int (*process_single) (struct cmd_context * cmd, + struct volume_group * vg, + struct physical_volume * pv)); int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg, - int (*process_single) (struct cmd_context *cmd, struct logical_volume * lv)); + int (*process_single) (struct cmd_context * cmd, + struct logical_volume * lv)); int is_valid_chars(char *n); @@ -55,7 +61,6 @@ char *extract_vgname(struct format_instance *fi, char *lv_name); * lvcreate/extend. */ struct list *create_pv_list(struct pool *mem, - struct volume_group *vg, - int argc, char **argv); + struct volume_group *vg, int argc, char **argv); #endif diff --git a/tools/tools.h b/tools/tools.h index de0b7f7f4..6677a2da6 100644 --- a/tools/tools.h +++ b/tools/tools.h @@ -45,7 +45,7 @@ #define MAX_ARGS 64 /* command functions */ -typedef int (*command_fn)(struct cmd_context *cmd, int argc, char **argv); +typedef int (*command_fn) (struct cmd_context * cmd, int argc, char **argv); #define xx(a, b...) int a(struct cmd_context *cmd, int argc, char **argv); #include "commands.h" @@ -68,7 +68,7 @@ typedef enum { struct arg { char short_arg; char *long_arg; - int (*fn)(struct arg *a); + int (*fn) (struct arg * a); int count; char *value; @@ -78,13 +78,13 @@ struct arg { /* a register of the lvm commands */ struct command { - const char *name; - const char *desc; - const char *usage; - command_fn fn; + const char *name; + const char *desc; + const char *usage; + command_fn fn; - int num_args; - int *valid_args; + int num_args; + int *valid_args; }; void usage(const char *name); @@ -101,11 +101,13 @@ int permission_arg(struct arg *a); char yes_no_prompt(const char *prompt, ...); /* we use the enums to access the switches */ -static inline int arg_count(struct cmd_context *cmd, int a) { +static inline int arg_count(struct cmd_context *cmd, int a) +{ return cmd->args[a].count; } -static inline char *arg_value(struct cmd_context *cmd, int a) { +static inline char *arg_value(struct cmd_context *cmd, int a) +{ return cmd->args[a].value; } @@ -114,7 +116,8 @@ static inline char *arg_str_value(struct cmd_context *cmd, int a, char *def) return arg_count(cmd, a) ? cmd->args[a].value : def; } -static inline uint32_t arg_int_value(struct cmd_context *cmd, int a, uint32_t def) +static inline uint32_t arg_int_value(struct cmd_context *cmd, int a, + uint32_t def) { return arg_count(cmd, a) ? cmd->args[a].i_value : def; } diff --git a/tools/vgcfgbackup.c b/tools/vgcfgbackup.c index 777147dc1..4d7c69ad6 100644 --- a/tools/vgcfgbackup.c +++ b/tools/vgcfgbackup.c @@ -36,8 +36,8 @@ static int vg_backup_single(struct cmd_context *cmd, const char *vg_name) return ECMD_FAILED; } - if (arg_count(cmd,file_ARG)) { - _backup_to_file(arg_value(cmd,file_ARG), vg); + if (arg_count(cmd, file_ARG)) { + _backup_to_file(arg_value(cmd, file_ARG), vg); } else { /* just use the normal backup code */ @@ -56,4 +56,3 @@ int vgcfgbackup(struct cmd_context *cmd, int argc, char **argv) { return process_each_vg(cmd, argc, argv, LCK_READ, &vg_backup_single); } - diff --git a/tools/vgcfgrestore.c b/tools/vgcfgrestore.c index 0a0322343..8e0050a96 100644 --- a/tools/vgcfgrestore.c +++ b/tools/vgcfgrestore.c @@ -17,16 +17,16 @@ int vgcfgrestore(struct cmd_context *cmd, int argc, char **argv) * FIXME: overloading the -l arg for now to display a * list of archive files for a particular vg */ - if (arg_count(cmd,list_ARG)) { + if (arg_count(cmd, list_ARG)) { if (!archive_display(cmd, argv[0])) return ECMD_FAILED; return 0; } - if (!(arg_count(cmd,file_ARG) ? - backup_restore_from_file(cmd, argv[0], - arg_str_value(cmd,file_ARG, "")) : + if (!(arg_count(cmd, file_ARG) ? + backup_restore_from_file(cmd, argv[0], + arg_str_value(cmd, file_ARG, "")) : backup_restore(cmd, argv[0]))) { log_err("Restore failed."); return ECMD_FAILED; diff --git a/tools/vgchange.c b/tools/vgchange.c index dc588db2b..5e768dc91 100644 --- a/tools/vgchange.c +++ b/tools/vgchange.c @@ -27,27 +27,28 @@ void vgchange_logicalvolume(struct cmd_context *cmd, struct volume_group *vg); int vgchange(struct cmd_context *cmd, int argc, char **argv) { - if (!(arg_count(cmd,available_ARG) + arg_count(cmd,logicalvolume_ARG) + - arg_count(cmd,resizeable_ARG))) { + if (! + (arg_count(cmd, available_ARG) + arg_count(cmd, logicalvolume_ARG) + + arg_count(cmd, resizeable_ARG))) { log_error("One of -a, -l or -x options required"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,available_ARG) + arg_count(cmd,logicalvolume_ARG) + - arg_count(cmd,resizeable_ARG) > 1) { + if (arg_count(cmd, available_ARG) + arg_count(cmd, logicalvolume_ARG) + + arg_count(cmd, resizeable_ARG) > 1) { log_error("Only one of -a, -l or -x options allowed"); return EINVALID_CMD_LINE; } - if (arg_count(cmd,available_ARG) == 1 && arg_count(cmd,autobackup_ARG)) { + if (arg_count(cmd, available_ARG) == 1 + && arg_count(cmd, autobackup_ARG)) { log_error("-A option not necessary with -a option"); return EINVALID_CMD_LINE; } - return process_each_vg(cmd, argc, argv, - (arg_count(cmd,available_ARG)) ? - LCK_READ : LCK_WRITE, - &vgchange_single); + return process_each_vg(cmd, argc, argv, + (arg_count(cmd, available_ARG)) ? + LCK_READ : LCK_WRITE, &vgchange_single); } static int vgchange_single(struct cmd_context *cmd, const char *vg_name) @@ -59,7 +60,7 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name) return ECMD_FAILED; } - if (!(vg->status & LVM_WRITE) && !arg_count(cmd,available_ARG)) { + if (!(vg->status & LVM_WRITE) && !arg_count(cmd, available_ARG)) { log_error("Volume group \"%s\" is read-only", vg->name); return ECMD_FAILED; } @@ -69,13 +70,13 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name) return ECMD_FAILED; } - if (arg_count(cmd,available_ARG)) + if (arg_count(cmd, available_ARG)) vgchange_available(cmd, vg); - if (arg_count(cmd,resizeable_ARG)) + if (arg_count(cmd, resizeable_ARG)) vgchange_resizeable(cmd, vg); - if (arg_count(cmd,logicalvolume_ARG)) + if (arg_count(cmd, logicalvolume_ARG)) vgchange_logicalvolume(cmd, vg); return 0; @@ -84,7 +85,7 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name) void vgchange_available(struct cmd_context *cmd, struct volume_group *vg) { int lv_open, lv_active; - int available = !strcmp(arg_str_value(cmd,available_ARG, "n"), "y"); + int available = !strcmp(arg_str_value(cmd, available_ARG, "n"), "y"); /* FIXME: Force argument to deactivate them? */ if (!available && (lv_open = lvs_in_vg_opened(vg))) { @@ -112,10 +113,11 @@ void vgchange_available(struct cmd_context *cmd, struct volume_group *vg) void vgchange_resizeable(struct cmd_context *cmd, struct volume_group *vg) { - int resizeable = !strcmp(arg_str_value(cmd,resizeable_ARG, "n"), "y"); + int resizeable = !strcmp(arg_str_value(cmd, resizeable_ARG, "n"), "y"); if (resizeable && (vg->status & RESIZEABLE_VG)) { - log_error("Volume group \"%s\" is already resizeable", vg->name); + log_error("Volume group \"%s\" is already resizeable", + vg->name); return; } @@ -145,7 +147,7 @@ void vgchange_resizeable(struct cmd_context *cmd, struct volume_group *vg) void vgchange_logicalvolume(struct cmd_context *cmd, struct volume_group *vg) { - int max_lv = arg_int_value(cmd,logicalvolume_ARG, 0); + int max_lv = arg_int_value(cmd, logicalvolume_ARG, 0); if (!(vg->status & RESIZEABLE_VG)) { log_error("Volume group \"%s\" must be resizeable " diff --git a/tools/vgck.c b/tools/vgck.c index a535a27eb..d39ceeec3 100644 --- a/tools/vgck.c +++ b/tools/vgck.c @@ -47,9 +47,8 @@ static int vgck_single(struct cmd_context *cmd, const char *vg_name) log_error("not all physical volumes of volume group \"%s\" online", log_error("volume group \"%s\" has physical volumes with ", "invalid version", -********/ +********/ /* FIXME: free */ return 0; } - diff --git a/tools/vgcreate.c b/tools/vgcreate.c index 2a50da7ee..5e2496fe1 100644 --- a/tools/vgcreate.c +++ b/tools/vgcreate.c @@ -24,7 +24,7 @@ #define DEFAULT_PV 255 #define DEFAULT_LV 255 -#define DEFAULT_EXTENT 4096 /* In KB */ +#define DEFAULT_EXTENT 4096 /* In KB */ int vgcreate(struct cmd_context *cmd, int argc, char **argv) { @@ -46,11 +46,12 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv) } vg_name = argv[0]; - max_lv = arg_int_value(cmd,maxlogicalvolumes_ARG, DEFAULT_LV); - max_pv = arg_int_value(cmd,maxphysicalvolumes_ARG, DEFAULT_PV); + max_lv = arg_int_value(cmd, maxlogicalvolumes_ARG, DEFAULT_LV); + max_pv = arg_int_value(cmd, maxphysicalvolumes_ARG, DEFAULT_PV); /* Units of 512-byte sectors */ - extent_size = arg_int_value(cmd,physicalextentsize_ARG, DEFAULT_EXTENT) * 2; + extent_size = + arg_int_value(cmd, physicalextentsize_ARG, DEFAULT_EXTENT) * 2; if (max_lv < 1) { log_error("maxlogicalvolumes too low"); @@ -62,25 +63,25 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } - /* Strip dev_dir if present */ - if (!strncmp(vg_name, cmd->dev_dir, strlen(cmd->dev_dir))) - vg_name += strlen(cmd->dev_dir); + /* Strip dev_dir if present */ + if (!strncmp(vg_name, cmd->dev_dir, strlen(cmd->dev_dir))) + vg_name += strlen(cmd->dev_dir); - snprintf(vg_path, PATH_MAX, "%s%s", cmd->dev_dir, vg_name); - if (path_exists(vg_path)) { + snprintf(vg_path, PATH_MAX, "%s%s", cmd->dev_dir, vg_name); + if (path_exists(vg_path)) { log_error("%s: already exists in filesystem", vg_path); return ECMD_FAILED; } - if (!is_valid_chars(vg_name)) { - log_error("New volume group name \"%s\" has invalid characters", - vg_name); - return ECMD_FAILED; - } + if (!is_valid_chars(vg_name)) { + log_error("New volume group name \"%s\" has invalid characters", + vg_name); + return ECMD_FAILED; + } /* Create the new VG */ if (!(vg = vg_create(cmd->fid, vg_name, extent_size, max_pv, max_lv, - argc - 1, argv + 1))) + argc - 1, argv + 1))) return ECMD_FAILED; if (max_lv != vg->max_lv) @@ -91,16 +92,16 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv) log_error("Warning: Setting maxphysicalvolumes to %d", vg->max_pv); - if (!lock_vol("", LCK_VG | LCK_WRITE)) { - log_error("Can't get lock for orphan PVs"); - return ECMD_FAILED; - } + if (!lock_vol("", LCK_VG | LCK_WRITE)) { + log_error("Can't get lock for orphan PVs"); + return ECMD_FAILED; + } - if (!lock_vol(vg_name, LCK_VG | LCK_WRITE | LCK_NONBLOCK)) { - log_error("Can't get lock for %s", vg_name); + if (!lock_vol(vg_name, LCK_VG | LCK_WRITE | LCK_NONBLOCK)) { + log_error("Can't get lock for %s", vg_name); lock_vol("", LCK_VG | LCK_NONE); - return ECMD_FAILED; - } + return ECMD_FAILED; + } if (!archive(vg)) { lock_vol(vg_name, LCK_VG | LCK_NONE); diff --git a/tools/vgdisplay.c b/tools/vgdisplay.c index 45a5d5610..a191c312e 100644 --- a/tools/vgdisplay.c +++ b/tools/vgdisplay.c @@ -24,12 +24,12 @@ static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name); int vgdisplay(struct cmd_context *cmd, int argc, char **argv) { - if (arg_count(cmd,colon_ARG) && arg_count(cmd,short_ARG)) { + if (arg_count(cmd, colon_ARG) && arg_count(cmd, short_ARG)) { log_error("Option -c is not allowed with option -s"); return EINVALID_CMD_LINE; } - if (argc && arg_count(cmd,activevolumegroups_ARG)) { + if (argc && arg_count(cmd, activevolumegroups_ARG)) { log_error("Option -A is not allowed with volume group names"); return EINVALID_CMD_LINE; } @@ -78,19 +78,19 @@ static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name) if (vg->status & EXPORTED_VG) log_print("WARNING: volume group \"%s\" is exported", vg_name); - if (arg_count(cmd,colon_ARG)) { + if (arg_count(cmd, colon_ARG)) { vgdisplay_colons(vg); return 0; } - if (arg_count(cmd,short_ARG)) { + if (arg_count(cmd, short_ARG)) { vgdisplay_short(vg); return 0; } vgdisplay_full(vg); /* was vg_show */ - if (arg_count(cmd,verbose_ARG)) { + if (arg_count(cmd, verbose_ARG)) { vgdisplay_extents(vg); process_each_lv_in_vg(cmd, vg, &lvdisplay_full); @@ -101,4 +101,3 @@ static int vgdisplay_single(struct cmd_context *cmd, const char *vg_name) return 0; } - diff --git a/tools/vgexport.c b/tools/vgexport.c index 19d683cb9..7605c6d8c 100644 --- a/tools/vgexport.c +++ b/tools/vgexport.c @@ -24,12 +24,12 @@ static int vgexport_single(struct cmd_context *cmd, const char *vg_name); int vgexport(struct cmd_context *cmd, int argc, char **argv) { - if (!argc && !arg_count(cmd,all_ARG)) { + if (!argc && !arg_count(cmd, all_ARG)) { log_error("Please supply volume groups or use -a for all."); return ECMD_FAILED; } - if (argc && arg_count(cmd,all_ARG)) { + if (argc && arg_count(cmd, all_ARG)) { log_error("No arguments permitted when using -a for all."); return ECMD_FAILED; } @@ -57,7 +57,7 @@ static int vgexport_single(struct cmd_context *cmd, const char *vg_name) } if (lvs_in_vg_activated(vg)) { - log_error("Volume group \"%s\" has active logical volumes", + log_error("Volume group \"%s\" has active logical volumes", vg_name); goto error; } @@ -67,15 +67,15 @@ static int vgexport_single(struct cmd_context *cmd, const char *vg_name) vg->status |= EXPORTED_VG; - if (!cmd->fid->ops->vg_write(cmd->fid,vg)) + if (!cmd->fid->ops->vg_write(cmd->fid, vg)) goto error; backup(vg); log_print("Volume group \"%s\" successfully exported", vg->name); - + return 0; - error: + error: return ECMD_FAILED; } diff --git a/tools/vgextend.c b/tools/vgextend.c index 6da503372..bb4b4e270 100644 --- a/tools/vgextend.c +++ b/tools/vgextend.c @@ -27,7 +27,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) if (!argc) { log_error("Please enter volume group name and " - "physical volume(s)"); + "physical volume(s)"); return EINVALID_CMD_LINE; } @@ -40,10 +40,10 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) argc--; argv++; - if (!lock_vol("", LCK_VG | LCK_WRITE)) { - log_error("Can't get lock for orphan PVs"); - return ECMD_FAILED; - } + if (!lock_vol("", LCK_VG | LCK_WRITE)) { + log_error("Can't get lock for orphan PVs"); + return ECMD_FAILED; + } log_verbose("Checking for volume group \"%s\"", vg_name); if (!lock_vol(vg_name, LCK_VG | LCK_WRITE | LCK_NONBLOCK)) { @@ -57,10 +57,10 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) goto error; } - if (vg->status & EXPORTED_VG) { - log_error("Volume group \"%s\" is exported", vg->name); - goto error; - } + if (vg->status & EXPORTED_VG) { + log_error("Volume group \"%s\" is exported", vg->name); + goto error; + } if (!(vg->status & LVM_WRITE)) { log_error("Volume group \"%s\" is read-only", vg_name); @@ -90,7 +90,7 @@ int vgextend(struct cmd_context *cmd, int argc, char **argv) log_verbose("Volume group \"%s\" will be extended by %d new " "physical volumes", vg_name, argc); - /* store vg on disk(s) */ + /* store vg on disk(s) */ if (!cmd->fid->ops->vg_write(cmd->fid, vg)) goto error; diff --git a/tools/vgimport.c b/tools/vgimport.c index e6467ca2c..5aead1280 100644 --- a/tools/vgimport.c +++ b/tools/vgimport.c @@ -24,15 +24,15 @@ static int vgimport_single(struct cmd_context *cmd, const char *vg_name); int vgimport(struct cmd_context *cmd, int argc, char **argv) { - if (!argc && !arg_count(cmd,all_ARG)) { - log_error("Please supply volume groups or use -a for all."); - return ECMD_FAILED; - } + if (!argc && !arg_count(cmd, all_ARG)) { + log_error("Please supply volume groups or use -a for all."); + return ECMD_FAILED; + } - if (argc && arg_count(cmd,all_ARG)) { - log_error("No arguments permitted when using -a for all."); - return ECMD_FAILED; - } + if (argc && arg_count(cmd, all_ARG)) { + log_error("No arguments permitted when using -a for all."); + return ECMD_FAILED; + } return process_each_vg(cmd, argc, argv, LCK_WRITE, &vgimport_single); } @@ -62,13 +62,13 @@ static int vgimport_single(struct cmd_context *cmd, const char *vg_name) vg->status &= ~EXPORTED_VG; - if (!cmd->fid->ops->vg_write(cmd->fid,vg)) + if (!cmd->fid->ops->vg_write(cmd->fid, vg)) goto error; backup(vg); log_print("Volume group \"%s\" successfully imported", vg->name); - + return 0; error: diff --git a/tools/vgmerge.c b/tools/vgmerge.c index 6e14d014f..8c4877284 100644 --- a/tools/vgmerge.c +++ b/tools/vgmerge.c @@ -20,7 +20,8 @@ #include "tools.h" -int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char *vg_name_from); +int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, + const char *vg_name_from); int vgmerge(struct cmd_context *cmd, int argc, char **argv) { @@ -46,7 +47,8 @@ int vgmerge(struct cmd_context *cmd, int argc, char **argv) return ret_max; } -int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char *vg_name_from) +int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, + const char *vg_name_from) { struct volume_group *vg_to, *vg_from; struct list *lvh1, *lvh2; @@ -69,11 +71,11 @@ int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char * return ECMD_FAILED; } - if (vg_to->status & EXPORTED_VG) { - log_error("Volume group \"%s\" is exported", vg_to->name); + if (vg_to->status & EXPORTED_VG) { + log_error("Volume group \"%s\" is exported", vg_to->name); lock_vol(vg_name_to, LCK_VG | LCK_NONE); - return ECMD_FAILED; - } + return ECMD_FAILED; + } if (!(vg_to->status & LVM_WRITE)) { log_error("Volume group \"%s\" is read-only", vg_to->name); @@ -93,10 +95,10 @@ int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char * goto error; } - if (vg_from->status & EXPORTED_VG) { - log_error("Volume group \"%s\" is exported", vg_from->name); - goto error; - } + if (vg_from->status & EXPORTED_VG) { + log_error("Volume group \"%s\" is exported", vg_from->name); + goto error; + } if (!(vg_from->status & LVM_WRITE)) { log_error("Volume group \"%s\" is read-only", vg_from->name); @@ -143,8 +145,7 @@ int vgmerge_single(struct cmd_context *cmd, const char *vg_name_to, const char * log_error("Duplicate logical volume " "name \"%s\" " "in \"%s\" and \"%s\"", - name1, vg_to->name, - vg_from->name); + name1, vg_to->name, vg_from->name); goto error; } } diff --git a/tools/vgreduce.c b/tools/vgreduce.c index 1f2d9c068..e64f4d4f1 100644 --- a/tools/vgreduce.c +++ b/tools/vgreduce.c @@ -20,7 +20,8 @@ #include "tools.h" -static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv); +static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, + struct physical_volume *pv); int vgreduce(struct cmd_context *cmd, int argc, char **argv) { @@ -34,12 +35,12 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv) return EINVALID_CMD_LINE; } - if (argc == 1 && !arg_count(cmd,all_ARG)) { + if (argc == 1 && !arg_count(cmd, all_ARG)) { log_error("Please enter physical volume paths or option -a"); return EINVALID_CMD_LINE; } - if (argc > 1 && arg_count(cmd,all_ARG)) { + if (argc > 1 && arg_count(cmd, all_ARG)) { log_error("Option -a and physical volume paths mutually " "exclusive"); return EINVALID_CMD_LINE; @@ -61,11 +62,11 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv) return ECMD_FAILED; } - if (vg->status & EXPORTED_VG) { - log_error("Volume group \"%s\" is exported", vg->name); + if (vg->status & EXPORTED_VG) { + log_error("Volume group \"%s\" is exported", vg->name); lock_vol(vg_name, LCK_VG | LCK_NONE); - return ECMD_FAILED; - } + return ECMD_FAILED; + } if (!(vg->status & LVM_WRITE)) { log_error("Volume group \"%s\" is read-only", vg_name); @@ -105,7 +106,8 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv) } /* Or take pv_name instead? */ -static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv) +static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, + struct physical_volume *pv) { struct pv_list *pvl; const char *name = dev_name(pv->dev); @@ -144,8 +146,7 @@ static int vgreduce_single(struct cmd_context *cmd, struct volume_group *vg, str if (!(cmd->fid->ops->vg_write(cmd->fid, vg))) { log_error("Removal of physical volume \"%s\" from " - "\"%s\" failed", - name, vg->name); + "\"%s\" failed", name, vg->name); return ECMD_FAILED; } diff --git a/tools/vgremove.c b/tools/vgremove.c index dce0281b8..d7bd16fee 100644 --- a/tools/vgremove.c +++ b/tools/vgremove.c @@ -30,8 +30,8 @@ int vgremove(struct cmd_context *cmd, int argc, char **argv) log_error("Can't get lock for orphan PVs"); return ECMD_FAILED; } - - ret = process_each_vg(cmd, argc, argv, LCK_WRITE | LCK_NONBLOCK, + + ret = process_each_vg(cmd, argc, argv, LCK_WRITE | LCK_NONBLOCK, &vgremove_single); lock_vol("", LCK_VG | LCK_NONE); @@ -52,10 +52,10 @@ static int vgremove_single(struct cmd_context *cmd, const char *vg_name) return ECMD_FAILED; } - if (vg->status & EXPORTED_VG) { - log_error("Volume group \"%s\" is exported", vg->name); - return ECMD_FAILED; - } + if (vg->status & EXPORTED_VG) { + log_error("Volume group \"%s\" is exported", vg->name); + return ECMD_FAILED; + } if (vg->status & PARTIAL_VG) { log_error("Cannot remove partial volume group \"%s\"", @@ -65,8 +65,7 @@ static int vgremove_single(struct cmd_context *cmd, const char *vg_name) if (vg->lv_count) { log_error("Volume group \"%s\" still contains %d " - "logical volume(s)", - vg_name, vg->lv_count); + "logical volume(s)", vg_name, vg->lv_count); return ECMD_FAILED; } @@ -84,8 +83,7 @@ static int vgremove_single(struct cmd_context *cmd, const char *vg_name) list_iterate(pvh, &vg->pvs) { pv = list_item(pvh, struct pv_list)->pv; log_verbose("Removing physical volume \"%s\" from " - "volume group \"%s\"", - dev_name(pv->dev), vg_name); + "volume group \"%s\"", dev_name(pv->dev), vg_name); *pv->vg_name = '\0'; if (!(cmd->fid->ops->pv_write(cmd->fid, pv))) { log_error("Failed to remove physical volume \"%s\"" diff --git a/tools/vgrename.c b/tools/vgrename.c index e9f95f1e2..e702cfb56 100644 --- a/tools/vgrename.c +++ b/tools/vgrename.c @@ -69,10 +69,10 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv) log_verbose("Checking for existing volume group \"%s\"", vg_name_old); - if (!lock_vol(vg_name_old, LCK_VG | LCK_WRITE)) { - log_error("Can't get lock for %s", vg_name_old); - return ECMD_FAILED; - } + if (!lock_vol(vg_name_old, LCK_VG | LCK_WRITE)) { + log_error("Can't get lock for %s", vg_name_old); + return ECMD_FAILED; + } if (!(vg_old = cmd->fid->ops->vg_read(cmd->fid, vg_name_old))) { log_error("Volume group \"%s\" doesn't exist", vg_name_old); @@ -80,11 +80,11 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv) return ECMD_FAILED; } - if (vg_old->status & EXPORTED_VG) { + if (vg_old->status & EXPORTED_VG) { lock_vol(vg_name_old, LCK_VG | LCK_NONE); - log_error("Volume group \"%s\" is exported", vg_old->name); - return ECMD_FAILED; - } + log_error("Volume group \"%s\" is exported", vg_old->name); + return ECMD_FAILED; + } if (!(vg_old->status & LVM_WRITE)) { lock_vol(vg_name_old, LCK_VG | LCK_NONE); @@ -143,7 +143,7 @@ int vgrename(struct cmd_context *cmd, int argc, char **argv) log_verbose("Renaming \"%s\" to \"%s\"", old_path, new_path); if (rename(old_path, new_path)) { log_error("Renaming \"%s\" to \"%s\" failed: %s", - old_path, new_path, strerror(errno)); + old_path, new_path, strerror(errno)); goto error; } } diff --git a/tools/vgscan.c b/tools/vgscan.c index 3a36b92b0..be86d02b3 100644 --- a/tools/vgscan.c +++ b/tools/vgscan.c @@ -51,9 +51,8 @@ static int vgscan_single(struct cmd_context *cmd, const char *vg_name) return ECMD_FAILED; } - log_print("Found %svolume group \"%s\"", - (vg->status & EXPORTED_VG) ? "exported " : "", - vg_name); + log_print("Found %svolume group \"%s\"", + (vg->status & EXPORTED_VG) ? "exported " : "", vg_name); return 0; } -- 2.43.5