cluster/tier: allow db queries to be interruptable

A query to the database may take a long time if the database
has many entries. The tier daemon also sends IPC calls to the
bricks which can run slowly, espcially in RHEL6. While it is
possible to track down each such instance, the snapshot
feature should not be affected by database operations. It requires
no migration be underway. Therefore it is okay to pause tiering
at any time except when DHT is moving a file.  This fix implements
this strategy by monitoring when control passes to DHT to
migrate a file using the GF_XATTR_FILE_MIGRATE_KEY trigger. If it
is not, the pause operation is successful.

> Change-Id: I21f168b1bd424077ad5f38cf82f794060a1fabf6
> BUG: 1287842
> Signed-off-by: Dan Lambright <dlambrig@redhat.com>
> Reviewed-on: http://review.gluster.org/13104
> Reviewed-by: Joseph Fernandes
> Tested-by: Gluster Build System <jenkins@build.gluster.com>
Signed-off-by: Dan Lambright <dlambrig@redhat.com>

Change-Id: I667e0af24eaa66afefa860c4d73b324e4f39b997
BUG: 1288352
Signed-off-by: Dan Lambright <dlambrig@redhat.com>
Reviewed-on: http://review.gluster.org/13199
Smoke: Gluster Build System <jenkins@build.gluster.com>
NetBSD-regression: NetBSD Build System <jenkins@build.gluster.org>
CentOS-regression: Gluster Build System <jenkins@build.gluster.com>

1 files changed, 55 insertions, 14 deletions

diff --git a/xlators/cluster/dht/src/dht-rebalance.c b/xlators/cluster/dht/src/dht-rebalance.c
index 3698b340fef..e28bb76be66 100644
--- a/xlators/cluster/dht/src/dht-rebalance.c
+++ b/xlators/cluster/dht/src/dht-rebalance.c
@@ -833,7 +833,7 @@ __tier_migrate_data (gf_defrag_info_t *defrag, xlator_t *from, xlator_t *to, fd_
                 else
                         ret = syncop_writev (to, dst, vector, count,
                                              offset, iobref, 0, NULL, NULL);
-                if (defrag->tier_conf.request_pause) {
+                if (gf_defrag_get_pause_state (&defrag->tier_conf) != TIER_RUNNING) {
                         gf_msg ("tier", GF_LOG_INFO, 0,
                                 DHT_MSG_TIER_PAUSED,
                                 "Migrate file paused");
@@ -3507,23 +3507,60 @@ out:
 }
 
 void
-gf_defrag_wake_pause_tier (gf_tier_conf_t *tier_conf, gf_boolean_t pause)
+gf_defrag_set_pause_state (gf_tier_conf_t *tier_conf, tier_pause_state_t state)
+{
+        pthread_mutex_lock (&tier_conf->pause_mutex);
+        tier_conf->pause_state = state;
+        pthread_mutex_unlock (&tier_conf->pause_mutex);
+}
+
+tier_pause_state_t
+gf_defrag_get_pause_state (gf_tier_conf_t *tier_conf)
+{
+        int state;
+
+        pthread_mutex_lock (&tier_conf->pause_mutex);
+        state = tier_conf->pause_state;
+        pthread_mutex_unlock (&tier_conf->pause_mutex);
+
+        return state;
+}
+
+tier_pause_state_t
+gf_defrag_check_pause_tier (gf_tier_conf_t *tier_conf)
 {
         int woke = 0;
+        int state  = -1;
 
         pthread_mutex_lock (&tier_conf->pause_mutex);
+
+        if (tier_conf->pause_state == TIER_RUNNING)
+                goto out;
+
+        if (tier_conf->pause_state == TIER_PAUSED)
+                goto out;
+
+        if (tier_conf->promote_in_progress ||
+            tier_conf->demote_in_progress)
+                goto out;
+
+        tier_conf->pause_state = TIER_PAUSED;
+
         if (tier_conf->pause_synctask) {
-                tier_conf->paused = pause;
                 synctask_wake (tier_conf->pause_synctask);
                 tier_conf->pause_synctask = 0;
                 woke = 1;
         }
-        pthread_mutex_unlock (&tier_conf->pause_mutex);
-        tier_conf->request_pause = 0;
 
         gf_msg ("tier", GF_LOG_DEBUG, 0,
                 DHT_MSG_TIER_PAUSED,
-                "woken %d paused %d", woke, tier_conf->paused);
+                "woken %d", woke);
+out:
+        state = tier_conf->pause_state;
+
+        pthread_mutex_unlock (&tier_conf->pause_mutex);
+
+        return state;
 }
 
 void
@@ -3546,7 +3583,7 @@ gf_defrag_pause_tier_timeout (void *data)
                 DHT_MSG_TIER_PAUSED,
                 "Request pause timer timeout");
 
-        gf_defrag_wake_pause_tier (&defrag->tier_conf, _gf_false);
+        gf_defrag_check_pause_tier (&defrag->tier_conf);
 
 out:
         return;
@@ -3564,12 +3601,16 @@ gf_defrag_pause_tier (xlator_t *this, gf_defrag_info_t *defrag)
 
         /*
          * Set flag requesting to pause tiering. Wait 'delay' seconds for
-         * tiering to actually stop as indicated by the "paused" boolean,
+         * tiering to actually stop as indicated by the pause state
          * before returning success or failure.
          */
-        defrag->tier_conf.request_pause = 1;
+        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_REQUEST_PAUSE);
 
-        if (defrag->tier_conf.paused == _gf_true)
+        /*
+         * If migration is not underway, can pause immediately.
+         */
+        gf_defrag_check_pause_tier (&defrag->tier_conf);
+        if (gf_defrag_get_pause_state (&defrag->tier_conf) == TIER_PAUSED)
                 goto out;
 
         gf_msg (this->name, GF_LOG_DEBUG, 0,
@@ -3586,11 +3627,12 @@ gf_defrag_pause_tier (xlator_t *this, gf_defrag_info_t *defrag)
 
         synctask_yield (defrag->tier_conf.pause_synctask);
 
-        if (defrag->tier_conf.paused == _gf_true)
+        if (gf_defrag_get_pause_state (&defrag->tier_conf) == TIER_PAUSED)
                 goto out;
 
-        ret = -1;
+        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
 
+        ret = -1;
 out:
 
         gf_msg (this->name, GF_LOG_DEBUG, 0,
@@ -3607,8 +3649,7 @@ gf_defrag_resume_tier (xlator_t *this, gf_defrag_info_t *defrag)
                 DHT_MSG_TIER_RESUME,
                 "Pause end. Resume tiering");
 
-        defrag->tier_conf.request_pause = 0;
-        defrag->tier_conf.paused = _gf_false;
+        gf_defrag_set_pause_state (&defrag->tier_conf, TIER_RUNNING);
 
         return 0;
 }