Land part 2 of clang-format changes

Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>

1 files changed, 666 insertions, 723 deletions

diff --git a/xlators/mgmt/glusterd/src/glusterd-locks.c b/xlators/mgmt/glusterd/src/glusterd-locks.c
index f9b0409b60d..4a7a5ba4479 100644
--- a/xlators/mgmt/glusterd/src/glusterd-locks.c
+++ b/xlators/mgmt/glusterd/src/glusterd-locks.c
@@ -28,205 +28,201 @@
 /* Valid entities that the mgmt_v3 lock can hold locks upon    *
  * To add newer entities to be locked, we can just add more    *
  * entries to this table along with the type and default value */
-glusterd_valid_entities   valid_types[] = {
-        { "vol",  _gf_true  },
-        { "snap", _gf_false },
-        { "global", _gf_false},
-        { NULL              },
+glusterd_valid_entities valid_types[] = {
+    {"vol", _gf_true},
+    {"snap", _gf_false},
+    {"global", _gf_false},
+    {NULL},
 };
 
 /* Checks if the lock request is for a valid entity */
 gf_boolean_t
-glusterd_mgmt_v3_is_type_valid (char *type)
+glusterd_mgmt_v3_is_type_valid(char *type)
 {
-        int32_t         i   = 0;
-        gf_boolean_t    ret = _gf_false;
+    int32_t i = 0;
+    gf_boolean_t ret = _gf_false;
 
-        GF_ASSERT (type);
+    GF_ASSERT(type);
 
-        for (i = 0; valid_types[i].type; i++) {
-                if (!strcmp (type, valid_types[i].type)) {
-                        ret = _gf_true;
-                        break;
-                }
+    for (i = 0; valid_types[i].type; i++) {
+        if (!strcmp(type, valid_types[i].type)) {
+            ret = _gf_true;
+            break;
         }
+    }
 
-        return ret;
+    return ret;
 }
 
 /* Initialize the global mgmt_v3 lock list(dict) when
  * glusterd is spawned */
 int32_t
-glusterd_mgmt_v3_lock_init ()
+glusterd_mgmt_v3_lock_init()
 {
-        int32_t             ret = -1;
-        xlator_t           *this   = NULL;
-        glusterd_conf_t    *priv   = NULL;
+    int32_t ret = -1;
+    xlator_t *this = NULL;
+    glusterd_conf_t *priv = NULL;
 
-        this = THIS;
-        GF_ASSERT (this);
-        priv = this->private;
-        GF_ASSERT (priv);
+    this = THIS;
+    GF_ASSERT(this);
+    priv = this->private;
+    GF_ASSERT(priv);
 
-        priv->mgmt_v3_lock = dict_new ();
-        if (!priv->mgmt_v3_lock)
-                goto out;
+    priv->mgmt_v3_lock = dict_new();
+    if (!priv->mgmt_v3_lock)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* Destroy the global mgmt_v3 lock list(dict) when
  * glusterd cleanup is performed */
 void
-glusterd_mgmt_v3_lock_fini ()
+glusterd_mgmt_v3_lock_fini()
 {
-        xlator_t           *this   = NULL;
-        glusterd_conf_t    *priv   = NULL;
+    xlator_t *this = NULL;
+    glusterd_conf_t *priv = NULL;
 
-        this = THIS;
-        GF_ASSERT (this);
-        priv = this->private;
-        GF_ASSERT (priv);
+    this = THIS;
+    GF_ASSERT(this);
+    priv = this->private;
+    GF_ASSERT(priv);
 
-        if (priv->mgmt_v3_lock)
-                dict_unref (priv->mgmt_v3_lock);
+    if (priv->mgmt_v3_lock)
+        dict_unref(priv->mgmt_v3_lock);
 }
 
 /* Initialize the global mgmt_v3_timer lock list(dict) when
  * glusterd is spawned */
 int32_t
-glusterd_mgmt_v3_lock_timer_init ()
+glusterd_mgmt_v3_lock_timer_init()
 {
-        int32_t             ret = -1;
-        xlator_t           *this   = NULL;
-        glusterd_conf_t    *priv   = NULL;
+    int32_t ret = -1;
+    xlator_t *this = NULL;
+    glusterd_conf_t *priv = NULL;
 
-        this = THIS;
-        GF_VALIDATE_OR_GOTO ("glusterd", this, out);
+    this = THIS;
+    GF_VALIDATE_OR_GOTO("glusterd", this, out);
 
-        priv = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, priv, out);
+    priv = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, priv, out);
 
-        priv->mgmt_v3_lock_timer = dict_new ();
-        if (!priv->mgmt_v3_lock_timer)
-                goto out;
+    priv->mgmt_v3_lock_timer = dict_new();
+    if (!priv->mgmt_v3_lock_timer)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 /* Destroy the global mgmt_v3_timer lock list(dict) when
  * glusterd cleanup is performed */
 void
-glusterd_mgmt_v3_lock_timer_fini ()
+glusterd_mgmt_v3_lock_timer_fini()
 {
-        xlator_t           *this   = NULL;
-        glusterd_conf_t    *priv   = NULL;
+    xlator_t *this = NULL;
+    glusterd_conf_t *priv = NULL;
 
-        this = THIS;
-        GF_VALIDATE_OR_GOTO ("glusterd", this, out);
+    this = THIS;
+    GF_VALIDATE_OR_GOTO("glusterd", this, out);
 
-        priv = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, priv, out);
+    priv = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, priv, out);
 
-        if (priv->mgmt_v3_lock_timer)
-                dict_unref (priv->mgmt_v3_lock_timer);
+    if (priv->mgmt_v3_lock_timer)
+        dict_unref(priv->mgmt_v3_lock_timer);
 out:
-        return;
+    return;
 }
 
 int32_t
-glusterd_get_mgmt_v3_lock_owner (char *key, uuid_t *uuid)
+glusterd_get_mgmt_v3_lock_owner(char *key, uuid_t *uuid)
 {
-        int32_t                         ret      = -1;
-        glusterd_mgmt_v3_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 (!key || !uuid) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        GD_MSG_INVALID_ENTRY, "key or uuid is null.");
-                ret = -1;
-                goto out;
-        }
+    int32_t ret = -1;
+    glusterd_mgmt_v3_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 (!key || !uuid) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY,
+               "key or uuid is null.");
+        ret = -1;
+        goto out;
+    }
 
-        ret = dict_get_bin (priv->mgmt_v3_lock, key, (void **) &lock_obj);
-        if (!ret)
-                gf_uuid_copy (*uuid, lock_obj->lock_owner);
-        else
-                gf_uuid_copy (*uuid, no_owner);
+    ret = dict_get_bin(priv->mgmt_v3_lock, key, (void **)&lock_obj);
+    if (!ret)
+        gf_uuid_copy(*uuid, lock_obj->lock_owner);
+    else
+        gf_uuid_copy(*uuid, no_owner);
 
