X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=managemon.c;h=c947552eb7161d69a7aa7f358962ed46d3c84097;hb=1eb252b8488bbdd62ad602561fe8a90ef9079271;hp=c7711040f89f4520ffff5879506b7ca19cf598ec;hpb=d52690acc48b3dcea1785d038fa12fc3de11d0a1;p=thirdparty%2Fmdadm.git

diff --git a/managemon.c b/managemon.c
index c7711040..c947552e 100644
--- a/managemon.c
+++ b/managemon.c
@@ -26,7 +26,18 @@
  * - When a device is added to the container, we add it to the metadata
  *   as a spare.
  *
- * - assist with activating spares by opening relevant sysfs file.
+ * - 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 to allocate a spare device
+ *    Add device as not in_sync and give a role
+ *    Update metadata.
+ *    Open sysfs files and pass to monitor.
+ *    Make sure that monitor Starts recovery....
  *
  * - Pass on metadata updates from external programs such as
  *   mdadm creating a new array.
@@ -74,7 +85,9 @@
 #endif
 #include	"mdadm.h"
 #include	"mdmon.h"
+#include	<sys/syscall.h>
 #include	<sys/socket.h>
+#include	<signal.h>
 
 static void close_aa(struct active_array *aa)
 {
@@ -86,7 +99,6 @@ static void close_aa(struct active_array *aa)
 	close(aa->action_fd);
 	close(aa->info.state_fd);
 	close(aa->resync_start_fd);
-	close(aa->sync_pos_fd);
 }
 
 static void free_aa(struct active_array *aa)
@@ -94,6 +106,7 @@ static void free_aa(struct active_array *aa)
 	/* Note that this doesn't close fds if they are being used
 	 * by a clone.  ->container will be set for a clone
 	 */
+	dprintf("%s: devnum: %d\n", __func__, aa->devnum);
 	if (!aa->container)
 		close_aa(aa);
 	while (aa->info.devs) {
@@ -104,16 +117,50 @@ static void free_aa(struct active_array *aa)
 	free(aa);
 }
 
-static void write_wakeup(struct supertype *c)
+static struct active_array *duplicate_aa(struct active_array *aa)
 {
-	static struct md_generic_cmd cmd = { .action = md_action_ping_monitor };
-	int err;
+	struct active_array *newa = malloc(sizeof(*newa));
+	struct mdinfo **dp1, **dp2;
+
+	*newa = *aa;
+	newa->next = NULL;
+	newa->replaces = NULL;
+	newa->info.next = NULL;
+
+	dp2 = &newa->info.devs;
+
+	for (dp1 = &aa->info.devs; *dp1; dp1 = &(*dp1)->next) {
+		struct mdinfo *d;
+		if ((*dp1)->state_fd < 0)
+			continue;
+
+		d = malloc(sizeof(*d));
+		*d = **dp1;
+		*dp2 = d;
+		dp2 = & d->next;
+	}
+	*dp2 = NULL;
 
-	active_cmd = &cmd;
+	return newa;
+}
+
+static void wakeup_monitor(void)
+{
+	/* tgkill(getpid(), mon_tid, SIGUSR1); */
+	int pid = getpid();
+	syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
+}
 
