Remove stopped arrays.

When an array becomes inactive, clean up and forget it.

This involves signalling the manager.

diff --git a/managemon.c b/managemon.c
index c7711040f89f4520ffff5879506b7ca19cf598ec..aa10a9930f3372ef3ff3676010d7dcdeec447944 100644 (file)
--- a/managemon.c
+++ b/managemon.c
@@ -75,6 +75,7 @@
 #include       "mdadm.h"
 #include       "mdmon.h"
 #include       <sys/socket.h>
 #include       "mdadm.h"
 #include       "mdmon.h"
 #include       <sys/socket.h>

+#include       <signal.h>

 
 static void close_aa(struct active_array *aa)
 {
 
 static void close_aa(struct active_array *aa)
 {


@@ -116,6 +117,17 @@ static void write_wakeup(struct supertype *c)
        read(c->mon_pipe[0], &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;
+       }
+}
+

 static void replace_array(struct supertype *container,
                          struct active_array *old,
                          struct active_array *new)
 static void replace_array(struct supertype *container,
                          struct active_array *old,
                          struct active_array *new)


@@ -126,16 +138,12 @@ static void replace_array(struct supertype *container,
         * and put it on 'discard_this'.  We take it from there
         * and discard it.
         */
         * and put it on 'discard_this'.  We take it from there
         * and discard it.
         */

-
+       remove_old();

        while (pending_discard) {
        while (pending_discard) {

+               write_wakeup(container);

                while (discard_this == NULL)
                        sleep(1);
                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;
        }
        pending_discard = old;
        new->replaces = old;


@@ -144,7 +152,6 @@ static void replace_array(struct supertype *container,
        write_wakeup(container);
 }
 
        write_wakeup(container);
 }
 

-

 static void manage_container(struct mdstat_ent *mdstat,
                             struct supertype *container)
 {
 static void manage_container(struct mdstat_ent *mdstat,
                             struct supertype *container)
 {


@@ -368,11 +375,26 @@ void read_sock(struct supertype *container)
 
        close(fd);
 }
 
        close(fd);
 }

+
+static int woke = 0;
+void wake_me(int sig)
+{
+       woke = 1;
+}
+

 void do_manager(struct supertype *container)
 {
        struct mdstat_ent *mdstat;
 void do_manager(struct supertype *container)
 {
        struct mdstat_ent *mdstat;

+       sigset_t block, orig;
+
+       sigemptyset(&block);
+       sigaddset(&block, SIGUSR1);
+
+       signal(SIGUSR1, wake_me);

 
        do {
 
        do {

+               woke = 0;
+

                mdstat = mdstat_read(1, 0);
 
                manage(mdstat, container);
                mdstat = mdstat_read(1, 0);
 
                manage(mdstat, container);


@@ -381,6 +403,11 @@ void do_manager(struct supertype *container)
 
                free_mdstat(mdstat);
 
 
                free_mdstat(mdstat);
 

-               mdstat_wait_fd(container->sock);
+               remove_old();
+
+               sigprocmask(SIG_SETMASK, &block, &orig);
+               if (woke == 0)
+                       mdstat_wait_fd(container->sock, &orig);
+               sigprocmask(SIG_SETMASK, &orig, NULL);

        } while(1);
 }
        } while(1);
 }

diff --git a/mdadm.h b/mdadm.h
index 5ff66cd897f6f15588dc10a5b0f2141879d82f63..20ed452027d63afeaadbc1fa9746ea563587eea8 100644 (file)
--- a/mdadm.h
+++ b/mdadm.h
@@ -292,7 +292,7 @@ struct mdstat_ent {
 extern struct mdstat_ent *mdstat_read(int hold, int start);
 extern void free_mdstat(struct mdstat_ent *ms);
 extern void mdstat_wait(int seconds);
 extern struct mdstat_ent *mdstat_read(int hold, int start);
 extern void free_mdstat(struct mdstat_ent *ms);
 extern void mdstat_wait(int seconds);

-extern void mdstat_wait_fd(int fd);
+extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);

 extern int mddev_busy(int devnum);
 
 struct map_ent {
 extern int mddev_busy(int devnum);
 
 struct map_ent {

diff --git a/mdmon.c b/mdmon.c
index c8a3341effc59ac0338f513cb03b6edb0671bcf3..7ba8be04a8d547653eb520b276d61eae7785c19f 100644 (file)
--- a/mdmon.c
+++ b/mdmon.c
@@ -48,6 +48,12 @@ struct md_generic_cmd *active_cmd;
 int run_child(void *v)
 {
        struct supertype *c = v;
 int run_child(void *v)
 {
        struct supertype *c = v;

+       sigset_t set;
+       /* SIGUSR is sent from child to parent,  So child must block it */
+       sigemptyset(&set);
+       sigaddset(&set, SIGUSR1);
+       sigprocmask(SIG_BLOCK, &set, NULL);
+

        do_monitor(c);
        return 0;
 }
        do_monitor(c);
        return 0;
 }

diff --git a/mdstat.c b/mdstat.c
index a65e7c3ab49b2362aa5a961feecaeec2ecfcf046..040df150c74cec0eb5b64597ad604d0c80129fcb 100644 (file)
--- a/mdstat.c
+++ b/mdstat.c
@@ -272,7 +272,7 @@ void mdstat_wait(int seconds)
        select(mdstat_fd >2 ? mdstat_fd+1:3, NULL, NULL, &fds, &tm);
 }
 
        select(mdstat_fd >2 ? mdstat_fd+1:3, NULL, NULL, &fds, &tm);
 }
 

-void mdstat_wait_fd(int fd)
+void mdstat_wait_fd(int fd, const sigset_t *sigmask)

 {
        fd_set fds, rfds;
 
 {
        fd_set fds, rfds;
 


@@ -282,7 +282,8 @@ void mdstat_wait_fd(int fd)
                FD_SET(mdstat_fd, &fds);
        FD_SET(fd, &rfds);
 
                FD_SET(mdstat_fd, &fds);
        FD_SET(fd, &rfds);
 

-       select(mdstat_fd >2 ? mdstat_fd+1:3, &rfds, NULL, &fds, NULL);
+       pselect(mdstat_fd >2 ? mdstat_fd+1:3, &rfds, NULL, &fds,
+               NULL, sigmask);

 }
 
 int mddev_busy(int devnum)
 }
 
 int mddev_busy(int devnum)

diff --git a/monitor.c b/monitor.c
index a630c9370f4698d35244cb81b8aa7f74f629300c..ead96d9d0f74afcfdeafc64ff7d29287572f0dd6 100644 (file)
--- a/monitor.c
+++ b/monitor.c
@@ -3,7 +3,7 @@
 #include "mdmon.h"
 
 #include <sys/select.h>
 #include "mdmon.h"
 
 #include <sys/select.h>

-
+#include <signal.h>

 
 static char *array_states[] = {
        "clear", "inactive", "suspended", "readonly", "read-auto",
 
 static char *array_states[] = {
        "clear", "inactive", "suspended", "readonly", "read-auto",


@@ -152,6 +152,10 @@ int read_dev_state(int fd)
        return rv;
 }
 
        return rv;
 }
 

+static void signal_manager(void)
+{
+       kill(getpid(), SIGUSR1);
+}

 
 /* Monitor a set of active md arrays - all of which share the
  * same metadata - and respond to events that require
 
 /* Monitor a set of active md arrays - all of which share the
  * same metadata - and respond to events that require


@@ -432,28 +436,41 @@ static int handle_pipe(struct md_generic_cmd *cmd, struct active_array *aa)
        return -1;
 }
 
        return -1;
 }
 

-static int wait_and_act(struct active_array *aa, int pfd, int monfd, int nowait)
+static int wait_and_act(struct active_array **aap, int pfd,
+                       int monfd, int nowait)

 {
        fd_set rfds;
        int maxfd = 0;
 {
        fd_set rfds;
        int maxfd = 0;

-       struct active_array *a;
+       struct active_array *a, **ap;

        int rv;
        struct mdinfo *mdi;
 
        FD_ZERO(&rfds);
 
        add_fd(&rfds, &maxfd, pfd);
        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;
                        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);
 
                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 (!nowait) {
        }
 
        if (!nowait) {


@@ -466,12 +483,12 @@ static int wait_and_act(struct active_array *aa, int pfd, int monfd, int nowait)
                        int err = -1;
 
                        if (read(pfd, &err, 1) > 0)
                        int err = -1;
 
                        if (read(pfd, &err, 1) > 0)

-                               err = handle_pipe(active_cmd, aa);
+                               err = handle_pipe(active_cmd, *aap);

                        write(monfd, &err, 1);
                }
        }
 
                        write(monfd, &err, 1);
                }
        }
 

-       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;
                if (a->replaces && !discard_this) {
                        struct active_array **ap;
                        for (ap = &a->next; *ap && *ap != a->replaces;


@@ -481,18 +498,19 @@ static int wait_and_act(struct active_array *aa, int pfd, int monfd, int nowait)
                                *ap = (*ap)->next;
                        discard_this = a->replaces;
                        a->replaces = NULL;
                                *ap = (*ap)->next;
                        discard_this = a->replaces;
                        a->replaces = NULL;

+                       signal_manager();

                }
                if (a->container)
                        rv += read_and_act(a);
        }
 
        /* propagate failures across container members */
                }
                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)
                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;
        }
 
        return rv;


@@ -503,7 +521,7 @@ void do_monitor(struct supertype *container)
        int rv;
        int first = 1;
        do {
        int rv;
        int first = 1;
        do {

-               rv = wait_and_act(container->arrays, container->mgr_pipe[0],
+               rv = wait_and_act(&container->arrays, container->mgr_pipe[0],

                                  container->mon_pipe[1], first);
                first = 0;
        } while (rv >= 0);
                                  container->mon_pipe[1], first);
                first = 0;
        } while (rv >= 0);