X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=monitor.c;h=e29d023a4c756c9ad1599b5c283988ad1c479f00;hp=e941a1abd8352548660122ae6a3770cac265e35d;hb=1eb252b8488bbdd62ad602561fe8a90ef9079271;hpb=0af73f61a25904edc7da24e2da9786b48bb8bec6

diff --git a/monitor.c b/monitor.c
index e941a1ab..e29d023a 100644
--- a/monitor.c
+++ b/monitor.c
@@ -1,9 +1,9 @@
 
 #include "mdadm.h"
 #include "mdmon.h"
-
+#include <sys/syscall.h>
 #include <sys/select.h>
-
+#include <signal.h>
 
 static char *array_states[] = {
 	"clear", "inactive", "suspended", "readonly", "read-auto",
@@ -47,24 +47,8 @@ static int read_attr(char *buf, int len, int fd)
 	return n;
 }
 
-static int get_sync_pos(struct active_array *a)
-{
-	char buf[30];
-	int n;
 
-	n = read_attr(buf, 30, a->sync_pos_fd);
-	if (n <= 0)
-		return n;
-
-	if (strncmp(buf, "max", 3) == 0) {
-		a->sync_pos = ~(unsigned long long)0;
-		return 1;
-	}
-	a->sync_pos = strtoull(buf, NULL, 10);
-	return 1;
-}
-
-static int get_resync_start(struct active_array *a)
+int get_resync_start(struct active_array *a)
 {
 	char buf[30];
 	int n;
@@ -152,6 +136,12 @@ int read_dev_state(int fd)
 	return rv;
 }
 
+static void signal_manager(void)
+{
+	/* tgkill(getpid(), mon_tid, SIGUSR1); */
+	int pid = getpid();
+	syscall(SYS_tgkill, pid, mgr_tid, SIGUSR1);
+}
 
 /* Monitor a set of active md arrays - all of which share the
  * same metadata - and respond to events that require
@@ -183,24 +173,10 @@ int read_dev_state(int fd)
  *    sync_action was 'resync' and becomes 'idle' and resync_start becomes
  *    MaxSector
  *    Notify metadata that sync is complete.
- *    "Deal with Degraded"
  *
  *  recovery completes
  *    sync_action changes from 'recover' to 'idle'
  *    Check each device state and mark metadata if 'faulty' or 'in_sync'.
- *    "Deal with Degraded"
- *
- *  deal with degraded array
- *    We only do this when first noticing the array is degraded.
- *    This can be when we first see the array, when sync completes or
- *    when recovery completes.
- *
- *    Check if number of failed devices suggests recovery is needed, and
- *    skip if not.
- *    Ask metadata for a spare device
- *    Add device as not in_sync and give a role
- *    Update metadata.
- *    Start recovery.
  *
  *  deal with resync
  *    This only happens on finding a new array... mdadm will have set
@@ -226,7 +202,7 @@ int read_dev_state(int fd)
 
 static int read_and_act(struct active_array *a)
 {
-	int check_degraded;
+	int check_degraded = 0;
 	int deactivate = 0;
 	struct mdinfo *mdi;
 
@@ -237,25 +213,25 @@ static int read_and_act(struct active_array *a)
 	a->curr_action = read_action(a->action_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->curr_state = read_dev_state(mdi->state_fd);
 	}
 
 	if (a->curr_state <= inactive &&
 	    a->prev_state > inactive) {
 		/* array has been stopped */
-		get_sync_pos(a);
-		a->container->ss->mark_clean(a, a->sync_pos);
+		a->container->ss->set_array_state(a, 1);
 		a->next_state = clear;
 		deactivate = 1;
 	}
 	if (a->curr_state == write_pending) {
-		a->container->ss->mark_dirty(a);
+		get_resync_start(a);
+		a->container->ss->set_array_state(a, 0);
 		a->next_state = active;
 	}
 	if (a->curr_state == active_idle) {
 		/* Set array to 'clean' FIRST, then
-		 * a->ss->mark_clean(a);
+		 * a->ss->mark_clean(a, ~0ULL);
 		 * just ignore for now.
 		 */
 	}
