glusterd/Vol-Locks : Moving globals into glusterd priv and code refactoring

Moved globals(vol_lock and txn_opinfo dicts and global_txn_id) into
glusterd priv

Moved glusterd_op_send_cli_response() out of gd_unlock_op_phase
as gd_unlock_op_phase and glusterd_clear_txn_opinfo should only
be called if the txn id has been successfully generated. The
cli resp should be sent irrespective of that.

Changed log levels from ERROR to WARNING for some volume lock logs
where the logs are expected and is not an error

Added logs for better transparency of transaction ids.

Change-Id: Ifac9b23aa9f1648c9ae252cfd3ac50bb2ed46728
BUG: 1011470
Signed-off-by: Avra Sengupta <asengupt@redhat.com>
Reviewed-on: http://review.gluster.org/6976
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Vijay Bellur <vbellur@redhat.com>

1 files changed, 59 insertions, 23 deletions

diff --git a/xlators/mgmt/glusterd/src/glusterd-locks.c b/xlators/mgmt/glusterd/src/glusterd-locks.c
index 68c6d74264b..9e8bbc21b81 100644
--- a/xlators/mgmt/glusterd/src/glusterd-locks.c
+++ b/xlators/mgmt/glusterd/src/glusterd-locks.c
@@ -26,17 +26,22 @@
 
 #include <signal.h>
 
