X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=Manage.c;h=6ccd275919ca2fa7fd41b1cacdfa6854dd421393;hb=054cba77190f1ec787e6d0fba5a5f76f03b96638;hp=9b5c82b56485294f009ad8107c43241be1062f0b;hpb=387fcd593c7a257618fa11ed4cf57d655ace4ada;p=thirdparty%2Fmdadm.git

diff --git a/Manage.c b/Manage.c
index 9b5c82b5..6ccd2759 100644
--- a/Manage.c
+++ b/Manage.c
@@ -1,7 +1,7 @@
 /*
  * mdadm - manage Linux "md" devices aka RAID arrays.
  *
- * Copyright (C) 2001-2012 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2013 Neil Brown <neilb@suse.de>
  *
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -27,9 +27,9 @@
 #include "md_p.h"
 #include <ctype.h>
 
-#define REGISTER_DEV 		_IO (MD_MAJOR, 1)
-#define START_MD     		_IO (MD_MAJOR, 2)
-#define STOP_MD      		_IO (MD_MAJOR, 3)
+#define REGISTER_DEV		_IO (MD_MAJOR, 1)
+#define START_MD		_IO (MD_MAJOR, 2)
+#define STOP_MD			_IO (MD_MAJOR, 3)
 
 int Manage_ro(char *devname, int fd, int readonly)
 {
@@ -54,7 +54,7 @@ int Manage_ro(char *devname, int fd, int readonly)
 	/* If this is an externally-managed array, we need to modify the
 	 * metadata_version so that mdmon doesn't undo our change.
 	 */