-        ret = 0;
+    ret = 0;
 out:
-        gf_msg_trace (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_trace(this->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 /* This function is called with the locked_count and type, to   *
  * release all the acquired locks. */
 static int32_t
-glusterd_release_multiple_locks_per_entity (dict_t *dict, uuid_t uuid,
-                                            int32_t locked_count,
-                                            char *type)
+glusterd_release_multiple_locks_per_entity(dict_t *dict, uuid_t uuid,
+                                           int32_t locked_count, char *type)
 {
-        char           name_buf[PATH_MAX]    = "";
-        char          *name                  = NULL;
-        int32_t        i                     = -1;
-        int32_t        op_ret                = 0;
-        int32_t        ret                   = -1;
-        xlator_t      *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT(this);
-        GF_ASSERT (dict);
-        GF_ASSERT (type);
-
-        if (locked_count == 0) {
-                gf_msg_debug (this->name, 0,
-                        "No %s locked as part of this transaction",
-                        type);
-                goto out;
+    char name_buf[PATH_MAX] = "";
+    char *name = NULL;
+    int32_t i = -1;
+    int32_t op_ret = 0;
+    int32_t ret = -1;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_ASSERT(dict);
+    GF_ASSERT(type);
+
+    if (locked_count == 0) {
+        gf_msg_debug(this->name, 0, "No %s locked as part of this transaction",
+                     type);
+        goto out;
+    }
+
+    /* Release all the locks held */
+    for (i = 0; i < locked_count; i++) {
+        snprintf(name_buf, sizeof(name_buf), "%sname%d", type, i + 1);
+
+        /* Looking for volname1, volname2 or snapname1, *
+         * as key in the dict snapname2 */
+        ret = dict_get_str(dict, name_buf, &name);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_GET_FAILED,
+                   "Unable to get %s locked_count = %d", name_buf,
+                   locked_count);
+            op_ret = ret;
+            continue;
         }
 
-        /* Release all the locks held */
-        for (i = 0; i < locked_count; i++) {
-                snprintf (name_buf, sizeof(name_buf),
-                          "%sname%d", type, i+1);
-
-                /* Looking for volname1, volname2 or snapname1, *
-                 * as key in the dict snapname2 */
-                ret = dict_get_str (dict, name_buf, &name);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_DICT_GET_FAILED,
-                                "Unable to get %s locked_count = %d",
-                                name_buf, locked_count);
-                        op_ret = ret;
-                        continue;
-                }
-
-                ret = glusterd_mgmt_v3_unlock (name, uuid, type);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MGMTV3_UNLOCK_FAIL,
-                                "Failed to release lock for %s.",
-                                name);
-                        op_ret = ret;
-                }
+        ret = glusterd_mgmt_v3_unlock(name, uuid, type);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_MGMTV3_UNLOCK_FAIL,
+                   "Failed to release lock for %s.", name);
+            op_ret = ret;
         }
+    }
 
 out:
-        gf_msg_trace (this->name, 0, "Returning %d", op_ret);
-        return op_ret;
+    gf_msg_trace(this->name, 0, "Returning %d", op_ret);
+    return op_ret;
 }
 
 /* Given the count and type of the entity this function acquires     *
@@ -234,71 +230,64 @@ out:
  * If type is "vol" this function tries to acquire locks on multiple *
  * volumes */
 static int32_t
-glusterd_acquire_multiple_locks_per_entity (dict_t *dict, uuid_t uuid,
-                                            uint32_t *op_errno,
-                                            int32_t count, char *type)
+glusterd_acquire_multiple_locks_per_entity(dict_t *dict, uuid_t uuid,
+                                           uint32_t *op_errno, int32_t count,
+                                           char *type)
 {
-        char           name_buf[PATH_MAX]    = "";
-        char          *name                  = NULL;
-        int32_t        i                     = -1;
-        int32_t        ret                   = -1;
-        int32_t        locked_count          = 0;
-        xlator_t      *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT(this);
-        GF_ASSERT (dict);
-        GF_ASSERT (type);
-
-        /* Locking one element after other */
-        for (i = 0; i < count; i++) {
-                snprintf (name_buf, sizeof(name_buf),
-                          "%sname%d", type, i+1);
-
-                /* Looking for volname1, volname2 or snapname1, *
-                 * as key in the dict snapname2 */
-                ret = dict_get_str (dict, name_buf, &name);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_DICT_GET_FAILED,
-                                "Unable to get %s count = %d",
-                                name_buf, count);
-                        break;
-                }
-
-                ret = glusterd_mgmt_v3_lock (name, uuid, op_errno, type);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MGMTV3_LOCK_GET_FAIL,
-                                "Failed to acquire lock for %s %s "
-                                "on behalf of %s. Reversing "
-                                "this transaction", type, name,
-                                uuid_utoa(uuid));
-                        break;
-                }
-                locked_count++;
-        }
-
-        if (count == locked_count) {
-                /* If all locking ops went successfully, return as success */
-                ret = 0;
-                goto out;
+    char name_buf[PATH_MAX] = "";
+    char *name = NULL;
+    int32_t i = -1;
+    int32_t ret = -1;
+    int32_t locked_count = 0;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_ASSERT(dict);
+    GF_ASSERT(type);
+
+    /* Locking one element after other */
+    for (i = 0; i < count; i++) {
+        snprintf(name_buf, sizeof(name_buf), "%sname%d", type, i + 1);
+
+        /* Looking for volname1, volname2 or snapname1, *
+         * as key in the dict snapname2 */
+        ret = dict_get_str(dict, name_buf, &name);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_GET_FAILED,
+                   "Unable to get %s count = %d", name_buf, count);
+            break;
         }
 
-        /* If we failed to lock one element, unlock others and return failure */
-        ret = glusterd_release_multiple_locks_per_entity (dict, uuid,
-                                                          locked_count,
-                                                          type);
+        ret = glusterd_mgmt_v3_lock(name, uuid, op_errno, type);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL,
-                        "Failed to release multiple %s locks",
-                        type);
-        }
-        ret = -1;
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_MGMTV3_LOCK_GET_FAIL,
+                   "Failed to acquire lock for %s %s "
+                   "on behalf of %s. Reversing "
+                   "this transaction",
+                   type, name, uuid_utoa(uuid));
+            break;
+        }
+        locked_count++;
+    }
+
+    if (count == locked_count) {
+        /* If all locking ops went successfully, return as success */
+        ret = 0;
+        goto out;
+    }
+
+    /* If we failed to lock one element, unlock others and return failure */
+    ret = glusterd_release_multiple_locks_per_entity(dict, uuid, locked_count,
+                                                     type);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL,
+               "Failed to release multiple %s locks", type);
+    }
+    ret = -1;
 out:
-        gf_msg_trace (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_trace(this->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 /* Given the type of entity, this function figures out if it should unlock a   *
@@ -306,74 +295,69 @@ out:
  * if the type is "vol", this function will accordingly unlock a single volume *
  * or multiple volumes */
 static int32_t
-glusterd_mgmt_v3_unlock_entity (dict_t *dict, uuid_t uuid, char *type,
-                                gf_boolean_t default_value)
+glusterd_mgmt_v3_unlock_entity(dict_t *dict, uuid_t uuid, char *type,
+                               gf_boolean_t default_value)
 {
-        char           name_buf[PATH_MAX]    = "";
-        char          *name                  = NULL;
-        int32_t        count                 = -1;
-        int32_t        ret                   = -1;
-        gf_boolean_t   hold_locks            = _gf_false;
-        xlator_t      *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT(this);
-        GF_ASSERT (dict);
-        GF_ASSERT (type);
-
-        snprintf (name_buf, sizeof(name_buf), "hold_%s_locks", type);
-        hold_locks = dict_get_str_boolean (dict, name_buf, default_value);
-
-        if (hold_locks == _gf_false) {
-                /* Locks were not held for this particular entity *
-                 * Hence nothing to release */
-                ret = 0;
-                goto out;
+    char name_buf[PATH_MAX] = "";
+    char *name = NULL;
+    int32_t count = -1;
+    int32_t ret = -1;
+    gf_boolean_t hold_locks = _gf_false;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_ASSERT(dict);
+    GF_ASSERT(type);
+
+    snprintf(name_buf, sizeof(name_buf), "hold_%s_locks", type);
+    hold_locks = dict_get_str_boolean(dict, name_buf, default_value);
+
+    if (hold_locks == _gf_false) {
+        /* Locks were not held for this particular entity *
+         * Hence nothing to release */
+        ret = 0;
+        goto out;
+    }
+
+    /* Looking for volcount or snapcount in the dict */
+    snprintf(name_buf, sizeof(name_buf), "%scount", type);
+    ret = dict_get_int32(dict, name_buf, &count);
+    if (ret) {
+        /* count is not present. Only one *
+         * element name needs to be unlocked */
+        snprintf(name_buf, sizeof(name_buf), "%sname", type);
+        ret = dict_get_str(dict, name_buf, &name);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_GET_FAILED,
+                   "Unable to fetch %sname", type);
+            goto out;
         }
 
-        /* Looking for volcount or snapcount in the dict */
-        snprintf (name_buf, sizeof(name_buf), "%scount", type);
-        ret = dict_get_int32 (dict, name_buf, &count);
+        ret = glusterd_mgmt_v3_unlock(name, uuid, type);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_MGMTV3_UNLOCK_FAIL,
+                   "Failed to release lock for %s %s "
+                   "on behalf of %s.",
+                   type, name, uuid_utoa(uuid));
+            goto out;
+        }
+    } else {
+        /* Unlocking one element name after another */
+        ret = glusterd_release_multiple_locks_per_entity(dict, uuid, count,
+                                                         type);
         if (ret) {
-                /* count is not present. Only one *
-                 * element name needs to be unlocked */
-                snprintf (name_buf, sizeof(name_buf), "%sname",
-                          type);
-                ret = dict_get_str (dict, name_buf, &name);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_DICT_GET_FAILED,
-                                "Unable to fetch %sname", type);
-                        goto out;
-                }
-
-                ret = glusterd_mgmt_v3_unlock (name, uuid, type);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MGMTV3_UNLOCK_FAIL,
-                                "Failed to release lock for %s %s "
-                                "on behalf of %s.", type, name,
-                                uuid_utoa(uuid));
-                        goto out;
-                }
-        } else {
-                /* Unlocking one element name after another */
-                ret = glusterd_release_multiple_locks_per_entity (dict,
-                                                                  uuid,
-                                                                  count,
-                                                                  type);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL,
-                                "Failed to release all %s locks", type);
-                        goto out;
-                }
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL,
+                   "Failed to release all %s locks", type);
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        gf_msg_trace (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_trace(this->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 /* Given the type of entity, this function figures out if it should lock a   *
@@ -381,541 +365,500 @@ out:
  * if the type is "vol", this function will accordingly lock a single volume *
  * or multiple volumes */
 static int32_t
-glusterd_mgmt_v3_lock_entity (dict_t *dict, uuid_t uuid, uint32_t *op_errno,
-                              char *type, gf_boolean_t default_value)
+glusterd_mgmt_v3_lock_entity(dict_t *dict, uuid_t uuid, uint32_t *op_errno,
+                             char *type, gf_boolean_t default_value)
 {
-        char           name_buf[PATH_MAX]    = "";
-        char          *name                  = NULL;
-        int32_t        count                 = -1;
-        int32_t        ret                   = -1;
-        gf_boolean_t   hold_locks            = _gf_false;
-        xlator_t      *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT(this);
-        GF_ASSERT (dict);
-        GF_ASSERT (type);
-
-        snprintf (name_buf, sizeof(name_buf), "hold_%s_locks", type);
-        hold_locks = dict_get_str_boolean (dict, name_buf, default_value);
-
-        if (hold_locks == _gf_false) {
-                /* Not holding locks for this particular entity */
-                ret = 0;
-                goto out;
+    char name_buf[PATH_MAX] = "";
+    char *name = NULL;
+    int32_t count = -1;
+    int32_t ret = -1;
+    gf_boolean_t hold_locks = _gf_false;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+    GF_ASSERT(dict);
+    GF_ASSERT(type);
+
+    snprintf(name_buf, sizeof(name_buf), "hold_%s_locks", type);
+    hold_locks = dict_get_str_boolean(dict, name_buf, default_value);
+
+    if (hold_locks == _gf_false) {
+        /* Not holding locks for this particular entity */
+        ret = 0;
+        goto out;
+    }
+
+    /* Looking for volcount or snapcount in the dict */
+    snprintf(name_buf, sizeof(name_buf), "%scount", type);
+    ret = dict_get_int32(dict, name_buf, &count);
+    if (ret) {
+        /* count is not present. Only one *
+         * element name needs to be locked */
+        snprintf(name_buf, sizeof(name_buf), "%sname", type);
+        ret = dict_get_str(dict, name_buf, &name);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_GET_FAILED,
+                   "Unable to fetch %sname", type);
+            goto out;
         }
 
-        /* Looking for volcount or snapcount in the dict */
-        snprintf (name_buf, sizeof(name_buf), "%scount", type);
-        ret = dict_get_int32 (dict, name_buf, &count);
+        ret = glusterd_mgmt_v3_lock(name, uuid, op_errno, type);
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_MGMTV3_LOCK_GET_FAIL,
+                   "Failed to acquire lock for %s %s "
+                   "on behalf of %s.",
+                   type, name, uuid_utoa(uuid));
+            goto out;
+        }
+    } else {
+        /* Locking one element name after another */
+        ret = glusterd_acquire_multiple_locks_per_entity(dict, uuid, op_errno,
+                                                         count, type);
         if (ret) {
-                /* count is not present. Only one *
-                 * element name needs to be locked */
-                snprintf (name_buf, sizeof(name_buf), "%sname",
-                          type);
-                ret = dict_get_str (dict, name_buf, &name);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_DICT_GET_FAILED,
-                                "Unable to fetch %sname", type);
-                        goto out;
-                }
-
-                ret = glusterd_mgmt_v3_lock (name, uuid, op_errno, type);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MGMTV3_LOCK_GET_FAIL,
-                                "Failed to acquire lock for %s %s "
-                                "on behalf of %s.", type, name,
-                                uuid_utoa(uuid));
-                        goto out;
-                }
-        } else {
-                /* Locking one element name after another */
-                ret = glusterd_acquire_multiple_locks_per_entity (dict,
-                                                                  uuid,
-                                                                  op_errno,
-                                                                  count,
-                                                                  type);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MULTIPLE_LOCK_ACQUIRE_FAIL,
-                                "Failed to acquire all %s locks", type);
-                        goto out;
-                }
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   GD_MSG_MULTIPLE_LOCK_ACQUIRE_FAIL,
+                   "Failed to acquire all %s locks", type);
+            goto out;
         }
