X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=Monitor.c;h=101bca4cc8053198a0a09ec0f87be96e5a4687c3;hp=658ba9cbde5821bdbd330ed45d3c3f374630f640;hb=9e6d9291275267d3fd4b6d85d7232081f89cd8e2;hpb=9bfc6a7d1a8335c4ec963f90a6c6ad4690a86310

diff --git a/Monitor.c b/Monitor.c
index 658ba9cb..101bca4c 100644
--- a/Monitor.c
+++ b/Monitor.c
@@ -44,7 +44,7 @@ struct state {
 	int active, working, failed, spare, raid;
 	int expected_spares;
 	int devstate[MaxDisks];
-	unsigned devid[MaxDisks];
+	dev_t devid[MaxDisks];
 	int percent;
 	int parent_dev; /* For subarray, devnum of parent.
 			 * For others, NoMdDev
@@ -58,20 +58,21 @@ struct state {
 	struct state *next;
 };
 
+struct alert_info {
+	char *mailaddr;
+	char *mailfrom;
+	char *alert_cmd;
+	int dosyslog;
+};
 static int make_daemon(char *pidfile);
 static int check_one_sharer(int scan);
-static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mailfrom,
-		  char *cmd, int dosyslog);
+static void alert(char *event, char *dev, char *disc, struct alert_info *info);
 static int check_array(struct state *st, struct mdstat_ent *mdstat,
-		       int test, char *mailaddr,
-		       char *mailfrom, char *alert_cmd, int dosyslog,
+		       int test, struct alert_info *info,
 		       int increments);
-static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist,
-			  int test, char *mailaddr, char *mailfrom,
-			  char *alert_cmd, int dosyslog);
-static void try_spare_migration(struct state *statelist,
-				char *mailaddr, char *mailfrom,
-				char *alert_cmd, int dosyslog);
+static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
+			  int test, struct alert_info *info);
+static void try_spare_migration(struct state *statelist, struct alert_info *info);
 static void link_containers_with_subarrays(struct state *list);
 
 int Monitor(struct mddev_dev *devlist,
@@ -126,6 +127,7 @@ int Monitor(struct mddev_dev *devlist,
 	int finished = 0;
 	struct mdstat_ent *mdstat = NULL;
 	char *mailfrom = NULL;
+	struct alert_info info;
 
 	if (!mailaddr) {
 		mailaddr = conf_get_mailaddr();
@@ -141,14 +143,20 @@ int Monitor(struct mddev_dev *devlist,
 			fprintf(stderr, Name ": Monitor using program \"%s\" from config file\n",
 			       alert_cmd);
 	}
-	if (scan && !mailaddr && !alert_cmd) {
+	if (scan && !mailaddr && !alert_cmd && !dosyslog) {
 		fprintf(stderr, Name ": No mail address or alert command - not monitoring.\n");
 		return 1;
 	}
+	info.alert_cmd = alert_cmd;
+	info.mailaddr = mailaddr;
+	info.mailfrom = mailfrom;
+	info.dosyslog = dosyslog;
 
-	if (daemonise)
-		if (make_daemon(pidfile))
-			return 1;
+	if (daemonise) {
+		int rv = make_daemon(pidfile);
+		if (rv >= 0)
+			return rv;
+	}
 
 	if (share) 
 		if (check_one_sharer(scan))
@@ -212,23 +220,20 @@ int Monitor(struct mddev_dev *devlist,
 		mdstat = mdstat_read(oneshot?0:1, 0);
 
 		for (st=statelist; st; st=st->next)
-			if (check_array(st, mdstat, test, mailaddr, mailfrom,
-					alert_cmd, dosyslog, increments))
+			if (check_array(st, mdstat, test, &info, increments))
 				anydegraded = 1;
 		
 		/* now check if there are any new devices found in mdstat */
 		if (scan)
-			new_found = add_new_arrays(mdstat, statelist, test,
-						   mailaddr, mailfrom, alert_cmd,
-						   dosyslog);
+			new_found = add_new_arrays(mdstat, &statelist, test,
+						   &info);
 
 		/* If an array has active < raid && spare == 0 && spare_group != NULL
 		 * Look for another array with spare > 0 and active == raid and same spare_group
 		 *  if found, choose a device and hotremove/hotadd
 		 */
 		if (share && anydegraded)
-			try_spare_migration(statelist, mailaddr, mailfrom,
-					    alert_cmd, dosyslog);
+			try_spare_migration(statelist, &info);
 		if (!new_found) {
 			if (oneshot)
 				break;
@@ -244,6 +249,12 @@ int Monitor(struct mddev_dev *devlist,
 
 static int make_daemon(char *pidfile)
 {
+	/* Return:
+	 * -1 in the forked daemon
+	 *  0 in the parent
+	 *  1 on error
+	 * so a none-negative becomes the exit code.
+	 */
 	int pid = fork();
 	if (pid > 0) {
 		if (!pidfile)
@@ -269,7 +280,7 @@ static int make_daemon(char *pidfile)
 	dup2(0,1);
 	dup2(0,2);
 	setsid();
-	return 0;
+	return -1;
 }
 
 static int check_one_sharer(int scan)
@@ -280,7 +291,8 @@ static int check_one_sharer(int scan)
 	struct stat buf;
 	fp = fopen("/var/run/mdadm/autorebuild.pid", "r");
 	if (fp) {
-		fscanf(fp, "%d", &pid);
+		if (fscanf(fp, "%d", &pid) != 1)
+			pid = -1;
 		sprintf(dir, "/proc/%d", pid);
 		rv = stat(dir, &buf);
 		if (rv != -1) {
@@ -293,37 +305,42 @@ static int check_one_sharer(int scan)
 			} else {
 				fprintf(stderr, Name ": Warning: One"
 					" autorebuild process already"
-					" running.");
+					" running.\n");
 			}
 		}
 		fclose(fp);
 	}
 	if (scan) {
-		fp = fopen("/var/run/mdadm/autorebuild.pid", "w");
-		if (!fp)
-			fprintf(stderr, Name ": Cannot create"
-				" autorebuild.pid "
-				"file\n");
-		else {
-			pid = getpid();
-			fprintf(fp, "%d\n", pid);
-			fclose(fp);
+		if (mkdir("/var/run/mdadm", S_IRWXU) < 0 &&
+		    errno != EEXIST) {
+			fprintf(stderr, Name ": Can't create "
+				"autorebuild.pid file\n");
+		} else {
+			fp = fopen("/var/run/mdadm/autorebuild.pid", "w");
+			if (!fp)
+				fprintf(stderr, Name ": Cannot create"
+					" autorebuild.pid"
+					"file\n");
+			else {
+				pid = getpid();
+				fprintf(fp, "%d\n", pid);
+				fclose(fp);
+			}
 		}
 	}
 	return 0;
 }
 
-static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mailfrom, char *cmd,
-		  int dosyslog)
+static void alert(char *event, char *dev, char *disc, struct alert_info *info)
 {
 	int priority;
 
-	if (!cmd && !mailaddr) {
+	if (!info->alert_cmd && !info->mailaddr && !info->dosyslog) {
 		time_t now = time(0);
 
 		printf("%1.15s: %s on %s %s\n", ctime(&now)+4, event, dev, disc?disc:"unknown device");
 	}
-	if (cmd) {
+	if (info->alert_cmd) {
 		int pid = fork();
 		switch(pid) {
 		default:
@@ -332,11 +349,12 @@ static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mail
 		case -1:
 			break;
 		case 0:
-			execl(cmd, cmd, event, dev, disc, NULL);
+			execl(info->alert_cmd, info->alert_cmd,
+			      event, dev, disc, NULL);
 			exit(2);
 		}
 	}
-	if (mailaddr &&
+	if (info->mailaddr &&
 	    (strncmp(event, "Fail", 4)==0 ||
 	     strncmp(event, "Test", 4)==0 ||
 	     strncmp(event, "Spares", 6)==0 ||
@@ -347,20 +365,27 @@ static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mail
 			char hname[256];
 			gethostname(hname, sizeof(hname));
 			signal(SIGPIPE, SIG_IGN);
-			if (mailfrom)
-				fprintf(mp, "From: %s\n", mailfrom);
+			if (info->mailfrom)
+				fprintf(mp, "From: %s\n", info->mailfrom);
 			else
 				fprintf(mp, "From: " Name " monitoring <root>\n");
-			fprintf(mp, "To: %s\n", mailaddr);
-			fprintf(mp, "Subject: %s event on %s:%s\n\n", event, dev, hname);
+			fprintf(mp, "To: %s\n", info->mailaddr);
+			fprintf(mp, "Subject: %s event on %s:%s\n\n",
+				event, dev, hname);
 
-			fprintf(mp, "This is an automatically generated mail message from " Name "\n");
+			fprintf(mp,
+				"This is an automatically generated"
+				" mail message from " Name "\n");
 			fprintf(mp, "running on %s\n\n", hname);
 
-			fprintf(mp, "A %s event had been detected on md device %s.\n\n", event, dev);
+			fprintf(mp,
+				"A %s event had been detected on"
+				" md device %s.\n\n", event, dev);
 
 			if (disc && disc[0] != ' ')
-				fprintf(mp, "It could be related to component device %s.\n\n", disc);
+				fprintf(mp,
+					"It could be related to"
+					" component device %s.\n\n", disc);
 			if (disc && disc[0] == ' ')
 				fprintf(mp, "Extra information:%s.\n\n", disc);
 
@@ -370,18 +395,19 @@ static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mail
 			if (mdstat) {
 				char buf[8192];
 				int n;
-				fprintf(mp, "\nP.S. The /proc/mdstat file currently contains the following:\n\n");
+				fprintf(mp,
+					"\nP.S. The /proc/mdstat file"
+					" currently contains the following:\n\n");
 				while ( (n=fread(buf, 1, sizeof(buf), mdstat)) > 0)
-					n=fwrite(buf, 1, n, mp); /* yes, i don't care about the result */
+					n=fwrite(buf, 1, n, mp);
 				fclose(mdstat);
 			}
 			pclose(mp);
 		}
-
 	}
 
 	/* log the event to syslog maybe */
-	if (dosyslog) {
+	if (info->dosyslog) {
 		/* Log at a different severity depending on the event.
 		 *
 		 * These are the critical events:  */
@@ -399,44 +425,47 @@ static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mail
 			priority = LOG_INFO;
 
 		if (disc)
-			syslog(priority, "%s event detected on md device %s, component device %s", event, dev, disc);
+			syslog(priority,
+			       "%s event detected on md device %s,"
+			       " component device %s", event, dev, disc);
 		else
-			syslog(priority, "%s event detected on md device %s", event, dev);
+			syslog(priority,
+			       "%s event detected on md device %s",
+			       event, dev);
 	}
 }
 
 static int check_array(struct state *st, struct mdstat_ent *mdstat,
-		       int test, char *mailaddr,
-		       char *mailfrom, char *alert_cmd, int dosyslog,
+		       int test, struct alert_info *ainfo,
 		       int increments)
 {
+	/* Update the state 'st' to reflect any changes shown in mdstat,
+	 * or found by directly examining the array, and return
+	 * '1' if the array is degraded, or '0' if it is optimal (or dead).
+	 */
 	struct { int state, major, minor; } info[MaxDisks];
 	mdu_array_info_t array;
 	struct mdstat_ent *mse = NULL, *mse2;
 	char *dev = st->devname;
 	int fd;
 	int i;
+	int remaining_disks;
+	int last_disk;
 
 	if (test)
-		alert("TestMessage", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+		alert("TestMessage", dev, NULL, ainfo);
 	fd = open(dev, O_RDONLY);
 	if (fd < 0) {
 		if (!st->err)
-			alert("DeviceDisappeared", dev, NULL,
-			      mailaddr, mailfrom, alert_cmd, dosyslog);
-/*					fprintf(stderr, Name ": cannot open %s: %s\n",
-					dev, strerror(errno));
-*/				st->err=1;
+			alert("DeviceDisappeared", dev, NULL, ainfo);
+		st->err=1;
 		return 0;
 	}
 	fcntl(fd, F_SETFD, FD_CLOEXEC);
 	if (ioctl(fd, GET_ARRAY_INFO, &array)<0) {
 		if (!st->err)
-			alert("DeviceDisappeared", dev, NULL,
-			      mailaddr, mailfrom, alert_cmd, dosyslog);
-/*					fprintf(stderr, Name ": cannot get array info for %s: %s\n",
-					dev, strerror(errno));
-*/				st->err=1;
+			alert("DeviceDisappeared", dev, NULL, ainfo);
+		st->err=1;
 		close(fd);
 		return 0;
 	}
@@ -445,8 +474,7 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 	 */
 	if (array.level == 0 || array.level == -1) {
 		if (!st->err)
-			alert("DeviceDisappeared", dev, "Wrong-Level",
-			      mailaddr, mailfrom, alert_cmd, dosyslog);
+			alert("DeviceDisappeared", dev, "Wrong-Level", ainfo);
 		st->err = 1;
 		close(fd);
 		return 0;
@@ -490,20 +518,23 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 		    ))) {
 		close(fd);
 		st->err = 0;
-		return 0;
+		if ((st->active < st->raid) && st->spare == 0)
+			return 1;
+		else
+			return 0;
 	}
 	if (st->utime == 0 && /* new array */
 	    mse->pattern && strchr(mse->pattern, '_') /* degraded */
 		)
-		alert("DegradedArray", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+		alert("DegradedArray", dev, NULL, ainfo);
 
 	if (st->utime == 0 && /* new array */
 	    st->expected_spares > 0 &&
 	    array.spare_disks < st->expected_spares)
-		alert("SparesMissing", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+		alert("SparesMissing", dev, NULL, ainfo);
 	if (st->percent == -1 &&
 	    mse->percent >= 0)
-		alert("RebuildStarted", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+		alert("RebuildStarted", dev, NULL, ainfo);
 	if (st->percent >= 0 &&
 	    mse->percent >= 0 &&
 	    (mse->percent / increments) > (st->percent / increments)) {
@@ -514,8 +545,7 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 		else
 			snprintf(percentalert, sizeof(percentalert), "Rebuild%02d", mse->percent);
 
-		alert(percentalert,
-		      dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+		alert(percentalert, dev, NULL, ainfo);
 	}
 
 	if (mse->percent == -1 &&
@@ -529,15 +559,16 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 		if (sra && sra->mismatch_cnt > 0) {
 			char cnt[40];
 			sprintf(cnt, " mismatches found: %d", sra->mismatch_cnt);
-			alert("RebuildFinished", dev, cnt, mailaddr, mailfrom, alert_cmd, dosyslog);
+			alert("RebuildFinished", dev, cnt, ainfo);
 		} else
-			alert("RebuildFinished", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+			alert("RebuildFinished", dev, NULL, ainfo);
 		if (sra)
 			free(sra);
 	}
 	st->percent = mse->percent;
 
-	for (i=0; i<MaxDisks && i <= array.raid_disks + array.nr_disks;
+	remaining_disks = array.nr_disks;
+	for (i=0; i<MaxDisks && remaining_disks > 0;
 	     i++) {
 		mdu_disk_info_t disc;
 		disc.number = i;
@@ -545,11 +576,15 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 			info[i].state = disc.state;
 			info[i].major = disc.major;
 			info[i].minor = disc.minor;
+			if (disc.major || disc.minor)
+				remaining_disks --;
 		} else
 			info[i].major = info[i].minor = 0;
 	}
+	last_disk = i;
 
-	if (strncmp(mse->metadata_version, "external:", 9) == 0 &&
+	if (mse->metadata_version &&
+	    strncmp(mse->metadata_version, "external:", 9) == 0 &&
 	    is_subarray(mse->metadata_version+9))
 		st->parent_dev =
 			devname2devnum(mse->metadata_version+10);
@@ -567,7 +602,7 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 		int change;
 		char *dv = NULL;
 		disc.number = i;
-		if (i > array.raid_disks + array.nr_disks) {
+		if (i >= last_disk) {
 			newstate = 0;
 			disc.major = disc.minor = 0;
 		} else if (info[i].major || info[i].minor) {
@@ -579,7 +614,7 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 		} else if (mse &&  mse->pattern && i < (int)strlen(mse->pattern)) {
 			switch(mse->pattern[i]) {
 			case 'U': newstate = 6 /* ACTIVE/SYNC */; break;
-			case '_': newstate = 0; break;
+			case '_': newstate = 8 /* REMOVED */; break;
 			}
 			disc.major = disc.minor = 0;
 		}
@@ -593,20 +628,20 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 			     ((st->devstate[i]&change)&(1<<MD_DISK_ACTIVE)) ||
 			     ((st->devstate[i]&change)&(1<<MD_DISK_SYNC)))
 				)
-				alert("Fail", dev, dv, mailaddr, mailfrom, alert_cmd, dosyslog);
+				alert("Fail", dev, dv, ainfo);
 			else if (i >= array.raid_disks &&
 				 (disc.major || disc.minor) &&
 				 st->devid[i] == makedev(disc.major, disc.minor) &&
 				 ((newstate&change)&(1<<MD_DISK_FAULTY))
 				)
-				alert("FailSpare", dev, dv, mailaddr, mailfrom, alert_cmd, dosyslog);
+				alert("FailSpare", dev, dv, ainfo);
 			else if (i < array.raid_disks &&
 				 ! (newstate & (1<<MD_DISK_REMOVED)) &&
 				 (((st->devstate[i]&change)&(1<<MD_DISK_FAULTY)) ||
 				  ((newstate&change)&(1<<MD_DISK_ACTIVE)) ||
 				  ((newstate&change)&(1<<MD_DISK_SYNC)))
 				)
-				alert("SpareActive", dev, dv, mailaddr, mailfrom, alert_cmd, dosyslog);
+				alert("SpareActive", dev, dv, ainfo);
 		}
 		st->devstate[i] = newstate;
 		st->devid[i] = makedev(disc.major, disc.minor);
@@ -623,9 +658,8 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 	return 0;
 }
 
-static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist,
-			   int test, char *mailaddr, char *mailfrom,
-			   char *alert_cmd, int dosyslog)
+static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
+			  int test, struct alert_info *info)
 {
 	struct mdstat_ent *mse;
 	int new_found = 0;
@@ -656,86 +690,241 @@ static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist,
 				continue;
 			}
 			close(fd);
-			st->next = statelist;
+			st->next = *statelist;
 			st->err = 1;
 			st->devnum = mse->devnum;
 			st->percent = -2;
 			st->expected_spares = -1;
-			if (strncmp(mse->metadata_version, "external:", 9) == 0 &&
+			if (mse->metadata_version &&
+			    strncmp(mse->metadata_version, "external:", 9) == 0 &&
 			    is_subarray(mse->metadata_version+9))
 				st->parent_dev =
 					devname2devnum(mse->metadata_version+10);
 			else
 				st->parent_dev = NoMdDev;
-			statelist = st;
+			*statelist = st;
 			if (test)
-				alert("TestMessage", st->devname, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
-			alert("NewArray", st->devname, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+				alert("TestMessage", st->devname, NULL, info);
+			alert("NewArray", st->devname, NULL, info);
 			new_found = 1;
 		}
 	return new_found;
 }
 
-static void try_spare_migration(struct state *statelist,
-				char *mailaddr, char *mailfrom,
-				char *alert_cmd, int dosyslog)
+static int get_min_spare_size_required(struct state *st, unsigned long long *sizep)
+{
+	int fd;
+
+	if (!st->metadata ||
+	    !st->metadata->ss->min_acceptable_spare_size) {
+		*sizep = 0;
+		return 0;
+	}
+
+	fd = open(st->devname, O_RDONLY);
+	if (fd < 0)
+		return 1;
+	if (st->metadata->ss->external)
+		st->metadata->ss->load_container(st->metadata, fd, st->devname);
+	else
+		st->metadata->ss->load_super(st->metadata, fd, st->devname);
+	close(fd);
+	if (!st->metadata->sb)
+		return 1;
+	*sizep = st->metadata->ss->min_acceptable_spare_size(st->metadata);
+	st->metadata->ss->free_super(st->metadata);
+
+	return 0;
+}
+
+static int check_donor(struct state *from, struct state *to)
 {
+	struct state *sub;
+
+	if (from == to)
+		return 0;
+	if (from->parent)
+		/* Cannot move from a member */
+		return 0;
+	if (from->err)
+		return 0;
+	for (sub = from->subarray; sub; sub = sub->subarray)
+		/* If source array has degraded subarrays, don't
+		 * remove anything
+		 */
+		if (sub->active < sub->raid)
+			return 0;
+	if (from->metadata->ss->external == 0)
+		if (from->active < from->raid)
+			return 0;
+	if (from->spare <= 0)
+		return 0;
+	return 1;
+}
+
+static dev_t choose_spare(struct state *from, struct state *to,
+			struct domainlist *domlist, unsigned long long min_size)
+{
+	int d;
+	dev_t dev = 0;
+
+	for (d = from->raid; !dev && d < MaxDisks; d++) {
+		if (from->devid[d] > 0 &&
+		    from->devstate[d] == 0) {
+			struct dev_policy *pol;
+			unsigned long long dev_size;
+
+			if (to->metadata->ss->external &&
+			    test_partition_from_id(from->devid[d]))
+				continue;
+
+			if (min_size &&
+			    dev_size_from_id(from->devid[d], &dev_size) &&
+			    dev_size < min_size)
+				continue;
+
+			pol = devnum_policy(from->devid[d]);
+			if (from->spare_group)
+				pol_add(&pol, pol_domain,
+					from->spare_group, NULL);
+			if (domain_test(domlist, pol, to->metadata->ss->name) == 1)
+			    dev = from->devid[d];
+			dev_policy_free(pol);
+		}
+	}
+	return dev;
+}
+
+static dev_t container_choose_spare(struct state *from, struct state *to,
+				    struct domainlist *domlist,
+				    unsigned long long min_size, int active)
+{
+	/* This is similar to choose_spare, but we cannot trust devstate,
+	 * so we need to read the metadata instead
+	 */
+	struct mdinfo *list;
+	struct supertype *st = from->metadata;
+	int fd = open(from->devname, O_RDONLY);
+	int err;
+	dev_t dev = 0;
+
+	if (fd < 0)
+		return 0;
+	if (!st->ss->getinfo_super_disks) {
+		close(fd);
+		return 0;
+	}
+	
+	err = st->ss->load_container(st, fd, NULL);
+	close(fd);
+	if (err)
+		return 0;
+	
+	if (from == to) {
+		/* We must check if number of active disks has not increased
+		 * since ioctl in main loop. mdmon may have added spare
+		 * to subarray. If so we do not need to look for more spares
+		 * so return non zero value */
+		int active_cnt = 0;
+		struct mdinfo *dp;
+		list = st->ss->getinfo_super_disks(st);
+		if (!list) {
+			st->ss->free_super(st);
+			return 1;
+		}
+		dp = list->devs;
+		while (dp) {
+			if (dp->disk.state & (1<<MD_DISK_SYNC) &&
+			    !(dp->disk.state & (1<<MD_DISK_FAULTY)))
+				active_cnt++;
+			dp = dp->next;
+		}
+		sysfs_free(list);
+		if (active < active_cnt) {
+			/* Spare just activated.*/
+			st->ss->free_super(st);
+			return 1;
+		}
+	}
+
+	/* We only need one spare so full list not needed */
+	list = container_choose_spares(st, min_size, domlist, from->spare_group,
+				       to->metadata->ss->name, 1);
+	if (list) {
+		struct mdinfo *disks = list->devs;
+		if (disks)
+			dev = makedev(disks->disk.major, disks->disk.minor);
+		sysfs_free(list);
+	}
+	st->ss->free_super(st);
+	return dev;
+}
+
+
+static void try_spare_migration(struct state *statelist, struct alert_info *info)
+{
+	struct state *from;
 	struct state *st;
 
 	link_containers_with_subarrays(statelist);
-	for (st = statelist; st; st=st->next)
+	for (st = statelist; st; st = st->next)
 		if (st->active < st->raid &&
-		    st->spare == 0 &&
-		    st->spare_group != NULL) {
-			struct state *st2;
-			for (st2=statelist ; st2 ; st2=st2->next)
-				if (st2 != st &&
-				    st2->spare > 0 &&
-				    st2->active == st2->raid &&
-				    st2->spare_group != NULL &&
-				    strcmp(st->spare_group, st2->spare_group) == 0) {
-					/* try to remove and add */
-					int fd1 = open(st->devname, O_RDONLY);
-					int fd2 = open(st2->devname, O_RDONLY);
-					int dev = -1;
-					int d;
-					if (fd1 < 0 || fd2 < 0) {
-						if (fd1>=0) close(fd1);
-						if (fd2>=0) close(fd2);
-						continue;
-					}
-					for (d=st2->raid; d < MaxDisks; d++) {
-						if (st2->devid[d] > 0 &&
-						    st2->devstate[d] == 0) {
-							dev = st2->devid[d];
-							break;
-						}
-					}
-					if (dev > 0) {
-						struct mddev_dev 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(dev), minor(dev));
-
-						devlist.disposition = 'r';
-						if (Manage_subdevs(st2->devname, fd2, &devlist, -1, 0) == 0) {
-							devlist.disposition = 'a';
-							if (Manage_subdevs(st->devname, fd1, &devlist, -1, 0) == 0) {
-								alert("MoveSpare", st->devname, st2->devname, mailaddr, mailfrom, alert_cmd, dosyslog);
-								close(fd1);
-								close(fd2);
-								break;
-							}
-							else Manage_subdevs(st2->devname, fd2, &devlist, -1, 0);
-						}
-					}
-					close(fd1);
-					close(fd2);
+		    st->spare == 0 && !st->err) {
+			struct domainlist *domlist = NULL;
+			int d;
+			struct state *to = st;
+			unsigned long long min_size;
+
+			if (to->parent_dev != NoMdDev && !to->parent)
+				/* subarray monitored without parent container
+				 * we can't move spares here */
+				continue;
+			
+			if (to->parent)
+				/* member of a container */
+				to = to->parent;
+
+			if (get_min_spare_size_required(to, &min_size))
+				continue;
+			if (to->metadata->ss->external) {
+				/* We must make sure there is
+				 * no suitable spare in container already.
+				 * If there is we don't add more */
+				dev_t devid = container_choose_spare(
+					to, to, NULL, min_size, st->active);
+				if (devid > 0)
+					continue;
+			}
+			for (d = 0; d < MaxDisks; d++)
+				if (to->devid[d])
+					domainlist_add_dev(&domlist,
+							   to->devid[d],
+							   to->metadata->ss->name);
+			if (to->spare_group)
+				domain_add(&domlist, to->spare_group);
+			/*
+			 * No spare migration if the destination
+			 * has no domain. Skip this array.
+			 */
+			if (!domlist)
+				continue;
+			for (from=statelist ; from ; from=from->next) {
+				dev_t devid;
+				if (!check_donor(from, to))
+					continue;
+				if (from->metadata->ss->external)
+					devid = container_choose_spare(
+						from, to, domlist, min_size, 0);
+				else
+					devid = choose_spare(from, to, domlist,
+							     min_size);
+				if (devid > 0
+				    && move_spare(from->devname, to->devname, devid)) {
+					alert("MoveSpare", to->devname, from->devname, info);
+					break;
 				}
+			}
+			domain_free(domlist);
 		}
 }
 
@@ -794,7 +983,7 @@ int Wait(char *dev)
 				if (is_subarray(&e->metadata_version[9]))
 					ping_monitor(&e->metadata_version[9]);
 				else
-					ping_monitor(devnum2devname(devnum));
+					ping_monitor_by_id(devnum);
 			}
 			free_mdstat(ms);
 			return rv;
@@ -804,3 +993,105 @@ int Wait(char *dev)
 		mdstat_wait(5);
 	}
 }
+
+#ifndef MDASSEMBLE
+
+static char *clean_states[] = {
+	"clear", "inactive", "readonly", "read-auto", "clean", NULL };
+
+int WaitClean(char *dev, int sock, int verbose)
+{
+	int fd;
+	struct mdinfo *mdi;
+	int rv = 1;
+	int devnum;
+
+	fd = open(dev, O_RDONLY);
+	if (fd < 0) {
+		if (verbose)
+			fprintf(stderr, Name ": Couldn't open %s: %s\n", dev, strerror(errno));
+		return 1;
+	}
+
+	devnum = fd2devnum(fd);
+	mdi = sysfs_read(fd, devnum, GET_VERSION|GET_LEVEL|GET_SAFEMODE);
+	if (!mdi) {
+		if (verbose)
+			fprintf(stderr, Name ": Failed to read sysfs attributes for "
+				"%s\n", dev);
+		close(fd);
+		return 0;
+	}
+
+	switch(mdi->array.level) {
+	case LEVEL_LINEAR:
+	case LEVEL_MULTIPATH:
+	case 0:
+		/* safemode delay is irrelevant for these levels */
+		rv = 0;
+	}
+
+	/* for internal metadata the kernel handles the final clean
+	 * transition, containers can never be dirty
+	 */
+	if (!is_subarray(mdi->text_version))
+		rv = 0;
+
+	/* safemode disabled ? */
+	if (mdi->safe_mode_delay == 0)
+		rv = 0;
+
+	if (rv) {
+		int state_fd = sysfs_open(fd2devnum(fd), NULL, "array_state");
+		char buf[20];
+		fd_set fds;
+		struct timeval tm;
+
+		/* minimize the safe_mode_delay and prepare to wait up to 5s
+		 * for writes to quiesce
+		 */
+		sysfs_set_safemode(mdi, 1);
+		tm.tv_sec = 5;
+		tm.tv_usec = 0;
+
+		FD_ZERO(&fds);
+
+		/* wait for array_state to be clean */
+		while (1) {
+			rv = read(state_fd, buf, sizeof(buf));
+			if (rv < 0)
+				break;
+			if (sysfs_match_word(buf, clean_states) <= 4)
+				break;
+			FD_SET(state_fd, &fds);
+			rv = select(state_fd + 1, NULL, NULL, &fds, &tm);
+			if (rv < 0 && errno != EINTR)
+				break;
+			lseek(state_fd, 0, SEEK_SET);
+		}
+		if (rv < 0)
+			rv = 1;
+		else if (fping_monitor(sock) == 0 ||
+			 ping_monitor(mdi->text_version) == 0) {
+			/* we need to ping to close the window between array
+			 * state transitioning to clean and the metadata being
+			 * marked clean
+			 */
+			rv = 0;
+		} else
+			rv = 1;
+		if (rv && verbose)
+			fprintf(stderr, Name ": Error waiting for %s to be clean\n",
+				dev);
+
+		/* restore the original safe_mode_delay */
+		sysfs_set_safemode(mdi, mdi->safe_mode_delay);
+		close(state_fd);
+	}
+
+	sysfs_free(mdi);
+	close(fd);
+
+	return rv;
+}
+#endif /* MDASSEMBLE */