-	mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
+	mdi = sysfs_read(fd, NULL, GET_LEVEL|GET_VERSION);
 	if (mdi &&
 	    mdi->array.major_version == -1 &&
 	    is_subarray(mdi->text_version)) {
@@ -127,12 +127,12 @@ out:
 
 #ifndef MDASSEMBLE
 
-static void remove_devices(int devnum, char *path)
+static void remove_devices(char *devnm, char *path)
 {
 	/*
 	 * Remove names at 'path' - possibly with
 	 * partition suffixes - which link to the 'standard'
-	 * name for devnum.  These were probably created
+	 * name for devnm.  These were probably created
 	 * by mdadm when the array was assembled.
 	 */
 	char base[40];
@@ -146,10 +146,7 @@ static void remove_devices(int devnum, char *path)
 	if (!path)
 		return;
 
-	if (devnum >= 0)
-		sprintf(base, "/dev/md%d", devnum);
-	else
-		sprintf(base, "/dev/md_d%d", -1-devnum);
+	sprintf(base, "/dev/%s", devnm);
 	be = base + strlen(base);
 
 	path2 = xmalloc(strlen(path)+20);
@@ -173,21 +170,45 @@ static void remove_devices(int devnum, char *path)
 	free(path2);
 }
 
-int Manage_runstop(char *devname, int fd, int runstop,
-		   int verbose,	int will_retry)
+int Manage_run(char *devname, int fd, struct context *c)
 {
-	/* Run or stop the array.  Array must already be configured
-	 * 'Run' requires >= 0.90.0
-	 * 'will_retry' is only relevant for 'stop', and means
-	 * that error messages are not wanted.
+	/* Run the array.  Array must already be configured
+	 *  Requires >= 0.90.0
+	 */
+	char nm[32], *nmp;
+
+	if (md_get_version(fd) < 9000) {
+		pr_err("need md driver version 0.90.0 or later\n");
+		return 1;
+	}
+	nmp = fd2devnm(fd);
+	if (!nmp) {
+		pr_err("Cannot find %s in sysfs!!\n", devname);
+		return 1;
+	}
+	strcpy(nm, nmp);
+	return IncrementalScan(c, nm);
+}
+
+int Manage_stop(char *devname, int fd, int verbose, int will_retry)
+{
+	/* Stop the array.  Array must already be configured
+	 * 'will_retry' means that error messages are not wanted.
 	 */
-	mdu_param_t param; /* unused */
 	int rv = 0;
+	struct map_ent *map = NULL;
+	struct mdinfo *mdi;
+	char devnm[32];
+	char container[32];
+	int err;
+	int count;
+	char buf[32];
+	unsigned long long rd1, rd2;
 
 	if (will_retry && verbose == 0)
 		verbose = -1;
 
-	if (runstop == -1 && md_get_version(fd) < 9000) {
+	if (md_get_version(fd) < 9000) {
 		if (ioctl(fd, STOP_MD, 0) == 0)
 			return 0;
 		pr_err("stopping device %s "
@@ -196,169 +217,294 @@ int Manage_runstop(char *devname, int fd, int runstop,
 		return 1;
 	}
 
-	if (md_get_version(fd) < 9000) {
-		pr_err("need md driver version 0.90.0 or later\n");
+	/* If this is an mdmon managed array, just write 'inactive'
+	 * to the array state and let mdmon clear up.
+	 */
+	strcpy(devnm, fd2devnm(fd));
+	/* Get EXCL access first.  If this fails, then attempting
+	 * to stop is probably a bad idea.
+	 */
+	mdi = sysfs_read(fd, NULL, GET_LEVEL|GET_COMPONENT|GET_VERSION);
+	if (mdi && is_subarray(mdi->text_version)) {
+		char *sl;
+		strncpy(container, mdi->text_version+1, sizeof(container));
+		container[sizeof(container)-1] = 0;
+		sl = strchr(container, '/');
+		if (sl)
+			*sl = 0;
+	} else
+		container[0] = 0;
+	close(fd);
+	count = 5;
+	while (((fd = ((devnm[0] == '/')
+		       ?open(devname, O_RDONLY|O_EXCL)
+		       :open_dev_flags(devnm, O_RDONLY|O_EXCL))) < 0
+		|| strcmp(fd2devnm(fd), devnm) != 0)
+	       && container[0]
+	       && mdmon_running(container)
+	       && count) {
+		if (fd >= 0)
+			close(fd);
+		flush_mdmon(container);
+		count--;
+	}
+	if (fd < 0 || strcmp(fd2devnm(fd), devnm) != 0) {
+		if (fd >= 0)
+			close(fd);
+		if (verbose >= 0)
+			pr_err("Cannot get exclusive access to %s:"
+			       "Perhaps a running "
+			       "process, mounted filesystem "
+			       "or active volume group?\n",
+			       devname);
 		return 1;
 	}
+	if (mdi &&
+	    mdi->array.level > 0 &&
+	    is_subarray(mdi->text_version)) {
+		int err;
+		/* This is mdmon managed. */
+		close(fd);
 
-	if (runstop > 0) {
-		if (ioctl(fd, RUN_ARRAY, &param)) {
+		/* As we have an O_EXCL open, any use of the device
+		 * which blocks STOP_ARRAY is probably a transient use,
+		 * so it is reasonable to retry for a while - 5 seconds.
+		 */
+		count = 25;
+		while (count &&
+		       (err = sysfs_set_str(mdi, NULL,
+					    "array_state",
+					    "inactive")) < 0
+		       && errno == EBUSY) {
+			usleep(200000);
+			count--;
+		}
+		if (err) {
 			if (verbose >= 0)
-				pr_err("failed to run array %s: %s\n",
+				pr_err("failed to stop array %s: %s\n",
 				       devname, strerror(errno));
-			return 1;
+			rv = 1;
+			goto out;
 		}
-		if (verbose >= 0)
-			pr_err("started %s\n", devname);
-	} else if (runstop < 0){
-		struct map_ent *map = NULL;
-		struct stat stb;
-		struct mdinfo *mdi;
-		int devnum;
-		int err;
-		int count;
-		/* If this is an mdmon managed array, just write 'inactive'
-		 * to the array state and let mdmon clear up.
-		 */
-		devnum = fd2devnum(fd);
-		/* Get EXCL access first.  If this fails, then attempting
-		 * to stop is probably a bad idea.
-		 */
-		close(fd);
-		fd = open(devname, O_RDONLY|O_EXCL);
-		if (fd < 0 || fd2devnum(fd) != devnum) {
-			if (fd >= 0)
-				close(fd);
+
+		/* Give monitor a chance to act */
+		ping_monitor(mdi->text_version);
+
+		fd = open_dev_excl(devnm);
+		if (fd < 0) {
 			if (verbose >= 0)
-				pr_err("Cannot get exclusive access to %s:"
-				       "Perhaps a running "
-				       "process, mounted filesystem "
-				       "or active volume group?\n",
+				pr_err("failed to completely stop %s"
+				       ": Device is busy\n",
 				       devname);
-			return 1;
+			rv = 1;
+			goto out;
 		}
-		mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
-		if (mdi &&
-		    mdi->array.level > 0 &&
-		    is_subarray(mdi->text_version)) {
-			int err;
-			/* This is mdmon managed. */
-			close(fd);
-
-			/* As we have an O_EXCL open, any use of the device
-			 * which blocks STOP_ARRAY is probably a transient use,
-			 * so it is reasonable to retry for a while - 5 seconds.
-			 */
-			count = 25;
-			while (count &&
-			       (err = sysfs_set_str(mdi, NULL,
-						    "array_state",
-						    "inactive")) < 0
-			       && errno == EBUSY) {
-				usleep(200000);
-				count--;
-			}
-			if (err) {
-				if (verbose >= 0)
-					pr_err("failed to stop array %s: %s\n",
-					       devname, strerror(errno));
-				rv = 1;
-				goto out;
-			}
-
-			/* Give monitor a chance to act */
-			ping_monitor(mdi->text_version);
+	} else if (mdi &&
+		   mdi->array.major_version == -1 &&
+		   mdi->array.minor_version == -2 &&
+		   !is_subarray(mdi->text_version)) {
+		struct mdstat_ent *mds, *m;
+		/* container, possibly mdmon-managed.
+		 * Make sure mdmon isn't opening it, which
+		 * would interfere with the 'stop'
+		 */
+		ping_monitor(mdi->sys_name);
 
-			fd = open_dev_excl(devnum);
-			if (fd < 0) {
+		/* now check that there are no existing arrays
+		 * which are members of this array
+		 */
+		mds = mdstat_read(0, 0);
+		for (m = mds; m; m = m->next)
+			if (m->metadata_version &&
+			    strncmp(m->metadata_version, "external:", 9)==0 &&
+			    metadata_container_matches(m->metadata_version+9,
+						       devnm)) {
 				if (verbose >= 0)
-					pr_err("failed to completely stop %s"
-					       ": Device is busy\n",
-					       devname);
+					pr_err("Cannot stop container %s: "
+					       "member %s still active\n",
+					       devname, m->dev);
+				free_mdstat(mds);
 				rv = 1;
 				goto out;
 			}
-		} else if (mdi &&
-			   mdi->array.major_version == -1 &&
-			   mdi->array.minor_version == -2 &&
-			   !is_subarray(mdi->text_version)) {
-			struct mdstat_ent *mds, *m;
-			/* container, possibly mdmon-managed.
-			 * Make sure mdmon isn't opening it, which
-			 * would interfere with the 'stop'
-			 */
-			ping_monitor(mdi->sys_name);
+	}
 
-			/* now check that there are no existing arrays
-			 * which are members of this array
+	/* If the array is undergoing a reshape which changes the number
+	 * of devices, then it would be nice to stop it at a point where
+	 * it has completed a full number of stripes in both old and
+	 * new layouts as this will allow the reshape to be reverted.
+	 * So if 'sync_action' is "reshape" and 'raid_disks' shows two
+	 * different numbers, then
+	 *  - freeze reshape
+	 *  - set sync_max to next multiple of both data_disks and
+	 *    chunk sizes (or next but one)
+	 *  - unfreeze reshape
+	 *  - wait on 'sync_completed' for that point to be reached.
+	 */
+	if (mdi && (mdi->array.level >= 4 && mdi->array.level <= 6) &&
+	    sysfs_attribute_available(mdi, NULL, "sync_action") &&
+	    sysfs_attribute_available(mdi, NULL, "reshape_direction") &&
+	    sysfs_get_str(mdi, NULL, "sync_action", buf, 20) > 0 &&
+	    strcmp(buf, "reshape\n") == 0 &&
+	    sysfs_get_two(mdi, NULL, "raid_disks", &rd1, &rd2) == 2 &&
+	    sysfs_set_str(mdi, NULL, "sync_action", "frozen") == 0) {
+		/* Array is frozen */
+		unsigned long long position, curr;
+		unsigned long long chunk1, chunk2;
+		unsigned long long rddiv, chunkdiv;
+		unsigned long long sectors;
+		unsigned long long sync_max, old_sync_max;
+		unsigned long long completed;
+		int backwards = 0;
+		int delay;
+		int scfd;
+
+		rd1 -= mdi->array.level == 6 ? 2 : 1;
+		rd2 -= mdi->array.level == 6 ? 2 : 1;
+		sysfs_get_str(mdi, NULL, "reshape_direction", buf, sizeof(buf));
+		if (strncmp(buf, "back", 4) == 0)
+			backwards = 1;
+		sysfs_get_ll(mdi, NULL, "reshape_position", &position);
+		sysfs_get_two(mdi, NULL, "chunk_size", &chunk1, &chunk2);
+		chunk1 /= 512;
+		chunk2 /= 512;
+		rddiv = GCD(rd1, rd2);
+		chunkdiv = GCD(chunk1, chunk2);
+		sectors = (chunk1/chunkdiv) * chunk2 * (rd1/rddiv) * rd2;
+
+		if (backwards) {
+			/* Need to subtract 'reshape_position' from
+			 * array size to get equivalent of sync_max.
+			 * Size calculation based on raid5_size in kernel.
 			 */
-			mds = mdstat_read(0, 0);
-			for (m = mds; m; m = m->next)
-				if (m->metadata_version &&
-				    strncmp(m->metadata_version, "external:", 9)==0 &&
-				    is_subarray(m->metadata_version+9) &&
-				    devname2devnum(m->metadata_version+10) == devnum) {
-					if (verbose >= 0)
-						pr_err("Cannot stop container %s: "
-						       "member %s still active\n",
-						       devname, m->dev);
-					free_mdstat(mds);
-					rv = 1;
-					goto out;
-				}
+			unsigned long long size = mdi->component_size;
+			size &= ~(chunk1-1);
+			size &= ~(chunk2-1);
+			/* rd1 must be smaller */
+			position = (position / sectors - 1) * sectors;
+			sync_max = size - position/rd1;
+		} else {
+			position = (position / sectors + 2) * sectors;
+			sync_max = position/rd1;
 		}
-
-		/* As we have an O_EXCL open, any use of the device
-		 * which blocks STOP_ARRAY is probably a transient use,
-		 * so it is reasonable to retry for a while - 5 seconds.
+		if (sysfs_get_ll(mdi, NULL, "sync_max", &old_sync_max) < 0)
+			old_sync_max = mdi->component_size;
+		/* Must not advance sync_max as that could confuse
+		 * the reshape monitor */
+		if (sync_max < old_sync_max)
+			sysfs_set_num(mdi, NULL, "sync_max", sync_max);
+		sysfs_set_str(mdi, NULL, "sync_action", "idle");
+
+		/* That should have set things going again.  Now we
+		 * wait a little while (3 second max) for sync_completed
+		 * to reach the target.
+		 * The reshape process can block for 500msec if
+		 * the sync speed limit is hit, so we need to wait
+		 * a lot longer than that. 1 second is usually
+		 * enough.  3 is safe.
 		 */
-		count = 25; err = 0;
-		while (count && fd >= 0
-		       && (err = ioctl(fd, STOP_ARRAY, NULL)) < 0
-		       && errno == EBUSY) {
-			usleep(200000);
-			count --;
-		}
-		if (fd >= 0 && err) {
-			if (verbose >= 0) {
-				pr_err("failed to stop array %s: %s\n",
-				       devname, strerror(errno));
-				if (errno == EBUSY)
-					fprintf(stderr, "Perhaps a running "
-						"process, mounted filesystem "
-						"or active volume group?\n");
+		delay = 3000;
+		scfd = sysfs_open(mdi->sys_name, NULL, "sync_completed");
+		while (scfd >= 0 && delay > 0 && old_sync_max > 0) {
+			sysfs_get_ll(mdi, NULL, "reshape_position", &curr);
+			sysfs_fd_get_str(scfd, buf, sizeof(buf));
+			if (strncmp(buf, "none", 4) == 0) {
+				/* Either reshape has aborted, or hasn't
+				 * quite started yet.  Wait a bit and
+				 * check  'sync_action' to see.
+				 */
+				usleep(10000);
+				sysfs_get_str(mdi, NULL, "sync_action", buf, sizeof(buf));
+				if (strncmp(buf, "reshape", 7) != 0)
+					break;
 			}
-			rv = 1;
-			goto out;
+
+			if (sysfs_fd_get_ll(scfd, &completed) == 0 &&
+			    (completed > sync_max ||
+			     (completed == sync_max && curr != position))) {
+				while (completed > sync_max) {
+					sync_max += sectors / rd1;
+					if (backwards)
+						position -= sectors;
+					else
+						position += sectors;
+				}
+				if (sync_max < old_sync_max)
+					sysfs_set_num(mdi, NULL, "sync_max", sync_max);
+			}
+
+			if (!backwards && curr >= position)
+				break;
+			if (backwards && curr <= position)
+				break;
+			sysfs_wait(scfd, &delay);
 		}
-		/* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
-		 * was stopped, so We'll do it here just to be sure.  Drop any
-		 * partitions as well...
-		 */
-		if (fd >= 0)
-			ioctl(fd, BLKRRPART, 0);
-		if (mdi)
-			sysfs_uevent(mdi, "change");
-
-		if (devnum != NoMdDev &&
-		    (stat("/dev/.udev", &stb) != 0 ||
-		     check_env("MDADM_NO_UDEV"))) {
-			struct map_ent *mp = map_by_devnum(&map, devnum);
-			remove_devices(devnum, mp ? mp->path : NULL);
+		if (scfd >= 0)
+			close(scfd);
+
+	}
+
+	/* As we have an O_EXCL open, any use of the device
+	 * which blocks STOP_ARRAY is probably a transient use,
+	 * so it is reasonable to retry for a while - 5 seconds.
+	 */
+	count = 25; err = 0;
+	while (count && fd >= 0
+	       && (err = ioctl(fd, STOP_ARRAY, NULL)) < 0
+	       && errno == EBUSY) {
+		usleep(200000);
+		count --;
+	}
+	if (fd >= 0 && err) {
+		if (verbose >= 0) {
+			pr_err("failed to stop array %s: %s\n",
+			       devname, strerror(errno));
+			if (errno == EBUSY)
+				cont_err("Perhaps a running "
+					 "process, mounted filesystem "
+					 "or active volume group?\n");
 		}
+		rv = 1;
+		goto out;
+	}
+	/* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
+	 * was stopped, so We'll do it here just to be sure.  Drop any
+	 * partitions as well...
+	 */
+	if (fd >= 0)
+		ioctl(fd, BLKRRPART, 0);
+	if (mdi)
+		sysfs_uevent(mdi, "change");
 
-		if (verbose >= 0)
-			pr_err("stopped %s\n", devname);
-		map_lock(&map);
-		map_remove(&map, devnum);
-		map_unlock(&map);
-	out:
-		if (mdi)
-			sysfs_free(mdi);
+	if (devnm[0] && use_udev()) {
+		struct map_ent *mp = map_by_devnm(&map, devnm);
+		remove_devices(devnm, mp ? mp->path : NULL);
 	}
+
+	if (verbose >= 0)
+		pr_err("stopped %s\n", devname);
+	map_lock(&map);
+	map_remove(&map, devnm);
+	map_unlock(&map);
+out:
+	if (mdi)
+		sysfs_free(mdi);
+
 	return rv;
 }
 
+static struct mddev_dev *add_one(struct mddev_dev *dv, char *name, char disp)
+{
+	struct mddev_dev *new;
+	new = xmalloc(sizeof(*new));
+	memset(new, 0, sizeof(*new));
+	new->devname = xstrdup(name);
+	new->disposition = disp;
+	new->next = dv->next;
+	dv->next = new;
+	return new;
+}
+
 static void add_faulty(struct mddev_dev *dv, int fd, char disp)
 {
 	mdu_array_info_t array;
@@ -371,7 +517,6 @@ static void add_faulty(struct mddev_dev *dv, int fd, char disp)
 
 	remaining_disks = array.nr_disks;
 	for (i = 0; i < MAX_DISKS && remaining_disks > 0; i++) {
-		struct mddev_dev *new;
 		char buf[40];
 		disk.number = i;
 		if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
@@ -382,12 +527,7 @@ static void add_faulty(struct mddev_dev *dv, int fd, char disp)
 		if ((disk.state & 1) == 0) /* not faulty */
 			continue;
 		sprintf(buf, "%d:%d", disk.major, disk.minor);
-		new = xmalloc(sizeof(*new));
-		new->devname = xstrdup(buf);
-		new->disposition = disp;
-		new->next = dv->next;
-		dv->next = new;
-		dv = new;
+		dv = add_one(dv, buf, disp);
 	}
 }
 
@@ -403,7 +543,6 @@ static void add_detached(struct mddev_dev *dv, int fd, char disp)
 
 	remaining_disks = array.nr_disks;
 	for (i = 0; i < MAX_DISKS && remaining_disks > 0; i++) {
-		struct mddev_dev *new;
 		char buf[40];
 		int sfd;
 		disk.number = i;
@@ -424,12 +563,41 @@ static void add_detached(struct mddev_dev *dv, int fd, char disp)
 		if (errno != ENXIO)
 			/* Probably not detached */
 			continue;
-		new = xmalloc(sizeof(*new));
-		new->devname = xstrdup(buf);
-		new->disposition = disp;
-		new->next = dv->next;
-		dv->next = new;
-		dv = new;
+		dv = add_one(dv, buf, disp);
+	}
+}
+
+static void add_set(struct mddev_dev *dv, int fd, char set_char)
+{
+	mdu_array_info_t array;
+	mdu_disk_info_t disk;
+	int remaining_disks;
+	int copies, set;
+	int i;
+
+	if (ioctl(fd, GET_ARRAY_INFO, &array) != 0)
+		return;
+	if (array.level != 10)
+		return;
+	copies = ((array.layout & 0xff) *
+		  ((array.layout >> 8) & 0xff));
+	if (array.raid_disks % copies)
+		return;
+
+	remaining_disks = array.nr_disks;
+	for (i = 0; i < MAX_DISKS && remaining_disks > 0; i++) {
+		char buf[40];
+		disk.number = i;
+		if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
+			continue;
+		if (disk.major == 0 && disk.minor == 0)
+			continue;
+		remaining_disks--;
+		set = disk.raid_disk % copies;
+		if (set_char != set + 'A')
+			continue;
+		sprintf(buf, "%d:%d", disk.major, disk.minor);
+		dv = add_one(dv, buf, dv->disposition);
 	}
 }
 
@@ -546,10 +714,8 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 			return -1;
 	}
 
-	if (tst->ss->validate_geometry(
-		    tst, array->level, array->layout,
-		    array->raid_disks, NULL,
-		    ldsize >> 9, NULL, NULL, 0) == 0) {
+	if (tst->ss == &super0 && ldsize > 4ULL*1024*1024*1024*1024) {
+		/* More than 4TB is wasted on v0.90 */
 		if (!force) {
 			pr_err("%s is larger than %s can "
 			       "effectively use.\n"
@@ -617,7 +783,8 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 				break;
 			}
 		/* FIXME this is a bad test to be using */
-		if (!tst->sb && dv->disposition != 'a') {
+		if (!tst->sb && (dv->disposition != 'a'
+				 && dv->disposition != 'S')) {
 			/* we are re-adding a device to a
 			 * completely dead array - have to depend
 			 * on kernel to check
@@ -647,7 +814,7 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 			dev_st = dup_super(tst);
 			dev_st->ss->load_super(dev_st, tfd, NULL);
 		}
-		if (dev_st && dev_st->sb) {
+		if (dev_st && dev_st->sb && dv->disposition != 'S') {
 			int rv = attempt_re_add(fd, tfd, dv,
 						dev_st, tst,
 						rdev,
@@ -680,13 +847,14 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 					continue;
 				if (disc.major == 0 && disc.minor == 0)
 					continue;
+				found++;
 				if (!(disc.state & (1<<MD_DISK_SYNC)))
 					continue;
 				avail[disc.raid_disk] = 1;
-				found++;
 			}
 			array_failed = !enough(array->level, array->raid_disks,
 					       array->layout, 1, avail);
+			free(avail);
 		} else
 			array_failed = 0;
 		if (array_failed) {
@@ -733,7 +901,7 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 			disc.state |= 1 << MD_DISK_WRITEMOSTLY;
 		dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
 		if (tst->ss->add_to_super(tst, &disc, dfd,
-					  dv->devname))
+					  dv->devname, INVALID_SECTORS))
 			return -1;
 		if (tst->ss->write_init_super(tst))
 			return -1;
@@ -774,10 +942,12 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 		struct mdinfo new_mdi;
 		struct mdinfo *sra;
 		int container_fd;
-		int devnum = fd2devnum(fd);
+		char devnm[32];
 		int dfd;
 
-		container_fd = open_dev_excl(devnum);
+		strcpy(devnm, fd2devnm(fd));
+
+		container_fd = open_dev_excl(devnm);
 		if (container_fd < 0) {
 			pr_err("add failed for %s:"
 			       " could not get exclusive access to container\n",
@@ -788,10 +958,10 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 
 		Kill(dv->devname, NULL, 0, -1, 0);
 		dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
-		if (mdmon_running(tst->container_dev))
+		if (mdmon_running(tst->container_devnm))
 			tst->update_tail = &tst->updates;
 		if (tst->ss->add_to_super(tst, &disc, dfd,
-					  dv->devname)) {
+					  dv->devname, INVALID_SECTORS)) {
 			close(dfd);
 			close(container_fd);
 			return -1;
@@ -801,7 +971,7 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 		else
 			tst->ss->sync_metadata(tst);
 
-		sra = sysfs_read(container_fd, -1, 0);
+		sra = sysfs_read(container_fd, NULL, 0);
 		if (!sra) {
 			pr_err("add failed for %s: sysfs_read failed\n",
 			       dv->devname);
@@ -825,7 +995,7 @@ int Manage_add(int fd, int tfd, struct mddev_dev *dv,
 			sysfs_free(sra);
 			return -1;
 		}
-		ping_monitor_by_id(devnum);
+		ping_monitor(devnm);
 		sysfs_free(sra);
 		close(container_fd);
 	} else {
@@ -858,8 +1028,9 @@ int Manage_remove(struct supertype *tst, int fd, struct mddev_dev *dv,
 		 * get an O_EXCL open on the container
 		 */
 		int ret;
-		int dnum = fd2devnum(fd);
-		lfd = open_dev_excl(dnum);
+		char devnm[32];
+		strcpy(devnm, fd2devnm(fd));
+		lfd = open_dev_excl(devnm);
 		if (lfd < 0) {
 			pr_err("Cannot get exclusive access "
 			       " to container - odd\n");
@@ -875,7 +1046,7 @@ int Manage_remove(struct supertype *tst, int fd, struct mddev_dev *dv,
 		if (rdev == 0)
 			ret = -1;
 		else
-			ret = sysfs_unique_holder(dnum, rdev);
+			ret = sysfs_unique_holder(devnm, rdev);
 		if (ret == 0) {
 			pr_err("%s is not a member, cannot remove.\n",
 			       dv->devname);
@@ -904,7 +1075,7 @@ int Manage_remove(struct supertype *tst, int fd, struct mddev_dev *dv,
 		if (err && errno == ENODEV) {
 			/* Old kernels rejected this if no personality
 			 * is registered */
-			struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
+			struct mdinfo *sra = sysfs_read(fd, NULL, GET_DEVS);
 			struct mdinfo *dv = NULL;
 			if (sra)
 				dv = sra->devs;
@@ -936,15 +1107,14 @@ int Manage_remove(struct supertype *tst, int fd, struct mddev_dev *dv,
 		 * 'add' event before reconciling this 'remove'
 		 * event.
 		 */
-		char *name = devnum2devname(fd2devnum(fd));
+		char *devnm = fd2devnm(fd);
 
-		if (!name) {
+		if (!devnm) {
 			pr_err("unable to get container name\n");
 			return -1;
 		}
 
-		ping_manager(name);
-		free(name);
+		ping_manager(devnm);
 	}
 	if (lfd >= 0)
 		close(lfd);
@@ -954,6 +1124,111 @@ int Manage_remove(struct supertype *tst, int fd, struct mddev_dev *dv,
 	return 1;
 }
 
+int Manage_replace(struct supertype *tst, int fd, struct mddev_dev *dv,
+		   unsigned long rdev, int verbose, char *devname)
+{
+	struct mdinfo *mdi, *di;
+	if (tst->ss->external) {
+		pr_err("--replace only supported for native metadata (0.90 or 1.x)\n");
+		return -1;
+	}
+	/* Need to find the device in sysfs and add 'want_replacement' to the
+	 * status.
+	 */
+	mdi = sysfs_read(fd, NULL, GET_DEVS);
+	if (!mdi || !mdi->devs) {
+		pr_err("Cannot find status of %s to enable replacement - strange\n",
+		       devname);
+		return -1;
+	}
+	for (di = mdi->devs; di; di = di->next)
+		if (di->disk.major == (int)major(rdev) &&
+		    di->disk.minor == (int)minor(rdev))
+			break;
+	if (di) {
+		int rv;
+		if (di->disk.raid_disk < 0) {
+			pr_err("%s is not active and so cannot be replaced.\n",
+			       dv->devname);
+			sysfs_free(mdi);
+			return -1;
+		}
+		rv = sysfs_set_str(mdi, di,
+				   "state", "want_replacement");
+		if (rv) {
+			sysfs_free(mdi);
+			pr_err("Failed to request replacement for %s\n",
+			       dv->devname);
+			return -1;
+		}
+		if (verbose >= 0)
+			pr_err("Marked %s (device %d in %s) for replacement\n",
+			       dv->devname, di->disk.raid_disk, devname);
+		/* If there is a matching 'with', we need to tell it which
+		 * raid disk
+		 */
+		while (dv && dv->disposition != 'W')
+			dv = dv->next;
+		if (dv) {
+			dv->disposition = 'w';
+			dv->used = di->disk.raid_disk;
+		}
+		return 1;
+	}
+	sysfs_free(mdi);
+	pr_err("%s not found in %s so cannot --replace it\n",
+	       dv->devname, devname);
+	return -1;
+}
+
+int Manage_with(struct supertype *tst, int fd, struct mddev_dev *dv,
+		unsigned long rdev, int verbose, char *devname)
+{
+	struct mdinfo *mdi, *di;
+	/* try to set 'slot' for 'rdev' in 'fd' to 'dv->used' */
+	mdi = sysfs_read(fd, NULL, GET_DEVS|GET_STATE);
+	if (!mdi || !mdi->devs) {
+		pr_err("Cannot find status of %s to enable replacement - strange\n",
+		       devname);
+		return -1;
+	}
+	for (di = mdi->devs; di; di = di->next)
+		if (di->disk.major == (int)major(rdev) &&
+		    di->disk.minor == (int)minor(rdev))
+			break;
+	if (di) {
+		int rv;
+		if (di->disk.state & (1<<MD_DISK_FAULTY)) {
+			pr_err("%s is faulty and cannot be a replacement\n",
+			       dv->devname);
+			sysfs_free(mdi);
+			return -1;
+		}
+		if (di->disk.raid_disk >= 0) {
+			pr_err("%s is active and cannot be a replacement\n",
+			       dv->devname);
+			sysfs_free(mdi);
+			return -1;
+		}
+		rv = sysfs_set_num(mdi, di,
+				   "slot", dv->used);
+		if (rv) {
+			sysfs_free(mdi);
+			pr_err("Failed to set %s as preferred replacement.\n",
+			       dv->devname);
+			return -1;
+		}
+		if (verbose >= 0)
+			pr_err("Marked %s in %s as replacement for device %d\n",
+			       dv->devname, devname, dv->used);
+		return 1;
+	}
+	sysfs_free(mdi);
+	pr_err("%s not found in %s so cannot make it preferred replacement\n",
+	       dv->devname, devname);
+	return -1;
+}
+
 int Manage_subdevs(char *devname, int fd,
 		   struct mddev_dev *devlist, int verbose, int test,
 		   char *update, int force)
@@ -963,6 +1238,7 @@ int Manage_subdevs(char *devname, int fd,
 	 *  'a' - add the device
 	 *	   try HOT_ADD_DISK
 	 *         If that fails EINVAL, try ADD_NEW_DISK
+	 *  'S' - add the device as a spare - don't try re-add
 	 *  'A' - re-add the device
 	 *  'r' - remove the device: HOT_REMOVE_DISK
 	 *        device can be 'faulty' or 'detached' in which case all
@@ -970,6 +1246,18 @@ int Manage_subdevs(char *devname, int fd,
 	 *  'f' - set the device faulty SET_DISK_FAULTY
 	 *        device can be 'detached' in which case any device that
 	 *	  is inaccessible will be marked faulty.
+	 *  'R' - mark this device as wanting replacement.
+	 *  'W' - this device is added if necessary and activated as
+	 *        a replacement for a previous 'R' device.
+	 * -----
+	 *  'w' - 'W' will be changed to 'w' when it is paired with
+	 *        a 'R' device.  If a 'W' is found while walking the list
+	 *        it must be unpaired, and is an error.
+	 *  'M' - this is created by a 'missing' target.  It is a slight
+	 *        variant on 'A'
+	 *  'F' - Another variant of 'A', where the device was faulty
+	 *        so must be removed from the array first.
+	 *
 	 * For 'f' and 'r', the device can also be a kernel-internal
 	 * name such as 'sdb'.
 	 */
@@ -984,13 +1272,14 @@ int Manage_subdevs(char *devname, int fd,
 	int count = 0; /* number of actions taken */
 	struct mdinfo info;
 	int frozen = 0;
+	int busy = 0;
 
 	if (ioctl(fd, GET_ARRAY_INFO, &array)) {
 		pr_err("Cannot get array info for %s\n",
 			devname);
 		goto abort;
 	}
-	sysfs_init(&info, fd, 0);
+	sysfs_init(&info, fd, NULL);
 
 	/* array.size is only 32 bits and may be truncated.
 	 * So read from sysfs if possible, and record number of sectors
@@ -1013,13 +1302,15 @@ int Manage_subdevs(char *devname, int fd,
 
 		if (strcmp(dv->devname, "failed") == 0 ||
 		    strcmp(dv->devname, "faulty") == 0) {
-			if (dv->disposition != 'r') {
+			if (dv->disposition != 'A'
+			    && dv->disposition != 'r') {
 				pr_err("%s only meaningful "
-					"with -r, not -%c\n",
+					"with -r or --re-add, not -%c\n",
 					dv->devname, dv->disposition);
 				goto abort;
 			}
-			add_faulty(dv, fd, 'r');
+			add_faulty(dv, fd, (dv->disposition == 'A'
+					    ? 'F' : 'r'));
 			continue;
 		}
 		if (strcmp(dv->devname, "detached") == 0) {
@@ -1054,6 +1345,35 @@ int Manage_subdevs(char *devname, int fd,
 			continue;
 		}
 
+		if (strncmp(dv->devname, "set-", 4) == 0 &&
+		    strlen(dv->devname) == 5) {
+			int copies;
+
+			if (dv->disposition != 'r' &&
+			    dv->disposition != 'f') {
+				pr_err("'%s' only meaningful with -r or -f\n",
+				       dv->devname);
+				goto abort;
+			}
+			if (array.level != 10) {
+				pr_err("'%s' only meaningful with RAID10 arrays\n",
+				       dv->devname);
+				goto abort;
+			}
+			copies = ((array.layout & 0xff) *
+				  ((array.layout >> 8) & 0xff));
+			if (array.raid_disks % copies != 0 ||
+			    dv->devname[4] < 'A' ||
+			    dv->devname[4] >= 'A' + copies ||
+			    copies > 26) {
+				pr_err("'%s' not meaningful with this array\n",
+				       dv->devname);
+				goto abort;
+			}
+			add_set(dv, fd, dv->devname[4]);
+			continue;
+		}
+
 		if (strchr(dv->devname, '/') == NULL &&
 		    strchr(dv->devname, ':') == NULL &&
 		    strlen(dv->devname) < 50) {
@@ -1068,7 +1388,7 @@ int Manage_subdevs(char *devname, int fd,
 			}
 
 			sprintf(dname, "dev-%s", dv->devname);
-			sysfd = sysfs_open(fd2devnum(fd), dname, "block/dev");
+			sysfd = sysfs_open(fd2devnm(fd), dname, "block/dev");
 			if (sysfd >= 0) {
 				char dn[20];
 				int mj,mn;
@@ -1081,7 +1401,7 @@ int Manage_subdevs(char *devname, int fd,
 				sysfd = -1;
 			}
 			if (!found) {
-				sysfd = sysfs_open(fd2devnum(fd), dname, "state");
+				sysfd = sysfs_open(fd2devnm(fd), dname, "state");
 				if (sysfd < 0) {
 					pr_err("%s does not appear "
 						"to be a component of %s\n",
@@ -1091,34 +1411,36 @@ int Manage_subdevs(char *devname, int fd,
 			}
 		} else {
 			tfd = dev_open(dv->devname, O_RDONLY);
-			if (tfd < 0 && dv->disposition == 'r' &&
-			    lstat(dv->devname, &stb) == 0)
-				/* Be happy, the lstat worked, that is
-				 * enough for --remove
-				 */
-				;
+			if (tfd >= 0)
+				fstat(tfd, &stb);
 			else {
-				if (tfd < 0 || fstat(tfd, &stb) != 0) {
-					if (tfd >= 0)
-						close(tfd);
+				int open_err = errno;
+				if (stat(dv->devname, &stb) != 0) {
+					pr_err("Cannot find %s: %s\n",
+					       dv->devname, strerror(errno));
+					goto abort;
+				}
+				if ((stb.st_mode & S_IFMT) != S_IFBLK) {
+					if (dv->disposition == 'M')
+						/* non-fatal. Also improbable */
+						continue;
+					pr_err("%s is not a block device.\n",
+					       dv->devname);
+					goto abort;
+				}
+				if (dv->disposition == 'r')
+					/* Be happy, the stat worked, that is
+					 * enough for --remove
+					 */
+					;
+				else {
 					if (dv->disposition == 'M')
 						/* non-fatal */
 						continue;
-					pr_err("cannot find %s: %s\n",
-						dv->devname, strerror(errno));
+					pr_err("Cannot open %s: %s\n",
+					       dv->devname, strerror(open_err));
 					goto abort;
 				}
-				close(tfd);
-				tfd = -1;
-			}
-			if ((stb.st_mode & S_IFMT) != S_IFBLK) {
-				if (dv->disposition == 'M')
-					/* non-fatal. Also improbable */
-					continue;
-				pr_err("%s is not a "
-					"block device.\n",
-					dv->devname);
-				goto abort;
 			}
 		}
 		switch(dv->disposition){
@@ -1127,8 +1449,10 @@ int Manage_subdevs(char *devname, int fd,
 				dv->devname, dv->disposition);
 			goto abort;
 		case 'a':
+		case 'S': /* --add-spare */
 		case 'A':
-		case 'M':
+		case 'M': /* --re-add missing */
+		case 'F': /* --re-add faulty  */
 			/* add the device */
 			if (subarray) {
 				pr_err("Cannot add disks to a"
@@ -1136,6 +1460,10 @@ int Manage_subdevs(char *devname, int fd,
 					" operation on the parent container\n");
 				goto abort;
 			}
+			if (dv->disposition == 'F')
+				/* Need to remove first */
+				ioctl(fd, HOT_REMOVE_DISK,
+				      (unsigned long)stb.st_rdev);
 			/* Make sure it isn't in use (in 2.6 or later) */
 			tfd = dev_open(dv->devname, O_RDONLY|O_EXCL);
 			if (tfd >= 0) {
@@ -1145,7 +1473,7 @@ int Manage_subdevs(char *devname, int fd,
 				 */
 				close(tfd);
 				tfd = dev_open(dv->devname, O_RDONLY);
-			}				
+			}
 			if (tfd < 0) {
 				if (dv->disposition == 'M')
 					continue;
@@ -1195,6 +1523,8 @@ int Manage_subdevs(char *devname, int fd,
 			if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
 			    (sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
 						(unsigned long) stb.st_rdev))) {
+				if (errno == EBUSY)
+					busy = 1;
 				pr_err("set device faulty failed for %s:  %s\n",
 					dv->devname, strerror(errno));
 				if (sysfd >= 0)
@@ -1209,6 +1539,38 @@ int Manage_subdevs(char *devname, int fd,
 				pr_err("set %s faulty in %s\n",
 					dv->devname, devname);
 			break;
+		case 'R': /* Mark as replaceable */
+			if (subarray) {
+				pr_err("Cannot replace disks in a"
+					" \'member\' array, perform this"
+					" operation on the parent container\n");
+				rv = -1;
+			} else {
+				if (!frozen) {
+					if (sysfs_freeze_array(&info) == 1)
+						frozen = 1;
+					else
+						frozen = -1;
+				}
+				rv = Manage_replace(tst, fd, dv,
+						    stb.st_rdev, verbose,
+						    devname);
+			}
+			if (rv < 0)
+				goto abort;
+			if (rv > 0)
+				count++;
+			break;
+		case 'W': /* --with device that doesn't match */
+			pr_err("No matching --replace device for --with %s\n",
+			       dv->devname);
+			goto abort;
+		case 'w': /* --with device which was matched */
+			rv = Manage_with(tst, fd, dv,
+					 stb.st_rdev, verbose, devname);
+			if (rv < 0)
+				goto abort;
+			break;
 		}
 	}
 	if (frozen > 0)
@@ -1220,7 +1582,7 @@ int Manage_subdevs(char *devname, int fd,
 abort:
 	if (frozen > 0)
 		sysfs_set_str(&info, NULL, "sync_action","idle");
-	return 1;
+	return !test && busy ? 2 : 1;
 }
 
 int autodetect(void)
@@ -1254,7 +1616,7 @@ int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident
 		goto free_super;
 	}
 
-	if (mdmon_running(st->devnum))
+	if (mdmon_running(st->devnm))
 		st->update_tail = &st->updates;
 
 	rv = st->ss->update_subarray(st, subarray, update, ident);