+    }
 
-        ret = 0;
+    ret = 0;
 out:
-        gf_msg_trace (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_trace(this->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 /* Try to release locks of multiple entities like *
  * volume, snaps etc. */
 int32_t
-glusterd_multiple_mgmt_v3_unlock (dict_t *dict, uuid_t uuid)
+glusterd_multiple_mgmt_v3_unlock(dict_t *dict, uuid_t uuid)
 {
-        int32_t        i                     = -1;
-        int32_t        ret                   = -1;
-        int32_t        op_ret                = 0;
-        xlator_t      *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT(this);
-
-        if (!dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_DICT_EMPTY, "dict is null.");
-                ret = -1;
-                goto out;
-        }
+    int32_t i = -1;
+    int32_t ret = -1;
+    int32_t op_ret = 0;
+    xlator_t *this = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+
+    if (!dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_EMPTY, "dict is null.");
+        ret = -1;
+        goto out;
+    }
 
-        for (i = 0; valid_types[i].type; i++) {
-                ret = glusterd_mgmt_v3_unlock_entity
-                                            (dict, uuid,
-                                             valid_types[i].type,
+    for (i = 0; valid_types[i].type; i++) {
+        ret = glusterd_mgmt_v3_unlock_entity(dict, uuid, valid_types[i].type,
                                              valid_types[i].default_value);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL,
-                                "Unable to unlock all %s",
-                                valid_types[i].type);
-                        op_ret = ret;
-                }
+        if (ret) {
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL, "Unable to unlock all %s",
+                   valid_types[i].type);
+            op_ret = ret;
         }
+    }
 
-        ret = op_ret;
+    ret = op_ret;
 out:
-        gf_msg_debug (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_debug(this->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 /* Try to acquire locks on multiple entities like *
  * volume, snaps etc. */
 int32_t
-glusterd_multiple_mgmt_v3_lock (dict_t *dict, uuid_t uuid, uint32_t *op_errno)
+glusterd_multiple_mgmt_v3_lock(dict_t *dict, uuid_t uuid, uint32_t *op_errno)
 {
-        int32_t        i                     = -1;
-        int32_t        ret                   = -1;
-        int32_t        locked_count          = 0;
-        xlator_t      *this                  = NULL;
-
-        this = THIS;
-        GF_ASSERT(this);
-
-        if (!dict) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_DICT_EMPTY, "dict is null.");
-                ret = -1;
-                goto out;
-        }
+    int32_t i = -1;
+    int32_t ret = -1;
+    int32_t locked_count = 0;
+    xlator_t *this = NULL;
 
-        /* Locking one entity after other */
-        for (i = 0; valid_types[i].type; i++) {
-                ret = glusterd_mgmt_v3_lock_entity
-                                            (dict, uuid, op_errno,
-                                             valid_types[i].type,
-                                             valid_types[i].default_value);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MULTIPLE_LOCK_ACQUIRE_FAIL,
-                                "Unable to lock all %s",
-                                valid_types[i].type);
-                        break;
-                }
-                locked_count++;
-        }
-
-        if (locked_count == GF_MAX_LOCKING_ENTITIES) {
-                /* If all locking ops went successfully, return as success */
-                ret = 0;
-                goto out;
-        }
+    this = THIS;
+    GF_ASSERT(this);
 
-        /* If we failed to lock one entity, unlock others and return failure */
-        for (i = 0; i < locked_count; i++) {
-                ret = glusterd_mgmt_v3_unlock_entity
-                                              (dict, uuid,
-                                               valid_types[i].type,
-                                               valid_types[i].default_value);
-                if (ret) {
-                        gf_msg (this->name, GF_LOG_ERROR, 0,
-                                GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL,
-                                "Unable to unlock all %s",
-                                valid_types[i].type);
-                }
-        }
+    if (!dict) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_EMPTY, "dict is null.");
         ret = -1;
