X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=monitor.c;h=59b4181954c24c0dc209e93c17c6ba391e2a4eab;hb=62a48395f60965d04da1a9cbb937bda79dd071c8;hp=fda3fc01049f2504340d66b55f76a9f35550694b;hpb=a35c070bcd05b308120dce5ada15bfbb2d71790c;p=thirdparty%2Fmdadm.git

diff --git a/monitor.c b/monitor.c
index fda3fc01..59b41819 100644
--- a/monitor.c
+++ b/monitor.c
@@ -1,3 +1,22 @@
+/*
+ * mdmon - monitor external metadata arrays
+ *
+ * Copyright (C) 2007-2009 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2007-2009 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
 
 #include "mdadm.h"
 #include "mdmon.h"
@@ -47,44 +66,36 @@ static int read_attr(char *buf, int len, int fd)
 	return n;
 }
 
-
-static int get_resync_start(struct active_array *a)
+static unsigned long long read_resync_start(int fd)
 {
 	char buf[30];
 	int n;
 
-	n = read_attr(buf, 30, a->resync_start_fd);
+	n = read_attr(buf, 30, fd);
 	if (n <= 0)
-		return n;
-
-	a->resync_start = strtoull(buf, NULL, 10);
-
-	return 1;
-}
-
-static int attr_match(const char *attr, const char *str)
-{
-	/* See if attr, read from a sysfs file, matches
-	 * str.  They must either be the same, or attr can
-	 * have a trailing newline or comma
-	 */
-	while (*attr && *str && *attr == *str) {
-		attr++;
-		str++;
-	}
-
-	if (*str || (*attr && *attr != ',' && *attr != '\n'))
 		return 0;
-	return 1;
+	if (strncmp(buf, "none", 4) == 0)
+		return MaxSector;
+	else
+		return strtoull(buf, NULL, 10);
 }
 
-static int match_word(const char *word, char **list)
+static unsigned long long read_sync_completed(int fd)
 {
+	unsigned long long val;
+	char buf[50];
 	int n;
-	for (n=0; list[n]; n++)
-		if (attr_match(word, list[n]))
-			break;
-	return n;
+	char *ep;
+
+	n = read_attr(buf, 50, fd);
+
+	if (n <= 0)
+		return 0;
+	buf[n] = 0;
+	val = strtoull(buf, &ep, 0);
+	if (ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))
+		return 0;
+	return val;
 }
 
 static enum array_state read_state(int fd)
@@ -94,7 +105,7 @@ static enum array_state read_state(int fd)
 
 	if (n <= 0)
 		return bad_word;
-	return (enum array_state) match_word(buf, array_states);
+	return (enum array_state) sysfs_match_word(buf, array_states);
 }
 
 static enum sync_action read_action( int fd)
@@ -104,7 +115,7 @@ static enum sync_action read_action( int fd)
 
 	if (n <= 0)
 		return bad_action;
-	return (enum sync_action) match_word(buf, sync_actions);
+	return (enum sync_action) sysfs_match_word(buf, sync_actions);
 }
 
 int read_dev_state(int fd)