@@ -266,33 +242,43 @@ static int read_and_act(struct active_array *a)
 		 * readonly ???
 		 */
 		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->mark_dirty(a);
+			a->container->ss->set_array_state(a, 0);
 			a->next_state = active;
 		}
 	}
 
-	if (a->curr_action == idle &&
+	if (!deactivate &&
+	    a->curr_action == idle &&
 	    a->prev_action == resync) {
-		/* check resync_start to see if it is 'max' */
+		/* 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->mark_sync(a, a->resync_start);
+		a->container->ss->set_array_state(a, 0);
 		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);
 			if (! (mdi->curr_state & DS_INSYNC))
 				check_degraded = 1;
 		}
+		a->container->ss->set_array_state(a, 0);
 	}
 
-
 	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,
@@ -302,35 +288,41 @@ static int read_and_act(struct active_array *a)
 		}
 	}
 
-	if (check_degraded) {
-		// FIXME;
-	}
-
-	a->container->ss->sync_metadata(a);
+	a->container->ss->sync_metadata(a->container);
+	dprintf("%s: update[%d]: (", __func__, a->info.container_member);
 
 	/* Effect state changes in the array */
-	if (a->next_state != bad_word)
+	if (a->next_state != bad_word) {
+		dprintf(" state:%s", array_states[a->next_state]);
 		write_attr(array_states[a->next_state], a->info.state_fd);
-	if (a->next_action != bad_action)
+	}
+	if (a->next_action != bad_action) {
 		write_attr(sync_actions[a->next_action], a->action_fd);
+		dprintf(" action:%s", array_states[a->next_state]);
+	}
 	for (mdi = a->info.devs; mdi ; mdi = mdi->next) {
-		if (mdi->next_state == DS_REMOVE && mdi->state_fd > 0) {
-			int remove_err;
+		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.
 			 */
-			remove_err = write_attr("remove", mdi->state_fd);
-			if (!remove_err) {
+			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);
 				close(mdi->state_fd);
 				mdi->state_fd = -1;
 			}
 		}
-		if (mdi->next_state & DS_INSYNC)
+		if (mdi->next_state & DS_INSYNC) {
 			write_attr("+in_sync", mdi->state_fd);
+			dprintf(" %d:+in_sync", mdi->disk.raid_disk);
+		}
 	}
+	dprintf(" )\n");
 
 	/* move curr_ to prev_ */
 	a->prev_state = a->curr_state;
@@ -342,6 +334,12 @@ static int read_and_act(struct active_array *a)
 		mdi->next_state = 0;
 	}
 
+	if (check_degraded) {
+		/* manager will do the actual check */
+		a->check_degraded = 1;
+		signal_manager();
+	}
+
 	if (deactivate)
 		a->container = NULL;
 
@@ -377,44 +375,119 @@ static void reconcile_failed(struct active_array *aa, struct mdinfo *failed)
 	}
 }
 