-out:
-        gf_msg_debug (this->name, 0, "Returning %d", ret);
-        return ret;
-}
-
-
-int32_t
-glusterd_mgmt_v3_lock (const char *name, uuid_t uuid, uint32_t *op_errno,
-                       char *type)
-{
-        char                            key[PATH_MAX]       = "";
-        int32_t                         ret                 = -1;
-        glusterd_mgmt_v3_lock_obj      *lock_obj            = NULL;
-        glusterd_mgmt_v3_lock_timer    *mgmt_lock_timer     = NULL;
-        glusterd_conf_t                *priv                = NULL;
-        gf_boolean_t                    is_valid            = _gf_true;
-        uuid_t                          owner               = {0};
-        xlator_t                       *this                = NULL;
-        char                           *bt                  = NULL;
-        struct timespec                 delay               = {0};
-        char                           *key_dup             = NULL;
-        glusterfs_ctx_t                *mgmt_lock_timer_ctx = NULL;
-        xlator_t                       *mgmt_lock_timer_xl  = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        priv = this->private;
-        GF_ASSERT (priv);
-
-        if (!name || !type) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        GD_MSG_INVALID_ENTRY, "name or type is null.");
-                ret = -1;
-                goto out;
-        }
-
-        is_valid = glusterd_mgmt_v3_is_type_valid (type);
-        if (is_valid != _gf_true) {
-                gf_msg_callingfn (this->name, GF_LOG_ERROR,
-                        EINVAL, GD_MSG_INVALID_ENTRY,
-                        "Invalid entity. Cannot perform locking "
-                        "operation on %s types", type);
-                ret = -1;
-                goto out;
-        }
-
-        ret = snprintf (key, sizeof(key), "%s_%s", name, type);
-        if (ret != strlen(name) + 1 + strlen(type)) {
-                ret = -1;
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_CREATE_KEY_FAIL, "Unable to create key");
-                goto out;
-        }
-
-        gf_msg_debug (this->name, 0,
-                "Trying to acquire lock of %s %s for %s as %s",
-                type, name, uuid_utoa (uuid), key);
-
-        ret = glusterd_get_mgmt_v3_lock_owner (key, &owner);
+        goto out;
+    }
+
+    /* Locking one entity after other */
+    for (i = 0; valid_types[i].type; i++) {
+        ret = glusterd_mgmt_v3_lock_entity(dict, uuid, op_errno,
+                                           valid_types[i].type,
+                                           valid_types[i].default_value);
         if (ret) {
-                gf_msg_debug (this->name, 0,
-                        "Unable to get mgmt_v3 lock owner");
-                goto out;
-        }
-
-        /* If the lock has already been held for the given volume
-         * we fail */
-        if (!gf_uuid_is_null (owner)) {
-                gf_msg_callingfn (this->name, GF_LOG_WARNING,
-                                  0, GD_MSG_LOCK_ALREADY_HELD,
-                                  "Lock for %s held by %s",
-                                  name, uuid_utoa (owner));
-                ret = -1;
-                *op_errno = EG_ANOTRANS;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   GD_MSG_MULTIPLE_LOCK_ACQUIRE_FAIL, "Unable to lock all %s",
+                   valid_types[i].type);
+            break;
         }
+        locked_count++;
+    }
 
-        lock_obj = GF_CALLOC (1, sizeof(glusterd_mgmt_v3_lock_obj),
-                              gf_common_mt_mgmt_v3_lock_obj_t);
-        if (!lock_obj) {
-                ret = -1;
-                goto out;
-        }
-
-        gf_uuid_copy (lock_obj->lock_owner, uuid);
+    if (locked_count == GF_MAX_LOCKING_ENTITIES) {
+        /* If all locking ops went successfully, return as success */
+        ret = 0;
+        goto out;
+    }
 
-        ret = dict_set_bin (priv->mgmt_v3_lock, key, lock_obj,
-                            sizeof(glusterd_mgmt_v3_lock_obj));
+    /* If we failed to lock one entity, unlock others and return failure */
+    for (i = 0; i < locked_count; i++) {
+        ret = glusterd_mgmt_v3_unlock_entity(dict, uuid, valid_types[i].type,
+                                             valid_types[i].default_value);
         if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_DICT_SET_FAILED,
-                        "Unable to set lock owner in mgmt_v3 lock");
-                GF_FREE (lock_obj);
-                goto out;
-        }
-
-        mgmt_lock_timer = GF_CALLOC (1, sizeof(glusterd_mgmt_v3_lock_timer),
-                                     gf_common_mt_mgmt_v3_lock_timer_t);
-
-        if (!mgmt_lock_timer) {
-                ret = -1;
-                goto out;
+            gf_msg(this->name, GF_LOG_ERROR, 0,
+                   GD_MSG_MULTIPLE_LOCK_RELEASE_FAIL, "Unable to unlock all %s",
+                   valid_types[i].type);
         }
+    }
+    ret = -1;
+out:
+    gf_msg_debug(this->name, 0, "Returning %d", ret);
+    return ret;
+}
 
-        mgmt_lock_timer->xl = THIS;
-        key_dup = gf_strdup (key);
-        delay.tv_sec = priv->mgmt_v3_lock_timeout;
-        delay.tv_nsec = 0;
-        /*changing to default timeout value*/
-        priv->mgmt_v3_lock_timeout = GF_LOCK_TIMER;
+int32_t
+glusterd_mgmt_v3_lock(const char *name, uuid_t uuid, uint32_t *op_errno,
+                      char *type)
+{
+    char key[PATH_MAX] = "";
+    int32_t ret = -1;
+    glusterd_mgmt_v3_lock_obj *lock_obj = NULL;
+    glusterd_mgmt_v3_lock_timer *mgmt_lock_timer = NULL;
+    glusterd_conf_t *priv = NULL;
+    gf_boolean_t is_valid = _gf_true;
+    uuid_t owner = {0};
+    xlator_t *this = NULL;
+    char *bt = NULL;
+    struct timespec delay = {0};
+    char *key_dup = NULL;
+    glusterfs_ctx_t *mgmt_lock_timer_ctx = NULL;
+    xlator_t *mgmt_lock_timer_xl = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+
+    priv = this->private;
+    GF_ASSERT(priv);
+
+    if (!name || !type) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY,
+               "name or type is null.");
+        ret = -1;
+        goto out;
+    }
+
+    is_valid = glusterd_mgmt_v3_is_type_valid(type);
+    if (is_valid != _gf_true) {
+        gf_msg_callingfn(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY,
+                         "Invalid entity. Cannot perform locking "
+                         "operation on %s types",
+                         type);
+        ret = -1;
+        goto out;
+    }
 
+    ret = snprintf(key, sizeof(key), "%s_%s", name, type);
+    if (ret != strlen(name) + 1 + strlen(type)) {
         ret = -1;
-        mgmt_lock_timer_xl = mgmt_lock_timer->xl;
-        GF_VALIDATE_OR_GOTO (this->name, mgmt_lock_timer_xl, out);
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_CREATE_KEY_FAIL,
+               "Unable to create key");
+        goto out;
+    }
+
+    gf_msg_debug(this->name, 0, "Trying to acquire lock of %s %s for %s as %s",
+                 type, name, uuid_utoa(uuid), key);
+
+    ret = glusterd_get_mgmt_v3_lock_owner(key, &owner);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "Unable to get mgmt_v3 lock owner");
+        goto out;
+    }
+
+    /* If the lock has already been held for the given volume
+     * we fail */
+    if (!gf_uuid_is_null(owner)) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0,
+                         GD_MSG_LOCK_ALREADY_HELD, "Lock for %s held by %s",
+                         name, uuid_utoa(owner));
+        ret = -1;
+        *op_errno = EG_ANOTRANS;
+        goto out;
+    }
 
-        mgmt_lock_timer_ctx = mgmt_lock_timer_xl->ctx;
-        GF_VALIDATE_OR_GOTO (this->name, mgmt_lock_timer_ctx, out);
+    lock_obj = GF_CALLOC(1, sizeof(glusterd_mgmt_v3_lock_obj),
+                         gf_common_mt_mgmt_v3_lock_obj_t);
+    if (!lock_obj) {
+        ret = -1;
+        goto out;
+    }
 
