featuress/changelog: On snapshot, notify irrespective of failures

During snapshot, changelog barrier is enabled and a
explicit rollover of changelog is initiated. During
rollover of changelog, if any error or changelog is
empty, the notification was not sent to reconfigure
and hence snapshot was failing because of timeout.
This patch addresses it by sending notification
irrespective of failures and sends error if any
back to barrier.

BUG: 1225543
Change-Id: I971ef3bdc63bb50bda0b655e55cd814e44254ba9
Reviewed-On: http://review.gluster.org/10951
Signed-off-by: Kotresh HR <khiremat@redhat.com>
Reviewed-on: http://review.gluster.org/10988
Tested-by: NetBSD Build System <jenkins@build.gluster.org>
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Venky Shankar <vshankar@redhat.com>

3 files changed, 33 insertions, 23 deletions

diff --git a/xlators/features/changelog/src/changelog-helpers.c b/xlators/features/changelog/src/changelog-helpers.c
index a7d3e955fd2..847b9d2a32a 100644
--- a/xlators/features/changelog/src/changelog-helpers.c
+++ b/xlators/features/changelog/src/changelog-helpers.c
@@ -498,30 +498,33 @@ changelog_rollover_changelog (xlator_t *this,
                 ev.ev_type = CHANGELOG_OP_TYPE_JOURNAL;
                 memcpy (ev.u.journal.path, nfile, strlen (nfile) + 1);
                 changelog_dispatch_event (this, priv, &ev);
+        }
+ out:
+        /* If this is explicit rollover initiated by snapshot,
+         * wakeup reconfigure thread waiting for changelog to
+         * rollover. This should happen even in failure cases as
+         * well otherwise snapshot will timeout and fail. Hence
+         * moved under out.
+         */
+        if (priv->explicit_rollover) {
+                priv->explicit_rollover = _gf_false;
 
-                /* If this is explicit rollover initiated by snapshot,
-                 * wakeup reconfigure thread waiting for changelog to
-                 * rollover
-                 */
-                if (priv->explicit_rollover) {
-                        priv->explicit_rollover = _gf_false;
-
-                        ret = pthread_mutex_lock (&priv->bn.bnotify_mutex);
-                        CHANGELOG_PTHREAD_ERROR_HANDLE_0 (ret, out);
-                        {
-                                priv->bn.bnotify = _gf_false;
-                                ret = pthread_cond_signal
-                                        (&priv->bn.bnotify_cond);
-                                CHANGELOG_PTHREAD_ERROR_HANDLE_0 (ret, out);
-                                gf_log (this->name, GF_LOG_INFO,
-                                        "Changelog published: %s signalled"
-                                        " bnotify", nfile);
+                pthread_mutex_lock (&priv->bn.bnotify_mutex);
+                {
+                        if (ret) {
+                                priv->bn.bnotify_error = _gf_true;
+                                gf_log (this->name, GF_LOG_ERROR, "Fail "
+                                        "snapshot because of previous errors");
+                        } else {
+                                gf_log (this->name, GF_LOG_INFO, "Explicit "
+                                        "rollover changelog: %s signaling "
+                                        "bnotify", nfile);
                         }
-                        ret = pthread_mutex_unlock (&priv->bn.bnotify_mutex);
-                        CHANGELOG_PTHREAD_ERROR_HANDLE_0 (ret, out);
+                        priv->bn.bnotify = _gf_false;
+                        pthread_cond_signal (&priv->bn.bnotify_cond);
                 }
+                pthread_mutex_unlock (&priv->bn.bnotify_mutex);
         }
- out:
         return ret;
 }
 
diff --git a/xlators/features/changelog/src/changelog-helpers.h b/xlators/features/changelog/src/changelog-helpers.h
index ccfbf9113d8..4416b9cdfdb 100644
--- a/xlators/features/changelog/src/changelog-helpers.h
+++ b/xlators/features/changelog/src/changelog-helpers.h
@@ -152,6 +152,7 @@ typedef struct barrier_notify {
          pthread_mutex_t        bnotify_mutex;
          pthread_cond_t         bnotify_cond;
          gf_boolean_t           bnotify;
+         gf_boolean_t           bnotify_error;
 } barrier_notify_t;
 
 /* Two separate mutex and conditional variable set is used
diff --git a/xlators/features/changelog/src/changelog.c b/xlators/features/changelog/src/changelog.c
index b07009d3f8f..ed589793a37 100644
--- a/xlators/features/changelog/src/changelog.c
+++ b/xlators/features/changelog/src/changelog.c
@@ -1963,6 +1963,7 @@ notify (xlator_t *this, int event, void *data, ...)
         int                     barrier         = DICT_DEFAULT;
         gf_boolean_t            bclean_req      = _gf_false;
         int                     ret             = 0;
+        int                     ret1            = 0;
         struct list_head        queue           = {0, };
 
         INIT_LIST_HEAD (&queue);
@@ -2113,13 +2114,17 @@ notify (xlator_t *this, int event, void *data, ...)
                                                                           out,
                                                                     bclean_req);
                                 }
+                                if (priv->bn.bnotify_error == _gf_true) {
+                                        ret = -1;
+                                        priv->bn.bnotify_error = _gf_false;
+                                }
                         }
-                        ret = pthread_mutex_unlock (&priv->bn.bnotify_mutex);
-                        CHANGELOG_PTHREAD_ERROR_HANDLE_1 (ret, out, bclean_req);
+                        ret1 = pthread_mutex_unlock (&priv->bn.bnotify_mutex);
+                        CHANGELOG_PTHREAD_ERROR_HANDLE_1 (ret1, out,
+                                                          bclean_req);
                         gf_log (this->name, GF_LOG_INFO,
                                 "Woke up: bnotify conditional wait");
 
-                        ret = 0;
                         goto out;
 
                 case DICT_DEFAULT:
@@ -2637,6 +2642,7 @@ init (xlator_t *this)
 
         /* Mutex is not needed as threads are not spawned yet */
         priv->bn.bnotify = _gf_false;
+        priv->bn.bnotify_error = _gf_false;
         ret = changelog_barrier_pthread_init (this, priv);
         if (ret)
                 goto cleanup_options;