]> git.ipfire.org Git - thirdparty/mdadm.git/blobdiff - managemon.c
mdmon: ping will wait for manage_mon to catch up.
[thirdparty/mdadm.git] / managemon.c
index 971dcd1d54aa66149eafeae7d1ef6a236ca4c88c..c947552eb7161d69a7aa7f358962ed46d3c84097 100644 (file)
  * - 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,6 +85,7 @@
 #endif
 #include       "mdadm.h"
 #include       "mdmon.h"
+#include       <sys/syscall.h>
 #include       <sys/socket.h>
 #include       <signal.h>
 
@@ -87,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)
@@ -95,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) {
@@ -105,16 +117,38 @@ 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;
 
-       active_cmd = &cmd;
+       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;
 
-       /* send the monitor thread a pointer to the ping action */
-       write(c->mgr_pipe[1], &err, 1);
-       read(c->mon_pipe[0], &err, 1);
+       return newa;
+}
+
+static void wakeup_monitor(void)
+{
+       /* tgkill(getpid(), mon_tid, SIGUSR1); */
+       int pid = getpid();
+       syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
 }
 
 static void remove_old(void)
@@ -125,6 +159,7 @@ static void remove_old(void)
                if (pending_discard == discard_this)
                        pending_discard = NULL;
                discard_this = NULL;
+               wakeup_monitor();
        }
 }
 
@@ -140,7 +175,6 @@ static void replace_array(struct supertype *container,
         */
        remove_old();
        while (pending_discard) {
-               write_wakeup(container);
                while (discard_this == NULL)
                        sleep(1);
                remove_old();
@@ -149,7 +183,48 @@ static void replace_array(struct supertype *container,
        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,
@@ -160,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
@@ -184,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,
@@ -204,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));
@@ -213,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.
@@ -237,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));
@@ -248,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.
@@ -314,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 */
@@ -353,49 +475,32 @@ 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);
 }
 
-static int woke = 0;
-void wake_me(int sig)
-{
-       woke = 1;
-}
-
 int exit_now = 0;
 int manager_ready = 0;
 void do_manager(struct supertype *container)
 {
        struct mdstat_ent *mdstat;
-       sigset_t block, orig;
-
-       sigemptyset(&block);
-       sigaddset(&block, SIGUSR1);
+       sigset_t set;
 
-       signal(SIGUSR1, wake_me);
+       sigprocmask(SIG_UNBLOCK, NULL, &set);
+       sigdelset(&set, SIGUSR1);
 
        do {
-               woke = 0;
 
                if (exit_now)
                        exit(0);
@@ -410,10 +515,10 @@ void do_manager(struct supertype *container)
 
                remove_old();
 
+               check_update_queue(container);
+
                manager_ready = 1;
-               sigprocmask(SIG_SETMASK, &block, &orig);
-               if (woke == 0)
-                       mdstat_wait_fd(container->sock, &orig);
-               sigprocmask(SIG_SETMASK, &orig, NULL);
+
+               mdstat_wait_fd(container->sock, &set);
        } while(1);
 }