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

diff --git a/Monitor.c b/Monitor.c
index e0c86917..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
@@ -70,7 +70,7 @@ 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, struct alert_info *info,
 		       int increments);
-static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist,
+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);
@@ -143,7 +143,7 @@ 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;
 	}
@@ -152,9 +152,11 @@ int Monitor(struct mddev_dev *devlist,
 	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))
@@ -223,7 +225,7 @@ int Monitor(struct mddev_dev *devlist,
 		
 		/* now check if there are any new devices found in mdstat */
 		if (scan)
-			new_found = add_new_arrays(mdstat, statelist, test,
+			new_found = add_new_arrays(mdstat, &statelist, test,
 						   &info);
 
 		/* If an array has active < raid && spare == 0 && spare_group != NULL
@@ -247,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)
@@ -272,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)
@@ -283,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) {
@@ -296,21 +305,27 @@ 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;
@@ -320,7 +335,7 @@ static void alert(char *event, char *dev, char *disc, struct alert_info *info)
 {
 	int priority;
 
-	if (!info->alert_cmd && !info->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");
@@ -424,12 +439,18 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 		       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, ainfo);
@@ -497,7 +518,10 @@ 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 */
@@ -543,7 +567,8 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat,
 	}
 	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;
@@ -551,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);
@@ -573,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) {
@@ -585,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;
 		}
@@ -629,7 +658,7 @@ 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,
+static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist,
 			  int test, struct alert_info *info)
 {
 	struct mdstat_ent *mse;
@@ -661,18 +690,19 @@ 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, info);
 			alert("NewArray", st->devname, NULL, info);
@@ -681,51 +711,73 @@ static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist,
 	return new_found;
 }
 
-unsigned long long min_spare_size_required(struct state *st)
+static int get_min_spare_size_required(struct state *st, unsigned long long *sizep)
 {
 	int fd;
-	unsigned long long rv = 0;
 
 	if (!st->metadata ||
-	    !st->metadata->ss->min_acceptable_spare_size)
-		return rv;
+	    !st->metadata->ss->min_acceptable_spare_size) {
+		*sizep = 0;
+		return 0;
+	}
 
 	fd = open(st->devname, O_RDONLY);
 	if (fd < 0)
-		return 0;
-	st->metadata->ss->load_super(st->metadata, fd, st->devname);
+		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);
-	rv = st->metadata->ss->min_acceptable_spare_size(st->metadata);
+	if (!st->metadata->sb)
+		return 1;
+	*sizep = st->metadata->ss->min_acceptable_spare_size(st->metadata);
 	st->metadata->ss->free_super(st->metadata);
 
-	return rv;
+	return 0;
 }
 
-static int move_spare(struct state *from, struct state *to,
-		      struct domainlist *domlist,
-		      struct alert_info *info)
+static int check_donor(struct state *from, struct state *to)
 {
-	struct mddev_dev devlist;
-	char devname[20];
-	unsigned long long min_size;
-
-	/* try to remove and add */
-	int fd1 = open(to->devname, O_RDONLY);
-	int fd2 = open(from->devname, O_RDONLY);
-	int dev = -1;
-	int d;
-	if (fd1 < 0 || fd2 < 0) {
-		if (fd1>=0) close(fd1);
-		if (fd2>=0) close(fd2);
+	struct state *sub;
+
+	if (from == to)
 		return 0;
-	}
-	min_size = min_spare_size_required(to);
-	for (d = from->raid; dev < 0 && d < MaxDisks; d++) {
+	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)
@@ -735,66 +787,80 @@ static int move_spare(struct state *from, struct state *to,
 			if (from->spare_group)
 				pol_add(&pol, pol_domain,
 					from->spare_group, NULL);
-			if (domain_test(domlist, pol, to->metadata->ss->name))
+			if (domain_test(domlist, pol, to->metadata->ss->name) == 1)
 			    dev = from->devid[d];
 			dev_policy_free(pol);
 		}
 	}
-	if (dev < 0) {
-		close(fd1);
-		close(fd2);
-		return 0;
-	}
-
-	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(from->devname, fd2, &devlist, -1, 0) == 0) {
-		devlist.disposition = 'a';
-		if (Manage_subdevs(to->devname, fd1, &devlist, -1, 0) == 0) {
-			alert("MoveSpare", to->devname, from->devname, info);
-			close(fd1);
-			close(fd2);
-			return 1;
-		}
-		else Manage_subdevs(from->devname, fd2, &devlist, -1, 0);
-	}
-	close(fd1);
-	close(fd2);
-	return 0;
+	return dev;
 }
 
-static int check_donor(struct state *from, struct state *to,
-		       struct domainlist *domlist)
+static dev_t container_choose_spare(struct state *from, struct state *to,
+				    struct domainlist *domlist,
+				    unsigned long long min_size, int active)
 {
-	struct state *sub;
+	/* 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 (from == to)
-		return 0;
-	if (from->parent)
-		/* Cannot move from a member */
+	if (fd < 0)
 		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)
+	if (!st->ss->getinfo_super_disks) {
+		close(fd);
 		return 0;
-	if (domlist == NULL)
+	}
+	
+	err = st->ss->load_container(st, fd, NULL);
+	close(fd);
+	if (err)
 		return 0;
-	return 1;
+	
+	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;
@@ -803,15 +869,32 @@ static void try_spare_migration(struct state *statelist, struct alert_info *info
 	link_containers_with_subarrays(statelist);
 	for (st = statelist; st; st = st->next)
 		if (st->active < st->raid &&
-		    st->spare == 0) {
+		    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,
@@ -819,11 +902,28 @@ static void try_spare_migration(struct state *statelist, struct alert_info *info
 							   to->metadata->ss->name);
 			if (to->spare_group)
 				domain_add(&domlist, to->spare_group);
-
-			for (from=statelist ; from ; from=from->next)
-				if (check_donor(from, to, domlist)
-				    && move_spare(from, to, domlist, info))
-						break;
+			/*
+			 * 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);
 		}
 }
@@ -883,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;
@@ -893,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 */