-        mgmt_lock_timer->timer = gf_timer_call_after
-                                     (mgmt_lock_timer_ctx, delay,
-                                      gd_mgmt_v3_unlock_timer_cbk,
-                                      key_dup);
+    gf_uuid_copy(lock_obj->lock_owner, uuid);
 
-        ret = dict_set_bin (priv->mgmt_v3_lock_timer, key, mgmt_lock_timer,
-                            sizeof (glusterd_mgmt_v3_lock_timer));
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_DICT_SET_FAILED,
-                        "Unable to set timer in mgmt_v3 lock");
-                GF_FREE (mgmt_lock_timer);
-                goto out;
-        }
+    ret = dict_set_bin(priv->mgmt_v3_lock, key, lock_obj,
+                       sizeof(glusterd_mgmt_v3_lock_obj));
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED,
+               "Unable to set lock owner in mgmt_v3 lock");
+        GF_FREE(lock_obj);
+        goto out;
+    }
 
+    mgmt_lock_timer = GF_CALLOC(1, sizeof(glusterd_mgmt_v3_lock_timer),
+                                gf_common_mt_mgmt_v3_lock_timer_t);
 
-        /* Saving the backtrace into the pre-allocated buffer, ctx->btbuf*/
-        if ((bt = gf_backtrace_save (NULL))) {
-                snprintf (key, sizeof (key), "debug.last-success-bt-%s-%s",
-                          name, type);
-                ret = dict_set_dynstr_with_alloc (priv->mgmt_v3_lock, key, bt);
-                if (ret)
-                        gf_msg (this->name, GF_LOG_WARNING, 0,
-                                GD_MSG_DICT_SET_FAILED, "Failed to save "
-                                "the back trace for lock %s-%s granted to %s",
-                                name, type, uuid_utoa (uuid));
-                ret = 0;
-        }
+    if (!mgmt_lock_timer) {
+        ret = -1;
+        goto out;
+    }
+
+    mgmt_lock_timer->xl = THIS;
+    key_dup = gf_strdup(key);
+    delay.tv_sec = priv->mgmt_v3_lock_timeout;
+    delay.tv_nsec = 0;
+    /*changing to default timeout value*/
+    priv->mgmt_v3_lock_timeout = GF_LOCK_TIMER;
+
+    ret = -1;
+    mgmt_lock_timer_xl = mgmt_lock_timer->xl;
+    GF_VALIDATE_OR_GOTO(this->name, mgmt_lock_timer_xl, out);
+
+    mgmt_lock_timer_ctx = mgmt_lock_timer_xl->ctx;
+    GF_VALIDATE_OR_GOTO(this->name, mgmt_lock_timer_ctx, out);
+
+    mgmt_lock_timer->timer = gf_timer_call_after(
+        mgmt_lock_timer_ctx, delay, gd_mgmt_v3_unlock_timer_cbk, key_dup);
+
+    ret = dict_set_bin(priv->mgmt_v3_lock_timer, key, mgmt_lock_timer,
+                       sizeof(glusterd_mgmt_v3_lock_timer));
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED,
+               "Unable to set timer in mgmt_v3 lock");
+        GF_FREE(mgmt_lock_timer);
+        goto out;
+    }
+
+    /* Saving the backtrace into the pre-allocated buffer, ctx->btbuf*/
+    if ((bt = gf_backtrace_save(NULL))) {
+        snprintf(key, sizeof(key), "debug.last-success-bt-%s-%s", name, type);
+        ret = dict_set_dynstr_with_alloc(priv->mgmt_v3_lock, key, bt);
+        if (ret)
+            gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_DICT_SET_FAILED,
+                   "Failed to save "
+                   "the back trace for lock %s-%s granted to %s",
+                   name, type, uuid_utoa(uuid));
+        ret = 0;
+    }
 
-        gf_msg_debug (this->name, 0,
-                "Lock for %s %s successfully held by %s",
-                type, name, uuid_utoa (uuid));
+    gf_msg_debug(this->name, 0, "Lock for %s %s successfully held by %s", type,
+                 name, uuid_utoa(uuid));
 
-        ret = 0;
+    ret = 0;
 out:
-        gf_msg_trace (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_trace(this->name, 0, "Returning %d", ret);
+    return ret;
 }
 
 /*
  * This call back will ensure to unlock the lock_obj, in case we hit a situation
  * where unlocking failed and stale lock exist*/
 void
-gd_mgmt_v3_unlock_timer_cbk (void *data)
+gd_mgmt_v3_unlock_timer_cbk(void *data)
 {
-        xlator_t                        *this               = NULL;
-        glusterd_conf_t                 *conf               = NULL;
-        glusterd_mgmt_v3_lock_timer     *mgmt_lock_timer    = NULL;
-        char                            *key                = NULL;
-        char                            *type               = NULL;
-        char                            bt_key[PATH_MAX]    = "";
-        char                            name[PATH_MAX]      = "";
-        int32_t                         ret                 = -1;
-        glusterfs_ctx_t                *mgmt_lock_timer_ctx = NULL;
-        xlator_t                       *mgmt_lock_timer_xl  = NULL;
-        gf_timer_t                     *timer               = NULL;
-
-        this = THIS;
-        GF_VALIDATE_OR_GOTO ("glusterd", this, out);
-
-        conf = this->private;
-        GF_VALIDATE_OR_GOTO (this->name, conf, out);
-
-        gf_log (THIS->name, GF_LOG_INFO, "In gd_mgmt_v3_unlock_timer_cbk");
-        GF_ASSERT (NULL != data);
-        key = (char *)data;
-
-        dict_del (conf->mgmt_v3_lock, key);
-
-        type = strrchr (key, '_');
-        strncpy (name, key, strlen (key) - strlen (type) - 1);
-
-        ret = snprintf (bt_key, PATH_MAX, "debug.last-success-bt-%s-%s",
-                        name, type + 1);
-        if (ret != SLEN ("debug.last-success-bt-") + strlen (name) +
-                   strlen (type)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_CREATE_KEY_FAIL, "Unable to create backtrace "
-                        "key");
-                goto out;
-        }
+    xlator_t *this = NULL;
+    glusterd_conf_t *conf = NULL;
+    glusterd_mgmt_v3_lock_timer *mgmt_lock_timer = NULL;
+    char *key = NULL;
+    char *type = NULL;
+    char bt_key[PATH_MAX] = "";
+    char name[PATH_MAX] = "";
+    int32_t ret = -1;
+    glusterfs_ctx_t *mgmt_lock_timer_ctx = NULL;
+    xlator_t *mgmt_lock_timer_xl = NULL;
+    gf_timer_t *timer = NULL;
+
+    this = THIS;
+    GF_VALIDATE_OR_GOTO("glusterd", this, out);
+
+    conf = this->private;
+    GF_VALIDATE_OR_GOTO(this->name, conf, out);
+
+    gf_log(THIS->name, GF_LOG_INFO, "In gd_mgmt_v3_unlock_timer_cbk");
+    GF_ASSERT(NULL != data);
+    key = (char *)data;
+
+    dict_del(conf->mgmt_v3_lock, key);
+
+    type = strrchr(key, '_');
+    strncpy(name, key, strlen(key) - strlen(type) - 1);
+
+    ret = snprintf(bt_key, PATH_MAX, "debug.last-success-bt-%s-%s", name,
+                   type + 1);
+    if (ret != SLEN("debug.last-success-bt-") + strlen(name) + strlen(type)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_CREATE_KEY_FAIL,
+               "Unable to create backtrace "
+               "key");
+        goto out;
+    }
+
+    dict_del(conf->mgmt_v3_lock, bt_key);
+
+    ret = dict_get_bin(conf->mgmt_v3_lock_timer, key,
+                       (void **)&mgmt_lock_timer);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED,
+               "Unable to get lock owner in mgmt_v3 lock");
+    }
 