-	/* send the monitor thread a pointer to the ping action */
-	write(c->mgr_pipe[1], &err, 1);
-	read(c->mon_pipe[0], &err, 1);
+static void remove_old(void)
+{
+	if (discard_this) {
+		discard_this->next = NULL;
+		free_aa(discard_this);
+		if (pending_discard == discard_this)
+			pending_discard = NULL;
+		discard_this = NULL;
+		wakeup_monitor();
+	}
 }
 
 static void replace_array(struct supertype *container,
@@ -126,24 +173,59 @@ static void replace_array(struct supertype *container,
 	 * and put it on 'discard_this'.  We take it from there
 	 * and discard it.
 	 */
-
+	remove_old();
 	while (pending_discard) {
 		while (discard_this == NULL)
 			sleep(1);
-		if (discard_this != pending_discard)
-			abort();
-		discard_this->next = NULL;
-		free_aa(discard_this);
-		discard_this = NULL;
-		pending_discard = NULL;
+		remove_old();
 	}
 	pending_discard = old;
 	new->replaces = old;
 	new->next = container->arrays;
 	container->arrays = new;
-	write_wakeup(container);
+	wakeup_monitor();
+}
+
+struct metadata_update *update_queue = NULL;
+struct metadata_update *update_queue_handled = NULL;
+struct metadata_update *update_queue_pending = NULL;
+
+void check_update_queue(struct supertype *container)
+{
+	while (update_queue_handled) {
+		struct metadata_update *this = update_queue_handled;
+		update_queue_handled = this->next;
+		free(this->buf);
+		if (this->space)
+			free(this->space);
+		free(this);
+	}
+	if (update_queue == NULL &&
+	    update_queue_pending) {
+		update_queue = update_queue_pending;
+		update_queue_pending = NULL;
+		wakeup_monitor();
+	}
 }
 
+static void queue_metadata_update(struct metadata_update *mu)
+{
+	struct metadata_update **qp;
+
+	qp = &update_queue_pending;
+	while (*qp)
+		qp = & ((*qp)->next);
+	*qp = mu;
+}
+
+void wait_update_handled(void)
+{
+	/* Wait for any pending update to be handled by monitor.
+	 * i.e. wait until update_queue is NULL
+	 */
+	while (update_queue)
+		usleep(100 * 1000);
+}
 
 static void manage_container(struct mdstat_ent *mdstat,
 			     struct supertype *container)
@@ -153,7 +235,6 @@ static void manage_container(struct mdstat_ent *mdstat,
 	 * array ignoring any metadata on it.
 	 * FIXME should we look for compatible metadata and take hints
 	 * about spare assignment.... probably not.
-	 *
 	 */
 	if (mdstat->devcnt != container->devcnt) {
 		/* read /sys/block/NAME/md/dev-??/block/dev to find out
@@ -177,12 +258,52 @@ static void manage_member(struct mdstat_ent *mdstat,
 	 * being requested.
 	 * Unfortunately decreases in raid_disks don't show up in
 	 * mdstat until the reshape completes FIXME.
+	 *
+	 * Actually, we also want to handle degraded arrays here by
+	 * trying to find and assign a spare.
+	 * We do that whenever the monitor tells us too.
 	 */
 	// FIXME
 	a->info.array.raid_disks = mdstat->raid_disks;
 	a->info.array.chunk_size = mdstat->chunk_size;
 	// MORE
 
+	if (a->check_degraded) {
+		struct metadata_update *updates = NULL;
+		struct mdinfo *newdev;
+		struct active_array *newa;
+		wait_update_handled();
+		a->check_degraded = 0;
+
+		/* The array may not be degraded, this is just a good time
+		 * to check.
+		 */
+		newdev = a->container->ss->activate_spare(a, &updates);
+		if (newdev) {
+			struct mdinfo *d;
+			/* Cool, we can add a device or several. */
+			newa = duplicate_aa(a);
+			/* suspend recovery - maybe not needed */
+
+			/* Add device to array and set offset/size/slot.
+			 * and open files for each newdev */
+			for (d = newdev; d ; d = d->next) {
+				struct mdinfo *newd;
+				if (sysfs_add_disk(&newa->info, d) < 0)
+					continue;
+				newd = newa->info.devs;
+				newd->state_fd = sysfs_open(a->devnum,
+							    newd->sys_name,
+							    "state");
+				newd->prev_state
+					= read_dev_state(newd->state_fd);
+				newd->curr_state = newd->prev_state;
+			}
+			queue_metadata_update(updates);
+			replace_array(a->container, a, newa);
+			sysfs_set_str(&a->info, NULL, "sync_action", "repair");
+		}
+	}
 }
 
 static void manage_new(struct mdstat_ent *mdstat,
@@ -197,8 +318,7 @@ static void manage_new(struct mdstat_ent *mdstat,
 
 	struct active_array *new;
 	struct mdinfo *mdi, *di;
-	char *n;
-	int inst;
+	char *inst;
 	int i;
 
 	new = malloc(sizeof(*new));
@@ -206,19 +326,17 @@ static void manage_new(struct mdstat_ent *mdstat,
 	memset(new, 0, sizeof(*new));
 
 	new->devnum = mdstat->devnum;
+	strcpy(new->info.sys_name, devnum2devname(new->devnum));
 
 	new->prev_state = new->curr_state = new->next_state = inactive;
 	new->prev_action= new->curr_action= new->next_action= idle;
 
 	new->container = container;
 
-	n = &mdstat->metadata_version[10+strlen(container->devname)+1];
-	inst = atoi(n);
-	if (inst < 0)
-		abort();//FIXME
+	inst = &mdstat->metadata_version[10+strlen(container->devname)+1];
 
 	mdi = sysfs_read(-1, new->devnum,
-			 GET_LEVEL|GET_CHUNK|GET_DISKS|
+			 GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
 			 GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
 	if (!mdi) {
 		/* Eeek. Cannot monitor this array.
@@ -230,6 +348,7 @@ static void manage_new(struct mdstat_ent *mdstat,
 	}
 
 	new->info.array = mdi->array;
+	new->info.component_size = mdi->component_size;
 
 	for (i = 0; i < new->info.array.raid_disks; i++) {
 		struct mdinfo *newd = malloc(sizeof(*newd));
@@ -241,25 +360,28 @@ static void manage_new(struct mdstat_ent *mdstat,
 		if (di) {
 			memcpy(newd, di, sizeof(*newd));
 
-			sprintf(newd->sys_name, "rd%d", i);
-
 			newd->state_fd = sysfs_open(new->devnum,
 						    newd->sys_name,
 						    "state");
 
 			newd->prev_state = read_dev_state(newd->state_fd);
-			newd->curr_state = newd->curr_state;
+			newd->curr_state = newd->prev_state;
 		} else {
 			newd->state_fd = -1;
+			newd->disk.raid_disk = i;
+			newd->prev_state = DS_REMOVE;
+			newd->curr_state = DS_REMOVE;
 		}
+		sprintf(newd->sys_name, "rd%d", i);
 		newd->next = new->info.devs;
 		new->info.devs = newd;
 	}
 	new->action_fd = sysfs_open(new->devnum, NULL, "sync_action");
 	new->info.state_fd = sysfs_open(new->devnum, NULL, "array_state");
 	new->resync_start_fd = sysfs_open(new->devnum, NULL, "resync_start");
-	new->sync_pos_fd = sysfs_open(new->devnum, NULL, "sync_completed");
-	new->sync_pos = 0;
+	get_resync_start(new);
+	dprintf("%s: inst: %d action: %d state: %d\n", __func__, atoi(inst),
+		new->action_fd, new->info.state_fd);
 
 	sysfs_free(mdi);
 	// finds and compares.
@@ -307,32 +429,39 @@ void manage(struct mdstat_ent *mdstat, struct supertype *container)
 	}
 }
 
-static int handle_message(struct supertype *container, struct md_message *msg)
+static void handle_message(struct supertype *container, struct metadata_update *msg)
 {
-	int err;
-	struct md_generic_cmd *cmd = msg->buf;
-
-	if (!cmd)
-		return 0;
-
-	switch (cmd->action) {
-	case md_action_remove_device:
-
-		/* forward to the monitor */
-		active_cmd = cmd;
-		write(container->mgr_pipe[1], &err, 1);
-		read(container->mon_pipe[0], &err, 1);
-		return err;
-
-	default:
-		return -1;
+	/* queue this metadata update through to the monitor */
+
+	struct metadata_update *mu;
+
+	if (msg->len == 0) {
+		int cnt = monitor_loop_cnt;
+		if (cnt & 1)
+			cnt += 2; /* wait until next pselect */
+		else
+			cnt += 3; /* wait for 2 pselects */
+		wakeup_monitor();
+		wait_update_handled();
+		while (monitor_loop_cnt - cnt < 0)
+			usleep(10 * 1000);
+	} else {
+		mu = malloc(sizeof(*mu));
+		mu->len = msg->len;
+		mu->buf = msg->buf;
+		msg->buf = NULL;
+		mu->space = NULL;
+		mu->next = NULL;
+		if (container->ss->prepare_update)
+			container->ss->prepare_update(container, mu);
+		queue_metadata_update(mu);
 	}
 }
 
 void read_sock(struct supertype *container)
 {
 	int fd;
-	struct md_message msg;
+	struct metadata_update msg;
 	int terminate = 0;
 	long fl;
 	int tmo = 3; /* 3 second timeout before hanging up the socket */
@@ -346,33 +475,36 @@ void read_sock(struct supertype *container)
 	fcntl(fd, F_SETFL, fl);
 
 	do {
-		int err;
-
 		msg.buf = NULL;
 
 		/* read and validate the message */
 		if (receive_message(fd, &msg, tmo) == 0) {
-			err = handle_message(container, &msg);
-			if (!err)
-				ack(fd, msg.seq, tmo);
-			else
-				nack(fd, err, tmo);
-		} else {
+			handle_message(container, &msg);
+			if (ack(fd, tmo) < 0)
+				terminate = 1;
+		} else
 			terminate = 1;
-			nack(fd, -1, tmo);
-		}
 
-		if (msg.buf)
-			free(msg.buf);
 	} while (!terminate);
 
 	close(fd);
 }
+
+int exit_now = 0;
+int manager_ready = 0;
 void do_manager(struct supertype *container)
 {
 	struct mdstat_ent *mdstat;
+	sigset_t set;
+
+	sigprocmask(SIG_UNBLOCK, NULL, &set);
+	sigdelset(&set, SIGUSR1);
 
 	do {
+
+		if (exit_now)
+			exit(0);
+
 		mdstat = mdstat_read(1, 0);
 
 		manage(mdstat, container);
@@ -381,6 +513,12 @@ void do_manager(struct supertype *container)
 
 		free_mdstat(mdstat);
 
-		mdstat_wait_fd(container->sock);
+		remove_old();
+
+		check_update_queue(container);
+
+		manager_ready = 1;
+
+		mdstat_wait_fd(container->sock, &set);
 	} while(1);
 }