mdmon: don't wait for O_EXCL when shutting down.

[thirdparty/mdadm.git] / monitor.c

diff --git a/monitor.c b/monitor.c
index 0a7d0f471e74d93e65f44f2a520d00b3e9ae47e7..69026ca0e35cc6d753b79c92e92d16e3255494a1 100644 (file)
--- a/monitor.c
+++ b/monitor.c
@@ -215,6 +215,7 @@ static int read_and_act(struct active_array *a)
 {
        unsigned long long sync_completed;
        int check_degraded = 0;
+       int check_reshape = 0;
        int deactivate = 0;
        struct mdinfo *mdi;
        int dirty = 0;
@@ -235,6 +236,13 @@ static int read_and_act(struct active_array *a)
                }
        }
 
+       if (a->curr_state > inactive &&
+           a->prev_state == inactive) {
+               /* array has been started
+                * possible that container operation has to be completed
+                */
+               a->container->ss->set_array_state(a, 0);
+       }
        if (a->curr_state <= inactive &&
            a->prev_state > inactive) {
                /* array has been stopped */
@@ -306,6 +314,15 @@ static int read_and_act(struct active_array *a)
                }
        }
 
+       if (!deactivate &&
+           a->curr_action == reshape &&
+           a->prev_action != reshape)
+               /* reshape was requested by mdadm.  Need to see if
+                * new devices have been added.  Manager does that
+                * when it sees check_reshape
+                */
+               check_reshape = 1;
+
        /* 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
@@ -330,8 +347,8 @@ static int read_and_act(struct active_array *a)
 
        /* 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.
+        * over checkpointing.  Note reshape checkpointing is handled
+        * in the second branch.
         */
        if (sync_completed > a->last_checkpoint &&
            sync_completed - a->last_checkpoint > a->info.component_size >> 4 &&
@@ -341,7 +358,37 @@ static int read_and_act(struct active_array *a)
                 */
                a->last_checkpoint = sync_completed;
                a->container->ss->set_array_state(a, a->curr_state <= clean);
-       } else if (sync_completed > a->last_checkpoint)
+       } else if ((a->curr_action == idle && a->prev_action == reshape) ||
+                  (a->curr_action == reshape
+                   && sync_completed > a->last_checkpoint) ) {
+               /* Reshape has progressed or completed so we need to
+                * update the array state - and possibly the array size
+                */
+               if (sync_completed != 0)
+                       a->last_checkpoint = sync_completed;
+               /* We might need to update last_checkpoint depending on
+                * the reason that reshape finished.
+                * if array reshape is really finished:
+                *        set check point to the end, this allows
+                *        set_array_state() to finalize reshape in metadata
+                * if reshape if broken: do not set checkpoint to the end
+                *        this allows for reshape restart from checkpoint
+                */
+               if ((a->curr_action != reshape) &&
+                   (a->prev_action == reshape)) {
+                       char buf[40];
+                       if ((sysfs_get_str(&a->info, NULL,
+                                         "reshape_position",
+                                         buf,
+                                         sizeof(buf)) >= 0) &&
+                            strncmp(buf, "none", 4) == 0)
+                               a->last_checkpoint = a->info.component_size;
+               }
+               a->container->ss->set_array_state(a, a->curr_state <= clean);
+               a->last_checkpoint = sync_completed;
+       }
+
+       if (sync_completed > a->last_checkpoint)
                a->last_checkpoint = sync_completed;
 
        a->container->ss->sync_metadata(a->container);
@@ -395,9 +442,12 @@ static int read_and_act(struct active_array *a)
                mdi->next_state = 0;
        }
 
-       if (check_degraded) {
+       if (check_degraded || check_reshape) {
                /* manager will do the actual check */
-               a->check_degraded = 1;
+               if (check_degraded)
+                       a->check_degraded = 1;
+               if (check_reshape)
+                       a->check_reshape = 1;
                signal_manager();
        }
 
@@ -485,7 +535,7 @@ static int wait_and_act(struct supertype *container, int nowait)
                /* once an array has been deactivated we want to
                 * ask the manager to discard it.
                 */
-               if (!a->container) {
+               if (!a->container || (a->info.array.level == 0)) {
                        if (discard_this) {
                                ap = &(*ap)->next;
                                continue;
@@ -513,7 +563,11 @@ static int wait_and_act(struct supertype *container, int nowait)
                 * problem as there are no active arrays, there is
                 * nothing that we need to be ready to do.
                 */
-               int fd = open_dev_excl(container->devnum);
+               int fd;
+               if (sigterm)
+                       fd = open_dev_excl(container->devnum);
+               else
+                       fd = open_dev_flags(container->devnum, O_RDONLY|O_EXCL);
                if (fd >= 0 || errno != EBUSY) {
                        /* OK, we are safe to leave */
                        if (sigterm && !dirty_arrays)
@@ -527,16 +581,25 @@ static int wait_and_act(struct supertype *container, int nowait)
                                remove_pidfile(container->devname);
                        exit_now = 1;
                        signal_manager();
+                       close(fd);
                        exit(0);
                }
        }
 
        if (!nowait) {
                sigset_t set;
+               struct timespec ts;
+               ts.tv_sec = 24*3600;
+               ts.tv_nsec = 0;
+               if (*aap == NULL) {
+                       /* just waiting to get O_EXCL access */
+                       ts.tv_sec = 0;
+                       ts.tv_nsec = 20000000ULL;
+               }
                sigprocmask(SIG_UNBLOCK, NULL, &set);
                sigdelset(&set, SIGUSR1);
                monitor_loop_cnt |= 1;
-               rv = pselect(maxfd+1, NULL, NULL, &rfds, NULL, &set);
+               rv = pselect(maxfd+1, NULL, NULL, &rfds, &ts, &set);
                monitor_loop_cnt += 1;
                if (rv == -1 && errno == EINTR)
                        rv = 0;