2001-06-08 04:36:23 +02:00
|
|
|
/*
|
2002-03-08 01:03:52 +01:00
|
|
|
* mdadm - manage Linux "md" devices aka RAID arrays.
|
2001-06-08 04:36:23 +02:00
|
|
|
*
|
2013-09-03 06:16:22 +02:00
|
|
|
* Copyright (C) 2001-2013 Neil Brown <neilb@suse.de>
|
2001-06-08 04:36:23 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
* Author: Neil Brown
|
2009-06-02 06:35:45 +02:00
|
|
|
* Email: <neilb@suse.de>
|
2005-06-08 01:16:35 +02:00
|
|
|
*
|
2007-12-14 10:13:43 +01:00
|
|
|
* Additions for bitmap and write-behind RAID options, Copyright (C) 2003-2004,
|
2005-06-08 01:16:35 +02:00
|
|
|
* Paul Clements, SteelEye Technology, Inc.
|
2001-06-08 04:36:23 +02:00
|
|
|
*/
|
|
|
|
|
2002-03-08 01:03:52 +01:00
|
|
|
#include "mdadm.h"
|
2001-06-08 04:36:23 +02:00
|
|
|
#include "md_p.h"
|
2004-06-04 14:03:19 +02:00
|
|
|
#include <ctype.h>
|
2001-06-08 04:36:23 +02:00
|
|
|
|
2012-07-09 09:19:07 +02:00
|
|
|
static int scan_assemble(struct supertype *ss,
|
|
|
|
struct context *c,
|
|
|
|
struct mddev_ident *ident);
|
2012-07-09 09:20:16 +02:00
|
|
|
static int misc_scan(char devmode, struct context *c);
|
2012-07-09 09:18:09 +02:00
|
|
|
static int stop_scan(int verbose);
|
2012-07-09 09:14:16 +02:00
|
|
|
static int misc_list(struct mddev_dev *devlist,
|
2012-07-09 09:19:17 +02:00
|
|
|
struct mddev_ident *ident,
|
2013-05-16 07:07:16 +02:00
|
|
|
char *dump_directory,
|
2012-07-09 09:19:17 +02:00
|
|
|
struct supertype *ss, struct context *c);
|
2015-02-11 22:25:03 +01:00
|
|
|
const char Name[] = "mdadm";
|
2012-07-09 09:14:16 +02:00
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
2002-04-04 03:58:32 +02:00
|
|
|
int mode = 0;
|
2001-08-23 04:33:20 +02:00
|
|
|
int opt;
|
2002-04-04 03:58:32 +02:00
|
|
|
int option_index;
|
2001-08-23 04:33:20 +02:00
|
|
|
int rv;
|
2005-05-04 01:44:32 +02:00
|
|
|
int i;
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2012-07-09 09:21:06 +02:00
|
|
|
unsigned long long array_size = 0;
|
2012-10-04 08:34:21 +02:00
|
|
|
unsigned long long data_offset = INVALID_SECTORS;
|
2010-11-22 10:58:05 +01:00
|
|
|
struct mddev_ident ident;
|
2001-08-23 04:33:20 +02:00
|
|
|
char *configfile = NULL;
|
2010-11-25 08:58:45 +01:00
|
|
|
int devmode = 0;
|
2005-06-08 01:16:35 +02:00
|
|
|
int bitmap_fd = -1;
|
2010-11-22 10:58:05 +01:00
|
|
|
struct mddev_dev *devlist = NULL;
|
|
|
|
struct mddev_dev **devlistend = & devlist;
|
|
|
|
struct mddev_dev *dv;
|
2018-01-22 10:12:08 +01:00
|
|
|
mdu_array_info_t array;
|
2001-08-23 04:33:20 +02:00
|
|
|
int devs_found = 0;
|
2006-08-11 10:00:05 +02:00
|
|
|
char *symlinks = NULL;
|
2011-10-03 00:26:48 +02:00
|
|
|
int grow_continue = 0;
|
2006-05-16 09:35:06 +02:00
|
|
|
/* autof indicates whether and how to create device node.
|
|
|
|
* bottom 3 bits are style. Rest (when shifted) are number of parts
|
|
|
|
* 0 - unset
|
|
|
|
* 1 - don't create (no)
|
|
|
|
* 2 - if is_standard, then create (yes)
|
|
|
|
* 3 - create as 'md' - reject is_standard mdp (md)
|
|
|
|
* 4 - create as 'mdp' - reject is_standard md (mdp)
|
|
|
|
* 5 - default to md if not is_standard (md in config file)
|
|
|
|
* 6 - default to mdp if not is_standard (part, or mdp in config file)
|
|
|
|
*/
|
2012-07-09 09:17:33 +02:00
|
|
|
struct context c = {
|
|
|
|
.require_homehost = 1,
|
|
|
|
};
|
2012-07-09 09:21:38 +02:00
|
|
|
struct shape s = {
|
2015-10-09 07:51:43 +02:00
|
|
|
.journaldisks = 0,
|
2012-07-09 09:21:38 +02:00
|
|
|
.level = UnSet,
|
|
|
|
.layout = UnSet,
|
|
|
|
.bitmap_chunk = UnSet,
|
2017-04-24 16:03:26 +02:00
|
|
|
.consistency_policy = CONSISTENCY_POLICY_UNKNOWN,
|
2012-07-09 09:21:38 +02:00
|
|
|
};
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2006-05-19 08:56:06 +02:00
|
|
|
char sys_hostname[256];
|
2001-08-23 04:33:20 +02:00
|
|
|
char *mailaddr = NULL;
|
|
|
|
char *program = NULL;
|
2009-10-19 04:13:58 +02:00
|
|
|
int increments = 20;
|
2003-03-03 00:11:38 +01:00
|
|
|
int daemonise = 0;
|
2004-11-01 05:49:34 +01:00
|
|
|
char *pidfile = NULL;
|
2003-07-29 01:59:00 +02:00
|
|
|
int oneshot = 0;
|
2010-11-22 10:58:06 +01:00
|
|
|
int spare_sharing = 1;
|
2005-05-04 01:44:40 +02:00
|
|
|
struct supertype *ss = NULL;
|
2016-11-29 23:02:11 +01:00
|
|
|
enum flag_mode writemostly = FlagDefault;
|
|
|
|
enum flag_mode failfast = FlagDefault;
|
2005-12-05 06:54:33 +01:00
|
|
|
char *shortopt = short_options;
|
2005-12-05 06:55:56 +01:00
|
|
|
int dosyslog = 0;
|
2006-12-21 07:10:52 +01:00
|
|
|
int rebuild_map = 0;
|
2010-11-22 10:58:06 +01:00
|
|
|
char *remove_path = NULL;
|
Dynamic hot-plug udev rules for policies
Neil,
Please consider this patch that once was discussed and I think agreed with in general direction. It was sent a while ago
but somehow did not merged into your devel3-2. This patch enables hot-plug of so called bare devices (as understand by domain policies rules in mdadm.conf).
Without this patch we do NOT serve hot-plug of bare devices at all.
Thanks,
Marcin Labun
Subject was: FW: Autorebuild, new dynamic udev rules for hot-plugs
>>From c0aecd4dd96691e8bfa6f2dc187261ec8bb2c5a2 Mon Sep 17 00:00:00 2001
From: Przemyslaw Czarnowski <przemyslaw.hawrylewicz.czarnowski@intel.com>
Date: Thu, 23 Dec 2010 16:35:01 +0100
Subject: [PATCH] Dynamic hot-plug udev rules for policies
Cc: linux-raid@vger.kernel.org, Williams, Dan J <dan.j.williams@intel.com>, Ciechanowski, Ed <ed.ciechanowski@intel.com>
When introducing policies, new hot-plug rules were added to support
bare disks. Mdadm was started for each hot plugged block device
to determine if it could be used as spare or as a replacement member for
degraded array.
This patch introduces limitation of range of devices that are handled
by mdadm.
It limits them to the ones specified in domains associated with
the actions: spare-same-port, spare and spare-force.
In order to enable hot-plug for bare disks one must update udev rules
with command
mdadm --activate-domains[=filename]
Above command writes udev rule configuration to stdout. If 'filename'
is given output is written to the file provided as parameter. It is up
to system administrator what should be done later. To make such rule
permanent (i.e. remain after reboot) rule should be writen to
/lib/udev/rules.d directory. Other cases will just need to write it to
/dev/.udev/rules.d directory where temporary rules lies. One should be
aware of the meaning of names/priorities of the udev rules.
After mdadm.conf is changed one is obliged to re-run
"mdadm --activate-domains" command in order to bring the system
configuration up to date.
All hot-plugged disks containing metadata are still handled by existing
rules.
Signed-off-by: Przemyslaw Czarnowski <przemyslaw.hawrylewicz.czarnowski@intel.com>
Signed-off-by: NeilBrown <neilb@suse.de>
2011-01-25 16:59:32 +01:00
|
|
|
char *udev_filename = NULL;
|
2013-05-16 07:07:16 +02:00
|
|
|
char *dump_directory = NULL;
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2006-01-30 01:13:26 +01:00
|
|
|
int print_help = 0;
|
2007-05-08 09:14:00 +02:00
|
|
|
FILE *outf;
|
2004-08-11 04:16:01 +02:00
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
int mdfd = -1;
|
2018-01-22 10:12:08 +01:00
|
|
|
int locked = 0;
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2005-06-08 01:03:48 +02:00
|
|
|
srandom(time(0) ^ getpid());
|
|
|
|
|
2017-03-29 18:02:14 +02:00
|
|
|
ident.uuid_set = 0;
|
2004-01-22 03:10:29 +01:00
|
|
|
ident.level = UnSet;
|
|
|
|
ident.raid_disks = UnSet;
|
2017-03-29 18:02:14 +02:00
|
|
|
ident.super_minor = UnSet;
|
|
|
|
ident.devices = 0;
|
2005-04-04 07:16:04 +02:00
|
|
|
ident.spare_group = NULL;
|
|
|
|
ident.autof = 0;
|
2005-06-08 01:16:36 +02:00
|
|
|
ident.st = NULL;
|
2005-06-08 01:16:35 +02:00
|
|
|
ident.bitmap_fd = -1;
|
2006-03-29 04:57:48 +02:00
|
|
|
ident.bitmap_file = NULL;
|
2005-08-09 07:23:20 +02:00
|
|
|
ident.name[0] = 0;
|
2008-11-04 00:35:09 +01:00
|
|
|
ident.container = NULL;
|
|
|
|
ident.member = NULL;
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2017-04-06 21:46:31 +02:00
|
|
|
if (get_linux_version() < 2006015) {
|
|
|
|
pr_err("This version of mdadm does not support kernels older than 2.6.15\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2017-03-29 18:02:14 +02:00
|
|
|
while ((option_index = -1),
|
|
|
|
(opt = getopt_long(argc, argv, shortopt, long_options,
|
|
|
|
&option_index)) != -1) {
|
2002-04-04 03:58:32 +02:00
|
|
|
int newmode = mode;
|
2009-04-06 07:54:51 +02:00
|
|
|
/* firstly, some mode-independent options */
|
2001-08-23 04:33:20 +02:00
|
|
|
switch(opt) {
|
2010-11-25 08:58:45 +01:00
|
|
|
case HelpOptions:
|
|
|
|
print_help = 2;
|
|
|
|
continue;
|
2001-08-23 04:33:20 +02:00
|
|
|
case 'h':
|
2010-11-25 08:58:45 +01:00
|
|
|
print_help = 1;
|
2006-01-30 01:13:26 +01:00
|
|
|
continue;
|
2001-08-23 04:33:20 +02:00
|
|
|
|
|
|
|
case 'V':
|
|
|
|
fputs(Version, stderr);
|
|
|
|
exit(0);
|
|
|
|
|
2012-07-09 09:17:33 +02:00
|
|
|
case 'v': c.verbose++;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
|
|
|
|
2012-07-09 09:18:48 +02:00
|
|
|
case 'q': c.verbose--;
|
2005-08-15 08:14:27 +02:00
|
|
|
continue;
|
|
|
|
|
2005-06-08 01:16:35 +02:00
|
|
|
case 'b':
|
2016-03-09 20:37:46 +01:00
|
|
|
if (mode == ASSEMBLE || mode == BUILD ||
|
|
|
|
mode == CREATE || mode == GROW ||
|
|
|
|
mode == INCREMENTAL || mode == MANAGE)
|
2005-06-08 01:16:35 +02:00
|
|
|
break; /* b means bitmap */
|
2010-11-25 08:58:45 +01:00
|
|
|
case Brief:
|
2012-07-09 09:17:33 +02:00
|
|
|
c.brief = 1;
|
2002-03-07 00:17:40 +01:00
|
|
|
continue;
|
|
|
|
|
mdadm: add --no-devices to avoid component devices detail information
When people assemble a md raid device with a large number of
component deivces (e.g. 1500 DASD disks), the raid device detail
information generated by 'mdadm --detail --export $devnode' is very
large. It is because the detail information contains information of
all the component disks (even the missing/failed ones).
In such condition, when udev-md-raid-arrays.rules is triggered and
internally calls "mdadm --detail --no-devices --export $devnode",
user may observe systemd error message ""invalid message length". It
is because the following on-stack raw message buffer in systemd code
is not big enough,
systemd/src/libudev/libudev-monitor.c
_public_ struct udev_device *udev_monito ...
struct ucred *cred;
union {
struct udev_monitor_netlink_header nlh;
char raw[8192];
} buf;
Even change size of raw[] from 8KB to larger size, it may still be not
enough for detail message of a md raid device with much larger number of
component devices.
To fix this problem, an extra option '--no-devices' is added (the
original idea is proposed by Neil Brown). When printing detailed
information of a md raid device, if '--no-devices' is specified, then
all component devices information will not be printed, then the output
message size can be restricted to a small number, even with the systemd
only has 8KB on-disk raw buffer, the md raid array udev rules can work
correctly without failure message.
Signed-off-by: Coly Li <colyli@suse.de>
Reviewed-by: NeilBrown <neilb@suse.com>
Signed-off-by: Jes Sorensen <jsorensen@fb.com>
2019-07-31 07:29:29 +02:00
|
|
|
case NoDevices:
|
|
|
|
c.no_devices = 1;
|
|
|
|
continue;
|
|
|
|
|
2012-07-09 09:17:33 +02:00
|
|
|
case 'Y': c.export++;
|
2007-05-08 09:17:33 +02:00
|
|
|
continue;
|
|
|
|
|
2006-05-19 07:50:08 +02:00
|
|
|
case HomeHost:
|
2009-05-11 07:46:46 +02:00
|
|
|
if (strcasecmp(optarg, "<ignore>") == 0)
|
2012-07-09 09:17:33 +02:00
|
|
|
c.require_homehost = 0;
|
2009-05-11 07:46:46 +02:00
|
|
|
else
|
2012-07-09 09:17:33 +02:00
|
|
|
c.homehost = optarg;
|
2006-05-19 07:50:08 +02:00
|
|
|
continue;
|
|
|
|
|
2012-01-25 15:18:02 +01:00
|
|
|
case OffRootOpt:
|
2013-02-01 16:15:17 +01:00
|
|
|
/* Silently ignore old option */
|
2012-01-25 15:18:02 +01:00
|
|
|
continue;
|
|
|
|
|
2012-04-18 03:00:07 +02:00
|
|
|
case Prefer:
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.prefer)
|
|
|
|
free(c.prefer);
|
|
|
|
if (asprintf(&c.prefer, "/%s/", optarg) <= 0)
|
|
|
|
c.prefer = NULL;
|
2012-04-18 03:00:07 +02:00
|
|
|
continue;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case ':':
|
|
|
|
case '?':
|
|
|
|
fputs(Usage, stderr);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
/* second, figure out the mode.
|
|
|
|
* Some options force the mode. Others
|
2007-12-14 10:13:43 +01:00
|
|
|
* set the mode if it isn't already
|
2002-04-04 03:58:32 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
switch(opt) {
|
2010-11-25 08:58:45 +01:00
|
|
|
case ManageOpt:
|
2005-12-05 06:54:33 +01:00
|
|
|
newmode = MANAGE;
|
2007-07-09 01:59:59 +02:00
|
|
|
shortopt = short_bitmap_options;
|
2005-12-05 06:54:33 +01:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
case 'a':
|
2010-11-25 08:58:45 +01:00
|
|
|
case Add:
|
2013-10-31 00:41:50 +01:00
|
|
|
case AddSpare:
|
2015-12-15 02:43:43 +01:00
|
|
|
case AddJournal:
|
2002-04-04 03:58:32 +02:00
|
|
|
case 'r':
|
2010-11-25 08:58:45 +01:00
|
|
|
case Remove:
|
2012-10-23 07:27:15 +02:00
|
|
|
case Replace:
|
|
|
|
case With:
|
2002-04-04 03:58:32 +02:00
|
|
|
case 'f':
|
2010-11-25 08:58:45 +01:00
|
|
|
case Fail:
|
2006-05-26 09:12:48 +02:00
|
|
|
case ReAdd: /* re-add */
|
2015-06-10 07:42:08 +02:00
|
|
|
case ClusterConfirm:
|
2005-12-05 06:54:33 +01:00
|
|
|
if (!mode) {
|
|
|
|
newmode = MANAGE;
|
2007-07-09 01:59:59 +02:00
|
|
|
shortopt = short_bitmap_options;
|
2005-12-05 06:54:33 +01:00
|
|
|
}
|
2005-04-04 07:18:57 +02:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
|
2012-07-09 09:00:50 +02:00
|
|
|
case 'A': newmode = ASSEMBLE;
|
|
|
|
shortopt = short_bitmap_auto_options;
|
|
|
|
break;
|
|
|
|
case 'B': newmode = BUILD;
|
|
|
|
shortopt = short_bitmap_auto_options;
|
|
|
|
break;
|
|
|
|
case 'C': newmode = CREATE;
|
|
|
|
shortopt = short_bitmap_auto_options;
|
|
|
|
break;
|
|
|
|
case 'F': newmode = MONITOR;
|
|
|
|
break;
|
2007-07-09 01:59:59 +02:00
|
|
|
case 'G': newmode = GROW;
|
|
|
|
shortopt = short_bitmap_options;
|
|
|
|
break;
|
2008-05-05 13:55:37 +02:00
|
|
|
case 'I': newmode = INCREMENTAL;
|
2012-07-09 09:00:50 +02:00
|
|
|
shortopt = short_bitmap_auto_options;
|
|
|
|
break;
|
2007-05-21 06:25:44 +02:00
|
|
|
case AutoDetect:
|
2011-11-02 22:06:47 +01:00
|
|
|
newmode = AUTODETECT;
|
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
|
2010-11-25 08:58:45 +01:00
|
|
|
case MiscOpt:
|
2002-04-04 03:58:32 +02:00
|
|
|
case 'D':
|
|
|
|
case 'E':
|
2005-06-08 01:16:35 +02:00
|
|
|
case 'X':
|
2011-11-02 22:06:47 +01:00
|
|
|
case 'Q':
|
2012-12-05 02:56:31 +01:00
|
|
|
case ExamineBB:
|
2013-05-16 07:07:16 +02:00
|
|
|
case Dump:
|
|
|
|
case Restore:
|
2014-05-22 07:55:31 +02:00
|
|
|
case Action:
|
2011-11-02 22:06:47 +01:00
|
|
|
newmode = MISC;
|
|
|
|
break;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case 'R':
|
|
|
|
case 'S':
|
|
|
|
case 'o':
|
|
|
|
case 'w':
|
2006-12-14 07:31:22 +01:00
|
|
|
case 'W':
|
2010-11-25 08:58:45 +01:00
|
|
|
case WaitOpt:
|
2008-09-16 05:58:42 +02:00
|
|
|
case Waitclean:
|
2008-12-09 00:59:18 +01:00
|
|
|
case DetailPlatform:
|
2010-06-16 02:55:41 +02:00
|
|
|
case KillSubarray:
|
2010-06-23 01:30:59 +02:00
|
|
|
case UpdateSubarray:
|
Dynamic hot-plug udev rules for policies
Neil,
Please consider this patch that once was discussed and I think agreed with in general direction. It was sent a while ago
but somehow did not merged into your devel3-2. This patch enables hot-plug of so called bare devices (as understand by domain policies rules in mdadm.conf).
Without this patch we do NOT serve hot-plug of bare devices at all.
Thanks,
Marcin Labun
Subject was: FW: Autorebuild, new dynamic udev rules for hot-plugs
>>From c0aecd4dd96691e8bfa6f2dc187261ec8bb2c5a2 Mon Sep 17 00:00:00 2001
From: Przemyslaw Czarnowski <przemyslaw.hawrylewicz.czarnowski@intel.com>
Date: Thu, 23 Dec 2010 16:35:01 +0100
Subject: [PATCH] Dynamic hot-plug udev rules for policies
Cc: linux-raid@vger.kernel.org, Williams, Dan J <dan.j.williams@intel.com>, Ciechanowski, Ed <ed.ciechanowski@intel.com>
When introducing policies, new hot-plug rules were added to support
bare disks. Mdadm was started for each hot plugged block device
to determine if it could be used as spare or as a replacement member for
degraded array.
This patch introduces limitation of range of devices that are handled
by mdadm.
It limits them to the ones specified in domains associated with
the actions: spare-same-port, spare and spare-force.
In order to enable hot-plug for bare disks one must update udev rules
with command
mdadm --activate-domains[=filename]
Above command writes udev rule configuration to stdout. If 'filename'
is given output is written to the file provided as parameter. It is up
to system administrator what should be done later. To make such rule
permanent (i.e. remain after reboot) rule should be writen to
/lib/udev/rules.d directory. Other cases will just need to write it to
/dev/.udev/rules.d directory where temporary rules lies. One should be
aware of the meaning of names/priorities of the udev rules.
After mdadm.conf is changed one is obliged to re-run
"mdadm --activate-domains" command in order to bring the system
configuration up to date.
All hot-plugged disks containing metadata are still handled by existing
rules.
Signed-off-by: Przemyslaw Czarnowski <przemyslaw.hawrylewicz.czarnowski@intel.com>
Signed-off-by: NeilBrown <neilb@suse.de>
2011-01-25 16:59:32 +01:00
|
|
|
case UdevRules:
|
2012-07-09 09:00:45 +02:00
|
|
|
case KillOpt:
|
2011-11-02 22:06:47 +01:00
|
|
|
if (!mode)
|
|
|
|
newmode = MISC;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NoSharing:
|
|
|
|
newmode = MONITOR;
|
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
}
|
|
|
|
if (mode && newmode == mode) {
|
|
|
|
/* everybody happy ! */
|
|
|
|
} else if (mode && newmode != mode) {
|
|
|
|
/* not allowed.. */
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("");
|
2002-04-04 03:58:32 +02:00
|
|
|
if (option_index >= 0)
|
|
|
|
fprintf(stderr, "--%s", long_options[option_index].name);
|
|
|
|
else
|
|
|
|
fprintf(stderr, "-%c", opt);
|
2005-04-04 07:16:29 +02:00
|
|
|
fprintf(stderr, " would set mdadm mode to \"%s\", but it is already set to \"%s\".\n",
|
2002-04-04 03:58:32 +02:00
|
|
|
map_num(modes, newmode),
|
|
|
|
map_num(modes, mode));
|
|
|
|
exit(2);
|
|
|
|
} else if (!mode && newmode) {
|
|
|
|
mode = newmode;
|
2011-05-10 08:30:40 +02:00
|
|
|
if (mode == MISC && devs_found) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No action given for %s in --misc mode\n",
|
2011-05-10 08:30:40 +02:00
|
|
|
devlist->devname);
|
2013-05-21 04:51:33 +02:00
|
|
|
cont_err("Action options must come before device names\n");
|
2011-05-10 08:30:40 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2002-04-04 03:58:32 +02:00
|
|
|
} else {
|
|
|
|
/* special case of -c --help */
|
2010-11-25 08:58:45 +01:00
|
|
|
if ((opt == 'c' || opt == ConfigFile) &&
|
2016-03-09 20:37:46 +01:00
|
|
|
(strncmp(optarg, "--h", 3) == 0 ||
|
|
|
|
strncmp(optarg, "-h", 2) == 0)) {
|
2007-05-08 09:14:00 +02:00
|
|
|
fputs(Help_config, stdout);
|
2002-04-04 03:58:32 +02:00
|
|
|
exit(0);
|
2002-03-07 00:17:40 +01:00
|
|
|
}
|
2005-04-04 07:18:57 +02:00
|
|
|
|
|
|
|
/* If first option is a device, don't force the mode yet */
|
|
|
|
if (opt == 1) {
|
|
|
|
if (devs_found == 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
dv = xmalloc(sizeof(*dv));
|
2005-04-04 07:18:57 +02:00
|
|
|
dv->devname = optarg;
|
|
|
|
dv->disposition = devmode;
|
2005-08-09 06:25:47 +02:00
|
|
|
dv->writemostly = writemostly;
|
2016-11-25 00:55:49 +01:00
|
|
|
dv->failfast = failfast;
|
2006-05-26 02:50:15 +02:00
|
|
|
dv->used = 0;
|
2005-04-04 07:18:57 +02:00
|
|
|
dv->next = NULL;
|
|
|
|
*devlistend = dv;
|
|
|
|
devlistend = &dv->next;
|
2007-12-14 10:13:43 +01:00
|
|
|
|
2005-04-04 07:18:57 +02:00
|
|
|
devs_found++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* No mode yet, and this is the second device ... */
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("An option must be given to set the mode before a second device\n"
|
2010-01-29 04:54:55 +01:00
|
|
|
" (%s) is listed\n", optarg);
|
2005-04-04 07:18:57 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2002-04-04 03:58:32 +02:00
|
|
|
if (option_index >= 0)
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--%s", long_options[option_index].name);
|
2002-04-04 03:58:32 +02:00
|
|
|
else
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("-%c", opt);
|
2005-04-04 07:18:57 +02:00
|
|
|
fprintf(stderr, " does not set the mode, and so cannot be the first option.\n");
|
2002-04-04 03:58:32 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we just set the mode, then done */
|
|
|
|
switch(opt) {
|
2010-11-25 08:58:45 +01:00
|
|
|
case ManageOpt:
|
|
|
|
case MiscOpt:
|
2002-04-04 03:58:32 +02:00
|
|
|
case 'A':
|
|
|
|
case 'B':
|
|
|
|
case 'C':
|
|
|
|
case 'F':
|
2004-06-04 14:03:19 +02:00
|
|
|
case 'G':
|
2006-12-21 07:10:52 +01:00
|
|
|
case 'I':
|
2007-05-21 06:25:44 +02:00
|
|
|
case AutoDetect:
|
2002-04-04 03:58:32 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (opt == 1) {
|
2012-10-04 08:34:11 +02:00
|
|
|
/* an undecorated option - must be a device name.
|
2002-04-04 03:58:32 +02:00
|
|
|
*/
|
2012-10-04 08:34:11 +02:00
|
|
|
|
|
|
|
if (devs_found > 0 && devmode == DetailPlatform) {
|
|
|
|
pr_err("controller may only be specified once. %s ignored\n",
|
|
|
|
optarg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-11-25 08:58:45 +01:00
|
|
|
if (devs_found > 0 && mode == MANAGE && !devmode) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("Must give one of -a/-r/-f for subsequent devices at %s\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2010-11-25 08:58:45 +01:00
|
|
|
if (devs_found > 0 && mode == GROW && !devmode) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("Must give -a/--add for devices to add: %s\n", optarg);
|
2004-08-11 04:16:01 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:14:16 +02:00
|
|
|
dv = xmalloc(sizeof(*dv));
|
2002-03-07 00:17:40 +01:00
|
|
|
dv->devname = optarg;
|
|
|
|
dv->disposition = devmode;
|
2005-08-09 06:25:47 +02:00
|
|
|
dv->writemostly = writemostly;
|
2016-11-25 00:55:49 +01:00
|
|
|
dv->failfast = failfast;
|
2008-11-04 10:51:12 +01:00
|
|
|
dv->used = 0;
|
2002-03-07 00:17:40 +01:00
|
|
|
dv->next = NULL;
|
|
|
|
*devlistend = dv;
|
|
|
|
devlistend = &dv->next;
|
2007-12-14 10:13:43 +01:00
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
devs_found++;
|
|
|
|
continue;
|
2001-06-14 07:33:53 +02:00
|
|
|
}
|
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
/* We've got a mode, and opt is now something else which
|
|
|
|
* could depend on the mode */
|
2010-11-25 08:58:45 +01:00
|
|
|
#define O(a,b) ((a<<16)|b)
|
2001-08-23 04:33:20 +02:00
|
|
|
switch (O(mode,opt)) {
|
2009-08-11 05:02:49 +02:00
|
|
|
case O(GROW,'c'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(GROW,ChunkSize):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(CREATE,'c'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(CREATE,ChunkSize):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(BUILD,'c'): /* chunk or rounding */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(BUILD,ChunkSize): /* chunk or rounding */
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.chunk) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("chunk/rounding may only be specified once. Second value is %s.\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
s.chunk = parse_size(optarg);
|
2012-10-04 08:34:20 +02:00
|
|
|
if (s.chunk == INVALID_SECTORS ||
|
|
|
|
s.chunk < 8 || (s.chunk&1)) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("invalid chunk/rounding value: %s\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2011-05-10 09:35:41 +02:00
|
|
|
/* Convert sectors to K */
|
2012-07-09 09:21:38 +02:00
|
|
|
s.chunk /= 2;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
2001-06-08 04:36:23 +02:00
|
|
|
|
2006-12-21 07:10:52 +01:00
|
|
|
case O(INCREMENTAL, 'e'):
|
2005-05-04 01:44:32 +02:00
|
|
|
case O(CREATE,'e'):
|
|
|
|
case O(ASSEMBLE,'e'):
|
|
|
|
case O(MISC,'e'): /* set metadata (superblock) information */
|
|
|
|
if (ss) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("metadata information already given\n");
|
2005-05-04 01:44:32 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2017-03-29 18:02:14 +02:00
|
|
|
for(i = 0; !ss && superlist[i]; i++)
|
2005-05-04 01:44:40 +02:00
|
|
|
ss = superlist[i]->match_metadata_desc(optarg);
|
|
|
|
|
2005-05-04 01:44:32 +02:00
|
|
|
if (!ss) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("unrecognised metadata identifier: %s\n", optarg);
|
2005-05-04 01:44:32 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2005-08-09 06:25:47 +02:00
|
|
|
case O(MANAGE,'W'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MANAGE,WriteMostly):
|
2005-08-09 06:25:47 +02:00
|
|
|
case O(BUILD,'W'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(BUILD,WriteMostly):
|
2005-08-09 06:25:47 +02:00
|
|
|
case O(CREATE,'W'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(CREATE,WriteMostly):
|
2005-08-09 06:25:47 +02:00
|
|
|
/* set write-mostly for following devices */
|
2016-11-29 23:02:11 +01:00
|
|
|
writemostly = FlagSet;
|
2005-08-09 06:25:47 +02:00
|
|
|
continue;
|
|
|
|
|
2008-10-25 09:20:49 +02:00
|
|
|
case O(MANAGE,'w'):
|
|
|
|
/* clear write-mostly for following devices */
|
2016-11-29 23:02:11 +01:00
|
|
|
writemostly = FlagClear;
|
2008-10-25 09:20:49 +02:00
|
|
|
continue;
|
|
|
|
|
2016-11-25 00:55:49 +01:00
|
|
|
case O(MANAGE,FailFast):
|
|
|
|
case O(CREATE,FailFast):
|
2016-11-29 23:02:11 +01:00
|
|
|
failfast = FlagSet;
|
2016-11-25 00:55:49 +01:00
|
|
|
continue;
|
|
|
|
case O(MANAGE,NoFailFast):
|
2016-11-29 23:02:11 +01:00
|
|
|
failfast = FlagClear;
|
2016-11-25 00:55:49 +01:00
|
|
|
continue;
|
|
|
|
|
2004-06-04 14:03:19 +02:00
|
|
|
case O(GROW,'z'):
|
2009-02-11 19:49:26 +01:00
|
|
|
case O(CREATE,'z'):
|
|
|
|
case O(BUILD,'z'): /* size */
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.size > 0) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("size may only be specified once. Second value is %s.\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(optarg, "max") == 0)
|
2012-07-09 09:21:38 +02:00
|
|
|
s.size = MAX_SIZE;
|
2004-06-04 14:03:19 +02:00
|
|
|
else {
|
2012-07-09 09:21:38 +02:00
|
|
|
s.size = parse_size(optarg);
|
2016-03-09 20:37:46 +01:00
|
|
|
if (s.size == INVALID_SECTORS || s.size < 8) {
|
|
|
|
pr_err("invalid size: %s\n", optarg);
|
2004-06-04 14:03:19 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2009-07-14 06:32:30 +02:00
|
|
|
/* convert sectors to K */
|
2012-07-09 09:21:38 +02:00
|
|
|
s.size /= 2;
|
2001-08-23 04:33:20 +02:00
|
|
|
}
|
|
|
|
continue;
|
2001-06-08 04:36:23 +02:00
|
|
|
|
2009-07-13 07:00:02 +02:00
|
|
|
case O(GROW,'Z'): /* array size */
|
2012-07-09 09:21:06 +02:00
|
|
|
if (array_size > 0) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("array-size may only be specified once. Second value is %s.\n", optarg);
|
2009-07-13 07:00:02 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
if (strcmp(optarg, "max") == 0)
|
2012-07-09 09:21:06 +02:00
|
|
|
array_size = MAX_SIZE;
|
2009-07-13 07:00:02 +02:00
|
|
|
else {
|
|
|
|
array_size = parse_size(optarg);
|
2012-10-04 08:34:20 +02:00
|
|
|
if (array_size == 0 ||
|
|
|
|
array_size == INVALID_SECTORS) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("invalid array size: %s\n",
|
2009-07-13 07:00:02 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2012-10-04 08:34:21 +02:00
|
|
|
case O(CREATE,DataOffset):
|
|
|
|
case O(GROW,DataOffset):
|
|
|
|
if (data_offset != INVALID_SECTORS) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("data-offset may only be specified one. Second value is %s.\n", optarg);
|
2012-10-04 08:34:21 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (mode == CREATE && strcmp(optarg, "variable") == 0)
|
2012-10-04 08:34:21 +02:00
|
|
|
data_offset = VARIABLE_OFFSET;
|
|
|
|
else
|
|
|
|
data_offset = parse_size(optarg);
|
2012-10-04 08:34:21 +02:00
|
|
|
if (data_offset == INVALID_SECTORS) {
|
2013-05-21 04:40:09 +02:00
|
|
|
pr_err("invalid data-offset: %s\n",
|
2012-10-04 08:34:21 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2009-08-11 05:02:49 +02:00
|
|
|
case O(GROW,'l'):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(CREATE,'l'):
|
|
|
|
case O(BUILD,'l'): /* set raid level*/
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.level != UnSet) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("raid level may only be set once. Second value is %s.\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
s.level = map_name(pers, optarg);
|
|
|
|
if (s.level == UnSet) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("invalid raid level: %s\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (s.level != 0 && s.level != LEVEL_LINEAR &&
|
|
|
|
s.level != 1 && s.level != LEVEL_MULTIPATH &&
|
|
|
|
s.level != LEVEL_FAULTY && s.level != 10 &&
|
2009-06-02 06:06:05 +02:00
|
|
|
mode == BUILD) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("Raid level %s not permitted with --build.\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.sparedisks > 0 && s.level < 1 && s.level >= -1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("raid level %s is incompatible with spare-devices setting.\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
ident.level = s.level;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
2001-06-08 04:36:23 +02:00
|
|
|
|
2009-07-14 04:13:29 +02:00
|
|
|
case O(GROW, 'p'): /* new layout */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(GROW, Layout):
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.layout_str) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("layout may only be sent once. Second value was %s\n", optarg);
|
2009-07-14 04:13:29 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
s.layout_str = optarg;
|
2009-07-14 04:13:29 +02:00
|
|
|
/* 'Grow' will parse the value */
|
|
|
|
continue;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(CREATE,'p'): /* raid5 layout */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(CREATE,Layout):
|
2004-11-01 05:49:34 +01:00
|
|
|
case O(BUILD,'p'): /* faulty layout */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(BUILD,Layout):
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.layout != UnSet) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("layout may only be sent once. Second value was %s\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
switch(s.level) {
|
2001-08-23 04:33:20 +02:00
|
|
|
default:
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("layout not meaningful for %s arrays.\n",
|
2012-07-09 09:21:38 +02:00
|
|
|
map_num(pers, s.level));
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
2004-01-22 03:10:29 +01:00
|
|
|
case UnSet:
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("raid level must be given before layout.\n");
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
|
2019-11-04 04:27:49 +01:00
|
|
|
case 0:
|
|
|
|
s.layout = map_name(r0layout, optarg);
|
|
|
|
if (s.layout == UnSet) {
|
|
|
|
pr_err("layout %s not understood for raid0.\n",
|
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
break;
|
2001-08-23 04:33:20 +02:00
|
|
|
case 5:
|
2012-07-09 09:21:38 +02:00
|
|
|
s.layout = map_name(r5layout, optarg);
|
2017-03-29 18:02:14 +02:00
|
|
|
if (s.layout == UnSet) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("layout %s not understood for raid5.\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
break;
|
2009-03-09 01:16:53 +01:00
|
|
|
case 6:
|
2012-07-09 09:21:38 +02:00
|
|
|
s.layout = map_name(r6layout, optarg);
|
2017-03-29 18:02:14 +02:00
|
|
|
if (s.layout == UnSet) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("layout %s not understood for raid6.\n",
|
2009-03-09 01:16:53 +01:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
break;
|
2004-08-11 04:16:01 +02:00
|
|
|
|
|
|
|
case 10:
|
2012-07-09 09:21:38 +02:00
|
|
|
s.layout = parse_layout_10(optarg);
|
|
|
|
if (s.layout < 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("layout for raid10 must be 'nNN', 'oNN' or 'fNN' where NN is a number, not %s\n", optarg);
|
2004-08-11 04:16:01 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
break;
|
2009-07-14 04:13:29 +02:00
|
|
|
case LEVEL_FAULTY:
|
|
|
|
/* Faulty
|
|
|
|
* modeNNN
|
|
|
|
*/
|
2012-07-09 09:21:38 +02:00
|
|
|
s.layout = parse_layout_faulty(optarg);
|
|
|
|
if (s.layout == -1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("layout %s not understood for faulty.\n",
|
2004-11-01 05:49:34 +01:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2009-07-14 03:29:20 +02:00
|
|
|
break;
|
2001-08-23 04:33:20 +02:00
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(CREATE,AssumeClean):
|
|
|
|
case O(BUILD,AssumeClean): /* assume clean */
|
2011-05-16 09:28:27 +02:00
|
|
|
case O(GROW,AssumeClean):
|
2012-07-09 09:21:38 +02:00
|
|
|
s.assume_clean = 1;
|
2004-06-04 14:03:19 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case O(GROW,'n'):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(CREATE,'n'):
|
|
|
|
case O(BUILD,'n'): /* number of raid disks */
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.raiddisks) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("raid-devices set twice: %d and %s\n",
|
2012-07-09 09:21:38 +02:00
|
|
|
s.raiddisks, optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2021-09-02 11:48:12 +02:00
|
|
|
if (parse_num(&s.raiddisks, optarg) != 0 || s.raiddisks <= 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("invalid number of raid devices: %s\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
ident.raid_disks = s.raiddisks;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
2015-06-10 07:42:12 +02:00
|
|
|
case O(ASSEMBLE, Nodes):
|
2016-03-25 03:22:03 +01:00
|
|
|
case O(GROW, Nodes):
|
2015-06-10 07:42:05 +02:00
|
|
|
case O(CREATE, Nodes):
|
2021-09-02 11:48:12 +02:00
|
|
|
if (parse_num(&c.nodes, optarg) != 0 || c.nodes < 2) {
|
2017-03-01 11:42:33 +01:00
|
|
|
pr_err("clustered array needs two nodes at least: %s\n",
|
2015-06-10 07:42:05 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
2015-06-10 07:42:06 +02:00
|
|
|
case O(CREATE, ClusterName):
|
2015-06-10 07:42:11 +02:00
|
|
|
case O(ASSEMBLE, ClusterName):
|
2015-06-10 07:42:06 +02:00
|
|
|
c.homecluster = optarg;
|
|
|
|
if (strlen(c.homecluster) > 64) {
|
|
|
|
pr_err("Cluster name too big.\n");
|
2017-08-04 07:30:02 +02:00
|
|
|
exit(2);
|
2015-06-10 07:42:06 +02:00
|
|
|
}
|
|
|
|
continue;
|
2012-07-09 09:00:50 +02:00
|
|
|
case O(CREATE,'x'): /* number of spare (eXtra) disks */
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.sparedisks) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("spare-devices set twice: %d and %s\n",
|
2012-07-09 09:21:38 +02:00
|
|
|
s.sparedisks, optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.level != UnSet && s.level <= 0 && s.level >= -1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("spare-devices setting is incompatible with raid level %d\n",
|
2012-07-09 09:21:38 +02:00
|
|
|
s.level);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2021-09-02 11:48:12 +02:00
|
|
|
if (parse_num(&s.sparedisks, optarg) != 0 || s.sparedisks < 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("invalid number of spare-devices: %s\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
2004-06-04 14:03:19 +02:00
|
|
|
|
|
|
|
case O(CREATE,'a'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(CREATE,Auto):
|
2004-06-04 14:03:19 +02:00
|
|
|
case O(BUILD,'a'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(BUILD,Auto):
|
2008-05-05 13:55:37 +02:00
|
|
|
case O(INCREMENTAL,'a'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(INCREMENTAL,Auto):
|
|
|
|
case O(ASSEMBLE,'a'):
|
|
|
|
case O(ASSEMBLE,Auto): /* auto-creation of device node */
|
2012-07-09 09:17:33 +02:00
|
|
|
c.autof = parse_auto(optarg, "--auto flag", 0);
|
2004-06-04 14:03:19 +02:00
|
|
|
continue;
|
|
|
|
|
2006-08-11 10:00:05 +02:00
|
|
|
case O(CREATE,Symlinks):
|
|
|
|
case O(BUILD,Symlinks):
|
|
|
|
case O(ASSEMBLE,Symlinks): /* auto creation of symlinks in /dev to /dev/md */
|
|
|
|
symlinks = optarg;
|
|
|
|
continue;
|
|
|
|
|
2003-07-29 01:59:00 +02:00
|
|
|
case O(BUILD,'f'): /* force honouring '-n 1' */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(BUILD,Force): /* force honouring '-n 1' */
|
2005-06-14 08:34:29 +02:00
|
|
|
case O(GROW,'f'): /* ditto */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(GROW,Force): /* ditto */
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(CREATE,'f'): /* force honouring of device list */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(CREATE,Force): /* force honouring of device list */
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(ASSEMBLE,'f'): /* force assembly */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(ASSEMBLE,Force): /* force assembly */
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MISC,'f'): /* force zero */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MISC,Force): /* force zero */
|
2011-09-08 05:05:31 +02:00
|
|
|
case O(MANAGE,Force): /* add device which is too large */
|
2017-03-29 18:02:14 +02:00
|
|
|
c.force = 1;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
|
|
|
/* now for the Assemble options */
|
2011-10-03 00:15:22 +02:00
|
|
|
case O(ASSEMBLE, FreezeReshape): /* Freeze reshape during
|
|
|
|
* initrd phase */
|
|
|
|
case O(INCREMENTAL, FreezeReshape):
|
2012-07-09 09:17:33 +02:00
|
|
|
c.freeze_reshape = 1;
|
2011-10-03 00:15:22 +02:00
|
|
|
continue;
|
2006-12-14 07:33:10 +01:00
|
|
|
case O(CREATE,'u'): /* uuid of array */
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(ASSEMBLE,'u'): /* uuid of array */
|
2001-08-23 04:33:20 +02:00
|
|
|
if (ident.uuid_set) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("uuid cannot be set twice. Second value %s.\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
if (parse_uuid(optarg, ident.uuid))
|
|
|
|
ident.uuid_set = 1;
|
|
|
|
else {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("Bad uuid: %s\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2005-08-09 07:23:20 +02:00
|
|
|
case O(CREATE,'N'):
|
|
|
|
case O(ASSEMBLE,'N'):
|
2010-06-23 01:30:59 +02:00
|
|
|
case O(MISC,'N'):
|
2005-08-09 07:23:20 +02:00
|
|
|
if (ident.name[0]) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("name cannot be set twice. Second value %s.\n", optarg);
|
2005-08-09 07:23:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (mode == MISC && !c.subarray) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("-N/--name only valid with --update-subarray in misc mode\n");
|
2010-06-23 01:30:59 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2005-08-09 07:23:20 +02:00
|
|
|
if (strlen(optarg) > 32) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("name '%s' is too long, 32 chars max.\n",
|
2005-08-09 07:23:20 +02:00
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
strcpy(ident.name, optarg);
|
|
|
|
continue;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(ASSEMBLE,'m'): /* super-minor for array */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(ASSEMBLE,SuperMinor):
|
2004-01-22 03:10:29 +01:00
|
|
|
if (ident.super_minor != UnSet) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("super-minor cannot be set twice. Second value: %s.\n", optarg);
|
2002-03-07 00:17:40 +01:00
|
|
|
exit(2);
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(optarg, "dev") == 0)
|
2003-03-03 00:11:38 +01:00
|
|
|
ident.super_minor = -2;
|
2021-09-02 11:48:12 +02:00
|
|
|
else if (parse_num(&ident.super_minor, optarg) != 0 || ident.super_minor < 0) {
|
|
|
|
pr_err("Bad super-minor number: %s.\n", optarg);
|
|
|
|
exit(2);
|
2002-03-07 00:17:40 +01:00
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2012-07-09 09:14:16 +02:00
|
|
|
case O(ASSEMBLE,'o'):
|
|
|
|
case O(MANAGE,'o'):
|
|
|
|
case O(CREATE,'o'):
|
2012-07-09 09:17:33 +02:00
|
|
|
c.readonly = 1;
|
2012-07-09 09:14:16 +02:00
|
|
|
continue;
|
|
|
|
|
2003-02-12 01:17:26 +01:00
|
|
|
case O(ASSEMBLE,'U'): /* update the superblock */
|
2010-06-23 01:30:59 +02:00
|
|
|
case O(MISC,'U'):
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.update) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("Can only update one aspect of superblock, both %s and %s given.\n",
|
2012-07-09 09:17:33 +02:00
|
|
|
c.update, optarg);
|
2003-02-12 01:17:26 +01:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (mode == MISC && !c.subarray) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("Only subarrays can be updated in misc mode\n");
|
2010-06-23 01:30:59 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.update = optarg;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "sparc2.2") == 0)
|
2004-08-11 04:16:01 +02:00
|
|
|
continue;
|
2012-07-09 09:17:33 +02:00
|
|
|
if (strcmp(c.update, "super-minor") == 0)
|
2003-02-12 01:17:26 +01:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "summaries") == 0)
|
2003-10-29 00:20:01 +01:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "resync") == 0)
|
2004-08-11 04:16:01 +02:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "uuid") == 0)
|
2005-12-05 06:56:33 +01:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "name") == 0)
|
2006-05-23 06:57:04 +02:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "homehost") == 0)
|
2006-05-23 07:16:32 +02:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "home-cluster") == 0)
|
2015-06-10 07:42:11 +02:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "nodes") == 0)
|
2015-06-10 07:42:12 +02:00
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "devicesize") == 0)
|
2006-12-14 07:31:03 +01:00
|
|
|
continue;
|
2021-01-15 06:46:58 +01:00
|
|
|
if (strcmp(c.update, "bitmap") == 0)
|
|
|
|
continue;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(c.update, "no-bitmap") == 0)
|
2010-11-30 06:46:01 +01:00
|
|
|
continue;
|
2012-10-03 09:07:13 +02:00
|
|
|
if (strcmp(c.update, "bbl") == 0)
|
|
|
|
continue;
|
|
|
|
if (strcmp(c.update, "no-bbl") == 0)
|
|
|
|
continue;
|
2015-12-21 04:56:38 +01:00
|
|
|
if (strcmp(c.update, "force-no-bbl") == 0)
|
|
|
|
continue;
|
2017-03-29 11:54:19 +02:00
|
|
|
if (strcmp(c.update, "ppl") == 0)
|
|
|
|
continue;
|
|
|
|
if (strcmp(c.update, "no-ppl") == 0)
|
|
|
|
continue;
|
2013-05-23 06:41:29 +02:00
|
|
|
if (strcmp(c.update, "metadata") == 0)
|
|
|
|
continue;
|
2013-05-23 07:48:48 +02:00
|
|
|
if (strcmp(c.update, "revert-reshape") == 0)
|
|
|
|
continue;
|
2019-11-04 04:27:49 +01:00
|
|
|
if (strcmp(c.update, "layout-original") == 0 ||
|
2020-10-14 04:12:48 +02:00
|
|
|
strcmp(c.update, "layout-alternate") == 0 ||
|
|
|
|
strcmp(c.update, "layout-unspecified") == 0)
|
2019-11-04 04:27:49 +01:00
|
|
|
continue;
|
2017-03-29 18:02:14 +02:00
|
|
|
if (strcmp(c.update, "byteorder") == 0) {
|
2005-08-09 06:25:27 +02:00
|
|
|
if (ss) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("must not set metadata type with --update=byteorder.\n");
|
2005-08-09 06:25:27 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2017-03-29 18:02:14 +02:00
|
|
|
for(i = 0; !ss && superlist[i]; i++)
|
2010-12-09 03:06:29 +01:00
|
|
|
ss = superlist[i]->match_metadata_desc(
|
|
|
|
"0.swap");
|
2005-08-09 06:25:27 +02:00
|
|
|
if (!ss) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("INTERNAL ERROR cannot find 0.swap\n");
|
2005-08-09 06:25:27 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (strcmp(c.update,"?") == 0 ||
|
|
|
|
strcmp(c.update, "help") == 0) {
|
2007-05-08 09:14:00 +02:00
|
|
|
outf = stdout;
|
2015-02-11 22:25:03 +01:00
|
|
|
fprintf(outf, "%s: ", Name);
|
2007-05-08 09:14:00 +02:00
|
|
|
} else {
|
|
|
|
outf = stderr;
|
|
|
|
fprintf(outf,
|
2015-02-11 22:25:03 +01:00
|
|
|
"%s: '--update=%s' is invalid. ",
|
|
|
|
Name, c.update);
|
2007-05-08 09:14:00 +02:00
|
|
|
}
|
|
|
|
fprintf(outf, "Valid --update options are:\n"
|
2015-06-10 07:42:12 +02:00
|
|
|
" 'sparc2.2', 'super-minor', 'uuid', 'name', 'nodes', 'resync',\n"
|
2015-06-10 07:42:11 +02:00
|
|
|
" 'summaries', 'homehost', 'home-cluster', 'byteorder', 'devicesize',\n"
|
2021-01-15 06:46:58 +01:00
|
|
|
" 'bitmap', 'no-bitmap', 'metadata', 'revert-reshape'\n"
|
2017-03-29 11:54:19 +02:00
|
|
|
" 'bbl', 'no-bbl', 'force-no-bbl', 'ppl', 'no-ppl'\n"
|
2020-10-14 04:12:48 +02:00
|
|
|
" 'layout-original', 'layout-alternate', 'layout-unspecified'\n"
|
2014-08-27 13:04:59 +02:00
|
|
|
);
|
2007-05-08 09:14:00 +02:00
|
|
|
exit(outf == stdout ? 0 : 2);
|
2003-02-12 01:17:26 +01:00
|
|
|
|
2010-12-09 03:06:29 +01:00
|
|
|
case O(MANAGE,'U'):
|
|
|
|
/* update=devicesize is allowed with --re-add */
|
2012-07-09 09:14:16 +02:00
|
|
|
if (devmode != 'A') {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("--update in Manage mode only allowed with --re-add.\n");
|
2010-12-09 03:06:29 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.update) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("Can only update one aspect of superblock, both %s and %s given.\n",
|
2012-07-09 09:17:33 +02:00
|
|
|
c.update, optarg);
|
2010-12-09 03:06:29 +01:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.update = optarg;
|
2012-10-03 09:07:13 +02:00
|
|
|
if (strcmp(c.update, "devicesize") != 0 &&
|
|
|
|
strcmp(c.update, "bbl") != 0 &&
|
2015-12-21 04:56:38 +01:00
|
|
|
strcmp(c.update, "force-no-bbl") != 0 &&
|
2012-10-03 09:07:13 +02:00
|
|
|
strcmp(c.update, "no-bbl") != 0) {
|
2015-12-21 04:56:38 +01:00
|
|
|
pr_err("only 'devicesize', 'bbl', 'no-bbl', and 'force-no-bbl' can be updated with --re-add\n");
|
2010-12-09 03:06:29 +01:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2010-08-09 19:26:24 +02:00
|
|
|
case O(INCREMENTAL,NoDegraded):
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--no-degraded is deprecated in Incremental mode\n");
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(ASSEMBLE,NoDegraded): /* --no-degraded */
|
2012-07-09 09:17:33 +02:00
|
|
|
c.runstop = -1; /* --stop isn't allowed for --assemble,
|
|
|
|
* so we overload slightly */
|
2006-05-19 06:53:22 +02:00
|
|
|
continue;
|
|
|
|
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(ASSEMBLE,'c'):
|
|
|
|
case O(ASSEMBLE,ConfigFile):
|
2008-09-18 07:05:46 +02:00
|
|
|
case O(INCREMENTAL, 'c'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(INCREMENTAL, ConfigFile):
|
2002-05-10 06:06:19 +02:00
|
|
|
case O(MISC, 'c'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MISC, ConfigFile):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MONITOR,'c'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MONITOR,ConfigFile):
|
2013-06-24 07:44:36 +02:00
|
|
|
case O(CREATE,ConfigFile):
|
2001-08-23 04:33:20 +02:00
|
|
|
if (configfile) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("configfile cannot be set twice. Second value is %s.\n", optarg);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
configfile = optarg;
|
2006-06-26 07:11:01 +02:00
|
|
|
set_conffile(configfile);
|
2001-08-23 04:33:20 +02:00
|
|
|
/* FIXME possibly check that config file exists. Even parse it */
|
|
|
|
continue;
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(ASSEMBLE,'s'): /* scan */
|
|
|
|
case O(MISC,'s'):
|
|
|
|
case O(MONITOR,'s'):
|
2006-12-21 07:10:52 +01:00
|
|
|
case O(INCREMENTAL,'s'):
|
2012-07-09 09:17:33 +02:00
|
|
|
c.scan = 1;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MONITOR,'m'): /* mail address */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MONITOR,EMail):
|
2001-08-23 04:33:20 +02:00
|
|
|
if (mailaddr)
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("only specify one mailaddress. %s ignored.\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
else
|
|
|
|
mailaddr = optarg;
|
|
|
|
continue;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MONITOR,'p'): /* alert program */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MONITOR,ProgramOpt): /* alert program */
|
2001-08-23 04:33:20 +02:00
|
|
|
if (program)
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("only specify one alter program. %s ignored.\n",
|
2001-08-23 04:33:20 +02:00
|
|
|
optarg);
|
|
|
|
else
|
|
|
|
program = optarg;
|
|
|
|
continue;
|
2001-06-08 04:36:23 +02:00
|
|
|
|
2009-10-19 04:13:58 +02:00
|
|
|
case O(MONITOR,'r'): /* rebuild increments */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MONITOR,Increment):
|
2021-09-02 11:48:12 +02:00
|
|
|
if (parse_num(&increments, optarg) != 0
|
|
|
|
|| increments > 99 || increments < 1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("please specify positive integer between 1 and 99 as rebuild increments.\n");
|
2009-10-19 04:13:58 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MONITOR,'d'): /* delay in seconds */
|
2005-06-08 01:03:46 +02:00
|
|
|
case O(GROW, 'd'):
|
2005-06-08 01:16:35 +02:00
|
|
|
case O(BUILD,'d'): /* delay for bitmap updates */
|
|
|
|
case O(CREATE,'d'):
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.delay)
|
2021-09-02 11:48:12 +02:00
|
|
|
pr_err("only specify delay once. %s ignored.\n", optarg);
|
|
|
|
else if (parse_num(&c.delay, optarg) != 0 || c.delay < 1) {
|
|
|
|
pr_err("invalid delay: %s\n", optarg);
|
|
|
|
exit(2);
|
2001-08-23 04:33:20 +02:00
|
|
|
}
|
|
|
|
continue;
|
2003-03-03 00:11:38 +01:00
|
|
|
case O(MONITOR,'f'): /* daemonise */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MONITOR,Fork):
|
2003-03-03 00:11:38 +01:00
|
|
|
daemonise = 1;
|
|
|
|
continue;
|
2004-11-01 05:49:34 +01:00
|
|
|
case O(MONITOR,'i'): /* pid */
|
|
|
|
if (pidfile)
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("only specify one pid file. %s ignored.\n",
|
2004-11-01 05:49:34 +01:00
|
|
|
optarg);
|
|
|
|
else
|
|
|
|
pidfile = optarg;
|
|
|
|
continue;
|
2003-07-29 01:59:00 +02:00
|
|
|
case O(MONITOR,'1'): /* oneshot */
|
|
|
|
oneshot = 1;
|
2011-09-19 03:01:19 +02:00
|
|
|
spare_sharing = 0;
|
2003-07-29 01:59:00 +02:00
|
|
|
continue;
|
2004-01-22 03:10:29 +01:00
|
|
|
case O(MONITOR,'t'): /* test */
|
2012-07-09 09:17:33 +02:00
|
|
|
c.test = 1;
|
2004-01-22 03:10:29 +01:00
|
|
|
continue;
|
2005-12-05 06:55:56 +01:00
|
|
|
case O(MONITOR,'y'): /* log messages to syslog */
|
2008-05-12 04:21:56 +02:00
|
|
|
openlog("mdadm", LOG_PID, SYSLOG_FACILITY);
|
2005-12-05 06:55:56 +01:00
|
|
|
dosyslog = 1;
|
|
|
|
continue;
|
2010-11-22 10:58:06 +01:00
|
|
|
case O(MONITOR, NoSharing):
|
|
|
|
spare_sharing = 0;
|
|
|
|
continue;
|
2012-07-09 09:00:50 +02:00
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
/* now the general management options. Some are applicable
|
|
|
|
* to other modes. None have arguments.
|
|
|
|
*/
|
2004-08-11 04:16:01 +02:00
|
|
|
case O(GROW,'a'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(GROW,Add):
|
|
|
|
case O(MANAGE,'a'):
|
|
|
|
case O(MANAGE,Add): /* add a drive */
|
2001-08-23 04:33:20 +02:00
|
|
|
devmode = 'a';
|
2005-08-16 08:45:23 +02:00
|
|
|
continue;
|
2013-10-31 00:41:50 +01:00
|
|
|
case O(MANAGE,AddSpare): /* add drive - never re-add */
|
|
|
|
devmode = 'S';
|
|
|
|
continue;
|
2015-12-15 02:43:43 +01:00
|
|
|
case O(MANAGE,AddJournal): /* add journal */
|
|
|
|
if (s.journaldisks && (s.level < 4 || s.level > 6)) {
|
|
|
|
pr_err("--add-journal is only supported for RAID level 4/5/6.\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
devmode = 'j';
|
|
|
|
continue;
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(MANAGE,ReAdd):
|
2012-07-09 09:14:16 +02:00
|
|
|
devmode = 'A';
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MANAGE,'r'): /* remove a drive */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MANAGE,Remove):
|
2001-08-23 04:33:20 +02:00
|
|
|
devmode = 'r';
|
|
|
|
continue;
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MANAGE,'f'): /* set faulty */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MANAGE,Fail):
|
|
|
|
case O(INCREMENTAL,'f'):
|
|
|
|
case O(INCREMENTAL,Remove):
|
|
|
|
case O(INCREMENTAL,Fail): /* r for incremental is taken, use f
|
2012-07-09 09:14:16 +02:00
|
|
|
* even though we will both fail and
|
|
|
|
* remove the device */
|
2001-08-23 04:33:20 +02:00
|
|
|
devmode = 'f';
|
|
|
|
continue;
|
2015-06-10 07:42:08 +02:00
|
|
|
case O(MANAGE, ClusterConfirm):
|
|
|
|
devmode = 'c';
|
|
|
|
continue;
|
2012-10-23 07:27:15 +02:00
|
|
|
case O(MANAGE,Replace):
|
|
|
|
/* Mark these devices for replacement */
|
|
|
|
devmode = 'R';
|
|
|
|
continue;
|
|
|
|
case O(MANAGE,With):
|
|
|
|
/* These are the replacements to use */
|
|
|
|
if (devmode != 'R') {
|
|
|
|
pr_err("--with must follow --replace\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
devmode = 'W';
|
|
|
|
continue;
|
2006-12-21 07:10:52 +01:00
|
|
|
case O(INCREMENTAL,'R'):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MANAGE,'R'):
|
|
|
|
case O(ASSEMBLE,'R'):
|
|
|
|
case O(BUILD,'R'):
|
|
|
|
case O(CREATE,'R'): /* Run the array */
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.runstop < 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("Cannot both Stop and Run an array\n");
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.runstop = 1;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MANAGE,'S'):
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.runstop > 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("Cannot both Run and Stop an array\n");
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.runstop = -1;
|
2001-08-23 04:33:20 +02:00
|
|
|
continue;
|
2010-07-06 03:46:04 +02:00
|
|
|
case O(MANAGE,'t'):
|
2012-07-09 09:17:33 +02:00
|
|
|
c.test = 1;
|
2010-07-06 03:46:04 +02:00
|
|
|
continue;
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MISC,'Q'):
|
|
|
|
case O(MISC,'D'):
|
|
|
|
case O(MISC,'E'):
|
2012-07-09 09:00:45 +02:00
|
|
|
case O(MISC,KillOpt):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MISC,'R'):
|
|
|
|
case O(MISC,'S'):
|
2005-06-08 01:16:35 +02:00
|
|
|
case O(MISC,'X'):
|
2012-12-05 02:56:31 +01:00
|
|
|
case O(MISC, ExamineBB):
|
2002-04-04 03:58:32 +02:00
|
|
|
case O(MISC,'o'):
|
|
|
|
case O(MISC,'w'):
|
2006-12-14 07:31:22 +01:00
|
|
|
case O(MISC,'W'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(MISC, WaitOpt):
|
2008-09-16 05:58:42 +02:00
|
|
|
case O(MISC, Waitclean):
|
2008-12-09 00:59:18 +01:00
|
|
|
case O(MISC, DetailPlatform):
|
2010-06-16 02:55:41 +02:00
|
|
|
case O(MISC, KillSubarray):
|
2010-06-23 01:30:59 +02:00
|
|
|
case O(MISC, UpdateSubarray):
|
2013-05-16 07:07:16 +02:00
|
|
|
case O(MISC, Dump):
|
|
|
|
case O(MISC, Restore):
|
2014-05-22 07:55:31 +02:00
|
|
|
case O(MISC ,Action):
|
2011-11-02 22:06:47 +01:00
|
|
|
if (opt == KillSubarray || opt == UpdateSubarray) {
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.subarray) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("subarray can only be specified once\n");
|
2011-11-02 22:06:47 +01:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.subarray = optarg;
|
2011-11-02 22:06:47 +01:00
|
|
|
}
|
2014-05-22 07:55:31 +02:00
|
|
|
if (opt == Action) {
|
|
|
|
if (c.action) {
|
|
|
|
pr_err("Only one --action can be specified\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
if (strcmp(optarg, "idle") == 0 ||
|
|
|
|
strcmp(optarg, "frozen") == 0 ||
|
|
|
|
strcmp(optarg, "check") == 0 ||
|
|
|
|
strcmp(optarg, "repair") == 0)
|
|
|
|
c.action = optarg;
|
|
|
|
else {
|
|
|
|
pr_err("action must be one of idle, frozen, check, repair\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
}
|
2002-04-04 03:58:32 +02:00
|
|
|
if (devmode && devmode != opt &&
|
2016-03-09 20:37:46 +01:00
|
|
|
(devmode == 'E' ||
|
|
|
|
(opt == 'E' && devmode != 'Q'))) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--examine/-E cannot be given with ");
|
2010-06-23 01:30:59 +02:00
|
|
|
if (devmode == 'E') {
|
|
|
|
if (option_index >= 0)
|
|
|
|
fprintf(stderr, "--%s\n",
|
|
|
|
long_options[option_index].name);
|
|
|
|
else
|
|
|
|
fprintf(stderr, "-%c\n", opt);
|
|
|
|
} else if (isalpha(devmode))
|
|
|
|
fprintf(stderr, "-%c\n", devmode);
|
|
|
|
else
|
|
|
|
fprintf(stderr, "previous option\n");
|
2002-04-04 03:58:32 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
devmode = opt;
|
2013-05-16 07:07:16 +02:00
|
|
|
if (opt == Dump || opt == Restore) {
|
|
|
|
if (dump_directory != NULL) {
|
|
|
|
pr_err("dump/restore directory specified twice: %s and %s\n",
|
|
|
|
dump_directory, optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
dump_directory = optarg;
|
|
|
|
}
|
2002-04-04 03:58:32 +02:00
|
|
|
continue;
|
2012-07-09 09:14:16 +02:00
|
|
|
case O(MISC, UdevRules):
|
|
|
|
if (devmode && devmode != opt) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("--udev-rules must be the only option.\n");
|
2012-07-09 09:14:16 +02:00
|
|
|
} else {
|
|
|
|
if (udev_filename)
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("only specify one udev rule filename. %s ignored.\n",
|
2012-07-09 09:14:16 +02:00
|
|
|
optarg);
|
|
|
|
else
|
|
|
|
udev_filename = optarg;
|
|
|
|
}
|
|
|
|
devmode = opt;
|
|
|
|
continue;
|
2003-10-29 00:20:01 +01:00
|
|
|
case O(MISC,'t'):
|
2012-07-09 09:17:33 +02:00
|
|
|
c.test = 1;
|
2003-10-29 00:20:01 +01:00
|
|
|
continue;
|
2002-04-04 03:58:32 +02:00
|
|
|
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(MISC, Sparc22):
|
2002-05-20 13:17:18 +02:00
|
|
|
if (devmode != 'E') {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--sparc2.2 only allowed with --examine\n");
|
2002-05-20 13:17:18 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.SparcAdjust = 1;
|
2002-05-20 13:17:18 +02:00
|
|
|
continue;
|
2005-06-08 01:16:35 +02:00
|
|
|
|
|
|
|
case O(ASSEMBLE,'b'): /* here we simply set the bitmap file */
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(ASSEMBLE,Bitmap):
|
2005-06-08 01:16:35 +02:00
|
|
|
if (!optarg) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("bitmap file needed with -b in --assemble mode\n");
|
2005-06-08 01:16:35 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2017-03-07 04:13:03 +01:00
|
|
|
if (strcmp(optarg, "internal") == 0 ||
|
|
|
|
strcmp(optarg, "clustered") == 0) {
|
|
|
|
pr_err("no need to specify --bitmap when assembling"
|
|
|
|
" arrays with internal or clustered bitmap\n");
|
2005-06-08 01:03:47 +02:00
|
|
|
continue;
|
|
|
|
}
|
2005-06-08 01:16:35 +02:00
|
|
|
bitmap_fd = open(optarg, O_RDWR);
|
|
|
|
if (!*optarg || bitmap_fd < 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("cannot open bitmap file %s: %s\n", optarg, strerror(errno));
|
2005-06-08 01:16:35 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
ident.bitmap_fd = bitmap_fd; /* for Assemble */
|
|
|
|
continue;
|
2005-06-08 01:03:46 +02:00
|
|
|
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(ASSEMBLE, BackupFile):
|
|
|
|
case O(GROW, BackupFile):
|
2006-03-27 08:38:46 +02:00
|
|
|
/* Specify a file into which grow might place a backup,
|
|
|
|
* or from which assemble might recover a backup
|
|
|
|
*/
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.backup_file) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("backup file already specified, rejecting %s\n", optarg);
|
2006-03-27 08:38:46 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
c.backup_file = optarg;
|
2006-03-27 08:38:46 +02:00
|
|
|
continue;
|
|
|
|
|
2011-10-03 00:26:48 +02:00
|
|
|
case O(GROW, Continue):
|
|
|
|
/* Continue interrupted grow
|
|
|
|
*/
|
|
|
|
grow_continue = 1;
|
|
|
|
continue;
|
2010-12-01 01:47:32 +01:00
|
|
|
case O(ASSEMBLE, InvalidBackup):
|
|
|
|
/* Acknowledge that the backupfile is invalid, but ask
|
|
|
|
* to continue anyway
|
|
|
|
*/
|
2012-07-09 09:17:33 +02:00
|
|
|
c.invalid_backup = 1;
|
2010-12-01 01:47:32 +01:00
|
|
|
continue;
|
|
|
|
|
2005-06-08 01:16:35 +02:00
|
|
|
case O(BUILD,'b'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(BUILD,Bitmap):
|
|
|
|
case O(CREATE,'b'):
|
|
|
|
case O(CREATE,Bitmap): /* here we create the bitmap */
|
2007-07-23 09:28:44 +02:00
|
|
|
case O(GROW,'b'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(GROW,Bitmap):
|
2017-03-20 06:21:03 +01:00
|
|
|
if (s.bitmap_file) {
|
|
|
|
pr_err("bitmap cannot be set twice. Second value: %s.\n", optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(optarg, "internal") == 0 ||
|
|
|
|
strcmp(optarg, "none") == 0 ||
|
2006-02-06 05:18:12 +01:00
|
|
|
strchr(optarg, '/') != NULL) {
|
2012-07-09 09:21:38 +02:00
|
|
|
s.bitmap_file = optarg;
|
2006-02-06 05:18:12 +01:00
|
|
|
continue;
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(optarg, "clustered") == 0) {
|
2015-06-10 07:42:05 +02:00
|
|
|
s.bitmap_file = optarg;
|
|
|
|
/* Set the default number of cluster nodes
|
|
|
|
* to 4 if not already set by user
|
|
|
|
*/
|
|
|
|
if (c.nodes < 1)
|
|
|
|
c.nodes = 4;
|
|
|
|
continue;
|
|
|
|
}
|
2006-02-06 05:18:12 +01:00
|
|
|
/* probable typo */
|
2016-08-02 11:18:40 +02:00
|
|
|
pr_err("bitmap file must contain a '/', or be 'internal', or be 'clustered', or 'none'\n"
|
2010-01-29 04:54:55 +01:00
|
|
|
" not '%s'\n", optarg);
|
2006-02-06 05:18:12 +01:00
|
|
|
exit(2);
|
2005-06-08 01:16:35 +02:00
|
|
|
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(GROW,BitmapChunk):
|
|
|
|
case O(BUILD,BitmapChunk):
|
|
|
|
case O(CREATE,BitmapChunk): /* bitmap chunksize */
|
2012-07-09 09:21:38 +02:00
|
|
|
s.bitmap_chunk = parse_size(optarg);
|
2012-10-04 08:34:20 +02:00
|
|
|
if (s.bitmap_chunk == 0 ||
|
|
|
|
s.bitmap_chunk == INVALID_SECTORS ||
|
2012-07-09 09:21:38 +02:00
|
|
|
s.bitmap_chunk & (s.bitmap_chunk - 1)) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("invalid bitmap chunksize: %s\n",
|
|
|
|
optarg);
|
2005-06-08 01:16:35 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
s.bitmap_chunk = s.bitmap_chunk * 512;
|
2005-06-08 01:16:35 +02:00
|
|
|
continue;
|
2005-08-09 06:25:47 +02:00
|
|
|
|
2007-07-09 03:29:04 +02:00
|
|
|
case O(GROW, WriteBehind):
|
2006-05-19 07:50:08 +02:00
|
|
|
case O(BUILD, WriteBehind):
|
2021-09-02 11:48:12 +02:00
|
|
|
case O(CREATE, WriteBehind):
|
2012-07-09 09:21:38 +02:00
|
|
|
s.write_behind = DEFAULT_MAX_WRITE_BEHIND;
|
2021-09-02 11:48:12 +02:00
|
|
|
if (parse_num(&s.write_behind, optarg) != 0 ||
|
|
|
|
s.write_behind < 0 || s.write_behind > 16383) {
|
|
|
|
pr_err("Invalid value for maximum outstanding write-behind writes: %s.\n\tMust be between 0 and 16383.\n",
|
|
|
|
optarg);
|
|
|
|
exit(2);
|
2005-08-09 06:25:47 +02:00
|
|
|
}
|
|
|
|
continue;
|
2006-12-21 07:10:52 +01:00
|
|
|
case O(INCREMENTAL, 'r'):
|
2010-11-25 08:58:45 +01:00
|
|
|
case O(INCREMENTAL, RebuildMapOpt):
|
2006-12-21 07:10:52 +01:00
|
|
|
rebuild_map = 1;
|
|
|
|
continue;
|
2010-11-22 10:58:06 +01:00
|
|
|
case O(INCREMENTAL, IncrementalPath):
|
|
|
|
remove_path = optarg;
|
|
|
|
continue;
|
2015-10-09 07:51:43 +02:00
|
|
|
case O(CREATE, WriteJournal):
|
|
|
|
if (s.journaldisks) {
|
|
|
|
pr_err("Please specify only one journal device for the array.\n");
|
|
|
|
pr_err("Ignoring --write-journal %s...\n", optarg);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
dv = xmalloc(sizeof(*dv));
|
|
|
|
dv->devname = optarg;
|
|
|
|
dv->disposition = 'j'; /* WriteJournal */
|
|
|
|
dv->used = 0;
|
|
|
|
dv->next = NULL;
|
|
|
|
*devlistend = dv;
|
|
|
|
devlistend = &dv->next;
|
|
|
|
devs_found++;
|
|
|
|
|
|
|
|
s.journaldisks = 1;
|
|
|
|
continue;
|
2017-03-29 11:54:15 +02:00
|
|
|
case O(CREATE, 'k'):
|
2017-03-29 11:54:20 +02:00
|
|
|
case O(GROW, 'k'):
|
2017-03-29 11:54:15 +02:00
|
|
|
s.consistency_policy = map_name(consistency_policies,
|
|
|
|
optarg);
|
2017-04-24 16:03:26 +02:00
|
|
|
if (s.consistency_policy < CONSISTENCY_POLICY_RESYNC) {
|
2017-03-29 11:54:15 +02:00
|
|
|
pr_err("Invalid consistency policy: %s\n",
|
|
|
|
optarg);
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
continue;
|
2001-08-23 04:33:20 +02:00
|
|
|
}
|
|
|
|
/* We have now processed all the valid options. Anything else is
|
|
|
|
* an error
|
|
|
|
*/
|
2006-03-27 08:38:46 +02:00
|
|
|
if (option_index > 0)
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err(":option --%s not valid in %s mode\n",
|
2006-03-27 08:38:46 +02:00
|
|
|
long_options[option_index].name,
|
|
|
|
map_num(modes, mode));
|
|
|
|
else
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("option -%c not valid in %s mode\n",
|
2006-03-27 08:38:46 +02:00
|
|
|
opt, map_num(modes, mode));
|
2001-06-08 04:36:23 +02:00
|
|
|
exit(2);
|
2001-08-23 04:33:20 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-01-30 01:13:26 +01:00
|
|
|
if (print_help) {
|
2012-07-09 09:14:16 +02:00
|
|
|
char *help_text;
|
2006-01-30 01:13:26 +01:00
|
|
|
if (print_help == 2)
|
|
|
|
help_text = OptionHelp;
|
|
|
|
else
|
2012-07-09 09:14:16 +02:00
|
|
|
help_text = mode_help[mode];
|
|
|
|
if (help_text == NULL)
|
|
|
|
help_text = Help;
|
2007-05-08 09:14:00 +02:00
|
|
|
fputs(help_text,stdout);
|
2006-01-30 01:13:26 +01:00
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2017-03-29 11:54:15 +02:00
|
|
|
if (s.journaldisks) {
|
|
|
|
if (s.level < 4 || s.level > 6) {
|
|
|
|
pr_err("--write-journal is only supported for RAID level 4/5/6.\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
2017-04-24 16:03:26 +02:00
|
|
|
if (s.consistency_policy != CONSISTENCY_POLICY_UNKNOWN &&
|
2017-03-29 11:54:15 +02:00
|
|
|
s.consistency_policy != CONSISTENCY_POLICY_JOURNAL) {
|
|
|
|
pr_err("--write-journal is not supported with consistency policy: %s\n",
|
|
|
|
map_num(consistency_policies, s.consistency_policy));
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-24 16:03:26 +02:00
|
|
|
if (mode == CREATE &&
|
|
|
|
s.consistency_policy != CONSISTENCY_POLICY_UNKNOWN) {
|
2017-03-29 11:54:15 +02:00
|
|
|
if (s.level <= 0) {
|
|
|
|
pr_err("--consistency-policy not meaningful with level %s.\n",
|
|
|
|
map_num(pers, s.level));
|
|
|
|
exit(2);
|
|
|
|
} else if (s.consistency_policy == CONSISTENCY_POLICY_JOURNAL &&
|
|
|
|
!s.journaldisks) {
|
|
|
|
pr_err("--write-journal is required for consistency policy: %s\n",
|
|
|
|
map_num(consistency_policies, s.consistency_policy));
|
|
|
|
exit(2);
|
|
|
|
} else if (s.consistency_policy == CONSISTENCY_POLICY_PPL &&
|
|
|
|
s.level != 5) {
|
|
|
|
pr_err("PPL consistency policy is only supported for RAID level 5.\n");
|
|
|
|
exit(2);
|
|
|
|
} else if (s.consistency_policy == CONSISTENCY_POLICY_BITMAP &&
|
|
|
|
(!s.bitmap_file ||
|
|
|
|
strcmp(s.bitmap_file, "none") == 0)) {
|
|
|
|
pr_err("--bitmap is required for consistency policy: %s\n",
|
|
|
|
map_num(consistency_policies, s.consistency_policy));
|
|
|
|
exit(2);
|
|
|
|
} else if (s.bitmap_file &&
|
|
|
|
strcmp(s.bitmap_file, "none") != 0 &&
|
|
|
|
s.consistency_policy != CONSISTENCY_POLICY_BITMAP &&
|
|
|
|
s.consistency_policy != CONSISTENCY_POLICY_JOURNAL) {
|
|
|
|
pr_err("--bitmap is not compatible with consistency policy: %s\n",
|
|
|
|
map_num(consistency_policies, s.consistency_policy));
|
|
|
|
exit(2);
|
|
|
|
}
|
2015-10-09 07:51:43 +02:00
|
|
|
}
|
|
|
|
|
2005-04-04 07:18:57 +02:00
|
|
|
if (!mode && devs_found) {
|
|
|
|
mode = MISC;
|
|
|
|
devmode = 'Q';
|
|
|
|
if (devlist->disposition == 0)
|
|
|
|
devlist->disposition = devmode;
|
|
|
|
}
|
2001-08-23 04:33:20 +02:00
|
|
|
if (!mode) {
|
|
|
|
fputs(Usage, stderr);
|
2001-06-08 04:36:23 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2006-08-11 10:00:05 +02:00
|
|
|
|
|
|
|
if (symlinks) {
|
|
|
|
struct createinfo *ci = conf_get_create_info();
|
|
|
|
|
|
|
|
if (strcasecmp(symlinks, "yes") == 0)
|
|
|
|
ci->symlinks = 1;
|
|
|
|
else if (strcasecmp(symlinks, "no") == 0)
|
|
|
|
ci->symlinks = 0;
|
|
|
|
else {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("option --symlinks must be 'no' or 'yes'\n");
|
2006-08-11 10:00:05 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
}
|
2001-08-23 04:33:20 +02:00
|
|
|
/* Ok, got the option parsing out of the way
|
|
|
|
* hopefully it's mostly right but there might be some stuff
|
|
|
|
* missing
|
|
|
|
*
|
2017-03-01 09:44:33 +01:00
|
|
|
* That is mostly checked in the per-mode stuff but...
|
2001-08-23 04:33:20 +02:00
|
|
|
*
|
2012-07-09 09:00:50 +02:00
|
|
|
* For @,B,C and A without -s, the first device listed must be
|
|
|
|
* an md device. We check that here and open it.
|
2001-06-08 04:36:23 +02:00
|
|
|
*/
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2016-03-09 20:37:46 +01:00
|
|
|
if (mode == MANAGE || mode == BUILD || mode == CREATE ||
|
|
|
|
mode == GROW || (mode == ASSEMBLE && ! c.scan)) {
|
2001-08-23 04:33:20 +02:00
|
|
|
if (devs_found < 1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("an md device must be given in this mode\n");
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if ((int)ident.super_minor == -2 && c.autof) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--super-minor=dev is incompatible with --auto\n");
|
2004-06-04 14:03:19 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
2008-11-04 00:35:37 +01:00
|
|
|
if (mode == MANAGE || mode == GROW) {
|
2008-11-04 00:35:31 +01:00
|
|
|
mdfd = open_mddev(devlist->devname, 1);
|
2008-11-04 00:35:37 +01:00
|
|
|
if (mdfd < 0)
|
|
|
|
exit(1);
|
2021-12-03 15:31:15 +01:00
|
|
|
} else {
|
|
|
|
char *bname = basename(devlist->devname);
|
|
|
|
|
|
|
|
if (strlen(bname) > MD_NAME_MAX) {
|
|
|
|
pr_err("Name %s is too long.\n", devlist->devname);
|
|
|
|
exit(1);
|
|
|
|
}
|
2008-11-04 00:35:37 +01:00
|
|
|
/* non-existent device is OK */
|
|
|
|
mdfd = open_mddev(devlist->devname, 0);
|
2021-12-03 15:31:15 +01:00
|
|
|
}
|
2008-11-04 00:35:37 +01:00
|
|
|
if (mdfd == -2) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("device %s exists but is not an md array.\n", devlist->devname);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(1);
|
2008-11-04 00:35:37 +01:00
|
|
|
}
|
2004-01-22 03:10:29 +01:00
|
|
|
if ((int)ident.super_minor == -2) {
|
2003-03-03 00:11:38 +01:00
|
|
|
struct stat stb;
|
2008-11-04 00:35:37 +01:00
|
|
|
if (mdfd < 0) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("--super-minor=dev given, and listed device %s doesn't exist.\n",
|
2008-11-04 00:35:37 +01:00
|
|
|
devlist->devname);
|
|
|
|
exit(1);
|
|
|
|
}
|
2003-03-03 00:11:38 +01:00
|
|
|
fstat(mdfd, &stb);
|
2005-04-04 07:16:13 +02:00
|
|
|
ident.super_minor = minor(stb.st_rdev);
|
2003-03-03 00:11:38 +01:00
|
|
|
}
|
2008-11-04 00:35:37 +01:00
|
|
|
if (mdfd >= 0 && mode != MANAGE && mode != GROW) {
|
|
|
|
/* We don't really want this open yet, we just might
|
|
|
|
* have wanted to check some things
|
|
|
|
*/
|
|
|
|
close(mdfd);
|
|
|
|
mdfd = -1;
|
|
|
|
}
|
2001-06-08 04:36:23 +02:00
|
|
|
}
|
2001-08-23 04:33:20 +02:00
|
|
|
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.raiddisks) {
|
|
|
|
if (s.raiddisks == 1 && !c.force && s.level != LEVEL_FAULTY) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("'1' is an unusual number of drives for an array, so it is probably\n"
|
2005-06-08 01:03:45 +02:00
|
|
|
" a mistake. If you really mean it you will need to specify --force before\n"
|
|
|
|
" setting the number of drives.\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
}
|
2005-06-08 01:16:35 +02:00
|
|
|
|
2015-07-24 04:50:54 +02:00
|
|
|
if (c.homehost == NULL && c.require_homehost)
|
2012-07-09 09:17:33 +02:00
|
|
|
c.homehost = conf_get_homehost(&c.require_homehost);
|
2016-03-09 20:37:46 +01:00
|
|
|
if (c.homehost == NULL || strcasecmp(c.homehost, "<system>") == 0) {
|
2006-05-19 08:56:06 +02:00
|
|
|
if (gethostname(sys_hostname, sizeof(sys_hostname)) == 0) {
|
|
|
|
sys_hostname[sizeof(sys_hostname)-1] = 0;
|
2012-07-09 09:17:33 +02:00
|
|
|
c.homehost = sys_hostname;
|
2006-05-19 08:56:06 +02:00
|
|
|
}
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
if (c.homehost &&
|
|
|
|
(!c.homehost[0] || strcasecmp(c.homehost, "<none>") == 0)) {
|
2012-07-09 09:17:33 +02:00
|
|
|
c.homehost = NULL;
|
|
|
|
c.require_homehost = 0;
|
2011-05-10 08:17:12 +02:00
|
|
|
}
|
2006-05-19 07:50:08 +02:00
|
|
|
|
2015-08-05 06:53:33 +02:00
|
|
|
rv = 0;
|
2015-10-19 10:03:20 +02:00
|
|
|
|
|
|
|
set_hooks(); /* set hooks from libs */
|
|
|
|
|
2015-06-10 07:42:06 +02:00
|
|
|
if (c.homecluster == NULL && (c.nodes > 0)) {
|
|
|
|
c.homecluster = conf_get_homecluster();
|
|
|
|
if (c.homecluster == NULL)
|
|
|
|
rv = get_cluster_name(&c.homecluster);
|
2015-08-05 06:53:33 +02:00
|
|
|
if (rv) {
|
2015-06-10 07:42:06 +02:00
|
|
|
pr_err("The md can't get cluster name\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-27 03:14:20 +02:00
|
|
|
if (c.update && strcmp(c.update, "nodes") == 0 && c.nodes == 0) {
|
|
|
|
pr_err("Please specify nodes number with --nodes\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-05-21 08:40:23 +02:00
|
|
|
if (c.backup_file && data_offset != INVALID_SECTORS) {
|
|
|
|
pr_err("--backup-file and --data-offset are incompatible\n");
|
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
|
2016-03-09 20:37:46 +01:00
|
|
|
if ((mode == MISC && devmode == 'E') ||
|
|
|
|
(mode == MONITOR && spare_sharing == 0))
|
2012-07-09 09:00:50 +02:00
|
|
|
/* Anyone may try this */;
|
|
|
|
else if (geteuid() != 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("must be super-user to perform this action\n");
|
2010-02-01 00:22:38 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2012-07-09 09:17:33 +02:00
|
|
|
ident.autof = c.autof;
|
2008-11-04 00:35:37 +01:00
|
|
|
|
2012-07-09 09:19:48 +02:00
|
|
|
if (c.scan && c.verbose < 2)
|
|
|
|
/* --scan implied --brief unless -vv */
|
|
|
|
c.brief = 1;
|
|
|
|
|
2018-01-22 10:12:08 +01:00
|
|
|
if (mode == CREATE) {
|
|
|
|
if (s.bitmap_file && strcmp(s.bitmap_file, "clustered") == 0) {
|
|
|
|
locked = cluster_get_dlmlock();
|
|
|
|
if (locked != 1)
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
} else if (mode == MANAGE || mode == GROW || mode == INCREMENTAL) {
|
|
|
|
if (!md_get_array_info(mdfd, &array) && (devmode != 'c')) {
|
|
|
|
if (array.state & (1 << MD_SB_CLUSTERED)) {
|
|
|
|
locked = cluster_get_dlmlock();
|
|
|
|
if (locked != 1)
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
switch(mode) {
|
2002-04-04 03:58:32 +02:00
|
|
|
case MANAGE:
|
2001-08-23 04:33:20 +02:00
|
|
|
/* readonly, add/remove, readwrite, runstop */
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.readonly > 0)
|
|
|
|
rv = Manage_ro(devlist->devname, mdfd, c.readonly);
|
2001-08-23 04:33:20 +02:00
|
|
|
if (!rv && devs_found>1)
|
2002-03-07 00:17:40 +01:00
|
|
|
rv = Manage_subdevs(devlist->devname, mdfd,
|
2012-07-09 09:18:48 +02:00
|
|
|
devlist->next, c.verbose, c.test,
|
2012-07-09 09:17:33 +02:00
|
|
|
c.update, c.force);
|
|
|
|
if (!rv && c.readonly < 0)
|
|
|
|
rv = Manage_ro(devlist->devname, mdfd, c.readonly);
|
2013-06-19 03:23:44 +02:00
|
|
|
if (!rv && c.runstop > 0)
|
2013-09-13 02:51:20 +02:00
|
|
|
rv = Manage_run(devlist->devname, mdfd, &c);
|
2013-06-19 03:23:44 +02:00
|
|
|
if (!rv && c.runstop < 0)
|
|
|
|
rv = Manage_stop(devlist->devname, mdfd, c.verbose, 0);
|
2001-08-23 04:33:20 +02:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
case ASSEMBLE:
|
2020-01-17 15:24:04 +01:00
|
|
|
if (!c.scan && c.runstop == -1) {
|
|
|
|
pr_err("--no-degraded not meaningful without a --scan assembly.\n");
|
|
|
|
exit(1);
|
|
|
|
} else if (devs_found == 1 && ident.uuid_set == 0 &&
|
|
|
|
ident.super_minor == UnSet && ident.name[0] == 0 &&
|
|
|
|
!c.scan) {
|
2003-03-03 00:11:38 +01:00
|
|
|
/* Only a device has been given, so get details from config file */
|
2010-11-22 10:58:05 +01:00
|
|
|
struct mddev_ident *array_ident = conf_get_ident(devlist->devname);
|
2004-11-01 05:49:34 +01:00
|
|
|
if (array_ident == NULL) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("%s not identified in config file.\n",
|
2004-11-01 05:49:34 +01:00
|
|
|
devlist->devname);
|
2003-03-03 00:11:38 +01:00
|
|
|
rv |= 1;
|
2008-11-04 00:35:37 +01:00
|
|
|
if (mdfd >= 0)
|
|
|
|
close(mdfd);
|
2004-11-01 05:49:34 +01:00
|
|
|
} else {
|
2008-11-04 00:35:37 +01:00
|
|
|
if (array_ident->autof == 0)
|
2012-07-09 09:17:33 +02:00
|
|
|
array_ident->autof = c.autof;
|
2008-11-04 00:35:37 +01:00
|
|
|
rv |= Assemble(ss, devlist->devname, array_ident,
|
2012-07-09 09:19:07 +02:00
|
|
|
NULL, &c);
|
2003-03-03 00:11:38 +01:00
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
} else if (!c.scan)
|
2008-11-04 00:35:37 +01:00
|
|
|
rv = Assemble(ss, devlist->devname, &ident,
|
2012-07-09 09:19:07 +02:00
|
|
|
devlist->next, &c);
|
2012-07-09 09:00:50 +02:00
|
|
|
else if (devs_found > 0) {
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.update && devs_found > 1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("can only update a single array at a time\n");
|
2003-02-12 01:17:26 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.backup_file && devs_found > 1) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("can only assemble a single array when providing a backup file.\n");
|
2006-03-27 08:38:46 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2017-03-29 18:02:14 +02:00
|
|
|
for (dv = devlist; dv; dv = dv->next) {
|
2010-11-22 10:58:05 +01:00
|
|
|
struct mddev_ident *array_ident = conf_get_ident(dv->devname);
|
2001-08-23 04:33:20 +02:00
|
|
|
if (array_ident == NULL) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("%s not identified in config file.\n",
|
2002-03-07 00:17:40 +01:00
|
|
|
dv->devname);
|
2001-08-23 04:33:20 +02:00
|
|
|
rv |= 1;
|
|
|
|
continue;
|
|
|
|
}
|
2008-11-04 00:35:37 +01:00
|
|
|
if (array_ident->autof == 0)
|
2012-07-09 09:17:33 +02:00
|
|
|
array_ident->autof = c.autof;
|
2008-11-04 00:35:37 +01:00
|
|
|
rv |= Assemble(ss, dv->devname, array_ident,
|
2012-07-09 09:19:07 +02:00
|
|
|
NULL, &c);
|
2001-08-23 04:33:20 +02:00
|
|
|
}
|
2003-02-12 01:17:26 +01:00
|
|
|
} else {
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.update) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--update not meaningful with a --scan assembly.\n");
|
2006-05-26 02:50:15 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.backup_file) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--backup_file not meaningful with a --scan assembly.\n");
|
2006-05-26 02:50:15 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-07-09 09:19:07 +02:00
|
|
|
rv = scan_assemble(ss, &c, &ident);
|
2001-08-23 04:33:20 +02:00
|
|
|
}
|
2012-07-09 09:14:10 +02:00
|
|
|
|
2001-08-23 04:33:20 +02:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
case BUILD:
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.delay == 0)
|
|
|
|
c.delay = DEFAULT_BITMAP_DELAY;
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.write_behind && !s.bitmap_file) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("write-behind mode requires a bitmap.\n");
|
2005-08-09 06:25:47 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.raiddisks == 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("no raid-devices specified.\n");
|
2007-05-21 06:25:47 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-08-09 06:25:47 +02:00
|
|
|
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.bitmap_file) {
|
2016-03-09 20:37:46 +01:00
|
|
|
if (strcmp(s.bitmap_file, "internal") == 0 ||
|
2015-08-18 23:38:27 +02:00
|
|
|
strcmp(s.bitmap_file, "clustered") == 0) {
|
|
|
|
pr_err("'internal' and 'clustered' bitmaps not supported with --build\n");
|
2005-06-08 01:03:47 +02:00
|
|
|
rv |= 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-06-08 01:16:35 +02:00
|
|
|
}
|
2012-07-09 09:21:57 +02:00
|
|
|
rv = Build(devlist->devname, devlist->next, &s, &c);
|
2001-08-23 04:33:20 +02:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
case CREATE:
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.delay == 0)
|
|
|
|
c.delay = DEFAULT_BITMAP_DELAY;
|
2015-06-10 07:42:05 +02:00
|
|
|
|
|
|
|
if (c.nodes) {
|
2016-03-09 20:37:46 +01:00
|
|
|
if (!s.bitmap_file ||
|
|
|
|
strcmp(s.bitmap_file, "clustered") != 0) {
|
2015-06-10 07:42:05 +02:00
|
|
|
pr_err("--nodes argument only compatible with --bitmap=clustered\n");
|
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-10-30 10:09:51 +01:00
|
|
|
if (s.level != 1 && s.level != 10) {
|
|
|
|
pr_err("--bitmap=clustered is currently supported with raid1/10 only\n");
|
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2018-01-03 08:01:22 +01:00
|
|
|
if (s.level == 10 && !(is_near_layout_10(s.layout) || s.layout == UnSet)) {
|
2017-10-30 10:09:51 +01:00
|
|
|
pr_err("only near layout is supported with clustered raid10\n");
|
2015-06-10 07:42:05 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.write_behind && !s.bitmap_file) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("write-behind mode requires a bitmap.\n");
|
2005-08-09 06:25:47 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.raiddisks == 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("no raid-devices specified.\n");
|
2007-05-21 06:25:47 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-05-04 01:44:32 +02:00
|
|
|
|
2012-07-09 09:22:05 +02:00
|
|
|
rv = Create(ss, devlist->devname,
|
|
|
|
ident.name, ident.uuid_set ? ident.uuid : NULL,
|
2012-07-09 09:19:24 +02:00
|
|
|
devs_found-1, devlist->next,
|
2012-10-04 08:34:21 +02:00
|
|
|
&s, &c, data_offset);
|
2001-08-23 04:33:20 +02:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
case MISC:
|
|
|
|
if (devmode == 'E') {
|
2012-07-09 09:17:33 +02:00
|
|
|
if (devlist == NULL && !c.scan) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No devices to examine\n");
|
2002-04-04 03:58:32 +02:00
|
|
|
exit(2);
|
|
|
|
}
|
|
|
|
if (devlist == NULL)
|
2006-06-26 07:11:01 +02:00
|
|
|
devlist = conf_get_devs();
|
2002-04-04 03:58:32 +02:00
|
|
|
if (devlist == NULL) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No devices listed in %s\n", configfile?configfile:DefaultConfFile);
|
2002-04-04 03:58:32 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-07-09 09:20:00 +02:00
|
|
|
rv = Examine(devlist, &c, ss);
|
2008-12-09 00:59:18 +01:00
|
|
|
} else if (devmode == DetailPlatform) {
|
2012-10-04 08:34:11 +02:00
|
|
|
rv = Detail_Platform(ss ? ss->ss : NULL, ss ? c.scan : 1,
|
|
|
|
c.verbose, c.export,
|
|
|
|
devlist ? devlist->devname : NULL);
|
2012-07-09 09:14:16 +02:00
|
|
|
} else if (devlist == NULL) {
|
2012-07-09 09:17:33 +02:00
|
|
|
if (devmode == 'S' && c.scan)
|
2012-07-09 09:18:48 +02:00
|
|
|
rv = stop_scan(c.verbose);
|
2016-03-09 20:37:46 +01:00
|
|
|
else if ((devmode == 'D' || devmode == Waitclean) &&
|
|
|
|
c.scan)
|
2012-07-09 09:20:16 +02:00
|
|
|
rv = misc_scan(devmode, &c);
|
2012-07-09 09:14:16 +02:00
|
|
|
else if (devmode == UdevRules)
|
|
|
|
rv = Write_rules(udev_filename);
|
|
|
|
else {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No devices given.\n");
|
2012-07-09 09:14:16 +02:00
|
|
|
exit(2);
|
2002-04-04 03:58:32 +02:00
|
|
|
}
|
2012-07-09 09:14:16 +02:00
|
|
|
} else
|
2013-05-16 07:07:16 +02:00
|
|
|
rv = misc_list(devlist, &ident, dump_directory, ss, &c);
|
2002-03-08 01:03:52 +01:00
|
|
|
break;
|
2002-04-04 03:58:32 +02:00
|
|
|
case MONITOR:
|
2012-07-09 09:17:33 +02:00
|
|
|
if (!devlist && !c.scan) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("Cannot monitor: need --scan or at least one device\n");
|
2002-04-04 03:58:32 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2004-11-01 05:49:34 +01:00
|
|
|
if (pidfile && !daemonise) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("Cannot write a pid file when not in daemon mode\n");
|
2004-11-01 05:49:34 +01:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.delay == 0) {
|
2021-07-30 11:16:00 +02:00
|
|
|
c.delay = conf_get_monitor_delay();
|
|
|
|
if (!c.delay)
|
2012-07-09 09:17:33 +02:00
|
|
|
c.delay = 60;
|
2009-06-02 06:35:44 +02:00
|
|
|
}
|
2017-03-29 18:02:14 +02:00
|
|
|
rv = Monitor(devlist, mailaddr, program,
|
|
|
|
&c, daemonise, oneshot,
|
|
|
|
dosyslog, pidfile, increments,
|
|
|
|
spare_sharing);
|
2002-03-08 01:03:52 +01:00
|
|
|
break;
|
2004-06-04 14:03:19 +02:00
|
|
|
|
|
|
|
case GROW:
|
2012-07-09 09:21:06 +02:00
|
|
|
if (array_size > 0) {
|
2009-07-13 07:00:02 +02:00
|
|
|
/* alway impose array size first, independent of
|
|
|
|
* anything else
|
2009-11-06 07:26:47 +01:00
|
|
|
* Do not allow level or raid_disks changes at the
|
|
|
|
* same time as that can be irreversibly destructive.
|
2009-07-13 07:00:02 +02:00
|
|
|
*/
|
|
|
|
struct mdinfo sra;
|
|
|
|
int err;
|
2012-07-09 09:21:38 +02:00
|
|
|
if (s.raiddisks || s.level != UnSet) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("cannot change array size in same operation as changing raiddisks or level.\n"
|
2009-11-06 07:26:47 +01:00
|
|
|
" Change size first, then check that data is still intact.\n");
|
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2017-03-30 22:52:37 +02:00
|
|
|
if (sysfs_init(&sra, mdfd, NULL)) {
|
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:21:06 +02:00
|
|
|
if (array_size == MAX_SIZE)
|
2009-07-13 07:00:02 +02:00
|
|
|
err = sysfs_set_str(&sra, NULL, "array_size", "default");
|
|
|
|
else
|
|
|
|
err = sysfs_set_num(&sra, NULL, "array_size", array_size / 2);
|
|
|
|
if (err < 0) {
|
|
|
|
if (errno == E2BIG)
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("--array-size setting is too large.\n");
|
2009-07-13 07:00:02 +02:00
|
|
|
else
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("current kernel does not support setting --array-size\n");
|
2009-07-13 07:00:02 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-06-24 08:13:00 +02:00
|
|
|
if (devs_found > 1 && s.raiddisks == 0 && s.level == UnSet) {
|
2004-08-11 04:16:01 +02:00
|
|
|
/* must be '-a'. */
|
2016-03-09 20:37:46 +01:00
|
|
|
if (s.size > 0 || s.chunk ||
|
|
|
|
s.layout_str || s.bitmap_file) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("--add cannot be used with other geometry changes in --grow mode\n");
|
2004-08-11 04:16:01 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2017-03-29 18:02:14 +02:00
|
|
|
for (dv = devlist->next; dv; dv = dv->next) {
|
2011-03-10 05:05:23 +01:00
|
|
|
rv = Grow_Add_device(devlist->devname, mdfd,
|
|
|
|
dv->devname);
|
2004-08-11 04:16:01 +02:00
|
|
|
if (rv)
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:21:38 +02:00
|
|
|
} else if (s.bitmap_file) {
|
|
|
|
if (s.size > 0 || s.raiddisks || s.chunk ||
|
2016-03-09 20:37:46 +01:00
|
|
|
s.layout_str || devs_found > 1) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("--bitmap changes cannot be used with other geometry changes in --grow mode\n");
|
2009-08-11 05:02:49 +02:00
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.delay == 0)
|
|
|
|
c.delay = DEFAULT_BITMAP_DELAY;
|
2012-07-09 09:22:12 +02:00
|
|
|
rv = Grow_addbitmap(devlist->devname, mdfd, &c, &s);
|
2011-10-03 00:26:48 +02:00
|
|
|
} else if (grow_continue)
|
|
|
|
rv = Grow_continue_command(devlist->devname,
|
2012-07-09 09:17:33 +02:00
|
|
|
mdfd, c.backup_file,
|
2012-07-09 09:18:48 +02:00
|
|
|
c.verbose);
|
2016-03-09 20:37:46 +01:00
|
|
|
else if (s.size > 0 || s.raiddisks || s.layout_str ||
|
|
|
|
s.chunk != 0 || s.level != UnSet ||
|
|
|
|
data_offset != INVALID_SECTORS) {
|
2012-07-09 09:22:09 +02:00
|
|
|
rv = Grow_reshape(devlist->devname, mdfd,
|
2012-10-04 08:34:21 +02:00
|
|
|
devlist->next,
|
|
|
|
data_offset, &c, &s);
|
2017-04-24 16:03:26 +02:00
|
|
|
} else if (s.consistency_policy != CONSISTENCY_POLICY_UNKNOWN) {
|
2017-03-29 11:54:20 +02:00
|
|
|
rv = Grow_consistency_policy(devlist->devname, mdfd, &c, &s);
|
2012-07-09 09:21:06 +02:00
|
|
|
} else if (array_size == 0)
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("no changes to --grow\n");
|
2004-06-04 14:03:19 +02:00
|
|
|
break;
|
2006-12-21 07:10:52 +01:00
|
|
|
case INCREMENTAL:
|
|
|
|
if (rebuild_map) {
|
|
|
|
RebuildMap();
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.scan) {
|
2013-09-15 01:14:25 +02:00
|
|
|
rv = 1;
|
|
|
|
if (devlist) {
|
|
|
|
pr_err("In --incremental mode, a device cannot be given with --scan.\n");
|
|
|
|
break;
|
|
|
|
}
|
2012-07-09 09:17:33 +02:00
|
|
|
if (c.runstop <= 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--incremental --scan meaningless without --run.\n");
|
2006-12-21 07:10:52 +01:00
|
|
|
break;
|
|
|
|
}
|
2010-06-30 08:55:17 +02:00
|
|
|
if (devmode == 'f') {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--incremental --scan --fail not supported.\n");
|
2010-06-30 08:55:17 +02:00
|
|
|
break;
|
|
|
|
}
|
2013-09-13 02:51:20 +02:00
|
|
|
rv = IncrementalScan(&c, NULL);
|
2006-12-21 07:10:52 +01:00
|
|
|
}
|
|
|
|
if (!devlist) {
|
2012-07-09 09:17:33 +02:00
|
|
|
if (!rebuild_map && !c.scan) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("--incremental requires a device.\n");
|
2006-12-21 07:10:52 +01:00
|
|
|
rv = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2013-12-03 04:01:24 +01:00
|
|
|
if (devmode == 'f') {
|
|
|
|
if (devlist->next) {
|
|
|
|
pr_err("'--incremental --fail' can only handle one device.\n");
|
|
|
|
rv = 1;
|
|
|
|
break;
|
|
|
|
}
|
2010-11-22 10:58:06 +01:00
|
|
|
rv = IncrementalRemove(devlist->devname, remove_path,
|
2012-07-09 09:18:48 +02:00
|
|
|
c.verbose);
|
2013-12-03 04:01:24 +01:00
|
|
|
} else
|
|
|
|
rv = Incremental(devlist, &c, ss);
|
2007-05-21 06:25:44 +02:00
|
|
|
break;
|
|
|
|
case AUTODETECT:
|
|
|
|
autodetect();
|
|
|
|
break;
|
2001-06-08 04:36:23 +02:00
|
|
|
}
|
2018-01-22 10:12:08 +01:00
|
|
|
if (locked)
|
|
|
|
cluster_release_dlmlock();
|
2021-11-24 11:48:33 +01:00
|
|
|
close_fd(&mdfd);
|
2001-08-23 04:33:20 +02:00
|
|
|
exit(rv);
|
2001-06-08 04:36:23 +02:00
|
|
|
}
|
2012-07-09 09:14:10 +02:00
|
|
|
|
2012-07-09 09:19:07 +02:00
|
|
|
static int scan_assemble(struct supertype *ss,
|
|
|
|
struct context *c,
|
|
|
|
struct mddev_ident *ident)
|
2012-07-09 09:14:10 +02:00
|
|
|
{
|
|
|
|
struct mddev_ident *a, *array_list = conf_get_ident(NULL);
|
|
|
|
struct mddev_dev *devlist = conf_get_devs();
|
|
|
|
struct map_ent *map = NULL;
|
|
|
|
int cnt = 0;
|
|
|
|
int rv = 0;
|
|
|
|
int failures, successes;
|
|
|
|
|
|
|
|
if (conf_verify_devnames(array_list)) {
|
2015-02-12 03:46:53 +01:00
|
|
|
pr_err("Duplicate MD device names in conf file were found.\n");
|
2012-07-09 09:14:10 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (devlist == NULL) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No devices listed in conf file were found.\n");
|
2012-07-09 09:14:10 +02:00
|
|
|
return 1;
|
|
|
|
}
|
2017-03-29 18:02:14 +02:00
|
|
|
for (a = array_list; a; a = a->next) {
|
2012-07-09 09:14:10 +02:00
|
|
|
a->assembled = 0;
|
|
|
|
if (a->autof == 0)
|
2012-07-09 09:19:07 +02:00
|
|
|
a->autof = c->autof;
|
2012-07-09 09:14:10 +02:00
|
|
|
}
|
|
|
|
if (map_lock(&map))
|
2015-02-12 03:21:17 +01:00
|
|
|
pr_err("failed to get exclusive lock on mapfile\n");
|
2012-07-09 09:14:10 +02:00
|
|
|
do {
|
|
|
|
failures = 0;
|
|
|
|
successes = 0;
|
|
|
|
rv = 0;
|
2017-03-29 18:02:14 +02:00
|
|
|
for (a = array_list; a; a = a->next) {
|
2012-07-09 09:14:10 +02:00
|
|
|
int r;
|
|
|
|
if (a->assembled)
|
|
|
|
continue;
|
|
|
|
if (a->devname &&
|
|
|
|
strcasecmp(a->devname, "<ignore>") == 0)
|
|
|
|
continue;
|
2013-06-19 04:31:45 +02:00
|
|
|
|
2012-07-09 09:14:10 +02:00
|
|
|
r = Assemble(ss, a->devname,
|
2012-07-09 09:19:07 +02:00
|
|
|
a, NULL, c);
|
2012-07-09 09:14:10 +02:00
|
|
|
if (r == 0) {
|
|
|
|
a->assembled = 1;
|
|
|
|
successes++;
|
|
|
|
} else
|
|
|
|
failures++;
|
|
|
|
rv |= r;
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
} while (failures && successes);
|
2012-07-09 09:19:07 +02:00
|
|
|
if (c->homehost && cnt == 0) {
|
2012-07-09 09:14:10 +02:00
|
|
|
/* Maybe we can auto-assemble something.
|
|
|
|
* Repeatedly call Assemble in auto-assemble mode
|
|
|
|
* until it fails
|
|
|
|
*/
|
|
|
|
int rv2;
|
|
|
|
int acnt;
|
2012-07-09 09:19:07 +02:00
|
|
|
ident->autof = c->autof;
|
2012-07-09 09:14:10 +02:00
|
|
|
do {
|
|
|
|
struct mddev_dev *devlist = conf_get_devs();
|
|
|
|
acnt = 0;
|
|
|
|
do {
|
|
|
|
rv2 = Assemble(ss, NULL,
|
|
|
|
ident,
|
2012-07-09 09:19:07 +02:00
|
|
|
devlist, c);
|
2016-03-09 20:37:46 +01:00
|
|
|
if (rv2 == 0) {
|
2012-07-09 09:14:10 +02:00
|
|
|
cnt++;
|
|
|
|
acnt++;
|
|
|
|
}
|
2016-03-09 20:37:46 +01:00
|
|
|
} while (rv2 != 2);
|
2012-07-09 09:14:10 +02:00
|
|
|
/* Incase there are stacked devices, we need to go around again */
|
|
|
|
} while (acnt);
|
|
|
|
if (cnt == 0 && rv == 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No arrays found in config file or automatically\n");
|
2012-07-09 09:14:10 +02:00
|
|
|
rv = 1;
|
|
|
|
} else if (cnt)
|
|
|
|
rv = 0;
|
|
|
|
} else if (cnt == 0 && rv == 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("No arrays found in config file\n");
|
2012-07-09 09:14:10 +02:00
|
|
|
rv = 1;
|
|
|
|
}
|
|
|
|
map_unlock(&map);
|
|
|
|
return rv;
|
|
|
|
}
|
2012-07-09 09:14:16 +02:00
|
|
|
|
2012-07-09 09:20:16 +02:00
|
|
|
static int misc_scan(char devmode, struct context *c)
|
2012-07-09 09:14:16 +02:00
|
|
|
{
|
|
|
|
/* apply --detail or --wait-clean to
|
|
|
|
* all devices in /proc/mdstat
|
|
|
|
*/
|
|
|
|
struct mdstat_ent *ms = mdstat_read(0, 1);
|
|
|
|
struct mdstat_ent *e;
|
|
|
|
struct map_ent *map = NULL;
|
|
|
|
int members;
|
|
|
|
int rv = 0;
|
|
|
|
|
|
|
|
for (members = 0; members <= 1; members++) {
|
2017-03-29 18:02:14 +02:00
|
|
|
for (e = ms; e; e = e->next) {
|
2013-05-13 04:56:38 +02:00
|
|
|
char *name = NULL;
|
2012-07-09 09:14:16 +02:00
|
|
|
struct map_ent *me;
|
2013-05-13 04:56:38 +02:00
|
|
|
struct stat stb;
|
2012-07-09 09:14:16 +02:00
|
|
|
int member = e->metadata_version &&
|
|
|
|
strncmp(e->metadata_version,
|
|
|
|
"external:/", 10) == 0;
|
|
|
|
if (members != member)
|
|
|
|
continue;
|
2012-11-01 06:14:01 +01:00
|
|
|
me = map_by_devnm(&map, e->devnm);
|
2017-05-16 19:52:15 +02:00
|
|
|
if (me && me->path && strcmp(me->path, "/unknown") != 0)
|
2012-07-09 09:14:16 +02:00
|
|
|
name = me->path;
|
2016-03-09 20:37:46 +01:00
|
|
|
if (name == NULL || stat(name, &stb) != 0)
|
2012-11-01 06:14:01 +01:00
|
|
|
name = get_md_name(e->devnm);
|
2012-07-09 09:14:16 +02:00
|
|
|
|
|
|
|
if (!name) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("cannot find device file for %s\n",
|
2015-07-02 00:15:10 +02:00
|
|
|
e->devnm);
|
2012-07-09 09:14:16 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (devmode == 'D')
|
2012-07-09 09:20:16 +02:00
|
|
|
rv |= Detail(name, c);
|
2012-07-09 09:14:16 +02:00
|
|
|
else
|
2017-11-21 11:30:20 +01:00
|
|
|
rv |= WaitClean(name, c->verbose);
|
2012-07-09 09:14:16 +02:00
|
|
|
put_md_name(name);
|
2018-06-11 11:03:44 +02:00
|
|
|
map_free(map);
|
|
|
|
map = NULL;
|
2012-07-09 09:14:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mdstat(ms);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2012-07-09 09:18:09 +02:00
|
|
|
static int stop_scan(int verbose)
|
2012-07-09 09:14:16 +02:00
|
|
|
{
|
|
|
|
/* apply --stop to all devices in /proc/mdstat */
|
|
|
|
/* Due to possible stacking of devices, repeat until
|
|
|
|
* nothing more can be stopped
|
|
|
|
*/
|
2017-03-29 18:02:14 +02:00
|
|
|
int progress = 1, err;
|
2012-07-09 09:14:16 +02:00
|
|
|
int last = 0;
|
|
|
|
int rv = 0;
|
|
|
|
do {
|
|
|
|
struct mdstat_ent *ms = mdstat_read(0, 0);
|
|
|
|
struct mdstat_ent *e;
|
|
|
|
|
|
|
|
if (!progress) last = 1;
|
|
|
|
progress = 0; err = 0;
|
2017-03-29 18:02:14 +02:00
|
|
|
for (e = ms; e; e = e->next) {
|
2012-11-01 06:14:01 +01:00
|
|
|
char *name = get_md_name(e->devnm);
|
2012-07-09 09:14:16 +02:00
|
|
|
int mdfd;
|
|
|
|
|
|
|
|
if (!name) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("cannot find device file for %s\n",
|
2015-07-02 00:15:10 +02:00
|
|
|
e->devnm);
|
2012-07-09 09:14:16 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mdfd = open_mddev(name, 1);
|
|
|
|
if (mdfd >= 0) {
|
2013-06-19 03:23:44 +02:00
|
|
|
if (Manage_stop(name, mdfd, verbose, !last))
|
2012-07-09 09:14:16 +02:00
|
|
|
err = 1;
|
|
|
|
else
|
|
|
|
progress = 1;
|
|
|
|
close(mdfd);
|
|
|
|
}
|
|
|
|
|
|
|
|
put_md_name(name);
|
|
|
|
}
|
|
|
|
free_mdstat(ms);
|
|
|
|
} while (!last && err);
|
|
|
|
if (err)
|
|
|
|
rv |= 1;
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int misc_list(struct mddev_dev *devlist,
|
2012-07-09 09:19:17 +02:00
|
|
|
struct mddev_ident *ident,
|
2013-05-16 07:07:16 +02:00
|
|
|
char *dump_directory,
|
2012-07-09 09:19:17 +02:00
|
|
|
struct supertype *ss, struct context *c)
|
2012-07-09 09:14:16 +02:00
|
|
|
{
|
|
|
|
struct mddev_dev *dv;
|
|
|
|
int rv = 0;
|
|
|
|
|
2017-03-29 18:02:14 +02:00
|
|
|
for (dv = devlist; dv; dv = (rv & 16) ? NULL : dv->next) {
|
2017-04-10 06:49:52 +02:00
|
|
|
int mdfd = -1;
|
2012-07-09 09:14:16 +02:00
|
|
|
|
|
|
|
switch(dv->disposition) {
|
|
|
|
case 'D':
|
2012-07-09 09:20:16 +02:00
|
|
|
rv |= Detail(dv->devname, c);
|
2012-07-09 09:14:16 +02:00
|
|
|
continue;
|
|
|
|
case KillOpt: /* Zero superblock */
|
|
|
|
if (ss)
|
2012-07-09 09:19:17 +02:00
|
|
|
rv |= Kill(dv->devname, ss, c->force, c->verbose,0);
|
2012-07-09 09:14:16 +02:00
|
|
|
else {
|
2012-07-09 09:19:17 +02:00
|
|
|
int v = c->verbose;
|
2012-07-09 09:14:16 +02:00
|
|
|
do {
|
2012-07-09 09:19:17 +02:00
|
|
|
rv |= Kill(dv->devname, NULL, c->force, v, 0);
|
2012-07-09 09:18:09 +02:00
|
|
|
v = -1;
|
2012-07-09 09:14:16 +02:00
|
|
|
} while (rv == 0);
|
2018-09-03 13:52:55 +02:00
|
|
|
rv &= ~4;
|
2012-07-09 09:14:16 +02:00
|
|
|
}
|
|
|
|
continue;
|
|
|
|
case 'Q':
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= Query(dv->devname);
|
|
|
|
continue;
|
2012-07-09 09:14:16 +02:00
|
|
|
case 'X':
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= ExamineBitmap(dv->devname, c->brief, ss);
|
|
|
|
continue;
|
2012-12-05 02:56:31 +01:00
|
|
|
case ExamineBB:
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= ExamineBadblocks(dv->devname, c->brief, ss);
|
|
|
|
continue;
|
2012-07-09 09:14:16 +02:00
|
|
|
case 'W':
|
|
|
|
case WaitOpt:
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= Wait(dv->devname);
|
|
|
|
continue;
|
2012-07-09 09:14:16 +02:00
|
|
|
case Waitclean:
|
2017-11-21 11:30:20 +01:00
|
|
|
rv |= WaitClean(dv->devname, c->verbose);
|
2017-03-29 17:55:19 +02:00
|
|
|
continue;
|
2012-07-09 09:14:16 +02:00
|
|
|
case KillSubarray:
|
2012-07-09 09:19:17 +02:00
|
|
|
rv |= Kill_subarray(dv->devname, c->subarray, c->verbose);
|
2012-07-09 09:14:16 +02:00
|
|
|
continue;
|
|
|
|
case UpdateSubarray:
|
2012-07-09 09:19:17 +02:00
|
|
|
if (c->update == NULL) {
|
2012-07-09 09:14:16 +02:00
|
|
|
pr_err("-U/--update must be specified with --update-subarray\n");
|
2012-07-09 09:14:16 +02:00
|
|
|
rv |= 1;
|
|
|
|
continue;
|
|
|
|
}
|
2012-07-09 09:19:17 +02:00
|
|
|
rv |= Update_subarray(dv->devname, c->subarray,
|
|
|
|
c->update, ident, c->verbose);
|
2012-07-09 09:14:16 +02:00
|
|
|
continue;
|
2013-05-16 07:07:16 +02:00
|
|
|
case Dump:
|
|
|
|
rv |= Dump_metadata(dv->devname, dump_directory, c, ss);
|
|
|
|
continue;
|
|
|
|
case Restore:
|
|
|
|
rv |= Restore_metadata(dv->devname, dump_directory, c, ss,
|
|
|
|
(dv == devlist && dv->next == NULL));
|
|
|
|
continue;
|
2014-05-22 07:55:31 +02:00
|
|
|
case Action:
|
|
|
|
rv |= SetAction(dv->devname, c->action);
|
|
|
|
continue;
|
2012-07-09 09:14:16 +02:00
|
|
|
}
|
2017-03-30 18:58:13 +02:00
|
|
|
|
|
|
|
if (dv->devname[0] != '/')
|
|
|
|
mdfd = open_dev(dv->devname);
|
|
|
|
if (dv->devname[0] == '/' || mdfd < 0)
|
|
|
|
mdfd = open_mddev(dv->devname, 1);
|
|
|
|
|
2017-03-29 18:02:14 +02:00
|
|
|
if (mdfd >= 0) {
|
2012-07-09 09:14:16 +02:00
|
|
|
switch(dv->disposition) {
|
|
|
|
case 'R':
|
2013-09-13 02:51:20 +02:00
|
|
|
c->runstop = 1;
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= Manage_run(dv->devname, mdfd, c);
|
|
|
|
break;
|
2012-07-09 09:14:16 +02:00
|
|
|
case 'S':
|
2021-05-05 13:01:02 +02:00
|
|
|
if (c->scan) {
|
|
|
|
pr_err("--stop not meaningful with both a --scan assembly and a device name.\n");
|
|
|
|
rv |= 1;
|
|
|
|
break;
|
|
|
|
}
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= Manage_stop(dv->devname, mdfd, c->verbose, 0);
|
|
|
|
break;
|
2012-07-09 09:14:16 +02:00
|
|
|
case 'o':
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= Manage_ro(dv->devname, mdfd, 1);
|
|
|
|
break;
|
2012-07-09 09:14:16 +02:00
|
|
|
case 'w':
|
2017-03-29 17:55:19 +02:00
|
|
|
rv |= Manage_ro(dv->devname, mdfd, -1);
|
|
|
|
break;
|
2012-07-09 09:14:16 +02:00
|
|
|
}
|
|
|
|
close(mdfd);
|
|
|
|
} else
|
|
|
|
rv |= 1;
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
2014-05-22 07:55:31 +02:00
|
|
|
|
|
|
|
int SetAction(char *dev, char *action)
|
|
|
|
{
|
|
|
|
int fd = open(dev, O_RDONLY);
|
|
|
|
struct mdinfo mdi;
|
2017-03-30 22:52:37 +02:00
|
|
|
int retval;
|
|
|
|
|
2014-05-22 07:55:31 +02:00
|
|
|
if (fd < 0) {
|
|
|
|
pr_err("Couldn't open %s: %s\n", dev, strerror(errno));
|
|
|
|
return 1;
|
|
|
|
}
|
2017-03-30 22:52:37 +02:00
|
|
|
retval = sysfs_init(&mdi, fd, NULL);
|
2014-05-22 07:55:31 +02:00
|
|
|
close(fd);
|
2017-03-30 22:52:37 +02:00
|
|
|
if (retval) {
|
2014-05-22 07:55:31 +02:00
|
|
|
pr_err("%s is no an md array\n", dev);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sysfs_set_str(&mdi, NULL, "sync_action", action) < 0) {
|
|
|
|
pr_err("Count not set action for %s to %s: %s\n",
|
|
|
|
dev, action, strerror(errno));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|