-static dict_t *vol_lock;
-
 /* Initialize the global vol-lock list(dict) when
  * glusterd is spawned */
 int32_t
 glusterd_vol_lock_init ()
 {
-        int32_t ret = -1;
+        int32_t             ret = -1;
+        xlator_t           *this   = NULL;
+        glusterd_conf_t    *priv   = NULL;
+
+        this = THIS;
+        GF_ASSERT (this);
+        priv = this->private;
+        GF_ASSERT (priv);
 
-        vol_lock = dict_new ();
-        if (!vol_lock)
+        priv->vol_lock = dict_new ();
+        if (!priv->vol_lock)
                 goto out;
 
         ret = 0;
@@ -49,16 +54,31 @@ out:
 void
 glusterd_vol_lock_fini ()
 {
-        if (vol_lock)
-                dict_unref (vol_lock);
+        xlator_t           *this   = NULL;
+        glusterd_conf_t    *priv   = NULL;
+
+        this = THIS;
+        GF_ASSERT (this);
+        priv = this->private;
+        GF_ASSERT (priv);
+
+        if (priv->vol_lock)
+                dict_unref (priv->vol_lock);
 }
 
 int32_t
 glusterd_get_vol_lock_owner (char *volname, uuid_t *uuid)
 {
-        int32_t        ret      = -1;
-        vol_lock_obj  *lock_obj = NULL;
-        uuid_t         no_owner = {0,};
+        int32_t                 ret      = -1;
+        glusterd_vol_lock_obj  *lock_obj = NULL;
+        glusterd_conf_t        *priv     = NULL;
+        uuid_t                  no_owner = {0,};
+        xlator_t               *this     = NULL;
+
+        this = THIS;
+        GF_ASSERT (this);
+        priv = this->private;
+        GF_ASSERT (priv);
 
         if (!volname || !uuid) {
                 gf_log ("", GF_LOG_ERROR, "volname or uuid is null.");
@@ -66,7 +86,7 @@ glusterd_get_vol_lock_owner (char *volname, uuid_t *uuid)
                 goto out;
         }
 
-        ret = dict_get_bin (vol_lock, volname, (void **) &lock_obj);
+        ret = dict_get_bin (priv->vol_lock, volname, (void **) &lock_obj);
         if (!ret)
                 uuid_copy (*uuid, lock_obj->lock_owner);
         else
@@ -81,9 +101,16 @@ out:
 int32_t
 glusterd_volume_lock (char *volname, uuid_t uuid)
 {
-        int32_t        ret      = -1;
-        vol_lock_obj  *lock_obj = NULL;
-        uuid_t         owner    = {0};
+        int32_t                 ret      = -1;
+        glusterd_vol_lock_obj  *lock_obj = NULL;
+        glusterd_conf_t        *priv     = NULL;
+        uuid_t                  owner    = {0};
+        xlator_t               *this     = NULL;
+
+        this = THIS;
+        GF_ASSERT (this);
+        priv = this->private;
+        GF_ASSERT (priv);
 
         if (!volname) {
                 gf_log ("", GF_LOG_ERROR, "volname is null.");
@@ -93,21 +120,22 @@ glusterd_volume_lock (char *volname, uuid_t uuid)
 
         ret = glusterd_get_vol_lock_owner (volname, &owner);
         if (ret) {
-                gf_log ("", GF_LOG_DEBUG, "Unable to get volume lock owner");
+                gf_log ("", GF_LOG_WARNING,
+                        "Unable to get volume lock owner");
                 goto out;
         }
 
         /* If the lock has already been held for the given volume
          * we fail */
         if (!uuid_is_null (owner)) {
-                gf_log ("", GF_LOG_ERROR, "Unable to acquire lock. "
+                gf_log ("", GF_LOG_WARNING, "Unable to acquire lock. "
                         "Lock for %s held by %s", volname,
                         uuid_utoa (owner));
                 ret = -1;
                 goto out;
         }
 
-        lock_obj = GF_CALLOC (1, sizeof(vol_lock_obj),
+        lock_obj = GF_CALLOC (1, sizeof(glusterd_vol_lock_obj),
                               gf_common_mt_vol_lock_obj_t);
         if (!lock_obj) {
                 ret = -1;
@@ -116,7 +144,8 @@ glusterd_volume_lock (char *volname, uuid_t uuid)
 
         uuid_copy (lock_obj->lock_owner, uuid);
 
-        ret = dict_set_bin (vol_lock, volname, lock_obj, sizeof(vol_lock_obj));
+        ret = dict_set_bin (priv->vol_lock, volname, lock_obj,
+                            sizeof(glusterd_vol_lock_obj));
         if (ret) {
                 gf_log ("", GF_LOG_ERROR, "Unable to set lock owner "
                                           "in volume lock");
@@ -137,8 +166,15 @@ out:
 int32_t
 glusterd_volume_unlock (char *volname, uuid_t uuid)
 {
-        int32_t        ret      = -1;
-        uuid_t         owner    = {0};
+        int32_t                 ret      = -1;
+        glusterd_conf_t        *priv     = NULL;
+        uuid_t                  owner    = {0};
+        xlator_t               *this     = NULL;
+
+        this = THIS;
+        GF_ASSERT (this);
+        priv = this->private;
+        GF_ASSERT (priv);
 
         if (!volname) {
                 gf_log ("", GF_LOG_ERROR, "volname is null.");
@@ -151,21 +187,21 @@ glusterd_volume_unlock (char *volname, uuid_t uuid)
                 goto out;
 
         if (uuid_is_null (owner)) {
-                gf_log ("", GF_LOG_ERROR, "Lock for %s not held", volname);
+                gf_log ("", GF_LOG_WARNING, "Lock for %s not held", volname);
                 ret = -1;
                 goto out;
         }
 
         ret = uuid_compare (uuid, owner);
         if (ret) {
-                gf_log (THIS->name, GF_LOG_ERROR, "Lock owner mismatch. "
+                gf_log (THIS->name, GF_LOG_WARNING, "Lock owner mismatch. "
                         "Lock for %s held by %s",
                         volname, uuid_utoa (owner));
                 goto out;
         }
 
         /* Removing the volume lock from the global list */
-        dict_del (vol_lock, volname);
+        dict_del (priv->vol_lock, volname);
 
         gf_log ("", GF_LOG_DEBUG, "Lock for %s successfully released",
                 volname);