if (ss && ss->detail_platform)
err = ss->detail_platform(verbose, 0);
else if (ss) {
- if (verbose)
+ if (verbose > 0)
pr_err("%s metadata is platform independent\n",
ss->name ? : "[no name]");
} else if (!scan) {
- if (verbose)
+ if (verbose > 0)
pr_err("specify a metadata type or --scan\n");
}
if (meta == ss)
continue;
- if (verbose)
+ if (verbose > 0)
pr_err("checking metadata %s\n",
meta->name ? : "[no name]");
if (!meta->detail_platform) {
- if (verbose)
+ if (verbose > 0)
pr_err("%s metadata is platform independent\n",
meta->name ? : "[no name]");
} else
static int reshape_array(char *container, int fd, char *devname,
struct supertype *st, struct mdinfo *info,
int force, struct mddev_dev *devlist,
- char *backup_file, int quiet, int forked,
+ char *backup_file, int verbose, int forked,
int restart, int freeze_reshape);
static int reshape_container(char *container, char *devname,
int mdfd,
struct mdinfo *info,
int force,
char *backup_file,
- int quiet, int restart, int freeze_reshape);
+ int verbose, int restart, int freeze_reshape);
-int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
+int Grow_reshape(char *devname, int fd, int verbose, char *backup_file,
long long size,
int level, char *layout_str, int chunksize, int raid_disks,
struct mddev_dev *devlist,
orig_size = array.size;
if (reshape_super(st, size, UnSet, UnSet, 0, 0, UnSet, NULL,
- devname, APPLY_METADATA_CHANGES, !quiet)) {
+ devname, APPLY_METADATA_CHANGES, verbose > 0)) {
rv = 1;
goto release;
}
if (reshape_super(st, orig_size, UnSet, UnSet, 0, 0,
UnSet, NULL, devname,
ROLLBACK_METADATA_CHANGES,
- !quiet) == 0)
+ verbose) == 0)
sync_metadata(st);
pr_err("Cannot set device size for %s: %s\n",
devname, strerror(err));
size = get_component_size(fd)/2;
if (size == 0)
size = array.size;
- if (!quiet) {
+ if (verbose >= 0) {
if (size == orig_size)
pr_err("component size of %s "
"unchanged at %lluK\n",
(chunksize == 0 || chunksize == array.chunk_size) &&
(raid_disks == 0 || raid_disks == array.raid_disks)) {
/* Nothing more to do */
- if (!changed && !quiet)
+ if (!changed && verbose >= 0)
pr_err("%s: no change requested\n",
devname);
goto release;
if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
pr_err("failed to set new layout\n");
rv = 1;
- } else if (!quiet)
+ } else if (verbose >= 0)
printf("layout for %s set to %d\n",
devname, array.layout);
}
* performed at the level of the container
*/
rv = reshape_container(container, devname, -1, st, &info,
- force, backup_file, quiet, 0, 0);
+ force, backup_file, verbose, 0, 0);
frozen = 0;
} else {
/* get spare devices from external metadata
info.new_layout, info.new_chunk,
info.array.raid_disks, info.delta_disks,
backup_file, devname, APPLY_METADATA_CHANGES,
- quiet)) {
+ verbose)) {
rv = 1;
goto release;
}
sync_metadata(st);
rv = reshape_array(container, fd, devname, st, &info, force,
- devlist, backup_file, quiet, 0, 0, 0);
+ devlist, backup_file, verbose, 0, 0, 0);
frozen = 0;
}
release:
static int reshape_array(char *container, int fd, char *devname,
struct supertype *st, struct mdinfo *info,
int force, struct mddev_dev *devlist,
- char *backup_file, int quiet, int forked,
+ char *backup_file, int verbose, int forked,
int restart, int freeze_reshape)
{
struct reshape reshape;
" before level can be changed\n");
goto release;
}
- if (!quiet)
+ if (verbose >= 0)
pr_err("level of %s changed to %s\n",
devname, c);
orig_level = array.level;
* level and frozen, we can safely add them.
*/
if (devlist)
- Manage_subdevs(devname, fd, devlist, !quiet,
+ Manage_subdevs(devname, fd, devlist, verbose,
0,NULL, 0);
if (reshape.backup_blocks == 0) {
if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
pr_err("failed to set new layout\n");
goto release;
- } else if (!quiet)
+ } else if (verbose >= 0)
printf("layout for %s set to %d\n",
devname, array.layout);
}
if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
pr_err("failed to set raid disks\n");
goto release;
- } else if (!quiet) {
+ } else if (verbose >= 0) {
printf("raid_disks for %s set to %d\n",
devname, array.raid_disks);
}
"chunk_size", info->new_chunk) != 0) {
pr_err("failed to set chunk size\n");
goto release;
- } else if (!quiet)
+ } else if (verbose >= 0)
printf("chunk size for %s set to %d\n",
devname, array.chunk_size);
}
struct mdinfo *info,
int force,
char *backup_file,
- int quiet, int restart, int freeze_reshape)
+ int verbose, int restart, int freeze_reshape)
{
struct mdinfo *cc = NULL;
int rv = restart;
info->new_layout, info->new_chunk,
info->array.raid_disks, info->delta_disks,
backup_file, devname, APPLY_METADATA_CHANGES,
- quiet)) {
+ verbose)) {
unfreeze(st);
return 1;
}
rv = reshape_array(container, fd, adev, st,
content, force, NULL,
- backup_file, quiet, 1, restart,
+ backup_file, verbose, 1, restart,
freeze_reshape);
close(fd);
#include "md_u.h"
#include "md_p.h"
-int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl)
+int Kill(char *dev, struct supertype *st, int force, int verbose, int noexcl)
{
/*
* Nothing fancy about Kill. It just zeroes out a superblock
noexcl = 1;
fd = open(dev, O_RDWR|(noexcl ? 0 : O_EXCL));
if (fd < 0) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Couldn't open %s for write - not zeroing\n",
dev);
return 2;
if (st == NULL)
st = guess_super(fd);
if (st == NULL || st->ss->init_super == NULL) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Unrecognised md component device - %s\n", dev);
close(fd);
return 2;
st->ss->free_super(st);
st->ss->init_super(st, NULL, 0, "", NULL, NULL);
if (st->ss->store_super(st, fd)) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Could not zero superblock on %s\n",
dev);
rv = 1;
} else if (rv) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("superblock zeroed anyway\n");
rv = 0;
}
return rv;
}
-int Kill_subarray(char *dev, char *subarray, int quiet)
+int Kill_subarray(char *dev, char *subarray, int verbose)
{
/* Delete a subarray out of a container, the subarry must be
* inactive. The subarray string must be a subarray index
memset(st, 0, sizeof(*st));
- fd = open_subarray(dev, subarray, st, quiet);
+ fd = open_subarray(dev, subarray, st, verbose < 0);
if (fd < 0)
return 2;
if (!st->ss->kill_subarray) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Operation not supported for %s metadata\n",
st->ss->name);
goto free_super;
}
if (is_subarray_active(subarray, st->devname)) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Subarray-%s still active, aborting\n",
subarray);
goto free_super;
/* ok we've found our victim, drop the axe */
rv = st->ss->kill_subarray(st);
if (rv) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Failed to delete subarray-%s from %s\n",
subarray, dev);
goto free_super;
else
st->ss->sync_metadata(st);
- if (!quiet)
+ if (verbose >= 0)
pr_err("Deleted subarray-%s from %s, UUIDs may have changed\n",
subarray, dev);
}
-int Manage_runstop(char *devname, int fd, int runstop, int quiet)
+int Manage_runstop(char *devname, int fd, int runstop,
+ int verbose, int will_retry)
{
/* Run or stop the array. array must already be configured
- * required >= 0.90.0
- * Only print failure messages if quiet == 0;
- * quiet > 0 means really be quiet
- * quiet < 0 means we will try again if it fails.
+ * 'Run' requires >= 0.90.0
+ * 'will_retry' is only relevant for 'stop', and means
+ * that error messages are not wanted.
*/
mdu_param_t param; /* unused */
int rv = 0;
+ if (will_retry && verbose == 0)
+ verbose = -1;
+
if (runstop == -1 && md_get_version(fd) < 9000) {
if (ioctl(fd, STOP_MD, 0)) {
pr_err("stopping device %s "
pr_err("need md driver version 0.90.0 or later\n");
return 1;
}
- /*
- if (ioctl(fd, GET_ARRAY_INFO, &array)) {
- pr_err("%s does not appear to be active.\n",
- devname);
- return 1;
- }
- */
+
if (runstop>0) {
if (ioctl(fd, RUN_ARRAY, ¶m)) {
- pr_err("failed to run array %s: %s\n",
- devname, strerror(errno));
+ if (verbose >= 0)
+ pr_err("failed to run array %s: %s\n",
+ devname, strerror(errno));
return 1;
}
- if (quiet <= 0)
+ if (verbose >= 0)
pr_err("started %s\n", devname);
} else if (runstop < 0){
struct map_ent *map = NULL;
if (fd < 0 || fd2devnum(fd) != devnum) {
if (fd >= 0)
close(fd);
- pr_err("Cannot get exclusive access to %s:"
- "Perhaps a running "
- "process, mounted filesystem "
- "or active volume group?\n",
- devname);
+ if (verbose >= 0)
+ pr_err("Cannot get exclusive access to %s:"
+ "Perhaps a running "
+ "process, mounted filesystem "
+ "or active volume group?\n",
+ devname);
return 1;
}
mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
usleep(200000);
count--;
}
- if (err && !quiet) {
- pr_err("failed to stop array %s: %s\n",
- devname, strerror(errno));
+ if (err) {
+ if (verbose >= 0)
+ pr_err("failed to stop array %s: %s\n",
+ devname, strerror(errno));
rv = 1;
goto out;
}
fd = open_dev_excl(devnum);
if (fd < 0) {
- pr_err("failed to completely stop %s"
- ": Device is busy\n",
- devname);
+ if (verbose >= 0)
+ pr_err("failed to completely stop %s"
+ ": Device is busy\n",
+ devname);
rv = 1;
goto out;
}
strncmp(m->metadata_version, "external:", 9)==0 &&
is_subarray(m->metadata_version+9) &&
devname2devnum(m->metadata_version+10) == devnum) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Cannot stop container %s: "
"member %s still active\n",
devname, m->dev);
count --;
}
if (fd >= 0 && err) {
- if (quiet == 0) {
+ if (verbose >= 0) {
pr_err("failed to stop array %s: %s\n",
devname, strerror(errno));
if (errno == EBUSY)
}
- if (quiet <= 0)
+ if (verbose >= 0)
pr_err("stopped %s\n", devname);
map_lock(&map);
map_remove(&map, devnum);
return rv;
}
-int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet)
+int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int verbose)
{
struct supertype supertype, *st = &supertype;
int fd, rv = 2;
memset(st, 0, sizeof(*st));
- fd = open_subarray(dev, subarray, st, quiet);
+ fd = open_subarray(dev, subarray, st, verbose < 0);
if (fd < 0)
return 2;
if (!st->ss->update_subarray) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Operation not supported for %s metadata\n",
st->ss->name);
goto free_super;
rv = st->ss->update_subarray(st, subarray, update, ident);
if (rv) {
- if (!quiet)
+ if (verbose >= 0)
pr_err("Failed to update %s of subarray-%s in %s\n",
update, subarray, dev);
} else if (st->update_tail)
else
st->ss->sync_metadata(st);
- if (rv == 0 && strcmp(update, "name") == 0 && !quiet)
+ if (rv == 0 && strcmp(update, "name") == 0 && verbose >= 0)
pr_err("Updated subarray-%s name from %s, UUIDs may have changed\n",
subarray, dev);
int freeze_reshape);
static int misc_scan(char devmode, int verbose, int export, int test,
char *homehost, char *prefer);
-static int stop_scan(int quiet);
+static int stop_scan(int verbose);
static int misc_list(struct mddev_dev *devlist,
int brief, int verbose, int export, int test,
char *homehost, char *prefer, char *subarray,
char *update, struct mddev_ident *ident,
- struct supertype *ss, int force, int quiet);
+ struct supertype *ss, int force);
int main(int argc, char *argv[])
if (!rv && c.readonly < 0)
rv = Manage_ro(devlist->devname, mdfd, c.readonly);
if (!rv && c.runstop)
- rv = Manage_runstop(devlist->devname, mdfd, c.runstop, c.quiet);
+ rv = Manage_runstop(devlist->devname, mdfd, c.runstop, c.verbose-c.quiet, 0);
break;
case ASSEMBLE:
if (devs_found == 1 && ident.uuid_set == 0 &&
pr_err("No devices listed in %s\n", configfile?configfile:DefaultConfFile);
exit(1);
}
- if (c.brief && c.verbose)
+ if (c.brief && c.verbose > 0)
c.brief = 2;
- rv = Examine(devlist, c.scan?(c.verbose>1?0:c.verbose+1):c.brief,
+ rv = Examine(devlist, c.scan?(c.verbose>1?0:c.verbose):c.brief,
c.export, c.scan,
c.SparcAdjust, ss, c.homehost);
} else if (devmode == DetailPlatform) {
- rv = Detail_Platform(ss ? ss->ss : NULL, ss ? c.scan : 1, c.verbose);
+ rv = Detail_Platform(ss ? ss->ss : NULL, ss ? c.scan : 1, c.verbose-c.quiet);
} else if (devlist == NULL) {
if (devmode == 'S' && c.scan)
- rv = stop_scan(c.quiet);
+ rv = stop_scan(c.verbose-c.quiet);
else if ((devmode == 'D' || devmode == Waitclean) && c.scan)
- rv = misc_scan(devmode, c.verbose, c.export,
+ rv = misc_scan(devmode, c.verbose-c.quiet, c.export,
c.test, c.homehost, c.prefer);
else if (devmode == UdevRules)
rv = Write_rules(udev_filename);
exit(2);
}
} else
- rv = misc_list(devlist, c.brief, c.verbose, c.export, c.test,
+ rv = misc_list(devlist, c.brief, c.verbose-c.quiet, c.export, c.test,
c.homehost, c.prefer, c.subarray, c.update,
&ident,
- ss, c.force, c.quiet);
+ ss, c.force);
break;
case MONITOR:
if (!devlist && !c.scan) {
} else if (grow_continue)
rv = Grow_continue_command(devlist->devname,
mdfd, c.backup_file,
- c.verbose);
+ c.verbose-c.quiet);
else if (size >= 0 || raiddisks != 0 || layout_str != NULL
|| chunk != 0 || level != UnSet) {
- rv = Grow_reshape(devlist->devname, mdfd, c.quiet, c.backup_file,
+ rv = Grow_reshape(devlist->devname, mdfd, c.verbose-c.quiet, c.backup_file,
size, level, layout_str, chunk, raiddisks,
devlist->next,
assume_clean, c.force);
pr_err("--incremental --scan --fail not supported.\n");
break;
}
- rv = IncrementalScan(c.verbose);
+ rv = IncrementalScan(c.verbose-c.quiet);
}
if (!devlist) {
if (!rebuild_map && !c.scan) {
return rv;
}
-static int stop_scan(int quiet)
+static int stop_scan(int verbose)
{
/* apply --stop to all devices in /proc/mdstat */
/* Due to possible stacking of devices, repeat until
}
mdfd = open_mddev(name, 1);
if (mdfd >= 0) {
- if (Manage_runstop(name, mdfd, -1, quiet?1:last?0:-1))
+ if (Manage_runstop(name, mdfd, -1, verbose, !last))
err = 1;
else
progress = 1;
int brief, int verbose, int export, int test,
char *homehost, char *prefer, char *subarray,
char *update, struct mddev_ident *ident,
- struct supertype *ss, int force, int quiet)
+ struct supertype *ss, int force)
{
struct mddev_dev *dv;
int rv = 0;
continue;
case KillOpt: /* Zero superblock */
if (ss)
- rv |= Kill(dv->devname, ss, force, quiet,0);
+ rv |= Kill(dv->devname, ss, force, verbose,0);
else {
- int q = quiet;
+ int v = verbose;
do {
- rv |= Kill(dv->devname, NULL, force, q, 0);
- q = 1;
+ rv |= Kill(dv->devname, NULL, force, v, 0);
+ v = -1;
} while (rv == 0);
rv &= ~2;
}
case WaitOpt:
rv |= Wait(dv->devname); continue;
case Waitclean:
- rv |= WaitClean(dv->devname, -1, verbose-quiet); continue;
+ rv |= WaitClean(dv->devname, -1, verbose); continue;
case KillSubarray:
- rv |= Kill_subarray(dv->devname, subarray, quiet);
+ rv |= Kill_subarray(dv->devname, subarray, verbose);
continue;
case UpdateSubarray:
if (update == NULL) {
continue;
}
rv |= Update_subarray(dv->devname, subarray,
- update, ident, quiet);
+ update, ident, verbose);
continue;
}
mdfd = open_mddev(dv->devname, 1);
if (mdfd>=0) {
switch(dv->disposition) {
case 'R':
- rv |= Manage_runstop(dv->devname, mdfd, 1, quiet); break;
+ rv |= Manage_runstop(dv->devname, mdfd, 1, verbose, 0); break;
case 'S':
- rv |= Manage_runstop(dv->devname, mdfd, -1, quiet); break;
+ rv |= Manage_runstop(dv->devname, mdfd, -1, verbose, 0); break;
case 'o':
rv |= Manage_ro(dv->devname, mdfd, 1); break;
case 'w':
extern int Manage_ro(char *devname, int fd, int readonly);
-extern int Manage_runstop(char *devname, int fd, int runstop, int quiet);
+extern int Manage_runstop(char *devname, int fd, int runstop, int quiet,
+ int will_retry);
extern int Manage_resize(char *devname, int fd, long long size, int raid_disks);
extern int Manage_subdevs(char *devname, int fd,
struct mddev_dev *devlist, int verbose, int test,
int dosyslog, int test, char *pidfile, int increments,
int share, char *prefer);
-extern int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl);
-extern int Kill_subarray(char *dev, char *subarray, int quiet);
+extern int Kill(char *dev, struct supertype *st, int force, int verbose, int noexcl);
+extern int Kill_subarray(char *dev, char *subarray, int verbose);
extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
extern int Wait(char *dev);
extern int WaitClean(char *dev, int sock, int verbose);
} else {
struct dl *d;
for (d = ddf->dlist; d; d=d->next)
- while (Kill(d->devname, NULL, 0, 1, 1) == 0);
+ while (Kill(d->devname, NULL, 0, -1, 1) == 0);
return __write_init_super_ddf(st);
}
}
unsigned long port_mask = (1 << port_count) - 1;
if (port_count > (int)sizeof(port_mask) * 8) {
- if (verbose)
+ if (verbose > 0)
pr_err("port_count %d out of range\n", port_count);
return 2;
}
/* retrieve the scsi device type */
if (asprintf(&device, "/sys/dev/block/%d:%d/device/xxxxxxx", major, minor) < 0) {
- if (verbose)
+ if (verbose > 0)
pr_err("failed to allocate 'device'\n");
err = 2;
break;
}
sprintf(device, "/sys/dev/block/%d:%d/device/type", major, minor);
if (load_sys(device, buf) != 0) {
- if (verbose)
+ if (verbose > 0)
pr_err("failed to read device type for %s\n",
path);
err = 2;
/* chop device path to 'host%d' and calculate the port number */
c = strchr(&path[hba_len], '/');
if (!c) {
- if (verbose)
+ if (verbose > 0)
pr_err("%s - invalid path name\n", path + hba_len);
err = 2;
break;
if (sscanf(&path[hba_len], "host%d", &port) == 1)
port -= host_base;
else {
- if (verbose) {
+ if (verbose > 0) {
*c = '/'; /* repair the full string */
pr_err("failed to determine port number for %s\n",
path);
list = find_intel_devices();
if (!list) {
- if (verbose)
+ if (verbose > 0)
pr_err("no active Intel(R) RAID "
"controller found.\n");
free_sys_dev(&list);
return 2;
- } else if (verbose)
+ } else if (verbose > 0)
print_found_intel_controllers(list);
for (hba = list; hba; hba = hba->next) {
if (hba->type == SYS_DEV_SATA) {
host_base = ahci_get_port_count(hba->path, &port_count);
if (ahci_enumerate_ports(hba->path, port_count, host_base, verbose)) {
- if (verbose)
+ if (verbose > 0)
pr_err("failed to enumerate "
"ports on SATA controller at %s.", hba->pci_id);
result |= 2;
} else {
struct dl *d;
for (d = super->disks; d; d = d->next)
- Kill(d->devname, NULL, 0, 1, 1);
+ Kill(d->devname, NULL, 0, -1, 1);
return write_super_imsm(st, 1);
}
}
fd = open(dev, O_RDONLY|O_EXCL, 0);
if (fd < 0) {
- if (verbose)
+ if (verbose > 0)
pr_err("imsm: Cannot open %s: %s\n",
dev, strerror(errno));
return 0;
* note that there is no fd for the disks in array.
*/
super = alloc_super();
- rv = find_intel_hba_capability(fd, super, verbose ? dev : NULL);
+ rv = find_intel_hba_capability(fd, super, verbose > 0 ? dev : NULL);
if (rv != 0) {
#if DEBUG
char str[256];
continue;
if (di->fd == -1)
continue;
- while (Kill(di->devname, NULL, 0, 1, 1) == 0)
+ while (Kill(di->devname, NULL, 0, -1, 1) == 0)
;
sb->disks[di->disk.number].state &= ~(1<<MD_DISK_FAULTY);
if (di->fd < 0)
continue;
- while (Kill(di->devname, NULL, 0, 1, 1) == 0)
+ while (Kill(di->devname, NULL, 0, -1, 1) == 0)
;
sb->dev_number = __cpu_to_le32(di->disk.number);