From eb0d9513ece40c5d4cb7f3bae13874bbfe4fcff8 Mon Sep 17 00:00:00 2001 From: Dan Lambright Date: Mon, 28 Dec 2015 10:57:53 -0500 Subject: 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 Reviewed-on: http://review.gluster.org/13104 Reviewed-by: Joseph Fernandes Tested-by: Gluster Build System --- xlators/cluster/dht/src/dht-rebalance.c | 69 ++++++++++++++++++++++++++------- 1 file changed, 55 insertions(+), 14 deletions(-) (limited to 'xlators/cluster/dht/src/dht-rebalance.c') diff --git a/xlators/cluster/dht/src/dht-rebalance.c b/xlators/cluster/dht/src/dht-rebalance.c index cc323c46f0d..ced907e7937 100644 --- a/xlators/cluster/dht/src/dht-rebalance.c +++ b/xlators/cluster/dht/src/dht-rebalance.c @@ -826,7 +826,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"); @@ -3619,23 +3619,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 @@ -3658,7 +3695,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; @@ -3676,12 +3713,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, @@ -3698,11 +3739,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, @@ -3719,8 +3761,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; } -- cgit