-        dict_del (conf->mgmt_v3_lock, bt_key);
+out:
+    if (mgmt_lock_timer && mgmt_lock_timer->timer) {
+        mgmt_lock_timer_xl = mgmt_lock_timer->xl;
+        GF_VALIDATE_OR_GOTO(this->name, mgmt_lock_timer_xl, ret_function);
 
-        ret = dict_get_bin (conf->mgmt_v3_lock_timer, key,
-                            (void **)&mgmt_lock_timer);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_DICT_SET_FAILED,
-                        "Unable to get lock owner in mgmt_v3 lock");
-        }
+        mgmt_lock_timer_ctx = mgmt_lock_timer_xl->ctx;
+        GF_VALIDATE_OR_GOTO(this->name, mgmt_lock_timer_ctx, ret_function);
 
-out:
-        if (mgmt_lock_timer && mgmt_lock_timer->timer) {
-                mgmt_lock_timer_xl = mgmt_lock_timer->xl;
-                GF_VALIDATE_OR_GOTO (this->name, mgmt_lock_timer_xl,
-                                     ret_function);
-
-                mgmt_lock_timer_ctx = mgmt_lock_timer_xl->ctx;
-                GF_VALIDATE_OR_GOTO (this->name, mgmt_lock_timer_ctx,
-                                     ret_function);
-
-                timer = mgmt_lock_timer->timer;
-                GF_FREE (timer->data);
-                gf_timer_call_cancel (mgmt_lock_timer_ctx,
-                                      mgmt_lock_timer->timer);
-                dict_del (conf->mgmt_v3_lock_timer, bt_key);
-                mgmt_lock_timer->timer = NULL;
-        }
+        timer = mgmt_lock_timer->timer;
+        GF_FREE(timer->data);
+        gf_timer_call_cancel(mgmt_lock_timer_ctx, mgmt_lock_timer->timer);
+        dict_del(conf->mgmt_v3_lock_timer, bt_key);
+        mgmt_lock_timer->timer = NULL;
+    }
 
 ret_function:
 
-        return;
-
+    return;
 }
 
 int32_t
-glusterd_mgmt_v3_unlock (const char *name, uuid_t uuid, char *type)
+glusterd_mgmt_v3_unlock(const char *name, uuid_t uuid, char *type)
 {
-        char                            key[PATH_MAX]       = "";
-        char                            key_dup[PATH_MAX]   = "";
-        int32_t                         ret                 = -1;
-        gf_boolean_t                    is_valid            = _gf_true;
-        glusterd_conf_t                 *priv               = NULL;
-        glusterd_volinfo_t              *volinfo            = NULL;
-        glusterd_mgmt_v3_lock_timer     *mgmt_lock_timer    = NULL;
-        uuid_t                          owner               = {0};
-        xlator_t                        *this               = NULL;
-        glusterfs_ctx_t                *mgmt_lock_timer_ctx = NULL;
-        xlator_t                       *mgmt_lock_timer_xl  = NULL;
-        gf_timer_t                     *timer               = NULL;
-
-        this = THIS;
-        GF_ASSERT (this);
-
-        priv = this->private;
-        GF_ASSERT (priv);
-
-        if (!name || !type) {
-                gf_msg (this->name, GF_LOG_ERROR, EINVAL,
-                        GD_MSG_INVALID_ENTRY, "name is null.");
-                ret = -1;
-                goto out;
-        }
-
-        is_valid = glusterd_mgmt_v3_is_type_valid (type);
-        if (is_valid != _gf_true) {
-                gf_msg_callingfn (this->name, GF_LOG_ERROR, EINVAL,
-                        GD_MSG_INVALID_ENTRY,
-                        "Invalid entity. Cannot perform unlocking "
-                        "operation on %s types", type);
-                ret = -1;
-                goto out;
-        }
-
-        ret = snprintf (key, sizeof(key), "%s_%s",
-                        name, type);
-        if (ret != strlen(name) + 1 + strlen(type)) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_CREATE_KEY_FAIL, "Unable to create key");
-                ret = -1;
-                goto out;
-        }
-        strncpy (key_dup, key, strlen(key));
-
-        gf_msg_debug (this->name, 0,
-                "Trying to release lock of %s %s for %s as %s",
-                type, name, uuid_utoa (uuid), key);
-
-        ret = glusterd_get_mgmt_v3_lock_owner (key, &owner);
-        if (ret) {
-                gf_msg_debug (this->name, 0,
-                        "Unable to get mgmt_v3 lock owner");
-                goto out;
-        }
-
-        if (gf_uuid_is_null (owner)) {
-                gf_msg_callingfn (this->name, GF_LOG_WARNING,
-                        0, GD_MSG_LOCK_NOT_HELD,
-                        "Lock for %s %s not held", type, name);
-                ret = -1;
-                goto out;
-        }
+    char key[PATH_MAX] = "";
+    char key_dup[PATH_MAX] = "";
+    int32_t ret = -1;
+    gf_boolean_t is_valid = _gf_true;
+    glusterd_conf_t *priv = NULL;
+    glusterd_volinfo_t *volinfo = NULL;
+    glusterd_mgmt_v3_lock_timer *mgmt_lock_timer = NULL;
+    uuid_t owner = {0};
+    xlator_t *this = NULL;
+    glusterfs_ctx_t *mgmt_lock_timer_ctx = NULL;
+    xlator_t *mgmt_lock_timer_xl = NULL;
+    gf_timer_t *timer = NULL;
+
+    this = THIS;
+    GF_ASSERT(this);
+
+    priv = this->private;
+    GF_ASSERT(priv);
+
+    if (!name || !type) {
+        gf_msg(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY,
+               "name is null.");
+        ret = -1;
+        goto out;
+    }
+
+    is_valid = glusterd_mgmt_v3_is_type_valid(type);
+    if (is_valid != _gf_true) {
+        gf_msg_callingfn(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY,
+                         "Invalid entity. Cannot perform unlocking "
+                         "operation on %s types",
+                         type);
+        ret = -1;
+        goto out;
+    }
 
