X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=Incremental.c;h=3a41a1e18260950a2948ffe2a64243310b255205;hb=61018da020ab3e25b21e0dffc7ecc4f708207a0b;hp=c5ec6340e0efe5c9a4ae865ebee27de1a379eea8;hpb=0ac91628b93b31636979b637c1ac7258064dea4e;p=thirdparty%2Fmdadm.git

diff --git a/Incremental.c b/Incremental.c
index c5ec6340..3a41a1e1 100644
--- a/Incremental.c
+++ b/Incremental.c
@@ -2,7 +2,7 @@
  * Incremental.c - support --incremental.  Part of:
  * mdadm - manage Linux "md" devices aka RAID arrays.
  *
- * Copyright (C) 2006 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
  *
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -29,12 +29,16 @@
  */
 
 #include	"mdadm.h"
+#include	<dirent.h>
+#include	<ctype.h>
 
 static int count_active(struct supertype *st, int mdfd, char **availp,
 			struct mdinfo *info);
 static void find_reject(int mdfd, struct supertype *st, struct mdinfo *sra,
 			int number, __u64 events, int verbose,
 			char *array_name);
+static int try_spare(char *devname, int *dfdp, struct dev_policy *pol,
+		     struct supertype *st, int verbose);
 
 int Incremental(char *devname, int verbose, int runstop,
 		struct supertype *st, char *homehost, int require_homehost,
@@ -78,17 +82,18 @@ int Incremental(char *devname, int verbose, int runstop,
 	 *   start the array (auto-readonly).
 	 */
 	struct stat stb;
-	struct mdinfo info;
+	struct mdinfo info, dinfo;
 	struct mddev_ident_s *array_list, *match;
 	char chosen_name[1024];
-	int rv;
+	int rv = 1;
 	struct map_ent *mp, *map = NULL;
-	int dfd, mdfd;
+	int dfd = -1, mdfd = -1;
 	char *avail;
 	int active_disks;
 	int trustworthy = FOREIGN;
 	char *name_to_use;
 	mdu_array_info_t ainf;
+	struct dev_policy *policy = NULL;
 
 	struct createinfo *ci = conf_get_create_info();
 
@@ -100,7 +105,7 @@ int Incremental(char *devname, int verbose, int runstop,
 			fprintf(stderr, Name
 				": %s not permitted by mdadm.conf.\n",
 				devname);
-		return 1;
+		goto out;
 	}
 
 	/* 2/ Find metadata, reject if none appropriate (check
@@ -111,39 +116,44 @@ int Incremental(char *devname, int verbose, int runstop,
 		if (verbose >= 0)
 			fprintf(stderr, Name ": cannot open %s: %s.\n",
 				devname, strerror(errno));
-		return 1;
+		goto out;
 	}
 	if (fstat(dfd, &stb) < 0) {
 		if (verbose >= 0)
 			fprintf(stderr, Name ": fstat failed for %s: %s.\n",
 				devname, strerror(errno));
-		close(dfd);
-		return 1;
+		goto out;
 	}
 	if ((stb.st_mode & S_IFMT) != S_IFBLK) {
 		if (verbose >= 0)
 			fprintf(stderr, Name ": %s is not a block device.\n",
 				devname);
-		close(dfd);
-		return 1;
+		goto out;
 	}
 
+	dinfo.disk.major = major(stb.st_rdev);
+	dinfo.disk.minor = minor(stb.st_rdev);
+
+	policy = disk_policy(&dinfo);
+
 	if (st == NULL && (st = guess_super(dfd)) == NULL) {
 		if (verbose >= 0)
 			fprintf(stderr, Name
 				": no recognisable superblock on %s.\n",
 				devname);
-		close(dfd);
-		return 1;
+		rv = try_spare(devname, &dfd, policy, st, verbose);
+		goto out;
 	}
-	if (st->ss->load_super(st, dfd, NULL)) {
+	if (st->ss->compare_super == NULL ||
+	    st->ss->load_super(st, dfd, NULL)) {
 		if (verbose >= 0)
 			fprintf(stderr, Name ": no RAID superblock on %s.\n",
 				devname);
-		close(dfd);
-		return 1;
+		rv = try_spare(devname, &dfd, policy, st, verbose);
+		free(st);
+		goto out;
 	}
-	close (dfd);
+	close (dfd); dfd = -1;
 
 	memset(&info, 0, sizeof(info));
 	st->ss->getinfo_super(st, &info);
@@ -207,7 +217,8 @@ int Incremental(char *devname, int verbose, int runstop,
 					fprintf(stderr, Name
 						": multiple lines in mdadm.conf match\n");
 			}
-			return 2;
+			rv = 2;
+			goto out;
 		}
 		match = array_list;
 	}
@@ -218,16 +229,7 @@ int Incremental(char *devname, int verbose, int runstop,
 			fprintf(stderr, Name ": array containing %s is explicitly"
 				" ignored by mdadm.conf\n",
 				devname);
-		return 1;
-	}
-
-	if (!match && !conf_test_metadata(st->ss->name)) {
-		if (verbose >= 1)
-			fprintf(stderr, Name
-				": %s has metadata type %s for which "
-				"auto-assembly is disabled\n",
-				devname, st->ss->name);
-		return 1;
+		goto out;
 	}
 
 	/* 3a/ if not, check for homehost match.  If no match, continue
@@ -236,11 +238,24 @@ int Incremental(char *devname, int verbose, int runstop,
 	 * on that. */
 	if (match)
 		trustworthy = LOCAL;
-	else if ((homehost == NULL ||
-		  st->ss->match_home(st, homehost) != 1) &&
-		 st->ss->match_home(st, "any") != 1)
-		trustworthy = FOREIGN;
+	else if (st->ss->match_home(st, homehost) == 1)
+		trustworthy = LOCAL;
+	else if (st->ss->match_home(st, "any") == 1)
+		trustworthy = LOCAL_ANY;
 	else
+		trustworthy = FOREIGN;
+
+
+	if (!match && !conf_test_metadata(st->ss->name,
+					  (trustworthy == LOCAL))) {
+		if (verbose >= 1)
+			fprintf(stderr, Name
+				": %s has metadata type %s for which "
+				"auto-assembly is disabled\n",
+				devname, st->ss->name);
+		goto out;
+	}
+	if (trustworthy == LOCAL_ANY)
 		trustworthy = LOCAL;
 
 	/* There are three possible sources for 'autof':  command line,
@@ -254,18 +269,25 @@ int Incremental(char *devname, int verbose, int runstop,
 		autof = ci->autof;
 
 	if (st->ss->container_content && st->loaded_container) {
+		if ((runstop > 0 && info.container_enough >= 0) ||
+		    info.container_enough > 0)
+			/* pass */;
+		else {
+			if (verbose)
+				fprintf(stderr, Name ": not enough devices to start the container\n");
+			rv = 0;
+			goto out;
+		}
+
 		/* This is a pre-built container array, so we do something
 		 * rather different.
 		 */
-		return Incremental_container(st, devname, verbose, runstop,
+		rv = Incremental_container(st, devname, verbose, runstop,
 					     autof, trustworthy);
+		goto out;
 	}
-	name_to_use = strchr(info.name, ':');
-	if (name_to_use)
-		name_to_use++;
-	else
-		name_to_use = info.name;
 
+	name_to_use = info.name;
 	if (name_to_use[0] == 0 &&
 	    info.array.level == LEVEL_CONTAINER &&
 	    trustworthy == LOCAL) {
@@ -277,40 +299,40 @@ int Incremental(char *devname, int verbose, int runstop,
 	    conf_name_is_free(name_to_use))
 		trustworthy = LOCAL;
 
+	/* strip "hostname:" prefix from name if we have decided
+	 * to treat it as LOCAL
+	 */
+	if (trustworthy == LOCAL && strchr(name_to_use, ':') != NULL)
+		name_to_use = strchr(name_to_use, ':')+1;
+
 	/* 4/ Check if array exists.
 	 */
-	map_lock(&map);
+	if (map_lock(&map))
+		fprintf(stderr, Name ": failed to get exclusive lock on "
+			"mapfile\n");
 	mp = map_by_uuid(&map, info.uuid);
-	if (mp) {
-		mdfd = open_mddev(mp->path, 0);
-		if (mdfd < 0 && mddev_busy(mp->devnum)) {
-			/* maybe udev hasn't created it yet. */
-			char buf[50];
-			sprintf(buf, "%d:%d", dev2major(mp->devnum),
-				dev2minor(mp->devnum));
-			mdfd = dev_open(buf, O_RDWR);
-		}
-	} else
+	if (mp)
+		mdfd = open_dev(mp->devnum);
+	else
 		mdfd = -1;
 
 	if (mdfd < 0) {
 		struct mdinfo *sra;
-		struct mdinfo dinfo;
 
 		/* Couldn't find an existing array, maybe make a new one */
 		mdfd = create_mddev(match ? match->devname : NULL,
 				    name_to_use, autof, trustworthy, chosen_name);
 
 		if (mdfd < 0)
-			return 1;
+			goto out;
 
 		sysfs_init(&info, mdfd, 0);
 
 		if (set_array_info(mdfd, st, &info) != 0) {
 			fprintf(stderr, Name ": failed to set array info for %s: %s\n",
 				chosen_name, strerror(errno));
-			close(mdfd);
-			return 2;
+			rv = 2;
+			goto out;
 		}
 
 		dinfo = info;
@@ -320,8 +342,8 @@ int Incremental(char *devname, int verbose, int runstop,
 			fprintf(stderr, Name ": failed to add %s to %s: %s.\n",
 				devname, chosen_name, strerror(errno));
 			ioctl(mdfd, STOP_ARRAY, 0);
-			close(mdfd);
-			return 2;
+			rv = 2;
+			goto out;
 		}
 		sra = sysfs_read(mdfd, fd2devnum(mdfd), GET_DEVS);
 		if (!sra || !sra->devs || sra->devs->disk.raid_disk >= 0) {
@@ -333,9 +355,9 @@ int Incremental(char *devname, int verbose, int runstop,
 			fprintf(stderr, Name
 		      ": You have an old buggy kernel which cannot support\n"
 				"      --incremental reliably.  Aborting.\n");
-			close(mdfd);
 			sysfs_free(sra);
-			return 2;
+			rv = 2;
+			goto out;
 		}
 		info.array.working_disks = 1;
 		sysfs_free(sra);
@@ -355,10 +377,45 @@ int Incremental(char *devname, int verbose, int runstop,
 		struct supertype *st2;
 		struct mdinfo info2, *d;
 
-		strcpy(chosen_name, mp->path);
+		if (mp->path)
+			strcpy(chosen_name, mp->path);
+		else
+			strcpy(chosen_name, devnum2devname(mp->devnum));
 
-		sra = sysfs_read(mdfd, fd2devnum(mdfd), (GET_DEVS | GET_STATE));
+		/* It is generally not OK to add non-spare drives to a
+		 * running array as they are probably missing because
+		 * they failed.  However if runstop is 1, then the
+		 * array was possibly started early and our best bet is
+		 * to add this anyway.
+		 * Also if action policy is re-add or better we allow
+		 * re-add
+		 */
+		if ((info.disk.state & (1<<MD_DISK_SYNC)) != 0
+		    && ! policy_action_allows(policy, st->ss->name,
+					      act_re_add)
+		    && runstop < 1) {
+			int active = 0;
+			
+			if (st->ss->external) {
+				char *devname = devnum2devname(fd2devnum(mdfd));
 
+				active = devname && is_container_active(devname);
+				free(devname);
+			} else if (ioctl(mdfd, GET_ARRAY_INFO, &ainf) == 0)
+				active = 1;
+			if (active) {
+				fprintf(stderr, Name
+					": not adding %s to active array (without --run) %s\n",
+					devname, chosen_name);
+				rv = 2;
+				goto out;
+			}
+		}
+		sra = sysfs_read(mdfd, fd2devnum(mdfd), (GET_DEVS | GET_STATE));
+		if (!sra) {
+			rv = 2;
+			goto out;
+		}
 		if (sra->devs) {
 			sprintf(dn, "%d:%d", sra->devs->disk.major,
 				sra->devs->disk.minor);
@@ -370,9 +427,9 @@ int Incremental(char *devname, int verbose, int runstop,
 					": metadata mismatch between %s and "
 					"chosen array %s\n",
 					devname, chosen_name);
-				close(mdfd);
 				close(dfd2);
-				return 2;
+				rv = 2;
+				goto out;
 			}
 			close(dfd2);
 			memset(&info2, 0, sizeof(info2));
@@ -384,8 +441,8 @@ int Incremental(char *devname, int verbose, int runstop,
 				fprintf(stderr, Name
 					": unexpected difference between %s and %s.\n",
 					chosen_name, devname);
-				close(mdfd);
-				return 2;
+				rv = 2;
+				goto out;
 			}
 		}
 		info2.disk.major = major(stb.st_rdev);
@@ -393,20 +450,20 @@ int Incremental(char *devname, int verbose, int runstop,
 		/* add disk needs to know about containers */
 		if (st->ss->external)
 			sra->array.level = LEVEL_CONTAINER;
-		err = add_disk(mdfd, st2, sra, &info2);
+		err = add_disk(mdfd, st, sra, &info2);
 		if (err < 0 && errno == EBUSY) {
 			/* could be another device present with the same
 			 * disk.number. Find and reject any such
 			 */
 			find_reject(mdfd, st, sra, info.disk.number,
 				    info.events, verbose, chosen_name);
-			err = add_disk(mdfd, st2, sra, &info2);
+			err = add_disk(mdfd, st, sra, &info2);
 		}
 		if (err < 0) {
 			fprintf(stderr, Name ": failed to add %s to %s: %s.\n",
 				devname, chosen_name, strerror(errno));
-			close(mdfd);
-			return 2;
+			rv = 2;
+			goto out;
 		}
 		info.array.working_disks = 0;
 		for (d = sra->devs; d; d=d->next)
@@ -426,8 +483,6 @@ int Incremental(char *devname, int verbose, int runstop,
 				chosen_name, info.array.working_disks);
 		wait_for(chosen_name, mdfd);
 		close(mdfd);
-		if (runstop < 0)
-			return 0; /* don't try to assemble */
 		rv = Incremental(chosen_name, verbose, runstop,
 				 NULL, homehost, require_homehost, autof);
 		if (rv == 1)
@@ -441,16 +496,15 @@ int Incremental(char *devname, int verbose, int runstop,
 	active_disks = count_active(st, mdfd, &avail, &info);
 	if (enough(info.array.level, info.array.raid_disks,
 		   info.array.layout, info.array.state & 1,
-		   avail, active_disks) == 0 ||
-	    (runstop < 0 && active_disks < info.array.raid_disks)) {
+		   avail, active_disks) == 0) {
 		free(avail);
 		if (verbose >= 0)
 			fprintf(stderr, Name
 			     ": %s attached to %s, not enough to start (%d).\n",
 				devname, chosen_name, active_disks);
 		map_unlock(&map);
-		close(mdfd);
-		return 0;
+		rv = 0;
+		goto out;
 	}
 	free(avail);
 
@@ -465,14 +519,14 @@ int Incremental(char *devname, int verbose, int runstop,
 			fprintf(stderr, Name
 			   ": %s attached to %s which is already active.\n",
 				devname, chosen_name);
-		close(mdfd);
 		map_unlock(&map);
-		return 0;
+		rv = 0;
+		goto out;
 	}
 
 	map_unlock(&map);
 	if (runstop > 0 || active_disks >= info.array.working_disks) {
-		struct mdinfo *sra;
+		struct mdinfo *sra, *dsk;
 		/* Let's try to start it */
 		if (match && match->bitmap_file) {
 			int bmfd = open(match->bitmap_file, O_RDWR);
@@ -480,20 +534,20 @@ int Incremental(char *devname, int verbose, int runstop,
 				fprintf(stderr, Name
 					": Could not open bitmap file %s.\n",
 					match->bitmap_file);
-				close(mdfd);
-				return 1;
+				goto out;
 			}
 			if (ioctl(mdfd, SET_BITMAP_FILE, bmfd) != 0) {
 				close(bmfd);
 				fprintf(stderr, Name
 					": Failed to set bitmapfile for %s.\n",
 					chosen_name);
-				close(mdfd);
-				return 1;
+				goto out;
 			}
 			close(bmfd);
 		}
-		sra = sysfs_read(mdfd, fd2devnum(mdfd), 0);
+		/* GET_* needed so add_disk works below */
+		sra = sysfs_read(mdfd, fd2devnum(mdfd),
+				 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
 		if ((sra == NULL || active_disks >= info.array.working_disks)
 		    && trustworthy != FOREIGN)
 			rv = ioctl(mdfd, RUN_ARRAY, NULL);
@@ -503,10 +557,23 @@ int Incremental(char *devname, int verbose, int runstop,
 		if (rv == 0) {
 			if (verbose >= 0)
 				fprintf(stderr, Name
-			   ": %s attached to %s, which has been started.\n",
+					": %s attached to %s, which has been started.\n",
 					devname, chosen_name);
 			rv = 0;
 			wait_for(chosen_name, mdfd);
+			/* We just started the array, so some devices
+			 * might have been evicted from the array
+			 * because their event counts were too old.
+			 * If the action=re-add policy is in-force for
+			 * those devices we should re-add them now.
+			 */
+			for (dsk = sra->devs; dsk ; dsk = dsk->next) {
+				if (disk_action_allows(dsk, st->ss->name, act_re_add) &&
+				    add_disk(mdfd, st, sra, dsk) == 0)
+					fprintf(stderr, Name
+						": %s re-added to %s\n",
+						dsk->sys_name, chosen_name);
+			}
 		} else {
 			fprintf(stderr, Name
                              ": %s attached to %s, but failed to start: %s.\n",
@@ -520,7 +587,13 @@ int Incremental(char *devname, int verbose, int runstop,
 				devname, chosen_name);
 		rv = 0;
 	}
-	close(mdfd);
+out:
+	if (dfd >= 0)
+		close(dfd);
+	if (mdfd >= 0)
+		close(mdfd);
+	if (policy)
+		dev_policy_free(policy);
 	return rv;
 }
 
@@ -578,6 +651,9 @@ static int count_active(struct supertype *st, int mdfd, char **availp,
 	struct mdinfo *sra = sysfs_read(mdfd, -1, GET_DEVS | GET_STATE);
 	char *avail = NULL;
 
+	if (!sra)
+		return 0;
+
 	for (d = sra->devs ; d ; d = d->next) {
 		char dn[30];
 		int dfd;
@@ -640,6 +716,368 @@ static int count_active(struct supertype *st, int mdfd, char **availp,
 	return cnt + cnt1;
 }
 
+static int array_try_spare(char *devname, int *dfdp, struct dev_policy *pol,
+			   struct supertype *st, int verbose)
+{
+	/* This device doesn't have any md metadata
+	 * If it is 'bare' and theh device policy allows 'spare' look for
+	 * an array or container to attach it to.
+	 * If st is set, then only arrays of that type are considered
+	 * Return 0 on success, or some exit code on failure, probably 1.
+	 */
+	int rv = -1;
+	struct stat stb;
+	struct map_ent *mp, *map = NULL;
+	struct mdinfo *chosen = NULL;
+	int dfd = *dfdp;
+
+	if (fstat(dfd, &stb) != 0)
+		return 1;
+
+	/*
+	 * Now we need to find a suitable array to add this to.
+	 * We only accept arrays that:
+	 *  - match 'st'
+	 *  - are in the same domains as the device
+	 *  - are of an size for which the device will be useful
+	 * and we choose the one that is the most degraded
+	 */
+
+	if (map_lock(&map)) {
+		fprintf(stderr, Name ": failed to get exclusive lock on "
+			"mapfile\n");
+		return 1;
+	}
+	for (mp = map ; mp ; mp = mp->next) {
+		struct supertype *st2;
+		struct domainlist *dl = NULL;
+		struct mdinfo *sra;
+		unsigned long long devsize;
+
+		if (is_subarray(mp->metadata))
+			continue;
+		if (st) {
+			st2 = st->ss->match_metadata_desc(mp->metadata);
+			if (!st2 ||
+			    (st->minor_version >= 0 &&
+			     st->minor_version != st2->minor_version)) {
+				if (verbose > 1)
+					fprintf(stderr, Name ": not adding %s to %s as metadata type doesn't match\n",
+						devname, mp->path);
+				free(st2);
+				continue;
+			}
+			free(st2);
+		}
+		sra = sysfs_read(-1, mp->devnum,
+				 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE|
+				 GET_DEGRADED|GET_COMPONENT|GET_VERSION);
+		if (!sra) {
+			/* Probably a container - no degraded info */
+			sra = sysfs_read(-1, mp->devnum,
+					 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE|
+					 GET_COMPONENT|GET_VERSION);
+			if (sra)
+				sra->array.failed_disks = 0;
+		}
+		if (!sra)
+			continue;
+		if (st == NULL) {
+			int i;
+			st2 = NULL;
+			for(i=0; !st2 && superlist[i]; i++)
+				st2 = superlist[i]->match_metadata_desc(
+					sra->text_version);
+		} else
+			st2 = st;
+		get_dev_size(dfd, NULL, &devsize);
+		if (st2->ss->avail_size(st2, devsize) < sra->component_size) {
+			if (verbose > 1)
+				fprintf(stderr, Name ": not adding %s to %s as it is too small\n",
+					devname, mp->path);
+			goto next;
+		}
+		dl = domain_from_array(sra, st2->ss->name);
+		if (!domain_test(dl, pol, st2->ss->name)) {
+			/* domain test fails */
+			if (verbose > 1)
+				fprintf(stderr, Name ": not adding %s to %s as it is not in a compatible domain\n",
+					devname, mp->path);
+
+			goto next;
+		}
+		/* all tests passed, OK to add to this array */
+		if (!chosen) {
+			chosen = sra;
+			sra = NULL;
+		} else if (chosen->array.failed_disks < sra->array.failed_disks) {
+			sysfs_free(chosen);
+			chosen = sra;
+			sra = NULL;
+		}
+	next:
+		if (sra)
+			sysfs_free(sra);
+		if (st != st2)
+			free(st2);
+		if (dl)
+			domain_free(dl);
+	}
+	if (chosen) {
+		/* add current device to chosen array as a spare */
+		int mdfd = open_dev(devname2devnum(chosen->sys_name));
+		if (mdfd >= 0) {
+			struct mddev_dev_s devlist;
+			char devname[20];
+			devlist.next = NULL;
+			devlist.used = 0;
+			devlist.re_add = 0;
+			devlist.writemostly = 0;
+			devlist.devname = devname;
+			sprintf(devname, "%d:%d", major(stb.st_rdev),
+				minor(stb.st_rdev));
+			devlist.disposition = 'a';
+			close(dfd);
+			*dfdp = -1;
+			rv =  Manage_subdevs(chosen->sys_name, mdfd, &devlist,
+					     -1, 0);
+			close(mdfd);
+		}
+		if (verbose > 0) {
+			if (rv == 0)
+				fprintf(stderr, Name ": added %s as spare for %s\n",
+					devname, chosen->sys_name);
+			else
+				fprintf(stderr, Name ": failed to add %s as spare for %s\n",
+					devname, chosen->sys_name);
+		}
+		sysfs_free(chosen);
+	}
+	return rv ? 0 : 1;
+}
+
+static int partition_try_spare(char *devname, int *dfdp, struct dev_policy *pol,
+			       struct supertype *st, int verbose)
+{
+	/* we know that at least one partition virtual-metadata is
+	 * allowed to incorporate spares like this device.  We need to
+	 * find a suitable device to copy partition information from.
+	 *
+	 * Getting a list of all disk (not partition) devices is
+	 * slightly non-trivial.  We could look at /sys/block, but
+	 * that is theoretically due to be removed.  Maybe best to use
+	 * /dev/disk/by-path/?* and ignore names ending '-partNN' as
+	 * we depend on this directory of 'path' info.  But that fails
+	 * to find loop devices and probably others.  Maybe don't
+	 * worry about that, they aren't the real target.
+	 *
+	 * So: check things in /dev/disk/by-path to see if they are in
+	 * a compatible domain, then load the partition table and see
+	 * if it is OK for the new device, and choose the largest
+	 * partition table that fits.
+	 */
+	DIR *dir;
+	struct dirent *de;
+	char *chosen = NULL;
+	unsigned long long chosen_size;
+	struct supertype *chosen_st = NULL;
+	int fd;
+
+	dir = opendir("/dev/disk/by-path");
+	if (!dir)
+		return 1;
+	while ((de = readdir(dir)) != NULL) {
+		char *ep;
+		struct dev_policy *pol2 = NULL;
+		struct domainlist *domlist = NULL;
+		int fd = -1;
+		struct mdinfo info;
+		struct supertype *st2 = NULL;
+		char *devname = NULL;
+		unsigned long long devsectors;
+
+		if (de->d_ino == 0 ||
+		    de->d_name[0] == '.' ||
+		    (de->d_type != DT_LNK && de->d_type != DT_UNKNOWN))
+			goto next;
+
+		ep = de->d_name + strlen(de->d_name);
+		while (ep > de->d_name &&
+		       isdigit(ep[-1]))
+			ep--;
+		if (ep > de->d_name + 5 &&
+		    strncmp(ep-5, "-part", 5) == 0)
+			/* This is a partition - skip it */
+			goto next;
+
+		pol2 = path_policy(de->d_name, type_disk);
+
+		domain_merge(&domlist, pol2, st ? st->ss->name : NULL);
+		if (domain_test(domlist, pol, st ? st->ss->name : NULL) == 0)
+			/* new device is incompatible with this device. */
+			goto next;
+
+		domain_free(domlist);
+		domlist = NULL;
+
+		asprintf(&devname, "/dev/disk/by-path/%s", de->d_name);
+		fd = open(devname, O_RDONLY);
+		if (fd < 0)
+			goto next;
+		if (get_dev_size(fd, devname, &devsectors) == 0)
+			goto next;
+		devsectors >>= 9;
+
+		if (st)
+			st2 = dup_super(st);
+		else
+			st2 = guess_super_type(fd, guess_partitions);
+		if (st2 == NULL ||
+		    st2->ss->load_super(st2, fd, NULL) < 0)
+			goto next;
+
+		if (!st) {
+			/* Check domain policy again, this time referring to metadata */
+			domain_merge(&domlist, pol2, st2->ss->name);
+			if (domain_test(domlist, pol, st2->ss->name) == 0)
+				/* Incompatible devices for this metadata type */
+				goto next;
+		}
+
+		st2->ss->getinfo_super(st2, &info);
+		if (info.component_size > devsectors)
+			/* This partitioning doesn't fit in the device */
+			goto next;
+
+		/* This is an acceptable device to copy partition
+		 * metadata from.  We could just stop here, but I
+		 * think I want to keep looking incase a larger
+		 * metadata which makes better use of the device can
+		 * be found.
+		 */
+		if (chosen == NULL ||
+		    chosen_size < info.component_size) {
+			chosen_size = info.component_size;
+			free(chosen);
+			chosen = devname;
+			devname = NULL;
+			if (chosen_st) {
+				chosen_st->ss->free_super(chosen_st);
+				free(chosen_st);
+			}
+			chosen_st = st2;
+			st2 = NULL;
+		}
+
+	next:
+		free(devname);
+		domain_free(domlist);
+		dev_policy_free(pol2);
+		if (st2)
+			st2->ss->free_super(st2);
+		free(st2);
+
+		if (fd >= 0)
+			close(fd);
+	}
+
+	if (!chosen)
+		return 1;
+
+	/* 'chosen' is the best device we can find.  Let's write its
+	 * metadata to devname dfd is read-only so don't use that
+	 */
+	fd = open(devname, O_RDWR);
+	if (fd >= 0) {
+		chosen_st->ss->store_super(chosen_st, fd);
+		close(fd);
+	}
+	free(chosen);
+	chosen_st->ss->free_super(chosen_st);
+	free(chosen_st);
+	return 0;
+}
+
+
+/* adding a spare to a regular array is quite different from adding one to
+ * a set-of-partitions virtual array.
+ * This function determines which is worth trying and tries as appropriate.
+ * Arrays are given priority over partitions.
+ */
+static int try_spare(char *devname, int *dfdp, struct dev_policy *pol,
+		     struct supertype *st, int verbose)
+{
+	int i;
+	int rv;
+	int arrays_ok = 0;
+	int partitions_ok = 0;
+	char bufpad[4096 + 4096];
+	char *buf = (char*)(((long)bufpad + 4096) & ~4095);
+	int dfd = *dfdp;
+
+	/* Can only add a spare if device has at least one domains */
+	if (pol_find(pol, pol_domain) == NULL)
+		return 1;
+	/* And only if some action allows spares */
+	if (!policy_action_allows(pol, st?st->ss->name:NULL, act_spare))
+		return 1;
+
+	/* Now check if the device is bare - we don't add non-bare devices
+	 * yet even if action=-spare
+	 */
+
+	if (lseek(dfd, 0, SEEK_SET) != 0 ||
+	    read(dfd, buf, 4096) != 4096) {
+	not_bare:
+		if (verbose > 1)
+			fprintf(stderr, Name ": %s is not bare, so not considering as a spare\n",
+				devname);
+		return 1;
+	}
+	if (buf[0] != '\0' && buf[0] != '\x5a' && buf[0] != '\xff')
+		goto not_bare;
+	if (memcmp(buf, buf+1, 4095) != 0)
+		goto not_bare;
+
+	/* OK, first 4K appear blank, try the end. */
+	if (lseek(dfd, -4096, SEEK_END) < 0 ||
+	    read(dfd, buf, 4096) != 4096)
+		goto not_bare;
+
+	if (buf[0] != '\0' && buf[0] != '\x5a' && buf[0] != '\xff')
+		goto not_bare;
+	if (memcmp(buf, buf+1, 4095) != 0)
+		goto not_bare;
+
+	/* This device passes our test for 'is bare'.
+	 * Let's see what policy allows for such things.
+	 */
+	if (st) {
+		/* just try try 'array' or 'partition' based on this metadata */
+		if (st->ss->add_to_super)
+			return array_try_spare(devname, dfdp, pol,
+					       st, verbose);
+		else
+			return partition_try_spare(devname, dfdp, pol,
+						   st, verbose);
+	}
+	/* Now see which metadata type support spare */
+	for (i = 0; (!arrays_ok || !partitions_ok) && superlist[i] ; i++) {
+		if (superlist[i]->add_to_super && !arrays_ok &&
+		    policy_action_allows(pol, superlist[i]->name, act_spare))
+			arrays_ok = 1;
+		if (superlist[i]->add_to_super == NULL && !partitions_ok &&
+		    policy_action_allows(pol, superlist[i]->name, act_spare))
+			partitions_ok = 1;
+	}
+	rv = 0;
+	if (arrays_ok)
+		rv = array_try_spare(devname, dfdp, pol, st, verbose);
+	if (rv == 0 && partitions_ok)
+		rv = partition_try_spare(devname, dfdp, pol, st, verbose);
+	return rv;
+}
+
 int IncrementalScan(int verbose)
 {
 	/* look at every device listed in the 'map' file.
@@ -660,7 +1098,7 @@ int IncrementalScan(int verbose)
 		mdu_array_info_t array;
 		mdu_bitmap_file_t bmf;
 		struct mdinfo *sra;
-		int mdfd = open_mddev(me->path, 0);
+		int mdfd = open_dev(me->devnum);
 
 		if (mdfd < 0)
 			continue;
@@ -671,8 +1109,8 @@ int IncrementalScan(int verbose)
 		}
 		/* Ok, we can try this one.   Maybe it needs a bitmap */
 		for (mddev = devs ; mddev ; mddev = mddev->next)
-			if (mddev->devname
-			    && strcmp(mddev->devname, me->path) == 0)
+			if (mddev->devname && me->path
+			    && devname_matches(mddev->devname, me->path))
 				break;
 		if (mddev && mddev->bitmap_file) {
 			/*
@@ -706,11 +1144,12 @@ int IncrementalScan(int verbose)
 				if (verbose >= 0)
 					fprintf(stderr, Name
 						": started array %s\n",
-						me->path);
+						me->path ?: devnum2devname(me->devnum));
 			} else {
 				fprintf(stderr, Name
 					": failed to start array %s: %s\n",
-					me->path, strerror(errno));
+					me->path ?: devnum2devname(me->devnum),
+					strerror(errno));
 				rv = 1;
 			}
 		}
@@ -754,7 +1193,9 @@ int Incremental_container(struct supertype *st, char *devname, int verbose,
 	struct mdinfo *ra;
 	struct map_ent *map = NULL;
 
-	map_lock(&map);
+	if (map_lock(&map))
+		fprintf(stderr, Name ": failed to get exclusive lock on "
+			"mapfile\n");
 
 	for (ra = list ; ra ; ra = ra->next) {
 		int mdfd;
@@ -766,7 +1207,10 @@ int Incremental_container(struct supertype *st, char *devname, int verbose,
 
 		if (mp) {
 			mdfd = open_dev(mp->devnum);
-			strcpy(chosen_name, mp->path);
+			if (mp->path)
+				strcpy(chosen_name, mp->path);
+			else
+				strcpy(chosen_name, devnum2devname(mp->devnum));
 		} else {
 
 			/* Check in mdadm.conf for container == devname and
@@ -837,3 +1281,45 @@ int Incremental_container(struct supertype *st, char *devname, int verbose,
 	map_unlock(&map);
 	return 0;
 }
+
+/*
+ * IncrementalRemove - Attempt to see if the passed in device belongs to any
+ * raid arrays, and if so first fail (if needed) and then remove the device.
+ *
+ * @devname - The device we want to remove
+ *
+ * Note: the device name must be a kernel name like "sda", so
+ * that we can find it in /proc/mdstat
+ */
+int IncrementalRemove(char *devname, int verbose)
+{
+	int mdfd;
+	int rv;
+	struct mdstat_ent *ent;
+	struct mddev_dev_s devlist;
+
+	if (strchr(devname, '/')) {
+		fprintf(stderr, Name ": incremental removal requires a "
+			"kernel device name, not a file: %s\n", devname);
+		return 1;
+	}
+	ent = mdstat_by_component(devname);
+	if (!ent) {
+		fprintf(stderr, Name ": %s does not appear to be a component "
+			"of any array\n", devname);
+		return 1;
+	}
+	mdfd = open_dev(ent->devnum);
+	if (mdfd < 0) {
+		fprintf(stderr, Name ": Cannot open array %s!!\n", ent->dev);
+		return 1;
+	}
+	memset(&devlist, 0, sizeof(devlist));
+	devlist.devname = devname;
+	devlist.disposition = 'f';
+	Manage_subdevs(ent->dev, mdfd, &devlist, verbose, 0);
+	devlist.disposition = 'r';
+	rv = Manage_subdevs(ent->dev, mdfd, &devlist, verbose, 0);
+	close(mdfd);
+	return rv;
+}