@@ -119,15 +130,15 @@ int read_dev_state(int fd)
 
 	cp = buf;
 	while (cp) {
-		if (attr_match(cp, "faulty"))
+		if (sysfs_attr_match(cp, "faulty"))
 			rv |= DS_FAULTY;
-		if (attr_match(cp, "in_sync"))
+		if (sysfs_attr_match(cp, "in_sync"))
 			rv |= DS_INSYNC;
-		if (attr_match(cp, "write_mostly"))
+		if (sysfs_attr_match(cp, "write_mostly"))
 			rv |= DS_WRITE_MOSTLY;
-		if (attr_match(cp, "spare"))
+		if (sysfs_attr_match(cp, "spare"))
 			rv |= DS_SPARE;
-		if (attr_match(cp, "blocked"))
+		if (sysfs_attr_match(cp, "blocked"))
 			rv |= DS_BLOCKED;
 		cp = strchr(cp, ',');
 		if (cp)
@@ -202,19 +213,25 @@ static void signal_manager(void)
 
 static int read_and_act(struct active_array *a)
 {
+	unsigned long long sync_completed;
 	int check_degraded = 0;
 	int deactivate = 0;
 	struct mdinfo *mdi;
+	int dirty = 0;
 
 	a->next_state = bad_word;
 	a->next_action = bad_action;
 
 	a->curr_state = read_state(a->info.state_fd);
 	a->curr_action = read_action(a->action_fd);
+	a->info.resync_start = read_resync_start(a->resync_start_fd);
+	sync_completed = read_sync_completed(a->sync_completed_fd);
 	for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
 		mdi->next_state = 0;
-		if (mdi->state_fd >= 0)
+		if (mdi->state_fd >= 0) {
+			mdi->recovery_start = read_resync_start(mdi->recovery_fd);
 			mdi->curr_state = read_dev_state(mdi->state_fd);
+		}
 	}
 
 	if (a->curr_state <= inactive &&
@@ -225,46 +242,61 @@ static int read_and_act(struct active_array *a)
 		deactivate = 1;
 	}
 	if (a->curr_state == write_pending) {
-		get_resync_start(a);
 		a->container->ss->set_array_state(a, 0);
 		a->next_state = active;
+		dirty = 1;
 	}
 	if (a->curr_state == active_idle) {
-		/* Set array to 'clean' FIRST, then
-		 * a->ss->mark_clean(a, ~0ULL);
-		 * just ignore for now.
+		/* Set array to 'clean' FIRST, then mark clean
+		 * in the metadata
 		 */
+		a->next_state = clean;
+		dirty = 1;
 	}
-
+	if (a->curr_state == clean) {
+		a->container->ss->set_array_state(a, 1);
+	}
+	if (a->curr_state == active ||
+	    a->curr_state == suspended ||
+	    a->curr_state == bad_word)
+		dirty = 1;
 	if (a->curr_state == readonly) {
-		/* Well, I'm ready to handle things, so
-		 * read-auto is OK. FIXME what if we really want
-		 * readonly ???
+		/* Well, I'm ready to handle things.  If readonly
+		 * wasn't requested, transition to read-auto.
 		 */
-		get_resync_start(a);
-//		printf("Found a readonly array at %llu\n", a->resync_start);
-		if (a->resync_start == ~0ULL)
-			a->next_state = read_auto; /* array is clean */
-		else {
-			a->container->ss->set_array_state(a, 0);
-			a->next_state = active;
+		char buf[64];
+		read_attr(buf, sizeof(buf), a->metadata_fd);
+		if (strncmp(buf, "external:-", 10) == 0) {
+			/* explicit request for readonly array.  Leave it alone */
+			;
+		} else {
+			if (a->container->ss->set_array_state(a, 2))
+				a->next_state = read_auto; /* array is clean */
+			else {
+				a->next_state = active; /* Now active for recovery etc */
+				dirty = 1;
+			}
 		}
 	}
 
-	if (a->curr_action == idle &&
+	if (!deactivate &&
+	    a->curr_action == idle &&
 	    a->prev_action == resync) {
 		/* A resync has finished.  The endpoint is recorded in
 		 * 'sync_start'.  We don't update the metadata
 		 * until the array goes inactive or readonly though.
 		 * Just check if we need to fiddle spares.
 		 */
-		get_resync_start(a);
-		a->container->ss->set_array_state(a, 0);
+		a->container->ss->set_array_state(a, a->curr_state <= clean);
 		check_degraded = 1;
 	}
 
-	if (a->curr_action == idle &&
+	if (!deactivate &&
+	    a->curr_action == idle &&
 	    a->prev_action == recover) {
+		/* A recovery has finished.  Some disks may be in sync now,
+		 * and the array may no longer be degraded
+		 */
 		for (mdi = a->info.devs ; mdi ; mdi = mdi->next) {
 			a->container->ss->set_disk(a, mdi->disk.raid_disk,
 						   mdi->curr_state);
@@ -273,17 +305,47 @@ static int read_and_act(struct active_array *a)
 		}
 	}
 
+	/* Check for failures and if found:
+	 * 1/ Record the failure in the metadata and unblock the device.
+	 *    FIXME update the kernel to stop notifying on failed drives when
+	 *    the array is readonly and we have cleared 'blocked'
+	 * 2/ Try to remove the device if the array is writable, or can be
+	 *    made writable.
+	 */
 	for (mdi = a->info.devs ; mdi ; mdi = mdi->next) {
 		if (mdi->curr_state & DS_FAULTY) {
 			a->container->ss->set_disk(a, mdi->disk.raid_disk,
 						   mdi->curr_state);
 			check_degraded = 1;
-			mdi->next_state = DS_REMOVE;
+			mdi->next_state |= DS_UNBLOCK;
+			if (a->curr_state == read_auto) {
+				a->container->ss->set_array_state(a, 0);
+				a->next_state = active;
+			}
+			if (a->curr_state > readonly)
+				mdi->next_state |= DS_REMOVE;
 		}
 	}
 
+	/* Check for recovery checkpoint notifications.  We need to be a
+	 * minimum distance away from the last checkpoint to prevent
+	 * over checkpointing.  Note reshape checkpointing is not
+	 * handled here.
+	 */
+	if (sync_completed > a->last_checkpoint &&
+	    sync_completed - a->last_checkpoint > a->info.component_size >> 4 &&
+	    a->curr_action > reshape) {
+		/* A (non-reshape) sync_action has reached a checkpoint.
+		 * Record the updated position in the metadata
+		 */
+		a->last_checkpoint = sync_completed;
+		a->container->ss->set_array_state(a, a->curr_state <= clean);
+	} else if (sync_completed > a->last_checkpoint)
+		a->last_checkpoint = sync_completed;
+
 	a->container->ss->sync_metadata(a->container);
-	dprintf("%s: update[%d]: (", __func__, a->info.container_member);
+	dprintf("%s(%d): state:%s action:%s next(", __func__, a->info.container_member,
+		array_states[a->curr_state], sync_actions[a->curr_action]);
 
 	/* Effect state changes in the array */
 	if (a->next_state != bad_word) {
@@ -292,18 +354,21 @@ static int read_and_act(struct active_array *a)
 	}
 	if (a->next_action != bad_action) {
 		write_attr(sync_actions[a->next_action], a->action_fd);
-		dprintf(" action:%s", array_states[a->next_state]);
+		dprintf(" action:%s", sync_actions[a->next_action]);
 	}
 	for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
-		if (mdi->next_state == DS_REMOVE && mdi->state_fd >= 0) {
+		if (mdi->next_state & DS_UNBLOCK) {
+			dprintf(" %d:-blocked", mdi->disk.raid_disk);
+			write_attr("-blocked", mdi->state_fd);
+		}
+
+		if ((mdi->next_state & DS_REMOVE) && mdi->state_fd >= 0) {
 			int remove_result;
 
-			write_attr("-blocked", mdi->state_fd);
 			/* the kernel may not be able to immediately remove the
 			 * disk, we can simply wait until the next event to try
 			 * again.
 			 */
-			dprintf(" %d:-blocked", mdi->disk.raid_disk);
 			remove_result = write_attr("remove", mdi->state_fd);
 			if (remove_result > 0) {
 				dprintf(" %d:removed", mdi->disk.raid_disk);
@@ -337,7 +402,7 @@ static int read_and_act(struct active_array *a)
 	if (deactivate)
 		a->container = NULL;
 
-	return 1;
+	return dirty;
 }
 
 static struct mdinfo *
@@ -399,6 +464,8 @@ static void dprint_wake_reasons(fd_set *fds)
 }
 #endif
 
+int monitor_loop_cnt;
+
 static int wait_and_act(struct supertype *container, int nowait)
 {
 	fd_set rfds;
@@ -407,6 +474,7 @@ static int wait_and_act(struct supertype *container, int nowait)
 	struct active_array *a, **ap;
 	int rv;
 	struct mdinfo *mdi;
+	static unsigned int dirty_arrays = ~0; /* start at some non-zero value */
 
 	FD_ZERO(&rfds);
 
@@ -429,25 +497,34 @@ static int wait_and_act(struct supertype *container, int nowait)
 
 		add_fd(&rfds, &maxfd, a->info.state_fd);
 		add_fd(&rfds, &maxfd, a->action_fd);
+		add_fd(&rfds, &maxfd, a->sync_completed_fd);
 		for (mdi = a->info.devs ; mdi ; mdi = mdi->next)
 			add_fd(&rfds, &maxfd, mdi->state_fd);
 
 		ap = &(*ap)->next;
 	}
 
-	if (manager_ready && *aap == NULL) {
-		/* No interesting arrays. Lets see about exiting.
-		 * Note that blocking at this point is not a problem
-		 * as there are no active arrays, there is nothing that
-		 * we need to be ready to do.
+	if (manager_ready && (*aap == NULL || (sigterm && !dirty_arrays))) {
+		/* No interesting arrays, or we have been told to
+		 * terminate and everything is clean.  Lets see about
+		 * exiting.  Note that blocking at this point is not a
+		 * problem as there are no active arrays, there is
+		 * nothing that we need to be ready to do.
 		 */
-		int fd = open(container->device_name, O_RDONLY|O_EXCL);
+		int fd = open_dev_excl(container->devnum);
 		if (fd >= 0 || errno != EBUSY) {
 			/* OK, we are safe to leave */
-			dprintf("no arrays to monitor... exiting\n");
+			if (sigterm && !dirty_arrays)
+				dprintf("caught sigterm, all clean... exiting\n");
+			else
+				dprintf("no arrays to monitor... exiting\n");
+			if (!sigterm)
+				/* On SIGTERM, someone (the take-over mdmon) will
+				 * clean up
+				 */
+				remove_pidfile(container->devname);
 			exit_now = 1;
 			signal_manager();
-			remove_pidfile(container->devname);
 			exit(0);
 		}
 	}
@@ -456,7 +533,9 @@ static int wait_and_act(struct supertype *container, int nowait)
 		sigset_t set;
 		sigprocmask(SIG_UNBLOCK, NULL, &set);
 		sigdelset(&set, SIGUSR1);
-		rv = pselect(maxfd+1, &rfds, NULL, NULL, NULL, &set);
+		monitor_loop_cnt |= 1;
+		rv = pselect(maxfd+1, NULL, NULL, &rfds, NULL, &set);
+		monitor_loop_cnt += 1;
 		if (rv == -1 && errno == EINTR)
 			rv = 0;
 		#ifdef DEBUG
@@ -477,7 +556,11 @@ static int wait_and_act(struct supertype *container, int nowait)
 		container->ss->sync_metadata(container);
 	}
 
+	rv = 0;
+	dirty_arrays = 0;
 	for (a = *aap; a ; a = a->next) {
+		int is_dirty;
+
 		if (a->replaces && !discard_this) {
 			struct active_array **ap;
 			for (ap = &a->next; *ap && *ap != a->replaces;
@@ -490,8 +573,17 @@ static int wait_and_act(struct supertype *container, int nowait)
 			/* FIXME check if device->state_fd need to be cleared?*/
 			signal_manager();
 		}
-		if (a->container)
-			rv += read_and_act(a);
+		if (a->container) {
+			is_dirty = read_and_act(a);
+			rv |= 1;
+			dirty_arrays += is_dirty;
+			/* when terminating stop manipulating the array after it
+			 * is clean, but make sure read_and_act() is given a
+			 * chance to handle 'active_idle'
+			 */
+			if (sigterm && !is_dirty)
+				a->container = NULL; /* stop touching this array */
+		}
 	}
 
 	/* propagate failures across container members */