-        ret = gf_uuid_compare (uuid, owner);
-        if (ret) {
-                gf_msg_callingfn (this->name, GF_LOG_WARNING,
-                                  0, GD_MSG_LOCK_OWNER_MISMATCH,
-                                  "Lock owner mismatch. "
-                                  "Lock for %s %s held by %s",
-                                  type, name, uuid_utoa (owner));
-                goto out;
-        }
+    ret = snprintf(key, sizeof(key), "%s_%s", name, type);
+    if (ret != strlen(name) + 1 + strlen(type)) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_CREATE_KEY_FAIL,
+               "Unable to create key");
+        ret = -1;
+        goto out;
+    }
+    strncpy(key_dup, key, strlen(key));
+
+    gf_msg_debug(this->name, 0, "Trying to release lock of %s %s for %s as %s",
+                 type, name, uuid_utoa(uuid), key);
+
+    ret = glusterd_get_mgmt_v3_lock_owner(key, &owner);
+    if (ret) {
+        gf_msg_debug(this->name, 0, "Unable to get mgmt_v3 lock owner");
+        goto out;
+    }
+
+    if (gf_uuid_is_null(owner)) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0, GD_MSG_LOCK_NOT_HELD,
+                         "Lock for %s %s not held", type, name);
+        ret = -1;
+        goto out;
+    }
+
+    ret = gf_uuid_compare(uuid, owner);
+    if (ret) {
+        gf_msg_callingfn(this->name, GF_LOG_WARNING, 0,
+                         GD_MSG_LOCK_OWNER_MISMATCH,
+                         "Lock owner mismatch. "
+                         "Lock for %s %s held by %s",
+                         type, name, uuid_utoa(owner));
+        goto out;
+    }
+
+    /* Removing the mgmt_v3 lock from the global list */
+    dict_del(priv->mgmt_v3_lock, key);
+
+    ret = dict_get_bin(priv->mgmt_v3_lock_timer, key,
+                       (void **)&mgmt_lock_timer);
+    if (ret) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED,
+               "Unable to get mgmt lock key in mgmt_v3 lock");
+        goto out;
+    }
+
+    /* Remove the backtrace key as well */
+    ret = snprintf(key, sizeof(key), "debug.last-success-bt-%s-%s", name, type);
+    if (ret !=
+        SLEN("debug.last-success-bt-") + strlen(name) + strlen(type) + 1) {
+        gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_CREATE_KEY_FAIL,
+               "Unable to create backtrace "
+               "key");
+        ret = -1;
+        goto out;
+    }
+    dict_del(priv->mgmt_v3_lock, key);
 
-        /* Removing the mgmt_v3 lock from the global list */
-        dict_del (priv->mgmt_v3_lock, key);
+    gf_msg_debug(this->name, 0, "Lock for %s %s successfully released", type,
+                 name);
 
-        ret = dict_get_bin (priv->mgmt_v3_lock_timer, key,
-                            (void **)&mgmt_lock_timer);
-        if (ret) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_DICT_SET_FAILED,
-                        "Unable to get mgmt lock key in mgmt_v3 lock");
-                goto out;
-        }
+    /* Release owner reference which was held during lock */
+    if (mgmt_lock_timer->timer) {
+        ret = -1;
+        mgmt_lock_timer_xl = mgmt_lock_timer->xl;
+        GF_VALIDATE_OR_GOTO(this->name, mgmt_lock_timer_xl, out);
 
-        /* Remove the backtrace key as well */
-        ret = snprintf (key, sizeof(key), "debug.last-success-bt-%s-%s", name,
-                        type);
-        if (ret != SLEN ("debug.last-success-bt-") + strlen (name) +
-                   strlen (type) + 1) {
-                gf_msg (this->name, GF_LOG_ERROR, 0,
-                        GD_MSG_CREATE_KEY_FAIL, "Unable to create backtrace "
-                        "key");
-                ret = -1;
-                goto out;
-        }
-        dict_del (priv->mgmt_v3_lock, key);
-
-        gf_msg_debug (this->name, 0,
-                "Lock for %s %s successfully released",
-                type, name);
-
-        /* Release owner reference which was held during lock */
-        if (mgmt_lock_timer->timer) {
-                ret = -1;
-                mgmt_lock_timer_xl = mgmt_lock_timer->xl;
-                GF_VALIDATE_OR_GOTO (this->name, mgmt_lock_timer_xl, out);
-
-                mgmt_lock_timer_ctx = mgmt_lock_timer_xl->ctx;
-                GF_VALIDATE_OR_GOTO (this->name, mgmt_lock_timer_ctx, out);
-                ret = 0;
-
-                timer = mgmt_lock_timer->timer;
-                GF_FREE (timer->data);
-                gf_timer_call_cancel (mgmt_lock_timer_ctx,
-                                    mgmt_lock_timer->timer);
-                dict_del (priv->mgmt_v3_lock_timer, key_dup);
-        }
-        ret = glusterd_volinfo_find (name, &volinfo);
-        if (volinfo && volinfo->stage_deleted) {
-                /* this indicates a volume still exists and the volume delete
-                 * operation has failed in some of the phases, need to ensure
-                 * stage_deleted flag is set back to false
-                 */
-                volinfo->stage_deleted = _gf_false;
-        }
+        mgmt_lock_timer_ctx = mgmt_lock_timer_xl->ctx;
+        GF_VALIDATE_OR_GOTO(this->name, mgmt_lock_timer_ctx, out);
         ret = 0;
+
+        timer = mgmt_lock_timer->timer;
+        GF_FREE(timer->data);
+        gf_timer_call_cancel(mgmt_lock_timer_ctx, mgmt_lock_timer->timer);
+        dict_del(priv->mgmt_v3_lock_timer, key_dup);
+    }
+    ret = glusterd_volinfo_find(name, &volinfo);
+    if (volinfo && volinfo->stage_deleted) {
+        /* this indicates a volume still exists and the volume delete
+         * operation has failed in some of the phases, need to ensure
+         * stage_deleted flag is set back to false
+         */
+        volinfo->stage_deleted = _gf_false;
+    }
+    ret = 0;
 out:
 
-        gf_msg_trace (this->name, 0, "Returning %d", ret);
-        return ret;
+    gf_msg_trace(this->name, 0, "Returning %d", ret);
+    return ret;
 }