-static int wait_and_act(struct active_array *aa, int pfd, int nowait)
+#ifdef DEBUG
+static void dprint_wake_reasons(fd_set *fds)
+{
+	int i;
+	char proc_path[256];
+	char link[256];
+	char *basename;
+	int rv;
+
+	fprintf(stderr, "monitor: wake ( ");
+	for (i = 0; i < FD_SETSIZE; i++) {
+		if (FD_ISSET(i, fds)) {
+			sprintf(proc_path, "/proc/%d/fd/%d",
+				(int) getpid(), i);
+
+			rv = readlink(proc_path, link, sizeof(link) - 1);
+			if (rv < 0) {
+				fprintf(stderr, "%d:unknown ", i);
+				continue;
+			}
+			link[rv] = '\0';
+			basename = strrchr(link, '/');
+			fprintf(stderr, "%d:%s ",
+				i, basename ? ++basename : link);
+		}
+	}
+	fprintf(stderr, ")\n");
+}
+#endif
+
+int monitor_loop_cnt;
+
+static int wait_and_act(struct supertype *container, int nowait)
 {
 	fd_set rfds;
 	int maxfd = 0;
-	struct active_array *a;
+	struct active_array **aap = &container->arrays;
+	struct active_array *a, **ap;
 	int rv;
 	struct mdinfo *mdi;
 
 	FD_ZERO(&rfds);
 
-	add_fd(&rfds, &maxfd, pfd);
-	for (a = aa ; a ; a = a->next) {
-		/* once an array has been deactivated only the manager
-		 * thread can make us care about it again
+	for (ap = aap ; *ap ;) {
+		a = *ap;
+		/* once an array has been deactivated we want to
+		 * ask the manager to discard it.
 		 */
-		if (!a->container)
+		if (!a->container) {
+			if (discard_this) {
+				ap = &(*ap)->next;
+				continue;
+			}
+			*ap = a->next;
+			a->next = NULL;
+			discard_this = a;
+			signal_manager();
 			continue;
+		}
 
 		add_fd(&rfds, &maxfd, a->info.state_fd);
 		add_fd(&rfds, &maxfd, a->action_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.
+		 */
+		int fd = open(container->device_name, O_RDONLY|O_EXCL);
+		if (fd >= 0 || errno != EBUSY) {
+			/* OK, we are safe to leave */
+			dprintf("no arrays to monitor... exiting\n");
+			remove_pidfile(container->devname);
+			exit_now = 1;
+			signal_manager();
+			exit(0);
+		}
 	}
 
 	if (!nowait) {
-		rv = select(maxfd+1, &rfds, NULL, NULL, NULL);
+		sigset_t set;
+		sigprocmask(SIG_UNBLOCK, NULL, &set);
+		sigdelset(&set, SIGUSR1);
+		monitor_loop_cnt |= 1;
+		rv = pselect(maxfd+1, &rfds, NULL, NULL, NULL, &set);
+		monitor_loop_cnt += 1;
+		if (rv == -1 && errno == EINTR)
+			rv = 0;
+		#ifdef DEBUG
+		dprint_wake_reasons(&rfds);
+		#endif
+
+	}
 
-		if (rv <= 0)
-			return rv;
+	if (update_queue) {
+		struct metadata_update *this;
 
-		if (FD_ISSET(pfd, &rfds)) {
-			char buf[4];
-			read(pfd, buf, 4);
-			; // FIXME read from the pipe
-		}
+		for (this = update_queue; this ; this = this->next)
+			container->ss->process_update(container, this);
+
+		update_queue_handled = update_queue;
+		update_queue = NULL;
+		signal_manager();
+		container->ss->sync_metadata(container);
 	}
 
-	for (a = aa; a ; a = a->next) {
+	for (a = *aap; a ; a = a->next) {
 		if (a->replaces && !discard_this) {
 			struct active_array **ap;
 			for (ap = &a->next; *ap && *ap != a->replaces;
@@ -424,18 +497,20 @@ static int wait_and_act(struct active_array *aa, int pfd, int nowait)
 				*ap = (*ap)->next;
 			discard_this = a->replaces;
 			a->replaces = NULL;
+			/* FIXME check if device->state_fd need to be cleared?*/
+			signal_manager();
 		}
 		if (a->container)
 			rv += read_and_act(a);
 	}
 
 	/* propagate failures across container members */
-	for (a = aa; a ; a = a->next) {
+	for (a = *aap; a ; a = a->next) {
 		if (!a->container)
 			continue;
 		for (mdi = a->info.devs ; mdi ; mdi = mdi->next)
 			if (mdi->curr_state & DS_FAULTY)
-				reconcile_failed(aa, mdi);
+				reconcile_failed(*aap, mdi);
 	}
 
 	return rv;
@@ -446,7 +521,7 @@ void do_monitor(struct supertype *container)
 	int rv;
 	int first = 1;
 	do {
-		rv = wait_and_act(container->arrays, container->pipe[0], first);
+		rv = wait_and_act(container, first);
 		first = 0;
 	} while (rv >= 0);
 }